effect 4.0.0-beta.74 → 4.0.0-beta.75

package/src/Schema.ts

@@ -125,12 +125,12 @@ import * as Record_ from "./Record.ts"
 import * as Redacted_ from "./Redacted.ts"
 import * as Result_ from "./Result.ts"
 import * as Scheduler from "./Scheduler.ts"
-import * as AST from "./SchemaAST.ts"
-import * as Getter from "./SchemaGetter.ts"
-import * as Issue from "./SchemaIssue.ts"
-import * as Parser from "./SchemaParser.ts"
+import * as SchemaAST from "./SchemaAST.ts"
+import * as SchemaGetter from "./SchemaGetter.ts"
+import * as SchemaIssue from "./SchemaIssue.ts"
+import * as SchemaParser from "./SchemaParser.ts"
 import type * as SchemaRepresentation from "./SchemaRepresentation.ts"
-import * as Transformation from "./SchemaTransformation.ts"
+import * as SchemaTransformation from "./SchemaTransformation.ts"
 import type { Assign, Lambda, Mutable, Simplify } from "./Struct.ts"
 import * as Struct_ from "./Struct.ts"
 import * as FastCheck from "./testing/FastCheck.ts"
@@ -189,7 +189,7 @@ export interface MakeOptions {
   /**
    * The parse options to use for the schema.
    */
-  readonly parseOptions?: AST.ParseOptions | undefined
+  readonly parseOptions?: SchemaAST.ParseOptions | undefined
   /**
    * Whether to disable validation for the schema.
    */
@@ -220,7 +220,7 @@ export interface Bottom<
   out E,
   out RD,
   out RE,
-  out Ast extends AST.AST,
+  out Ast extends SchemaAST.AST,
   out Rebuild extends Top,
   out TypeMakeIn = T,
   out Iso = T,
@@ -255,7 +255,7 @@ export interface Bottom<
 
   annotate(annotations: Annotations.Bottom<this["Type"], this["~type.parameters"]>): this["Rebuild"]
   annotateKey(annotations: Annotations.Key<this["Type"]>): this["Rebuild"]
-  check(...checks: readonly [AST.Check<this["Type"]>, ...Array<AST.Check<this["Type"]>>]): this["Rebuild"]
+  check(...checks: readonly [SchemaAST.Check<this["Type"]>, ...Array<SchemaAST.Check<this["Type"]>>]): this["Rebuild"]
   rebuild(ast: this["ast"]): this["Rebuild"]
   /**
    * Constructs a value from the make input representation synchronously.
@@ -324,7 +324,7 @@ export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<T
     E,
     TypeParameters[number]["DecodingServices"],
     TypeParameters[number]["EncodingServices"],
-    AST.Declaration,
+    SchemaAST.Declaration,
     declareConstructor<T, E, TypeParameters, Iso>,
     T,
     Iso,
@@ -337,6 +337,11 @@ export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<T
  * `Array<A>`, `Option<A>`, etc.) by accepting a list of type-parameter schemas
  * and a decoder factory.
  *
+ * **When to use**
+ *
+ * Use when you are defining a schema for a generic container whose validation
+ * depends on one or more type-parameter schemas.
+ *
  * **Details**
  *
  * The outer call `declareConstructor<T, E, Iso>()` fixes the decoded type `T`,
@@ -366,7 +371,7 @@ export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<T
  *     ([itemCodec]) =>
  *       (u, ast, options) => {
  *         if (!isBox(u)) {
- *           return Effect.fail(new Issue.InvalidType(ast, Option.some(u)))
+ *           return Effect.fail(new SchemaIssue.InvalidType(ast, Option.some(u)))
  *         }
  *         return Effect.map(
  *           SchemaParser.decodeUnknownEffect(itemCodec)(u.value, options),
@@ -388,12 +393,16 @@ export function declareConstructor<T, E = T, Iso = T>() {
       typeParameters: {
         readonly [K in keyof TypeParameters]: Codec<TypeParameters[K]["Type"], TypeParameters[K]["Encoded"]>
       }
-    ) => (u: unknown, self: AST.Declaration, options: AST.ParseOptions) => Effect.Effect<T, Issue.Issue>,
+    ) => (
+      u: unknown,
+      self: SchemaAST.Declaration,
+      options: SchemaAST.ParseOptions
+    ) => Effect.Effect<T, SchemaIssue.Issue>,
     annotations?: Annotations.Declaration<T, TypeParameters>
   ): declareConstructor<T, E, TypeParameters, Iso> => {
     return make(
-      new AST.Declaration(
-        typeParameters.map(AST.getAST),
+      new SchemaAST.Declaration(
+        typeParameters.map(SchemaAST.getAST),
         (typeParameters) => run(typeParameters.map((ast) => make(ast)) as any),
         annotations
       )
@@ -416,10 +425,10 @@ export interface declare<T, Iso = T> extends declareConstructor<T, T, readonly [
  * function. The schema accepts any unknown value and succeeds when `is` returns
  * `true`, failing with an `InvalidType` issue otherwise.
  *
- * **Details**
+ * **When to use**
  *
- * Use this when the type has no type parameters. For parametric types such as
- * `Option<A>` or `Array<A>`, use {@link declareConstructor} instead.
+ * Use when you are defining a schema for an opaque type with no type parameters
+ * and validation can be expressed as a type guard.
  *
  * **Example** (Schema for a custom `UserId` branded type)
  *
@@ -451,7 +460,7 @@ export function declare<T, Iso = T>(
     () => (input, ast) =>
       is(input) ?
         Effect.succeed(input) :
-        Effect.fail(new Issue.InvalidType(ast, Option_.some(input))),
+        Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input))),
     annotations
   )
 }
@@ -605,7 +614,7 @@ export function annotateEncoded<S extends Top>(annotations: Annotations.Bottom<S
  */
 export function annotateKey<S extends Top>(annotations: Annotations.Key<S["Type"]>) {
   return (self: S): S["Rebuild"] => {
-    return self.rebuild(AST.annotateKey(self.ast, annotations))
+    return self.rebuild(SchemaAST.annotateKey(self.ast, annotations))
   }
 }
 
@@ -633,7 +642,7 @@ export interface Top extends
     unknown,
     unknown,
     unknown,
-    AST.AST,
+    SchemaAST.AST,
     Top,
     unknown,
     unknown,
@@ -921,7 +930,7 @@ export {
    *
    * **Details**
    *
-   * The `issue` field contains a structured {@link Issue.Issue} tree describing
+   * 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.
@@ -1045,17 +1054,17 @@ function makeStandardResult<A>(exit: Exit_.Exit<StandardSchemaV1.Result<A>>): St
 export function toStandardSchemaV1<S extends Decoder<unknown>>(
   self: S,
   options?: {
-    readonly leafHook?: Issue.LeafHook | undefined
-    readonly checkHook?: Issue.CheckHook | undefined
-    readonly parseOptions?: AST.ParseOptions | undefined
+    readonly leafHook?: SchemaIssue.LeafHook | undefined
+    readonly checkHook?: SchemaIssue.CheckHook | undefined
+    readonly parseOptions?: SchemaAST.ParseOptions | undefined
   }
 ): StandardSchemaV1<S["Encoded"], S["Type"]> & S {
-  const decodeUnknownEffect = Parser.decodeUnknownEffect(self) as (
+  const decodeUnknownEffect = SchemaParser.decodeUnknownEffect(self) as (
     input: unknown,
-    options?: AST.ParseOptions
-  ) => Effect.Effect<S["Type"], Issue.Issue>
-  const parseOptions: AST.ParseOptions = { errors: "all", ...options?.parseOptions }
-  const formatter = Issue.makeFormatterStandardSchemaV1(options)
+    options?: SchemaAST.ParseOptions
+  ) => Effect.Effect<S["Type"], SchemaIssue.Issue>
+  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 fiber = Effect.runFork(
@@ -1177,7 +1186,7 @@ export function toStandardJSONSchemaV1<S extends Top>(self: S): StandardJSONSche
  * @category guards
  * @since 3.10.0
  */
-export const is = Parser.is
+export const is = SchemaParser.is
 
 /**
  * Creates an assertion function that throws an error if the input doesn't match
@@ -1186,7 +1195,7 @@ export const is = Parser.is
  * **When to use**
  *
  * Use to validate unknown input at runtime while narrowing the value with a
- * TypeScript `asserts` predicate.
+ * TypeScript assertion signature.
  *
  * **Details**
  *
@@ -1216,7 +1225,7 @@ export const is = Parser.is
  * @category guards
  * @since 4.0.0
  */
-export const asserts: <S extends Top, I>(schema: S, input: I) => asserts input is I & S["Type"] = Parser.asserts
+export const asserts: <S extends Top, I>(schema: S, input: I) => asserts input is I & S["Type"] = SchemaParser.asserts
 
 /**
  * Decodes an `unknown` input against a schema, returning an `Effect` that
@@ -1224,7 +1233,8 @@ export const asserts: <S extends Top, I>(schema: S, input: I) => asserts input i
  *
  * **When to use**
  *
- * Use when decoding input whose type is not statically known.
+ * Use when you need to decode unknown input in an `Effect` whose failure
+ * channel is `SchemaError`.
  *
  * **Details**
  *
@@ -1233,12 +1243,17 @@ export const asserts: <S extends Top, I>(schema: S, input: I) => asserts input i
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodeUnknownEffect} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 4.0.0
  */
-export function decodeUnknownEffect<S extends Top>(schema: S, options?: AST.ParseOptions) {
-  const parser = Parser.decodeUnknownEffect(schema, options)
-  return (input: unknown, options?: AST.ParseOptions): Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]> => {
+export function decodeUnknownEffect<S extends Top>(schema: S, options?: SchemaAST.ParseOptions) {
+  const parser = SchemaParser.decodeUnknownEffect(schema, options)
+  return (
+    input: unknown,
+    options?: SchemaAST.ParseOptions
+  ): Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]> => {
     return Effect.mapErrorEager(parser(input, options), (issue) => new SchemaError(issue))
   }
 }
@@ -1250,7 +1265,8 @@ export function decodeUnknownEffect<S extends Top>(schema: S, options?: AST.Pars
  *
  * **When to use**
  *
- * Use when the input is already typed as the schema's `Encoded` type.
+ * Use when you need to decode input already typed as the schema's `Encoded`
+ * type in an `Effect` whose failure channel is `SchemaError`.
  *
  * **Details**
  *
@@ -1258,14 +1274,18 @@ export function decodeUnknownEffect<S extends Top>(schema: S, options?: AST.Pars
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodeEffect} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 4.0.0
  */
 export const decodeEffect: <S extends Top>(
   schema: S,
-  options?: AST.ParseOptions
-) => (input: S["Encoded"], options?: AST.ParseOptions) => Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]> =
-  decodeUnknownEffect
+  options?: SchemaAST.ParseOptions
+) => (
+  input: S["Encoded"],
+  options?: SchemaAST.ParseOptions
+) => Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]> = decodeUnknownEffect
 
 /**
  * Decodes an `unknown` input against a schema synchronously, returning an
@@ -1274,8 +1294,8 @@ export const decodeEffect: <S extends Top>(
  *
  * **When to use**
  *
- * Use when the input type is not statically known and decoding should return an
- * `Exit` instead of failing or throwing.
+ * Use when you need to decode unknown input into an `Exit` whose failure
+ * contains `SchemaError`.
  *
  * **Details**
  *
@@ -1285,12 +1305,14 @@ export const decodeEffect: <S extends Top>(
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodeUnknownExit} for the adapter whose failure contains `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 4.0.0
  */
-export function decodeUnknownExit<S extends Decoder<unknown>>(schema: S, options?: AST.ParseOptions) {
-  const parser = Parser.decodeUnknownExit(schema, options)
-  return (input: unknown, options?: AST.ParseOptions): Exit_.Exit<S["Type"], SchemaError> => {
+export function decodeUnknownExit<S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) {
+  const parser = SchemaParser.decodeUnknownExit(schema, options)
+  return (input: unknown, options?: SchemaAST.ParseOptions): Exit_.Exit<S["Type"], SchemaError> => {
     return Exit_.mapError(parser(input, options), (issue) => new SchemaError(issue))
   }
 }
@@ -1302,8 +1324,8 @@ export function decodeUnknownExit<S extends Decoder<unknown>>(schema: S, options
  *
  * **When to use**
  *
- * Use when typed input should be decoded into an `Exit` instead of failing or
- * throwing.
+ * Use when you need to decode already typed `Encoded` input into an `Exit`
+ * whose failure contains `SchemaError`.
  *
  * **Details**
  *
@@ -1312,13 +1334,15 @@ export function decodeUnknownExit<S extends Decoder<unknown>>(schema: S, options
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodeExit} for the adapter whose failure contains `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 4.0.0
  */
 export const decodeExit: <S extends Decoder<unknown>>(
   schema: S,
-  options?: AST.ParseOptions
-) => (input: S["Encoded"], options?: AST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError> = decodeUnknownExit
+  options?: SchemaAST.ParseOptions
+) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError> = decodeUnknownExit
 
 /**
  * Decodes an `unknown` input against a schema, returning an `Option` that is
@@ -1326,20 +1350,24 @@ export const decodeExit: <S extends Decoder<unknown>>(
  *
  * **When to use**
  *
- * Use when the input type is not statically known and you only need to know
+ * Use when you do not know the input type statically and only need to know
  * whether decoding succeeded.
  *
  * **Details**
  *
  * Prefer this over {@link decodeUnknownExit} or {@link decodeUnknownEffect}
- * when you don't need error details. For typed input use {@link decodeOption}.
+ * when you don't need error details. For input already typed as the schema's
+ * `Encoded` type use {@link decodeOption}.
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
  * @category decoding
  * @since 3.10.0
  */
-export const decodeUnknownOption = Parser.decodeUnknownOption
+export const decodeUnknownOption: <S extends Decoder<unknown>>(
+  schema: S,
+  options?: SchemaAST.ParseOptions
+) => (input: unknown, options?: SchemaAST.ParseOptions) => Option_.Option<S["Type"]> = SchemaParser.decodeUnknownOption
 
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema,
@@ -1348,7 +1376,8 @@ export const decodeUnknownOption = Parser.decodeUnknownOption
  *
  * **When to use**
  *
- * Use when typed input should be decoded and only success or failure matters.
+ * Use when you already have input typed as the schema's `Encoded` type and
+ * only need to know whether decoding succeeded.
  *
  * **Details**
  *
@@ -1359,37 +1388,48 @@ export const decodeUnknownOption = Parser.decodeUnknownOption
  * @category decoding
  * @since 3.10.0
  */
-export const decodeOption = Parser.decodeOption
+export const decodeOption: <S extends Decoder<unknown>>(
+  schema: S,
+  options?: SchemaAST.ParseOptions
+) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Option_.Option<S["Type"]> = decodeUnknownOption
 
 /**
  * Decodes an `unknown` input against a schema, returning a `Result` that
- * succeeds with the decoded value or fails with a schema issue.
+ * succeeds with the decoded value or fails with a {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when the input type is not statically known and decoding should return a
- * `Result` with structured issue data.
+ * Use when you do not know the input type statically and want decoding to
+ * return a `Result` with `SchemaError` failure data.
  *
  * **Details**
  *
- * For typed input use {@link decodeResult}.
+ * For input already typed as the schema's `Encoded` type use
+ * {@link decodeResult}.
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodeUnknownResult} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 4.0.0
  */
-export const decodeUnknownResult = Parser.decodeUnknownResult
+export function decodeUnknownResult<S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) {
+  const parser = SchemaParser.decodeUnknownResult(schema, options)
+  return (input: unknown, options?: SchemaAST.ParseOptions): Result_.Result<S["Type"], SchemaError> => {
+    return Result_.mapError(parser(input, options), (issue) => new SchemaError(issue))
+  }
+}
 
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema,
  * returning a `Result` that succeeds with the decoded value or fails with a
- * schema issue.
+ * {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when typed input should be decoded into a `Result` with structured issue
- * data.
+ * Use when you already have input typed as the schema's `Encoded` type and
+ * want decoding to return a `Result` with `SchemaError` failure data.
  *
  * **Details**
  *
@@ -1397,38 +1437,55 @@ export const decodeUnknownResult = Parser.decodeUnknownResult
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodeResult} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 4.0.0
  */
-export const decodeResult = Parser.decodeResult
+export const decodeResult: <S extends Decoder<unknown>>(
+  schema: S,
+  options?: SchemaAST.ParseOptions
+) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Result_.Result<S["Type"], SchemaError> =
+  decodeUnknownResult
 
 /**
  * Decodes an `unknown` input against a schema, returning a `Promise` that
- * resolves with the decoded value or rejects with a schema issue.
+ * resolves with the decoded value or rejects with a {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when integrating unknown input validation with Promise-based APIs.
+ * Use when you need decoding of unknown input to return a JavaScript `Promise`
+ * that rejects with `SchemaError`.
  *
  * **Details**
  *
- * For typed input use {@link decodePromise}.
+ * For input already typed as the schema's `Encoded` type use
+ * {@link decodePromise}.
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodeUnknownPromise} for the adapter that rejects with `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 3.10.0
  */
-export const decodeUnknownPromise = Parser.decodeUnknownPromise
+export function decodeUnknownPromise<S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) {
+  const parser = decodeUnknownEffect(schema, options)
+  return (input: unknown, options?: SchemaAST.ParseOptions): Promise<S["Type"]> => {
+    return Effect.runPromise(parser(input, options))
+  }
+}
 
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema,
  * returning a `Promise` that resolves with the decoded value or rejects with a
- * schema issue.
+ * {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when integrating typed input decoding with Promise-based APIs.
+ * Use when you already have input typed as the schema's `Encoded` type and
+ * need decoding to return a JavaScript `Promise` that rejects with
+ * `SchemaError`.
  *
  * **Details**
  *
@@ -1436,23 +1493,28 @@ export const decodeUnknownPromise = Parser.decodeUnknownPromise
  * Options may be provided either when creating the decoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.decodePromise} for the adapter that rejects with `SchemaIssue.Issue` directly
+ *
  * @category decoding
  * @since 3.10.0
  */
-export const decodePromise = Parser.decodePromise
+export const decodePromise: <S extends Decoder<unknown>>(
+  schema: S,
+  options?: SchemaAST.ParseOptions
+) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Promise<S["Type"]> = decodeUnknownPromise
 
 /**
  * Decodes an `unknown` input against a schema synchronously, returning the
- * decoded value or throwing an `Error` whose cause contains the schema issue.
+ * decoded value or throwing a {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when validating unknown data at a boundary and treating schema mismatches
- * as exceptions.
+ * Use when you need to validate unknown data at a synchronous boundary and want
+ * schema mismatches to throw `SchemaError`.
  *
  * **Details**
  *
- * For typed input use `decodeSync`.
+ * For input already typed as the schema's `Encoded` type use `decodeSync`.
  * Only service-free schemas can be decoded synchronously. For non-throwing
  * alternatives see `decodeUnknownOption`, `decodeUnknownExit`, or
  * `decodeUnknownEffect`. Options may be provided either when creating the
@@ -1475,20 +1537,26 @@ export const decodePromise = Parser.decodePromise
  * //         └─ Expected a numeric string, actual "not a number"
  * ```
  *
+ * @see {@link SchemaParser.decodeUnknownSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`
+ *
  * @category decoding
  * @since 4.0.0
  */
-export const decodeUnknownSync = Parser.decodeUnknownSync
+export function decodeUnknownSync<S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) {
+  const parser = decodeUnknownEffect(schema, options)
+  return (input: unknown, options?: SchemaAST.ParseOptions): S["Type"] => {
+    return Effect.runSync(parser(input, options) as Effect.Effect<S["Type"], SchemaError>)
+  }
+}
 
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema
- * synchronously, returning the decoded value or throwing an `Error` whose cause
- * contains the schema issue.
+ * synchronously, returning the decoded value or throwing a {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when typed input should be decoded synchronously and schema mismatches
- * should throw.
+ * Use when you already have input typed as the schema's `Encoded` type and
+ * want schema mismatches to throw `SchemaError` synchronously.
  *
  * **Details**
  *
@@ -1497,10 +1565,15 @@ export const decodeUnknownSync = Parser.decodeUnknownSync
  * provided either when creating the decoder or when applying it; application
  * options override creation options.
  *
+ * @see {@link SchemaParser.decodeSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`
+ *
  * @category decoding
  * @since 4.0.0
  */
-export const decodeSync = Parser.decodeSync
+export const decodeSync: <S extends Decoder<unknown>>(
+  schema: S,
+  options?: SchemaAST.ParseOptions
+) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => S["Type"] = decodeUnknownSync
 
 /**
  * Encodes an `unknown` input against a schema, returning an `Effect` that
@@ -1508,11 +1581,12 @@ export const decodeSync = Parser.decodeSync
  *
  * **When to use**
  *
- * Use when encoding input whose type is not statically known.
+ * Use when you need to encode unknown input in an `Effect` whose failure
+ * channel is `SchemaError`.
  *
  * **Details**
  *
- * Prefer {@link encodeEffect} when the input is already typed as the schema's
+ * Prefer {@link encodeEffect} when the value is already typed as the schema's
  * `Type`.
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
@@ -1528,14 +1602,16 @@ export const decodeSync = Parser.decodeSync
  * // Output: "42"
  * ```
  *
+ * @see {@link SchemaParser.encodeUnknownEffect} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 4.0.0
  */
-export function encodeUnknownEffect<S extends Top>(schema: S, options?: AST.ParseOptions) {
-  const parser = Parser.encodeUnknownEffect(schema, options)
+export function encodeUnknownEffect<S extends Top>(schema: S, options?: SchemaAST.ParseOptions) {
+  const parser = SchemaParser.encodeUnknownEffect(schema, options)
   return (
     input: unknown,
-    options?: AST.ParseOptions
+    options?: SchemaAST.ParseOptions
   ): Effect.Effect<S["Encoded"], SchemaError, S["EncodingServices"]> => {
     return Effect.mapErrorEager(parser(input, options), (issue) => new SchemaError(issue))
   }
@@ -1548,7 +1624,8 @@ export function encodeUnknownEffect<S extends Top>(schema: S, options?: AST.Pars
  *
  * **When to use**
  *
- * Use when the input is already typed as the schema's `Type`.
+ * Use when you need to encode input already typed as the schema's `Type` in
+ * an `Effect` whose failure channel is `SchemaError`.
  *
  * **Details**
  *
@@ -1556,14 +1633,18 @@ export function encodeUnknownEffect<S extends Top>(schema: S, options?: AST.Pars
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodeEffect} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 4.0.0
  */
 export const encodeEffect: <S extends Top>(
   schema: S,
-  options?: AST.ParseOptions
-) => (input: S["Type"], options?: AST.ParseOptions) => Effect.Effect<S["Encoded"], SchemaError, S["EncodingServices"]> =
-  encodeUnknownEffect
+  options?: SchemaAST.ParseOptions
+) => (
+  input: S["Type"],
+  options?: SchemaAST.ParseOptions
+) => Effect.Effect<S["Encoded"], SchemaError, S["EncodingServices"]> = encodeUnknownEffect
 
 /**
  * Encodes an `unknown` input against a schema synchronously, returning an
@@ -1572,22 +1653,24 @@ export const encodeEffect: <S extends Top>(
  *
  * **When to use**
  *
- * Use when the input type is not statically known and encoding should return an
- * `Exit` instead of failing or throwing.
+ * Use when you need to encode unknown input into an `Exit` whose failure
+ * contains `SchemaError`.
  *
  * **Details**
  *
  * Only usable with schemas that have no `EncodingServices` requirement. Prefer
- * {@link encodeExit} when the input is already typed as the schema's `Type`.
+ * {@link encodeExit} when the value is already typed as the schema's `Type`.
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodeUnknownExit} for the adapter whose failure contains `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 4.0.0
  */
-export function encodeUnknownExit<S extends Encoder<unknown>>(schema: S, options?: AST.ParseOptions) {
-  const parser = Parser.encodeUnknownExit(schema, options)
-  return (input: unknown, options?: AST.ParseOptions): Exit_.Exit<S["Encoded"], SchemaError> => {
+export function encodeUnknownExit<S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) {
+  const parser = SchemaParser.encodeUnknownExit(schema, options)
+  return (input: unknown, options?: SchemaAST.ParseOptions): Exit_.Exit<S["Encoded"], SchemaError> => {
     return Exit_.mapError(parser(input, options), (issue) => new SchemaError(issue))
   }
 }
@@ -1599,8 +1682,8 @@ export function encodeUnknownExit<S extends Encoder<unknown>>(schema: S, options
  *
  * **When to use**
  *
- * Use when typed input should be encoded into an `Exit` instead of failing or
- * throwing.
+ * Use when you need to encode already typed schema values into an `Exit` whose
+ * failure contains `SchemaError`.
  *
  * **Details**
  *
@@ -1609,13 +1692,15 @@ export function encodeUnknownExit<S extends Encoder<unknown>>(schema: S, options
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodeExit} for the adapter whose failure contains `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 4.0.0
  */
 export const encodeExit: <S extends Encoder<unknown>>(
   schema: S,
-  options?: AST.ParseOptions
-) => (input: S["Type"], options?: AST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError> = encodeUnknownExit
+  options?: SchemaAST.ParseOptions
+) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError> = encodeUnknownExit
 
 /**
  * Encodes an `unknown` input against a schema, returning an `Option` that is
@@ -1623,20 +1708,25 @@ export const encodeExit: <S extends Encoder<unknown>>(
  *
  * **When to use**
  *
- * Use when the input type is not statically known and you only need to know
+ * Use when you do not know the input type statically and only need to know
  * whether encoding succeeded.
  *
  * **Details**
  *
  * Prefer this over {@link encodeUnknownExit} or {@link encodeUnknownEffect}
- * when you don't need error details. For typed input use {@link encodeOption}.
+ * when you don't need error details. For values already typed as the schema's
+ * `Type` use {@link encodeOption}.
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
  * @category encoding
  * @since 3.10.0
  */
-export const encodeUnknownOption = Parser.encodeUnknownOption
+export const encodeUnknownOption: <S extends Encoder<unknown>>(
+  schema: S,
+  options?: SchemaAST.ParseOptions
+) => (input: unknown, options?: SchemaAST.ParseOptions) => Option_.Option<S["Encoded"]> =
+  SchemaParser.encodeUnknownOption
 
 /**
  * Encodes a typed input (the schema's `Type`) against a schema, returning an
@@ -1645,7 +1735,8 @@ export const encodeUnknownOption = Parser.encodeUnknownOption
  *
  * **When to use**
  *
- * Use when typed input should be encoded and only success or failure matters.
+ * Use when you already have a value typed as the schema's `Type` and only need
+ * to know whether encoding succeeded.
  *
  * **Details**
  *
@@ -1656,36 +1747,47 @@ export const encodeUnknownOption = Parser.encodeUnknownOption
  * @category encoding
  * @since 3.10.0
  */
-export const encodeOption = Parser.encodeOption
+export const encodeOption: <S extends Encoder<unknown>>(
+  schema: S,
+  options?: SchemaAST.ParseOptions
+) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Option_.Option<S["Encoded"]> = encodeUnknownOption
 
 /**
  * Encodes an `unknown` input against a schema, returning a `Result` that
- * succeeds with the encoded value or fails with a schema issue.
+ * succeeds with the encoded value or fails with a {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when the input type is not statically known and encoding should return a
- * `Result` with structured issue data.
+ * Use when you do not know the input type statically and want encoding to
+ * return a `Result` with `SchemaError` failure data.
  *
  * **Details**
  *
- * For typed input use {@link encodeResult}.
+ * For values already typed as the schema's `Type` use {@link encodeResult}.
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodeUnknownResult} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 4.0.0
  */
-export const encodeUnknownResult = Parser.encodeUnknownResult
+export function encodeUnknownResult<S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) {
+  const parser = SchemaParser.encodeUnknownResult(schema, options)
+  return (input: unknown, options?: SchemaAST.ParseOptions): Result_.Result<S["Encoded"], SchemaError> => {
+    return Result_.mapError(parser(input, options), (issue) => new SchemaError(issue))
+  }
+}
 
 /**
  * Encodes a typed input (the schema's `Type`) against a schema, returning a
- * `Result` that succeeds with the encoded value or fails with a schema issue.
+ * `Result` that succeeds with the encoded value or fails with a
+ * {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when typed input should be encoded into a `Result` with structured issue
- * data.
+ * Use when you already have a value typed as the schema's `Type` and want
+ * encoding to return a `Result` with `SchemaError` failure data.
  *
  * **Details**
  *
@@ -1693,29 +1795,43 @@ export const encodeUnknownResult = Parser.encodeUnknownResult
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodeResult} for the adapter that fails with `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 4.0.0
  */
-export const encodeResult = Parser.encodeResult
+export const encodeResult: <S extends Encoder<unknown>>(
+  schema: S,
+  options?: SchemaAST.ParseOptions
+) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Result_.Result<S["Encoded"], SchemaError> =
+  encodeUnknownResult
 
 /**
  * Encodes an `unknown` input against a schema, returning a `Promise` that
- * resolves with the encoded value or rejects with a schema issue.
+ * resolves with the encoded value or rejects with a {@link SchemaError}.
  *
  * **When to use**
  *
- * Use when integrating unknown input serialization with Promise-based APIs.
+ * Use when you need encoding of unknown input to return a JavaScript `Promise`
+ * that rejects with `SchemaError`.
  *
  * **Details**
  *
- * For typed input use {@link encodePromise}.
+ * For values already typed as the schema's `Type` use {@link encodePromise}.
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodeUnknownPromise} for the adapter that rejects with `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 3.10.0
  */
-export const encodeUnknownPromise = Parser.encodeUnknownPromise
+export function encodeUnknownPromise<S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) {
+  const parser = encodeUnknownEffect(schema, options)
+  return (input: unknown, options?: SchemaAST.ParseOptions): Promise<S["Encoded"]> => {
+    return Effect.runPromise(parser(input, options))
+  }
+}
 
 /**
  * Encodes a typed input (the schema's `Type`) against a schema, returning a
@@ -1724,7 +1840,8 @@ export const encodeUnknownPromise = Parser.encodeUnknownPromise
  *
  * **When to use**
  *
- * Use when integrating typed input serialization with Promise-based APIs.
+ * Use when you already have a value typed as the schema's `Type` and need
+ * encoding to return a JavaScript `Promise` that rejects with `SchemaError`.
  *
  * **Details**
  *
@@ -1732,10 +1849,15 @@ export const encodeUnknownPromise = Parser.encodeUnknownPromise
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodePromise} for the adapter that rejects with `SchemaIssue.Issue` directly
+ *
  * @category encoding
  * @since 3.10.0
  */
-export const encodePromise = Parser.encodePromise
+export const encodePromise: <S extends Encoder<unknown>>(
+  schema: S,
+  options?: SchemaAST.ParseOptions
+) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Promise<S["Encoded"]> = encodeUnknownPromise
 
 /**
  * Encodes an `unknown` input against a schema synchronously, throwing a
@@ -1743,21 +1865,28 @@ export const encodePromise = Parser.encodePromise
  *
  * **When to use**
  *
- * Use when serializing unknown data at a boundary and treating schema
- * mismatches as unrecoverable errors.
+ * Use when you need to serialize unknown data at a synchronous boundary and
+ * want schema mismatches to throw `SchemaError`.
  *
  * **Details**
  *
  * For non-throwing alternatives see {@link encodeUnknownOption},
- * {@link encodeUnknownExit}, or {@link encodeUnknownEffect}. For typed input
- * use {@link encodeSync}.
+ * {@link encodeUnknownExit}, or {@link encodeUnknownEffect}. For values
+ * already typed as the schema's `Type` use {@link encodeSync}.
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodeUnknownSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`
+ *
  * @category encoding
  * @since 4.0.0
  */
-export const encodeUnknownSync = Parser.encodeUnknownSync
+export function encodeUnknownSync<S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) {
+  const parser = encodeUnknownEffect(schema, options)
+  return (input: unknown, options?: SchemaAST.ParseOptions): S["Encoded"] => {
+    return Effect.runSync(parser(input, options) as Effect.Effect<S["Encoded"], SchemaError>)
+  }
+}
 
 /**
  * Encodes a typed input (the schema's `Type`) against a schema synchronously,
@@ -1765,8 +1894,8 @@ export const encodeUnknownSync = Parser.encodeUnknownSync
  *
  * **When to use**
  *
- * Use when typed input should be encoded synchronously and schema mismatches
- * should throw.
+ * Use when you already have a value typed as the schema's `Type` and want
+ * schema mismatches to throw `SchemaError` synchronously.
  *
  * **Details**
  *
@@ -1774,10 +1903,15 @@ export const encodeUnknownSync = Parser.encodeUnknownSync
  * Options may be provided either when creating the encoder or when applying it;
  * application options override creation options.
  *
+ * @see {@link SchemaParser.encodeSync} for the adapter that throws an `Error` whose cause is `SchemaIssue.Issue`
+ *
  * @category encoding
  * @since 4.0.0
  */
-export const encodeSync = Parser.encodeSync
+export const encodeSync: <S extends Encoder<unknown>>(
+  schema: S,
+  options?: SchemaAST.ParseOptions
+) => (input: S["Type"], options?: SchemaAST.ParseOptions) => S["Encoded"] = encodeUnknownSync
 
 /**
  * Creates a schema from an AST (Abstract Syntax Tree) node.
@@ -1890,7 +2024,9 @@ interface optionalKeyLambda extends Lambda {
  * @category combinators
  * @since 4.0.0
  */
-export const optionalKey = Struct_.lambda<optionalKeyLambda>((schema) => make(AST.optionalKey(schema.ast), { schema }))
+export const optionalKey = Struct_.lambda<optionalKeyLambda>((schema) =>
+  make(SchemaAST.optionalKey(schema.ast), { schema })
+)
 
 interface requiredKeyLambda extends Lambda {
   <S extends Top>(self: optionalKey<S>): S
@@ -2020,7 +2156,9 @@ interface mutableKeyLambda extends Lambda {
  * @category combinators
  * @since 4.0.0
  */
-export const mutableKey = Struct_.lambda<mutableKeyLambda>((schema) => make(AST.mutableKey(schema.ast), { schema }))
+export const mutableKey = Struct_.lambda<mutableKeyLambda>((schema) =>
+  make(SchemaAST.mutableKey(schema.ast), { schema })
+)
 
 interface readonlyKeyLambda extends Lambda {
   <S extends Top>(self: mutableKey<S>): S
@@ -2079,7 +2217,7 @@ interface toTypeLambda extends Lambda {
  * @category transforming
  * @since 4.0.0
  */
-export const toType = Struct_.lambda<toTypeLambda>((schema) => make(AST.toType(schema.ast), { schema }))
+export const toType = Struct_.lambda<toTypeLambda>((schema) => make(SchemaAST.toType(schema.ast), { schema }))
 
 /**
  * Type-level representation returned by {@link toEncoded}.
@@ -2093,7 +2231,7 @@ export interface toEncoded<S extends Top> extends
     S["Encoded"],
     never,
     never,
-    AST.AST,
+    SchemaAST.AST,
     toEncoded<S>,
     S["Encoded"],
     S["Encoded"],
@@ -2119,7 +2257,7 @@ interface toEncodedLambda extends Lambda {
  * @category transforming
  * @since 4.0.0
  */
-export const toEncoded = Struct_.lambda<toEncodedLambda>((schema) => make(AST.toEncoded(schema.ast), { schema }))
+export const toEncoded = Struct_.lambda<toEncodedLambda>((schema) => make(SchemaAST.toEncoded(schema.ast), { schema }))
 
 const FlipTypeId = "~effect/Schema/flip"
 
@@ -2135,7 +2273,7 @@ export interface flip<S extends Top> extends
     S["Type"],
     S["EncodingServices"],
     S["DecodingServices"],
-    AST.AST,
+    SchemaAST.AST,
     flip<S>,
     S["Encoded"],
     S["Encoded"],
@@ -2183,9 +2321,9 @@ function isFlip$(schema: Top): schema is flip<any> {
 export function flip<S extends Top>(schema: S): S extends flip<infer F> ? F["Rebuild"] : flip<S>
 export function flip<S extends Top>(schema: S): flip<S> {
   if (isFlip$(schema)) {
-    return schema.schema.rebuild(AST.flip(schema.ast))
+    return schema.schema.rebuild(SchemaAST.flip(schema.ast))
   }
-  return make(AST.flip(schema.ast), { [FlipTypeId]: FlipTypeId, schema })
+  return make(SchemaAST.flip(schema.ast), { [FlipTypeId]: FlipTypeId, schema })
 }
 
 /**
@@ -2194,9 +2332,11 @@ export function flip<S extends Top>(schema: S): flip<S> {
  * @category models
  * @since 3.10.0
  */
-export interface Literal<L extends AST.LiteralValue> extends Bottom<L, L, never, never, AST.Literal, Literal<L>> {
+export interface Literal<L extends SchemaAST.LiteralValue>
+  extends Bottom<L, L, never, never, SchemaAST.Literal, Literal<L>>
+{
   readonly literal: L
-  transform<L2 extends AST.LiteralValue>(to: L2): decodeTo<Literal<L2>, Literal<L>>
+  transform<L2 extends SchemaAST.LiteralValue>(to: L2): decodeTo<Literal<L2>, Literal<L>>
 }
 
 /**
@@ -2217,13 +2357,13 @@ export interface Literal<L extends AST.LiteralValue> extends Bottom<L, L, never,
  * @category constructors
  * @since 3.10.0
  */
-export function Literal<L extends AST.LiteralValue>(literal: L): Literal<L> {
-  const out = make<Literal<L>>(new AST.Literal(literal), {
+export function Literal<L extends SchemaAST.LiteralValue>(literal: L): Literal<L> {
+  const out = make<Literal<L>>(new SchemaAST.Literal(literal), {
     literal,
-    transform<L2 extends AST.LiteralValue>(to: L2): decodeTo<Literal<L2>, Literal<L>> {
+    transform<L2 extends SchemaAST.LiteralValue>(to: L2): decodeTo<Literal<L2>, Literal<L>> {
       return out.pipe(decodeTo(Literal(to), {
-        decode: Getter.transform(() => to),
-        encode: Getter.transform(() => literal)
+        decode: SchemaGetter.transform(() => to),
+        encode: SchemaGetter.transform(() => literal)
       }))
     }
   })
@@ -2306,7 +2446,7 @@ export interface TemplateLiteral<Parts extends TemplateLiteral.Parts> extends
     TemplateLiteral.Encoded<Parts>,
     never,
     never,
-    AST.TemplateLiteral,
+    SchemaAST.TemplateLiteral,
     TemplateLiteral<Parts>
   >
 {
@@ -2314,13 +2454,18 @@ export interface TemplateLiteral<Parts extends TemplateLiteral.Parts> extends
 }
 
 function templateLiteralFromParts<Parts extends TemplateLiteral.Parts>(parts: Parts) {
-  return new AST.TemplateLiteral(parts.map((part) => isSchema(part) ? part.ast : new AST.Literal(part)))
+  return new SchemaAST.TemplateLiteral(parts.map((part) => isSchema(part) ? part.ast : new SchemaAST.Literal(part)))
 }
 
 /**
  * Creates a schema that validates strings matching a template literal pattern. Each part can be
  * a literal string/number/bigint or a schema whose encoded type is a string, number, or bigint.
  *
+ * **When to use**
+ *
+ * Use when the decoded value should remain the matched string and you do not
+ * need the individual template parts parsed into a tuple.
+ *
  * **Example** (URL path pattern)
  *
  * ```ts
@@ -2376,7 +2521,7 @@ export interface TemplateLiteralParser<Parts extends TemplateLiteral.Parts> exte
     TemplateLiteral.Encoded<Parts>,
     never,
     never,
-    AST.Arrays,
+    SchemaAST.Arrays,
     TemplateLiteralParser<Parts>
   >
 {
@@ -2422,7 +2567,7 @@ export function TemplateLiteralParser<const Parts extends TemplateLiteral.Parts>
  * @since 4.0.0
  */
 export interface Enum<A extends { [x: string]: string | number }>
-  extends Bottom<A[keyof A], A[keyof A], never, never, AST.Enum, Enum<A>>
+  extends Bottom<A[keyof A], A[keyof A], never, never, SchemaAST.Enum, Enum<A>>
 {
   readonly enums: A
 }
@@ -2449,7 +2594,7 @@ export interface Enum<A extends { [x: string]: string | number }>
  */
 export function Enum<A extends { [x: string]: string | number }>(enums: A): Enum<A> {
   return make(
-    new AST.Enum(
+    new SchemaAST.Enum(
       Object.keys(enums).filter(
         (key) => typeof enums[enums[key]] !== "number"
       ).map((key) => [key, enums[key]])
@@ -2464,7 +2609,7 @@ export function Enum<A extends { [x: string]: string | number }>(enums: A): Enum
  * @category models
  * @since 3.10.0
  */
-export interface Never extends Bottom<never, never, never, never, AST.Never, Never> {}
+export interface Never extends Bottom<never, never, never, never, SchemaAST.Never, Never> {}
 
 /**
  * Schema for the `never` type. Always fails validation — no value satisfies it.
@@ -2472,7 +2617,7 @@ export interface Never extends Bottom<never, never, never, never, AST.Never, Nev
  * @category schemas
  * @since 3.10.0
  */
-export const Never: Never = make(AST.never)
+export const Never: Never = make(SchemaAST.never)
 
 /**
  * Type-level representation of {@link Any}.
@@ -2480,7 +2625,7 @@ export const Never: Never = make(AST.never)
  * @category models
  * @since 3.10.0
  */
-export interface Any extends Bottom<any, any, never, never, AST.Any, Any> {}
+export interface Any extends Bottom<any, any, never, never, SchemaAST.Any, Any> {}
 
 /**
  * Schema for the `any` type. Accepts any value without validation.
@@ -2489,7 +2634,7 @@ export interface Any extends Bottom<any, any, never, never, AST.Any, Any> {}
  * @category schemas
  * @since 3.10.0
  */
-export const Any: Any = make(AST.any)
+export const Any: Any = make(SchemaAST.any)
 
 /**
  * Type-level representation of {@link Unknown}.
@@ -2497,16 +2642,21 @@ export const Any: Any = make(AST.any)
  * @category models
  * @since 3.10.0
  */
-export interface Unknown extends Bottom<unknown, unknown, never, never, AST.Unknown, Unknown> {}
+export interface Unknown extends Bottom<unknown, unknown, never, never, SchemaAST.Unknown, Unknown> {}
 
 /**
  * Schema for the `unknown` type. Accepts any value without validation.
  *
+ * **When to use**
+ *
+ * Use as a top schema when you need to accept any input while preserving
+ * TypeScript's `unknown` safety at use sites.
+ *
  * @see {@link Any} for the `any` variant.
  * @category schemas
  * @since 3.10.0
  */
-export const Unknown: Unknown = make(AST.unknown)
+export const Unknown: Unknown = make(SchemaAST.unknown)
 
 /**
  * Type-level representation of {@link Null}.
@@ -2514,7 +2664,7 @@ export const Unknown: Unknown = make(AST.unknown)
  * @category models
  * @since 3.10.0
  */
-export interface Null extends Bottom<null, null, never, never, AST.Null, Null> {}
+export interface Null extends Bottom<null, null, never, never, SchemaAST.Null, Null> {}
 
 /**
  * Schema for the `null` literal. Validates that the input is strictly `null`.
@@ -2523,7 +2673,7 @@ export interface Null extends Bottom<null, null, never, never, AST.Null, Null> {
  * @category schemas
  * @since 3.10.0
  */
-export const Null: Null = make(AST.null)
+export const Null: Null = make(SchemaAST.null)
 
 /**
  * Type-level representation of {@link Undefined}.
@@ -2531,7 +2681,7 @@ export const Null: Null = make(AST.null)
  * @category models
  * @since 3.10.0
  */
-export interface Undefined extends Bottom<undefined, undefined, never, never, AST.Undefined, Undefined> {}
+export interface Undefined extends Bottom<undefined, undefined, never, never, SchemaAST.Undefined, Undefined> {}
 
 /**
  * Schema for the `undefined` literal. Validates that the input is strictly `undefined`.
@@ -2540,7 +2690,7 @@ export interface Undefined extends Bottom<undefined, undefined, never, never, AS
  * @category schemas
  * @since 3.10.0
  */
-export const Undefined: Undefined = make(AST.undefined)
+export const Undefined: Undefined = make(SchemaAST.undefined)
 
 /**
  * Type-level representation of {@link String}.
@@ -2548,7 +2698,7 @@ export const Undefined: Undefined = make(AST.undefined)
  * @category models
  * @since 4.0.0
  */
-export interface String extends Bottom<string, string, never, never, AST.String, String> {}
+export interface String extends Bottom<string, string, never, never, SchemaAST.String, String> {}
 
 /**
  * Schema for `string` values. Validates that the input is `typeof` `"string"`.
@@ -2556,7 +2706,7 @@ export interface String extends Bottom<string, string, never, never, AST.String,
  * @category schemas
  * @since 4.0.0
  */
-export const String: String = make(AST.string)
+export const String: String = make(SchemaAST.string)
 
 /**
  * Type-level representation of {@link Number}.
@@ -2564,7 +2714,7 @@ export const String: String = make(AST.string)
  * @category models
  * @since 4.0.0
  */
-export interface Number extends Bottom<number, number, never, never, AST.Number, Number> {}
+export interface Number extends Bottom<number, number, never, never, SchemaAST.Number, Number> {}
 
 /**
  * Schema for `number` values, including `NaN`, `Infinity`, and `-Infinity`.
@@ -2580,7 +2730,7 @@ export interface Number extends Bottom<number, number, never, never, AST.Number,
  * @category schemas
  * @since 4.0.0
  */
-export const Number: Number = make(AST.number)
+export const Number: Number = make(SchemaAST.number)
 
 /**
  * Type-level representation of {@link Boolean}.
@@ -2588,7 +2738,7 @@ export const Number: Number = make(AST.number)
  * @category models
  * @since 4.0.0
  */
-export interface Boolean extends Bottom<boolean, boolean, never, never, AST.Boolean, Boolean> {}
+export interface Boolean extends Bottom<boolean, boolean, never, never, SchemaAST.Boolean, Boolean> {}
 
 /**
  * Schema for `boolean` values. Validates that the input is `typeof` `"boolean"`.
@@ -2602,7 +2752,7 @@ export interface Boolean extends Bottom<boolean, boolean, never, never, AST.Bool
  * @category boolean
  * @since 4.0.0
  */
-export const Boolean: Boolean = make(AST.boolean)
+export const Boolean: Boolean = make(SchemaAST.boolean)
 
 /**
  * Type-level representation of {@link Symbol}.
@@ -2610,7 +2760,7 @@ export const Boolean: Boolean = make(AST.boolean)
  * @category models
  * @since 4.0.0
  */
-export interface Symbol extends Bottom<symbol, symbol, never, never, AST.Symbol, Symbol> {}
+export interface Symbol extends Bottom<symbol, symbol, never, never, SchemaAST.Symbol, Symbol> {}
 
 /**
  * Schema for `symbol` values. Validates that the input is `typeof` `"symbol"`.
@@ -2619,7 +2769,7 @@ export interface Symbol extends Bottom<symbol, symbol, never, never, AST.Symbol,
  * @category schemas
  * @since 4.0.0
  */
-export const Symbol: Symbol = make(AST.symbol)
+export const Symbol: Symbol = make(SchemaAST.symbol)
 
 /**
  * Type-level representation of {@link BigInt}.
@@ -2627,7 +2777,7 @@ export const Symbol: Symbol = make(AST.symbol)
  * @category models
  * @since 4.0.0
  */
-export interface BigInt extends Bottom<bigint, bigint, never, never, AST.BigInt, BigInt> {}
+export interface BigInt extends Bottom<bigint, bigint, never, never, SchemaAST.BigInt, BigInt> {}
 
 /**
  * Schema for `bigint` values. Validates that the input is `typeof` `"bigint"`.
@@ -2642,7 +2792,7 @@ export interface BigInt extends Bottom<bigint, bigint, never, never, AST.BigInt,
  * @category schemas
  * @since 4.0.0
  */
-export const BigInt: BigInt = make(AST.bigInt)
+export const BigInt: BigInt = make(SchemaAST.bigInt)
 
 /**
  * Type-level representation of {@link Void}.
@@ -2650,7 +2800,7 @@ export const BigInt: BigInt = make(AST.bigInt)
  * @category models
  * @since 3.10.0
  */
-export interface Void extends Bottom<void, void, never, never, AST.Void, Void> {}
+export interface Void extends Bottom<void, void, never, never, SchemaAST.Void, Void> {}
 
 /**
  * Schema for the `void` type. Accepts `undefined` as the encoded value.
@@ -2658,7 +2808,7 @@ export interface Void extends Bottom<void, void, never, never, AST.Void, Void> {
  * @category schemas
  * @since 3.10.0
  */
-export const Void: Void = make(AST.void)
+export const Void: Void = make(SchemaAST.void)
 
 /**
  * Type-level representation of {@link ObjectKeyword}.
@@ -2666,7 +2816,7 @@ export const Void: Void = make(AST.void)
  * @category models
  * @since 4.0.0
  */
-export interface ObjectKeyword extends Bottom<object, object, never, never, AST.ObjectKeyword, ObjectKeyword> {}
+export interface ObjectKeyword extends Bottom<object, object, never, never, SchemaAST.ObjectKeyword, ObjectKeyword> {}
 
 /**
  * Schema for the `object` type. Validates that the input is a non-null object or function
@@ -2675,7 +2825,7 @@ export interface ObjectKeyword extends Bottom<object, object, never, never, AST.
  * @category schemas
  * @since 4.0.0
  */
-export const ObjectKeyword: ObjectKeyword = make(AST.objectKeyword)
+export const ObjectKeyword: ObjectKeyword = make(SchemaAST.objectKeyword)
 
 /**
  * Type-level representation returned by {@link UniqueSymbol}.
@@ -2684,7 +2834,7 @@ export const ObjectKeyword: ObjectKeyword = make(AST.objectKeyword)
  * @since 4.0.0
  */
 export interface UniqueSymbol<sym extends symbol>
-  extends Bottom<sym, sym, never, never, AST.UniqueSymbol, UniqueSymbol<sym>>
+  extends Bottom<sym, sym, never, never, SchemaAST.UniqueSymbol, UniqueSymbol<sym>>
 {}
 
 /**
@@ -2704,7 +2854,7 @@ export interface UniqueSymbol<sym extends symbol>
  * @since 4.0.0
  */
 export function UniqueSymbol<const sym extends symbol>(symbol: sym): UniqueSymbol<sym> {
-  return make(new AST.UniqueSymbol(symbol))
+  return make(new SchemaAST.UniqueSymbol(symbol))
 }
 
 /**
@@ -2880,7 +3030,7 @@ export interface Struct<Fields extends Struct.Fields> extends
     Struct.Encoded<Fields>,
     Struct.DecodingServices<Fields>,
     Struct.EncodingServices<Fields>,
-    AST.Objects,
+    SchemaAST.Objects,
     Struct<Fields>,
     Struct.MakeIn<Fields>,
     Struct.Iso<Fields>
@@ -2932,7 +3082,7 @@ export interface Struct<Fields extends Struct.Fields> extends
   ): Struct<Simplify<Readonly<To>>>
 }
 
-function makeStruct<const Fields extends Struct.Fields>(ast: AST.Objects, fields: Fields): Struct<Fields> {
+function makeStruct<const Fields extends Struct.Fields>(ast: SchemaAST.Objects, fields: Fields): Struct<Fields> {
   return make(ast, {
     fields,
     mapFields<To extends Struct.Fields>(
@@ -2943,7 +3093,7 @@ function makeStruct<const Fields extends Struct.Fields>(ast: AST.Objects, fields
       } | undefined
     ): Struct<To> {
       const fields = f(this.fields)
-      return makeStruct(AST.struct(fields, options?.unsafePreserveChecks ? this.ast.checks : undefined), fields)
+      return makeStruct(SchemaAST.struct(fields, options?.unsafePreserveChecks ? this.ast.checks : undefined), fields)
     }
   })
 }
@@ -2982,7 +3132,7 @@ function makeStruct<const Fields extends Struct.Fields>(ast: AST.Objects, fields
  * @since 3.10.0
  */
 export function Struct<const Fields extends Struct.Fields>(fields: Fields): Struct<Fields> {
-  return makeStruct(AST.struct(fields, undefined), fields)
+  return makeStruct(SchemaAST.struct(fields, undefined), fields)
 }
 
 interface fieldsAssign<NewFields extends Struct.Fields> extends Lambda {
@@ -2999,8 +3149,8 @@ interface fieldsAssign<NewFields extends Struct.Fields> extends Lambda {
  *
  * **When to use**
  *
- * Use to add the same fields to an existing struct or to every struct member of
- * a union.
+ * Use to add the same fields to an existing struct or every struct member of a
+ * union.
  *
  * **Details**
  *
@@ -3091,7 +3241,7 @@ export function encodeKeys<
     }
     return Struct(fields).pipe(decodeTo(
       self,
-      Transformation.transform<any, any>({
+      SchemaTransformation.transform<any, any>({
         decode: Struct_.renameKeys(reverseMapping),
         encode: Struct_.renameKeys(mapping)
       })
@@ -3143,7 +3293,7 @@ export function extendTo<S extends Struct<Struct.Fields>, const Fields extends S
     const to = Struct({ ...f, ...fields })
     return self.pipe(decodeTo(
       to,
-      Transformation.transform({
+      SchemaTransformation.transform({
         decode: (input) => {
           const out: any = { ...input }
           for (const k in fields) {
@@ -3302,7 +3452,7 @@ export interface $Record<Key extends Record.Key, Value extends Top> extends
     Record.Encoded<Key, Value>,
     Record.DecodingServices<Key, Value>,
     Record.EncodingServices<Key, Value>,
-    AST.Objects,
+    SchemaAST.Objects,
     $Record<Key, Value>,
     Simplify<Record.MakeIn<Key, Value>>,
     Record.Iso<Key, Value>
@@ -3344,9 +3494,9 @@ export function Record<Key extends Record.Key, Value extends Top>(
   }
 ): $Record<Key, Value> {
   const keyValueCombiner = options?.keyValueCombiner?.decode || options?.keyValueCombiner?.encode
-    ? new AST.KeyValueCombiner(options.keyValueCombiner.decode, options.keyValueCombiner.encode)
+    ? new SchemaAST.KeyValueCombiner(options.keyValueCombiner.decode, options.keyValueCombiner.encode)
     : undefined
-  return make(AST.record(key.ast, value.ast, keyValueCombiner), { key, value })
+  return make(SchemaAST.record(key.ast, value.ast, keyValueCombiner), { key, value })
 }
 
 /**
@@ -3367,7 +3517,7 @@ export declare namespace StructWithRest {
    * @category utility types
    * @since 4.0.0
    */
-  export type Objects = Top & { readonly ast: AST.Objects }
+  export type Objects = Top & { readonly ast: SchemaAST.Objects }
 
   /**
    * Readonly list of record schemas that provide the additional index signatures
@@ -3382,6 +3532,14 @@ export declare namespace StructWithRest {
     Head & MergeTuple<Tail>
     : {}
 
+  type Intersect<
+    S extends Objects,
+    Records extends StructWithRest.Records,
+    Side extends "Type" | "Iso" | "Encoded" | "~type.make"
+  > =
+    & S[Side]
+    & MergeTuple<{ readonly [K in keyof Records]: Records[K][Side] }>
+
   /**
    * Computes the decoded type for `StructWithRest` by intersecting the base object
    * schema's decoded `Type` with the decoded types of all rest record schemas.
@@ -3389,9 +3547,7 @@ export declare namespace StructWithRest {
    * @category utility types
    * @since 3.10.0
    */
-  export type Type<S extends Objects, Records extends StructWithRest.Records> =
-    & S["Type"]
-    & MergeTuple<{ readonly [K in keyof Records]: Records[K]["Type"] }>
+  export type Type<S extends Objects, Records extends StructWithRest.Records> = Intersect<S, Records, "Type">
 
   /**
    * Computes the iso type for `StructWithRest` by intersecting the base object
@@ -3400,9 +3556,7 @@ export declare namespace StructWithRest {
    * @category utility types
    * @since 4.0.0
    */
-  export type Iso<S extends Objects, Records extends StructWithRest.Records> =
-    & S["Iso"]
-    & MergeTuple<{ readonly [K in keyof Records]: Records[K]["Iso"] }>
+  export type Iso<S extends Objects, Records extends StructWithRest.Records> = Intersect<S, Records, "Iso">
 
   /**
    * Computes the encoded type for `StructWithRest` by intersecting the base object
@@ -3411,9 +3565,25 @@ export declare namespace StructWithRest {
    * @category utility types
    * @since 3.10.0
    */
-  export type Encoded<S extends Objects, Records extends StructWithRest.Records> =
-    & S["Encoded"]
-    & MergeTuple<{ readonly [K in keyof Records]: Records[K]["Encoded"] }>
+  export type Encoded<S extends Objects, Records extends StructWithRest.Records> = Intersect<S, Records, "Encoded">
+
+  /**
+   * Computes the input type accepted when constructing a `StructWithRest` value by
+   * intersecting the base object's make input with the make inputs of all rest
+   * record schemas.
+   *
+   * @category utility types
+   * @since 4.0.0
+   */
+  export type MakeIn<S extends Objects, Records extends StructWithRest.Records> = Intersect<S, Records, "~type.make">
+
+  type Services<
+    S extends Objects,
+    Records extends StructWithRest.Records,
+    Side extends "DecodingServices" | "EncodingServices"
+  > =
+    | S[Side]
+    | { [K in keyof Records]: Records[K][Side] }[number]
 
   /**
    * Union of the decoding service requirements of the base object schema and all
@@ -3422,9 +3592,11 @@ export declare namespace StructWithRest {
    * @category utility types
    * @since 4.0.0
    */
-  export type DecodingServices<S extends Objects, Records extends StructWithRest.Records> =
-    | S["DecodingServices"]
-    | { [K in keyof Records]: Records[K]["DecodingServices"] }[number]
+  export type DecodingServices<S extends Objects, Records extends StructWithRest.Records> = Services<
+    S,
+    Records,
+    "DecodingServices"
+  >
 
   /**
    * Union of the encoding service requirements of the base object schema and all
@@ -3433,21 +3605,43 @@ export declare namespace StructWithRest {
    * @category utility types
    * @since 4.0.0
    */
-  export type EncodingServices<S extends Objects, Records extends StructWithRest.Records> =
-    | S["EncodingServices"]
-    | { [K in keyof Records]: Records[K]["EncodingServices"] }[number]
+  export type EncodingServices<S extends Objects, Records extends StructWithRest.Records> = Services<
+    S,
+    Records,
+    "EncodingServices"
+  >
+
+  type IncompatibleKeys<A, B, OK extends (keyof A & keyof B) = Extract<keyof A, keyof B>> = {
+    [K in OK]: Required<Pick<A, K>>[K] extends B[K] ? never : K
+  }[OK]
+
+  type IncompatibleSideKeys<
+    S extends Objects,
+    Records extends StructWithRest.Records,
+    Side extends "Type" | "Encoded" | "Iso" | "~type.make"
+  > = {
+    [I in keyof Records]: Records[I][Side] extends object ? IncompatibleKeys<S[Side], Records[I][Side]> : never
+  }[number]
 
   /**
-   * Computes the input type accepted when constructing a `StructWithRest` value by
-   * intersecting the base object's make input with the make inputs of all rest
-   * record schemas.
+   * Validates that the records are compatible with the struct.
    *
    * @category utility types
    * @since 4.0.0
    */
-  export type MakeIn<S extends Objects, Records extends StructWithRest.Records> =
-    & S["~type.make"]
-    & MergeTuple<{ readonly [K in keyof Records]: Records[K]["~type.make"] }>
+  export type ValidateRecords<S extends Objects, Records extends StructWithRest.Records> = [
+    | IncompatibleSideKeys<S, Records, "Type">
+    | IncompatibleSideKeys<S, Records, "Encoded">
+    | IncompatibleSideKeys<S, Records, "Iso">
+    | IncompatibleSideKeys<S, Records, "~type.make">
+  ] extends [never] ? unknown
+    : {
+      "incompatible index signatures":
+        | IncompatibleSideKeys<S, Records, "Type">
+        | IncompatibleSideKeys<S, Records, "Encoded">
+        | IncompatibleSideKeys<S, Records, "Iso">
+        | IncompatibleSideKeys<S, Records, "~type.make">
+    }
 }
 
 /**
@@ -3465,7 +3659,7 @@ export interface StructWithRest<
     Simplify<StructWithRest.Encoded<S, Records>>,
     StructWithRest.DecodingServices<S, Records>,
     StructWithRest.EncodingServices<S, Records>,
-    AST.Objects,
+    SchemaAST.Objects,
     StructWithRest<S, Records>,
     Simplify<StructWithRest.MakeIn<S, Records>>,
     Simplify<StructWithRest.Iso<S, Records>>
@@ -3486,10 +3680,10 @@ export interface StructWithRest<
  *
  * const schema = Schema.StructWithRest(
  *   Schema.Struct({ id: Schema.Number }),
- *   [Schema.Record(Schema.String, Schema.String)]
+ *   [Schema.Record(Schema.String, Schema.Number)]
  * )
  *
- * // { readonly id: number } & { readonly [x: string]: string }
+ * // { readonly id: number, readonly [x: string]: number }
  * type T = typeof schema.Type
  * ```
  *
@@ -3501,9 +3695,9 @@ export function StructWithRest<
   const Records extends StructWithRest.Records
 >(
   schema: S,
-  records: Records
+  records: Records & StructWithRest.ValidateRecords<S, Records>
 ): StructWithRest<S, Records> {
-  return make(AST.structWithRest(schema.ast, records.map(AST.getAST)), { schema, records })
+  return make(SchemaAST.structWithRest(schema.ast, records.map(SchemaAST.getAST)), { schema, records })
 }
 
 /**
@@ -3649,7 +3843,7 @@ export interface Tuple<Elements extends Tuple.Elements> extends
     Tuple.Encoded<Elements>,
     Tuple.DecodingServices<Elements>,
     Tuple.EncodingServices<Elements>,
-    AST.Arrays,
+    SchemaAST.Arrays,
     Tuple<Elements>,
     Tuple.MakeIn<Elements>,
     Tuple.Iso<Elements>
@@ -3680,7 +3874,7 @@ export interface Tuple<Elements extends Tuple.Elements> extends
   ): Tuple<Simplify<Readonly<To>>>
 }
 
-function makeTuple<Elements extends Tuple.Elements>(ast: AST.Arrays, elements: Elements): Tuple<Elements> {
+function makeTuple<Elements extends Tuple.Elements>(ast: SchemaAST.Arrays, elements: Elements): Tuple<Elements> {
   return make(ast, {
     elements,
     mapElements<To extends Tuple.Elements>(
@@ -3691,7 +3885,7 @@ function makeTuple<Elements extends Tuple.Elements>(ast: AST.Arrays, elements: E
       } | undefined
     ): Tuple<Simplify<Readonly<To>>> {
       const elements = f(this.elements)
-      return makeTuple(AST.tuple(elements, options?.unsafePreserveChecks ? this.ast.checks : undefined), elements)
+      return makeTuple(SchemaAST.tuple(elements, options?.unsafePreserveChecks ? this.ast.checks : undefined), elements)
     }
   })
 }
@@ -3715,7 +3909,7 @@ function makeTuple<Elements extends Tuple.Elements>(ast: AST.Arrays, elements: E
  * @since 3.10.0
  */
 export function Tuple<const Elements extends ReadonlyArray<Top>>(elements: Elements): Tuple<Elements> {
-  return makeTuple(AST.tuple(elements), elements)
+  return makeTuple(SchemaAST.tuple(elements), elements)
 }
 
 /**
@@ -3741,7 +3935,7 @@ export declare namespace TupleWithRest {
   export type TupleType = Top & {
     readonly Type: ReadonlyArray<unknown>
     readonly Encoded: ReadonlyArray<unknown>
-    readonly ast: AST.Arrays
+    readonly ast: SchemaAST.Arrays
     readonly "~type.make": ReadonlyArray<unknown>
     readonly "Iso": ReadonlyArray<unknown>
   }
@@ -3855,7 +4049,7 @@ export interface TupleWithRest<
     TupleWithRest.Encoded<S["Encoded"], Rest>,
     S["DecodingServices"] | Rest[number]["DecodingServices"],
     S["EncodingServices"] | Rest[number]["EncodingServices"],
-    AST.Arrays,
+    SchemaAST.Arrays,
     TupleWithRest<S, Rest>,
     TupleWithRest.MakeIn<S["~type.make"], Rest>,
     TupleWithRest.Iso<S["Iso"], Rest>
@@ -3899,7 +4093,7 @@ export function TupleWithRest<S extends Tuple<Tuple.Elements>, const Rest extend
   schema: S,
   rest: Rest
 ): TupleWithRest<S, Rest> {
-  return make(AST.tupleWithRest(schema.ast, rest.map(AST.getAST)), { schema, rest })
+  return make(SchemaAST.tupleWithRest(schema.ast, rest.map(SchemaAST.getAST)), { schema, rest })
 }
 
 /**
@@ -3914,7 +4108,7 @@ export interface $Array<S extends Top> extends
     ReadonlyArray<S["Encoded"]>,
     S["DecodingServices"],
     S["EncodingServices"],
-    AST.Arrays,
+    SchemaAST.Arrays,
     $Array<S>,
     ReadonlyArray<S["~type.make"]>,
     ReadonlyArray<S["Iso"]>
@@ -3933,7 +4127,7 @@ interface ArrayLambda extends Lambda {
  * @since 4.0.0
  */
 const ArraySchema = Struct_.lambda<ArrayLambda>((schema) =>
-  make(new AST.Arrays(false, [], [schema.ast]), { value: schema })
+  make(new SchemaAST.Arrays(false, [], [schema.ast]), { value: schema })
 )
 
 export {
@@ -3970,7 +4164,7 @@ export interface NonEmptyArray<S extends Top> extends
     readonly [S["Encoded"], ...Array<S["Encoded"]>],
     S["DecodingServices"],
     S["EncodingServices"],
-    AST.Arrays,
+    SchemaAST.Arrays,
     NonEmptyArray<S>,
     readonly [S["~type.make"], ...Array<S["~type.make"]>],
     readonly [S["Iso"], ...Array<S["Iso"]>]
@@ -4003,7 +4197,7 @@ interface NonEmptyArrayLambda extends Lambda {
  * @since 3.10.0
  */
 export const NonEmptyArray = Struct_.lambda<NonEmptyArrayLambda>((schema) =>
-  make(new AST.Arrays(false, [schema.ast], [schema.ast]), { value: schema })
+  make(new SchemaAST.Arrays(false, [schema.ast], [schema.ast]), { value: schema })
 )
 
 /**
@@ -4045,7 +4239,7 @@ export interface ArrayEnsure<S extends Top> extends decodeTo<$Array<toType<S>>,
 export function ArrayEnsure<S extends Top>(schema: S): ArrayEnsure<S> {
   return Union([schema, ArraySchema(schema)]).pipe(decodeTo(
     ArraySchema(toType(schema)),
-    Transformation.transform({
+    SchemaTransformation.transform({
       decode: Arr.ensure,
       encode: (array) => array.length === 1 ? array[0] : array
     })
@@ -4083,7 +4277,7 @@ export function UniqueArray<S extends Top>(item: S): UniqueArray<S> {
  * @category transforming
  * @since 3.10.0
  */
-export interface mutable<S extends Top & { readonly "ast": AST.Arrays }> extends
+export interface mutable<S extends Top & { readonly "ast": SchemaAST.Arrays }> extends
   Bottom<
     Mutable<S["Type"]>,
     Mutable<S["Encoded"]>,
@@ -4107,8 +4301,9 @@ export interface mutable<S extends Top & { readonly "ast": AST.Arrays }> extends
 }
 
 interface mutableLambda extends Lambda {
-  <S extends Top & { readonly "ast": AST.Arrays }>(self: S): mutable<S>
-  readonly "~lambda.out": this["~lambda.in"] extends Top & { readonly "ast": AST.Arrays } ? mutable<this["~lambda.in"]>
+  <S extends Top & { readonly "ast": SchemaAST.Arrays }>(self: S): mutable<S>
+  readonly "~lambda.out": this["~lambda.in"] extends Top & { readonly "ast": SchemaAST.Arrays } ?
+    mutable<this["~lambda.in"]>
     : "Error: schema not eligible for mutable"
 }
 
@@ -4130,7 +4325,7 @@ interface mutableLambda extends Lambda {
  * @since 3.10.0
  */
 export const mutable = Struct_.lambda<mutableLambda>((schema) => {
-  return make(new AST.Arrays(true, schema.ast.elements, schema.ast.rest), { schema })
+  return make(new SchemaAST.Arrays(true, schema.ast.elements, schema.ast.rest), { schema })
 })
 
 /**
@@ -4145,7 +4340,7 @@ export interface Union<Members extends ReadonlyArray<Top>> extends
     { [K in keyof Members]: Members[K]["Encoded"] }[number],
     { [K in keyof Members]: Members[K]["DecodingServices"] }[number],
     { [K in keyof Members]: Members[K]["EncodingServices"] }[number],
-    AST.Union<{ [K in keyof Members]: Members[K]["ast"] }[number]>,
+    SchemaAST.Union<{ [K in keyof Members]: Members[K]["ast"] }[number]>,
     Union<Members>,
     { [K in keyof Members]: Members[K]["~type.make"] }[number],
     { [K in keyof Members]: Members[K]["Iso"] }[number]
@@ -4177,7 +4372,7 @@ export interface Union<Members extends ReadonlyArray<Top>> extends
 }
 
 function makeUnion<Members extends ReadonlyArray<Top>>(
-  ast: AST.Union<Members[number]["ast"]>,
+  ast: SchemaAST.Union<Members[number]["ast"]>,
   members: Members
 ): Union<Members> {
   return make(ast, {
@@ -4191,7 +4386,7 @@ function makeUnion<Members extends ReadonlyArray<Top>>(
     ): Union<Simplify<Readonly<To>>> {
       const members = f(this.members)
       return makeUnion(
-        AST.union(members, this.ast.mode, options?.unsafePreserveChecks ? this.ast.checks : undefined),
+        SchemaAST.union(members, this.ast.mode, options?.unsafePreserveChecks ? this.ast.checks : undefined),
         members
       )
     }
@@ -4226,7 +4421,7 @@ export function Union<const Members extends ReadonlyArray<Top>>(
   members: Members,
   options?: { mode?: "anyOf" | "oneOf" }
 ): Union<Members> {
-  return makeUnion(AST.union(members, options?.mode ?? "anyOf", undefined), members)
+  return makeUnion(SchemaAST.union(members, options?.mode ?? "anyOf", undefined), members)
 }
 
 /**
@@ -4235,8 +4430,8 @@ export function Union<const Members extends ReadonlyArray<Top>>(
  * @category models
  * @since 4.0.0
  */
-export interface Literals<L extends ReadonlyArray<AST.LiteralValue>>
-  extends Bottom<L[number], L[number], never, never, AST.Union<AST.Literal>, Literals<L>>
+export interface Literals<L extends ReadonlyArray<SchemaAST.LiteralValue>>
+  extends Bottom<L[number], L[number], never, never, SchemaAST.Union<SchemaAST.Literal>, Literals<L>>
 {
   readonly literals: L
   readonly members: { readonly [K in keyof L]: Literal<L[K]> }
@@ -4247,7 +4442,7 @@ export interface Literals<L extends ReadonlyArray<AST.LiteralValue>>
 
   pick<const L2 extends ReadonlyArray<L[number]>>(literals: L2): Literals<L2>
 
-  transform<const L2 extends { readonly [I in keyof L]: AST.LiteralValue }>(
+  transform<const L2 extends { readonly [I in keyof L]: SchemaAST.LiteralValue }>(
     to: L2
   ): Union<{ [I in keyof L]: decodeTo<Literal<L2[I]>, Literal<L[I]>> }>
 }
@@ -4268,9 +4463,9 @@ export interface Literals<L extends ReadonlyArray<AST.LiteralValue>>
  * @category constructors
  * @since 4.0.0
  */
-export function Literals<const L extends ReadonlyArray<AST.LiteralValue>>(literals: L): Literals<L> {
+export function Literals<const L extends ReadonlyArray<SchemaAST.LiteralValue>>(literals: L): Literals<L> {
   const members = literals.map(Literal) as { readonly [K in keyof L]: Literal<L[K]> }
-  return make(AST.union(members, "anyOf", undefined), {
+  return make(SchemaAST.union(members, "anyOf", undefined), {
     literals,
     members,
     mapMembers<To extends ReadonlyArray<Top>>(
@@ -4282,7 +4477,7 @@ export function Literals<const L extends ReadonlyArray<AST.LiteralValue>>(litera
     pick<const L2 extends ReadonlyArray<L[number]>>(literals: L2): Literals<L2> {
       return Literals(literals)
     },
-    transform<const L2 extends { readonly [I in keyof L]: AST.LiteralValue }>(
+    transform<const L2 extends { readonly [I in keyof L]: SchemaAST.LiteralValue }>(
       to: L2
     ): Union<{ [I in keyof L]: decodeTo<Literal<L2[I]>, Literal<L[I]>> }> {
       return Union(members.map((member, index) => member.transform(to[index]))) as any
@@ -4371,7 +4566,7 @@ export interface suspend<S extends Top> extends
     S["Encoded"],
     S["DecodingServices"],
     S["EncodingServices"],
-    AST.Suspend,
+    SchemaAST.Suspend,
     suspend<S>,
     S["~type.make.in"],
     S["Iso"],
@@ -4410,7 +4605,7 @@ export interface suspend<S extends Top> extends
  * @since 3.10.0
  */
 export function suspend<S extends Top>(f: () => S): suspend<S> {
-  return make(new AST.Suspend(() => f().ast))
+  return make(new SchemaAST.Suspend(() => f().ast))
 }
 
 /**
@@ -4430,7 +4625,9 @@ export function suspend<S extends Top>(f: () => S): suspend<S> {
  * @category filtering
  * @since 4.0.0
  */
-export function check<S extends Top>(...checks: readonly [AST.Check<S["Type"]>, ...Array<AST.Check<S["Type"]>>]) {
+export function check<S extends Top>(
+  ...checks: readonly [SchemaAST.Check<S["Type"]>, ...Array<SchemaAST.Check<S["Type"]>>]
+) {
   return (self: S): S["Rebuild"] => self.check(...checks)
 }
 
@@ -4482,7 +4679,7 @@ export function refine<S extends Top, T extends S["Type"]>(
   annotations?: Annotations.Filter
 ) {
   return (schema: S): refine<T, S> =>
-    make(AST.appendChecks(schema.ast, [AST.makeFilterByGuard(refinement, annotations)]), { schema })
+    make(SchemaAST.appendChecks(schema.ast, [SchemaAST.makeFilterByGuard(refinement, annotations)]), { schema })
 }
 
 type DistributeBrands<B> = UnionToIntersection<B extends infer U extends string ? Brand.Brand<U> : never>
@@ -4537,7 +4734,7 @@ export interface brand<S extends Top, B> extends
  */
 export function brand<B extends string>(identifier: B) {
   return <S extends Top>(schema: S): brand<S["Rebuild"], B> =>
-    make(AST.brand(schema.ast, identifier), { schema, identifier })
+    make(SchemaAST.brand(schema.ast, identifier), { schema, identifier })
 }
 
 /**
@@ -4610,13 +4807,13 @@ export interface middlewareDecoding<S extends Top, RD> extends
  */
 export function middlewareDecoding<S extends Top, RD>(
   decode: (
-    effect: Effect.Effect<Option_.Option<S["Type"]>, Issue.Issue, S["DecodingServices"]>,
-    options: AST.ParseOptions
-  ) => Effect.Effect<Option_.Option<S["Type"]>, Issue.Issue, RD>
+    effect: Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue, S["DecodingServices"]>,
+    options: SchemaAST.ParseOptions
+  ) => Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue, RD>
 ) {
   return (schema: S): middlewareDecoding<S, RD> =>
     make(
-      AST.middlewareDecoding(schema.ast, new Transformation.Middleware(decode, identity)),
+      SchemaAST.middlewareDecoding(schema.ast, new SchemaTransformation.Middleware(decode, identity)),
       { schema }
     )
 }
@@ -4676,13 +4873,13 @@ export interface middlewareEncoding<S extends Top, RE> extends
  */
 export function middlewareEncoding<S extends Top, RE>(
   encode: (
-    effect: Effect.Effect<Option_.Option<S["Encoded"]>, Issue.Issue, S["EncodingServices"]>,
-    options: AST.ParseOptions
-  ) => Effect.Effect<Option_.Option<S["Encoded"]>, Issue.Issue, RE>
+    effect: Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue, S["EncodingServices"]>,
+    options: SchemaAST.ParseOptions
+  ) => Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue, RE>
 ) {
   return (schema: S): middlewareEncoding<S, RE> =>
     make(
-      AST.middlewareEncoding(schema.ast, new Transformation.Middleware(identity, encode)),
+      SchemaAST.middlewareEncoding(schema.ast, new SchemaTransformation.Middleware(identity, encode)),
       { schema }
     )
 }
@@ -4710,7 +4907,7 @@ export function middlewareEncoding<S extends Top, RE>(
  * @since 4.0.0
  */
 export function catchDecoding<S extends Top>(
-  f: (issue: Issue.Issue) => Effect.Effect<Option_.Option<S["Type"]>, Issue.Issue>
+  f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue>
 ): (self: S) => S["Rebuild"] {
   return catchDecodingWithContext(f)
 }
@@ -4720,7 +4917,8 @@ export function catchDecoding<S extends Top>(
  *
  * **When to use**
  *
- * Use when decoding fallback logic needs services from the Effect context.
+ * Use when you need decoding fallback logic to require services from the Effect
+ * context.
  *
  * **Details**
  *
@@ -4735,7 +4933,7 @@ export function catchDecoding<S extends Top>(
  * @since 4.0.0
  */
 export function catchDecodingWithContext<S extends Top, R = never>(
-  f: (issue: Issue.Issue) => Effect.Effect<Option_.Option<S["Type"]>, Issue.Issue, R>
+  f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue, R>
 ) {
   return (self: S): middlewareDecoding<S, S["DecodingServices"] | R> =>
     self.pipe(middlewareDecoding(Effect.catchEager(f)))
@@ -4754,7 +4952,7 @@ export function catchDecodingWithContext<S extends Top, R = never>(
  * @since 4.0.0
  */
 export function catchEncoding<S extends Top>(
-  f: (issue: Issue.Issue) => Effect.Effect<Option_.Option<S["Encoded"]>, Issue.Issue>
+  f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue>
 ): (self: S) => S["Rebuild"] {
   return catchEncodingWithContext(f)
 }
@@ -4764,7 +4962,8 @@ export function catchEncoding<S extends Top>(
  *
  * **When to use**
  *
- * Use when encoding fallback logic needs services from the Effect context.
+ * Use when you need encoding fallback logic to require services from the Effect
+ * context.
  *
  * **Details**
  *
@@ -4779,7 +4978,7 @@ export function catchEncoding<S extends Top>(
  * @since 4.0.0
  */
 export function catchEncodingWithContext<S extends Top, R = never>(
-  f: (issue: Issue.Issue) => Effect.Effect<Option_.Option<S["Encoded"]>, Issue.Issue, R>
+  f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue, R>
 ) {
   return (self: S): middlewareEncoding<S, S["EncodingServices"] | R> =>
     self.pipe(middlewareEncoding(Effect.catchEager(f)))
@@ -4825,25 +5024,28 @@ export interface compose<To extends Top, From extends Top> extends decodeTo<To,
 /**
  * Creates a schema that transforms from a source schema to a target schema.
  *
+ * **When to use**
+ *
+ * Use when decoding should change the schema's decoded type or encoded shape,
+ * with an optional custom bidirectional transformation.
+ *
  * **Details**
  *
- * This is a curried function: call it with the target schema `to` (and optionally a transformation),
- * then call the returned function with the source schema `from`. The resulting schema decodes from
- * `From["Encoded"]` to `To["Type"]` and encodes from `To["Type"]` back to `From["Encoded"]`.
+ * Call it with the target schema `to` and then pipe the source schema `from`
+ * into the returned function. The resulting schema decodes from
+ * `From["Encoded"]` to `To["Type"]` and encodes from `To["Type"]` back to
+ * `From["Encoded"]`.
+ *
+ * When no transformation is provided, `SchemaTransformation.passthrough()` is
+ * used, so `From["Type"]` must already be compatible with `To["Encoded"]`.
+ * The resulting schema combines decoding and encoding services from both
+ * schemas and any custom transformation.
  *
- * Key guarantees:
- * - Resulting schema has `Type = To["Type"]` and `Encoded = From["Encoded"]`
- * - When `transformation` is omitted, uses `Transformation.passthrough()` (schema composition)
- * - Combines decoding/encoding services from both `from` and `to` schemas
- * - Transformation `decode` maps `From["Type"]` → `To["Encoded"]` (used during encoding)
- * - Transformation `encode` maps `To["Encoded"]` → `From["Type"]` (used during decoding)
+ * **Gotchas**
  *
- * Common mistakes:
- * - **Direction confusion**: Remember `to` is the target (what you decode TO), `from` is the source (what you decode FROM)
- * - **Currying**: This is curried - must use pipe: `from.pipe(Schema.decodeTo(to))`
- * - **Transformation direction**: `decode` goes `From["Type"]` → `To["Encoded"]`, `encode` goes `To["Encoded"]` → `From["Type"]`
- * - **Passthrough assumption**: Without transformation, schemas must satisfy `To["Encoded"] === From["Type"]` or use passthrough helpers
- * - **Service dependencies**: Resulting schema requires services from both schemas; use `Schema.provideService` if needed
+ * In a custom transformation, `decode` maps `From["Type"]` to `To["Encoded"]`
+ * and is used on the encoding path, while `encode` maps `To["Encoded"]` to
+ * `From["Type"]` and is used on the decoding path.
  *
  * **Example** (String to Number with transformation)
  *
@@ -4871,23 +5073,23 @@ export function decodeTo<To extends Top>(to: To): <From extends Top>(from: From)
 export function decodeTo<To extends Top, From extends Top, RD = never, RE = never>(
   to: To,
   transformation: {
-    readonly decode: Getter.Getter<NoInfer<To["Encoded"]>, NoInfer<From["Type"]>, RD>
-    readonly encode: Getter.Getter<NoInfer<From["Type"]>, NoInfer<To["Encoded"]>, RE>
+    readonly decode: SchemaGetter.Getter<NoInfer<To["Encoded"]>, NoInfer<From["Type"]>, RD>
+    readonly encode: SchemaGetter.Getter<NoInfer<From["Type"]>, NoInfer<To["Encoded"]>, RE>
   }
 ): (from: From) => decodeTo<To, From, RD, RE>
 export function decodeTo<To extends Top, From extends Top, RD = never, RE = never>(
   to: To,
   transformation?: {
-    readonly decode: Getter.Getter<To["Encoded"], From["Type"], RD>
-    readonly encode: Getter.Getter<From["Type"], To["Encoded"], RE>
+    readonly decode: SchemaGetter.Getter<To["Encoded"], From["Type"], RD>
+    readonly encode: SchemaGetter.Getter<From["Type"], To["Encoded"], RE>
   } | undefined
 ) {
   return (from: From) => {
     return make(
-      AST.decodeTo(
+      SchemaAST.decodeTo(
         from.ast,
         to.ast,
-        transformation ? Transformation.make(transformation) : Transformation.passthrough()
+        transformation ? SchemaTransformation.make(transformation) : SchemaTransformation.passthrough()
       ),
       {
         from,
@@ -4900,23 +5102,26 @@ export function decodeTo<To extends Top, From extends Top, RD = never, RE = neve
 /**
  * Applies a transformation to a schema, creating a new schema with the same type but transformed encoding/decoding.
  *
+ * **When to use**
+ *
+ * Use when the decoded type stays the same and the transformation only
+ * normalizes values during encoding and decoding.
+ *
  * **Details**
  *
- * This is a curried function: call it with a transformation object, then call the returned function with a schema.
- * The resulting schema has `Type = S["Type"]` and `Encoded = S["Encoded"]`, with the transformation applied during
- * encoding and decoding operations.
+ * Call it with a transformation object and then pipe a schema into the returned
+ * function. The resulting schema keeps the same `Type` and `Encoded` types as
+ * the source schema, while applying the transformation during both decoding and
+ * encoding.
+ *
+ * Internally this uses `toType(self)` as the target schema and combines service
+ * requirements from the source schema and the transformation.
  *
- * Key guarantees:
- * - Resulting schema has `Type = S["Type"]` and `Encoded = S["Encoded"]`
- * - Uses `toType(self)` as the target schema internally (creates a schema where both Type and Encoded are `S["Type"]`)
- * - Combines decoding/encoding services from the source schema and transformation
- * - Transformation `decode` maps `S["Type"]` → `S["Type"]` (used during encoding)
- * - Transformation `encode` maps `S["Type"]` → `S["Type"]` (used during decoding)
+ * **Gotchas**
  *
- * Common mistakes:
- * - **Currying**: This is curried - must use pipe: `schema.pipe(Schema.decode(transformation))`
- * - **Transformation direction**: `decode` and `encode` both operate on `S["Type"]` (same type, different values)
- * - **Service dependencies**: Resulting schema requires services from the source schema and transformation; use `Schema.provideService` if needed
+ * Use {@link decodeTo} instead when the transformation should change the
+ * decoded type. For this helper, both transformation getters operate on
+ * `S["Type"]` values.
  *
  * **Example** (Trimming string values during encoding/decoding)
  *
@@ -4938,8 +5143,8 @@ export function decodeTo<To extends Top, From extends Top, RD = never, RE = neve
  * @since 3.10.0
  */
 export function decode<S extends Top, RD = never, RE = never>(transformation: {
-  readonly decode: Getter.Getter<S["Type"], S["Type"], RD>
-  readonly encode: Getter.Getter<S["Type"], S["Type"], RE>
+  readonly decode: SchemaGetter.Getter<S["Type"], S["Type"], RD>
+  readonly encode: SchemaGetter.Getter<S["Type"], S["Type"], RE>
 }) {
   return (self: S): decodeTo<toType<S>, S, RD, RE> => {
     return self.pipe(decodeTo(toType(self), transformation))
@@ -4981,15 +5186,15 @@ export function encodeTo<To extends Top>(
 export function encodeTo<To extends Top, From extends Top, RD = never, RE = never>(
   to: To,
   transformation: {
-    readonly decode: Getter.Getter<NoInfer<From["Encoded"]>, NoInfer<To["Type"]>, RD>
-    readonly encode: Getter.Getter<NoInfer<To["Type"]>, NoInfer<From["Encoded"]>, RE>
+    readonly decode: SchemaGetter.Getter<NoInfer<From["Encoded"]>, NoInfer<To["Type"]>, RD>
+    readonly encode: SchemaGetter.Getter<NoInfer<To["Type"]>, NoInfer<From["Encoded"]>, RE>
   }
 ): (from: From) => decodeTo<From, To, RD, RE>
 export function encodeTo<To extends Top, From extends Top, RD = never, RE = never>(
   to: To,
   transformation?: {
-    readonly decode: Getter.Getter<From["Encoded"], To["Type"], RD>
-    readonly encode: Getter.Getter<To["Type"], From["Encoded"], RE>
+    readonly decode: SchemaGetter.Getter<From["Encoded"], To["Type"], RD>
+    readonly encode: SchemaGetter.Getter<To["Type"], From["Encoded"], RE>
   }
 ) {
   return (from: From): decodeTo<From, To, RD, RE> => {
@@ -5025,8 +5230,8 @@ export function encodeTo<To extends Top, From extends Top, RD = never, RE = neve
  * @since 3.10.0
  */
 export function encode<S extends Top, RD = never, RE = never>(transformation: {
-  readonly decode: Getter.Getter<S["Encoded"], S["Encoded"], RD>
-  readonly encode: Getter.Getter<S["Encoded"], S["Encoded"], RE>
+  readonly decode: SchemaGetter.Getter<S["Encoded"], S["Encoded"], RD>
+  readonly encode: SchemaGetter.Getter<S["Encoded"], S["Encoded"], RE>
 }) {
   return (self: S): decodeTo<S, toEncoded<S>, RD, RE> => {
     return toEncoded(self).pipe(decodeTo(self, transformation))
@@ -5108,7 +5313,7 @@ export function withConstructorDefault<S extends Top & WithoutConstructorDefault
   defaultValue: Effect.Effect<S["~type.make.in"], SchemaError>
 ) {
   return (schema: S): withConstructorDefault<S> =>
-    make(AST.withConstructorDefault(schema.ast, Effect.mapErrorEager(defaultValue, (e) => e.issue)), { schema })
+    make(SchemaAST.withConstructorDefault(schema.ast, Effect.mapErrorEager(defaultValue, (e) => e.issue)), { schema })
 }
 
 /**
@@ -5175,10 +5380,10 @@ export function withDecodingDefaultKey<S extends Top, R = never>(
   defaultValue: Effect.Effect<S["Encoded"], SchemaError, R>,
   options?: DecodingDefaultOptions
 ) {
-  const encode = options?.encodingStrategy === "omit" ? Getter.omit() : Getter.passthrough()
+  const encode = options?.encodingStrategy === "omit" ? SchemaGetter.omit() : SchemaGetter.passthrough()
   return (self: S): withDecodingDefaultKey<S, R> => {
     return optionalKey(toEncoded(self)).pipe(decodeTo(self, {
-      decode: Getter.withDefault(Effect.mapErrorEager(defaultValue, (e) => e.issue)),
+      decode: SchemaGetter.withDefault(Effect.mapErrorEager(defaultValue, (e) => e.issue)),
       encode
     }))
   }
@@ -5245,6 +5450,11 @@ export interface withDecodingDefault<S extends Top, R = never> extends decodeTo<
  * and provides a default `Encoded` value when the field is missing or
  * `undefined` during decoding.
  *
+ * **When to use**
+ *
+ * Use when the default is expressed in the encoded representation, before the
+ * field's decoding transformation runs.
+ *
  * **Details**
  *
  * The default value is specified in terms of the `Encoded` type (before any
@@ -5278,10 +5488,10 @@ export function withDecodingDefault<S extends Top, R = never>(
   defaultValue: Effect.Effect<S["Encoded"], SchemaError, R>,
   options?: DecodingDefaultOptions
 ) {
-  const encode = options?.encodingStrategy === "omit" ? Getter.omit() : Getter.passthrough()
+  const encode = options?.encodingStrategy === "omit" ? SchemaGetter.omit() : SchemaGetter.passthrough()
   return (self: S): withDecodingDefault<S, R> => {
     return optional(toEncoded(self)).pipe(decodeTo(self, {
-      decode: Getter.withDefault(Effect.mapErrorEager(defaultValue, (e) => e.issue)),
+      decode: SchemaGetter.withDefault(Effect.mapErrorEager(defaultValue, (e) => e.issue)),
       encode
     }))
   }
@@ -5304,6 +5514,11 @@ export interface withDecodingDefaultType<S extends Top, R = never>
  * and provides a default `Type` value when the field is missing or
  * `undefined` during decoding.
  *
+ * **When to use**
+ *
+ * Use when the default is already in the decoded representation and should not
+ * pass through the field's decoding transformation.
+ *
  * **Details**
  *
  * Unlike {@link withDecodingDefault}, the default value is specified in terms
@@ -5339,7 +5554,7 @@ export function withDecodingDefaultType<S extends Top, R = never>(
  * @category constructors
  * @since 3.10.0
  */
-export interface tag<Tag extends AST.LiteralValue> extends withConstructorDefault<Literal<Tag>> {}
+export interface tag<Tag extends SchemaAST.LiteralValue> extends withConstructorDefault<Literal<Tag>> {}
 
 /**
  * Combines a {@link Literal} schema with {@link withConstructorDefault}, making it ideal
@@ -5363,7 +5578,7 @@ export interface tag<Tag extends AST.LiteralValue> extends withConstructorDefaul
  * @category constructors
  * @since 3.10.0
  */
-export function tag<Tag extends AST.LiteralValue>(literal: Tag): tag<Tag> {
+export function tag<Tag extends SchemaAST.LiteralValue>(literal: Tag): tag<Tag> {
   return Literal(literal).pipe(withConstructorDefault(Effect.succeed(literal)))
 }
 
@@ -5399,7 +5614,7 @@ export function tag<Tag extends AST.LiteralValue>(literal: Tag): tag<Tag> {
  * @category constructors
  * @since 4.0.0
  */
-export function tagDefaultOmit<Tag extends AST.LiteralValue>(literal: Tag) {
+export function tagDefaultOmit<Tag extends SchemaAST.LiteralValue>(literal: Tag) {
   return tag(literal).pipe(withDecodingDefaultKey(Effect.succeed(literal), { encodingStrategy: "omit" }))
 }
 
@@ -5409,7 +5624,7 @@ export function tagDefaultOmit<Tag extends AST.LiteralValue>(literal: Tag) {
  * @category models
  * @since 3.10.0
  */
-export type TaggedStruct<Tag extends AST.LiteralValue, Fields extends Struct.Fields> = Struct<
+export type TaggedStruct<Tag extends SchemaAST.LiteralValue, Fields extends Struct.Fields> = Struct<
   Simplify<{ readonly _tag: tag<Tag> } & Fields>
 >
 
@@ -5459,7 +5674,7 @@ export type TaggedStruct<Tag extends AST.LiteralValue, Fields extends Struct.Fie
  * @category constructors
  * @since 3.10.0
  */
-export function TaggedStruct<const Tag extends AST.LiteralValue, const Fields extends Struct.Fields>(
+export function TaggedStruct<const Tag extends SchemaAST.LiteralValue, const Fields extends Struct.Fields>(
   value: Tag,
   fields: Fields
 ): TaggedStruct<Tag, Fields> {
@@ -5554,13 +5769,13 @@ export function toTaggedUnion<const Tag extends PropertyKey>(tag: Tag) {
       const ast = schema.ast
 
       if (
-        AST.isUnion(ast) && "members" in schema && globalThis.Array.isArray(schema.members) &&
+        SchemaAST.isUnion(ast) && "members" in schema && globalThis.Array.isArray(schema.members) &&
         schema.members.every(isSchema)
       ) {
         return schema.members.forEach(walk)
       }
 
-      const sentinels = AST.collectSentinels(ast)
+      const sentinels = SchemaAST.collectSentinels(ast)
       if (sentinels.length > 0) {
         const literal = sentinels.find((s) => s.key === tag)?.literal
         if (Predicate.isPropertyKey(literal)) {
@@ -5599,7 +5814,7 @@ export interface TaggedUnion<Cases extends Record<string, Top>> extends
     { [K in keyof Cases]: Cases[K]["Encoded"] }[keyof Cases],
     { [K in keyof Cases]: Cases[K]["DecodingServices"] }[keyof Cases],
     { [K in keyof Cases]: Cases[K]["EncodingServices"] }[keyof Cases],
-    AST.Union<AST.Objects>,
+    SchemaAST.Union<SchemaAST.Objects>,
     TaggedUnion<Cases>,
     { [K in keyof Cases]: Cases[K]["~type.make"] }[keyof Cases]
   >
@@ -5755,7 +5970,7 @@ export function instanceOf<C extends abstract new(...args: any) => any, Iso = In
 }
 
 /**
- * Constructs an `AST.Link` that describes how a value of type `T` encodes to and decodes from a `To` schema.
+ * Constructs an `SchemaAST.Link` that describes how a value of type `T` encodes to and decodes from a `To` schema.
  * Used when building low-level AST transformations that bridge two schema types.
  *
  * @category transforming
@@ -5765,11 +5980,11 @@ export function link<T>() {
   return <To extends Top>(
     encodeTo: To,
     transformation: {
-      readonly decode: Getter.Getter<T, NoInfer<To["Type"]>>
-      readonly encode: Getter.Getter<NoInfer<To["Type"]>, T>
+      readonly decode: SchemaGetter.Getter<T, NoInfer<To["Type"]>>
+      readonly encode: SchemaGetter.Getter<NoInfer<To["Type"]>, T>
     }
-  ): AST.Link => {
-    return new AST.Link(encodeTo.ast, Transformation.make(transformation))
+  ): SchemaAST.Link => {
+    return new SchemaAST.Link(encodeTo.ast, SchemaTransformation.make(transformation))
   }
 }
 
@@ -5836,10 +6051,10 @@ export function link<T>() {
  * @since 4.0.0
  */
 export const makeFilter: <T>(
-  filter: (input: T, ast: AST.AST, options: AST.ParseOptions) => FilterOutput,
+  filter: (input: T, ast: SchemaAST.AST, options: SchemaAST.ParseOptions) => FilterOutput,
   annotations?: Annotations.Filter | undefined,
   abort?: boolean
-) => AST.Filter<T> = AST.makeFilter
+) => SchemaAST.Filter<T> = SchemaAST.makeFilter
 
 /**
  * A single failure reported by a filter predicate. Used as the element type
@@ -5848,20 +6063,20 @@ export const makeFilter: <T>(
  * **Details**
  *
  * - `string`: failure with that string as the message. Produces an
- *   {@link Issue.InvalidValue} wrapping the input, with the string used as
+ *   {@link SchemaIssue.InvalidValue} wrapping the input, with the string used as
  *   the issue's `message` annotation.
- * - {@link Issue.Issue}: a fully-formed issue, returned as-is.
+ * - {@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 Issue.InvalidValue}) or a full
- *   {@link Issue.Issue}; the result is wrapped in an {@link Issue.Pointer}
+ *   a `string` (wrapped in an {@link SchemaIssue.InvalidValue}) or a full
+ *   {@link SchemaIssue.Issue}; the result is wrapped in an {@link SchemaIssue.Pointer}
  *   at the given `path`.
  *
  * @category models
  * @since 3.10.0
  */
-export type FilterIssue = string | Issue.Issue | {
+export type FilterIssue = string | SchemaIssue.Issue | {
   readonly path: ReadonlyArray<PropertyKey>
-  readonly issue: string | Issue.Issue
+  readonly issue: string | SchemaIssue.Issue
 }
 
 /**
@@ -5869,20 +6084,20 @@ export type FilterIssue = string | Issue.Issue | {
  *
  * **Details**
  *
- * Each shape is normalized into an {@link Issue.Issue} (or `undefined` for
+ * Each shape is normalized into an {@link SchemaIssue.Issue} (or `undefined` for
  * success) before being attached to the parse result:
  *
  * - `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 Issue.InvalidValue} wrapping
+ * - `false`: generic failure. Produces an {@link SchemaIssue.InvalidValue} wrapping
  *   the input, with no custom message.
  * - {@link FilterIssue}: a single failure. See {@link FilterIssue} for the
- *   shapes (`string`, {@link Issue.Issue}, or `{ path, issue }`).
+ *   shapes (`string`, {@link SchemaIssue.Issue}, or `{ path, issue }`).
  * - `ReadonlyArray<FilterIssue>`: several failures reported together. An
  *   empty array is treated as success; a single-element array is equivalent
  *   to returning that element directly; otherwise the entries are grouped
- *   into an {@link Issue.Composite}.
+ *   into an {@link SchemaIssue.Composite}.
  *
  * @category models
  * @since 3.10.0
@@ -5894,17 +6109,17 @@ export type FilterOutput =
   | ReadonlyArray<FilterIssue>
 
 /**
- * Groups multiple checks into a single {@link AST.FilterGroup}, applying
+ * Groups multiple checks into a single {@link SchemaAST.FilterGroup}, applying
  * optional shared annotations to the group as a whole.
  *
  * @category constructors
  * @since 4.0.0
  */
 export function makeFilterGroup<T>(
-  checks: readonly [AST.Check<T>, ...Array<AST.Check<T>>],
+  checks: readonly [SchemaAST.Check<T>, ...Array<SchemaAST.Check<T>>],
   annotations: Annotations.Filter | undefined = undefined
-): AST.FilterGroup<T> {
-  return new AST.FilterGroup(checks, annotations)
+): SchemaAST.FilterGroup<T> {
+  return new SchemaAST.FilterGroup(checks, annotations)
 }
 
 const TRIMMED_PATTERN = "^\\S[\\s\\S]*\\S$|^\\S$|^$"
@@ -5963,8 +6178,8 @@ export function isTrimmed(annotations?: Annotations.Filter) {
  * @category String checks
  * @since 4.0.0
  */
-export const isPattern: (regExp: globalThis.RegExp, annotations?: Annotations.Filter) => AST.Filter<string> =
-  AST.isPattern
+export const isPattern: (regExp: globalThis.RegExp, annotations?: Annotations.Filter) => SchemaAST.Filter<string> =
+  SchemaAST.isPattern
 
 /**
  * Validates that a string represents a finite number.
@@ -5984,7 +6199,7 @@ export const isPattern: (regExp: globalThis.RegExp, annotations?: Annotations.Fi
  * @category String checks
  * @since 4.0.0
  */
-export const isStringFinite: (annotations?: Annotations.Filter) => AST.Filter<string> = AST.isStringFinite
+export const isStringFinite: (annotations?: Annotations.Filter) => SchemaAST.Filter<string> = SchemaAST.isStringFinite
 
 /**
  * Validates that a string is a signed base-10 integer literal for Effect's
@@ -6003,7 +6218,7 @@ export const isStringFinite: (annotations?: Annotations.Filter) => AST.Filter<st
  * @category String checks
  * @since 4.0.0
  */
-export const isStringBigInt: (annotations?: Annotations.Filter) => AST.Filter<string> = AST.isStringBigInt
+export const isStringBigInt: (annotations?: Annotations.Filter) => SchemaAST.Filter<string> = SchemaAST.isStringBigInt
 
 /**
  * Validates that a string has the `Symbol(description)` format used by Effect's
@@ -6017,7 +6232,7 @@ export const isStringBigInt: (annotations?: Annotations.Filter) => AST.Filter<st
  * @category String checks
  * @since 4.0.0
  */
-export const isStringSymbol: (annotations?: Annotations.Filter) => AST.Filter<string> = AST.isStringSymbol
+export const isStringSymbol: (annotations?: Annotations.Filter) => SchemaAST.Filter<string> = SchemaAST.isStringSymbol
 
 /**
  * Returns a RegExp for validating an RFC 4122 UUID.
@@ -6874,7 +7089,7 @@ export function isInt(annotations?: Annotations.Filter) {
  * @since 4.0.0
  */
 export function isInt32(annotations?: Annotations.Filter) {
-  return new AST.FilterGroup(
+  return new SchemaAST.FilterGroup(
     [
       isInt(annotations),
       isBetween({ minimum: -2147483648, maximum: 2147483647 })
@@ -6906,7 +7121,7 @@ export function isInt32(annotations?: Annotations.Filter) {
  * @since 4.0.0
  */
 export function isUint32(annotations?: Annotations.Filter) {
-  return new AST.FilterGroup(
+  return new SchemaAST.FilterGroup(
     [
       isInt(),
       isBetween({ minimum: 0, maximum: 4294967295 })
@@ -7377,7 +7592,7 @@ export function isMinLength(minLength: number, annotations?: Annotations.Filter)
         _tag: "isMinLength",
         minLength
       },
-      [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+      [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
       toArbitraryConstraint: {
         string: {
           minLength
@@ -7444,7 +7659,7 @@ export function isMaxLength(maxLength: number, annotations?: Annotations.Filter)
         _tag: "isMaxLength",
         maxLength
       },
-      [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+      [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
       toArbitraryConstraint: {
         string: {
           maxLength
@@ -7492,7 +7707,7 @@ export function isLengthBetween(minimum: number, maximum: number, annotations?:
         minimum,
         maximum
       },
-      [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+      [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
       toArbitraryConstraint: {
         string: {
           minLength: minimum,
@@ -7538,7 +7753,7 @@ export function isMinSize(minSize: number, annotations?: Annotations.Filter) {
         _tag: "isMinSize",
         minSize
       },
-      [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+      [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
       toArbitraryConstraint: {
         array: {
           minLength: minSize
@@ -7579,7 +7794,7 @@ export function isMaxSize(maxSize: number, annotations?: Annotations.Filter) {
         _tag: "isMaxSize",
         maxSize
       },
-      [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+      [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
       toArbitraryConstraint: {
         array: {
           maxLength: maxSize
@@ -7624,7 +7839,7 @@ export function isSizeBetween(minimum: number, maximum: number, annotations?: An
         minimum,
         maximum
       },
-      [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+      [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
       toArbitraryConstraint: {
         array: {
           minLength: minimum,
@@ -7667,7 +7882,7 @@ export function isMinProperties(minProperties: number, annotations?: Annotations
         _tag: "isMinProperties",
         minProperties
       },
-      [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+      [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
       toArbitraryConstraint: {
         array: {
           minLength: minProperties
@@ -7708,7 +7923,7 @@ export function isMaxProperties(maxProperties: number, annotations?: Annotations
         _tag: "isMaxProperties",
         maxProperties
       },
-      [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+      [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
       toArbitraryConstraint: {
         array: {
           maxLength: maxProperties
@@ -7753,7 +7968,7 @@ export function isPropertiesLengthBetween(minimum: number, maximum: number, anno
         minimum,
         maximum
       },
-      [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+      [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
       toArbitraryConstraint: {
         array: {
           minLength: minimum,
@@ -7783,20 +7998,20 @@ export function isPropertiesLengthBetween(minimum: number, maximum: number, anno
  */
 export function isPropertyNames(keySchema: Top, annotations?: Annotations.Filter) {
   const propertyNames = toEncoded(keySchema)
-  const parser = Parser._issue(propertyNames.ast)
+  const parser = SchemaParser._issue(propertyNames.ast)
   return makeFilter<object>(
     (input, ast, options) => {
       const keys = Reflect.ownKeys(input)
-      const issues: Array<Issue.Issue> = []
+      const issues: Array<SchemaIssue.Issue> = []
       for (const key of keys) {
         const issue = parser(key, options)
         if (issue !== undefined) {
-          issues.push(new Issue.Pointer([key], issue))
+          issues.push(new SchemaIssue.Pointer([key], issue))
           if (options.errors === "first") break
         }
       }
       if (Arr.isArrayNonEmpty(issues)) {
-        return new Issue.Composite(ast, Option_.some(input), issues)
+        return new SchemaIssue.Composite(ast, Option_.some(input), issues)
       }
       return true
     },
@@ -7806,7 +8021,7 @@ export function isPropertyNames(keySchema: Top, annotations?: Annotations.Filter
         _tag: "isPropertyNames",
         propertyNames: propertyNames.ast
       },
-      [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+      [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
       ...annotations
     }
   )
@@ -7952,14 +8167,15 @@ export function Option<A extends Top>(value: A): Option<A> {
           return Effect.succeedNone
         }
         return Effect.mapBothEager(
-          Parser.decodeUnknownEffect(value)(input.value, options),
+          SchemaParser.decodeUnknownEffect(value)(input.value, options),
           {
             onSuccess: Option_.some,
-            onFailure: (issue) => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["value"], issue)])
+            onFailure: (issue) =>
+              new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["value"], issue)])
           }
         )
       }
-      return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)))
+      return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
     },
     {
       typeConstructor: {
@@ -7977,7 +8193,7 @@ export function Option<A extends Top>(value: A): Option<A> {
             Struct({ _tag: Literal("Some"), value }),
             Struct({ _tag: Literal("None") })
           ]),
-          Transformation.transform({
+          SchemaTransformation.transform({
             decode: (e) => e._tag === "None" ? Option_.none() : Option_.some(e.value),
             encode: (o) => (Option_.isSome(o) ? { _tag: "Some", value: o.value } as const : { _tag: "None" } as const)
           })
@@ -8015,13 +8231,8 @@ export interface OptionFromNullOr<S extends Top> extends decodeTo<Option<toType<
  *
  * **Details**
  *
- * Decoding:
- * - `null` is decoded as `None`
- * - other values are decoded as `Some`
- *
- * Encoding:
- * - `None` is encoded as `null`
- * - `Some` is encoded as the value
+ * Decoding maps `null` to `None` and all other values to `Some`. Encoding maps
+ * `None` to `null` and maps `Some` to its value.
  *
  * @category Option
  * @since 3.10.0
@@ -8029,7 +8240,7 @@ export interface OptionFromNullOr<S extends Top> extends decodeTo<Option<toType<
 export function OptionFromNullOr<S extends Top>(schema: S): OptionFromNullOr<S> {
   return NullOr(schema).pipe(decodeTo(
     Option(toType(schema)),
-    Transformation.optionFromNullOr()
+    SchemaTransformation.optionFromNullOr()
   ))
 }
 
@@ -8044,17 +8255,13 @@ export interface OptionFromUndefinedOr<S extends Top> extends decodeTo<Option<to
 }
 
 /**
- * Decodes an undefined-or value `T` to a required `Option<T>` value.
+ * Decodes a required value that may be `undefined` to a required `Option<T>`
+ * value.
  *
  * **Details**
  *
- * Decoding:
- * - `undefined` is decoded as `None`
- * - other values are decoded as `Some`
- *
- * Encoding:
- * - `None` is encoded as `undefined`
- * - `Some` is encoded as the value
+ * Decoding maps `undefined` to `None` and all other values to `Some`. Encoding
+ * maps `None` to `undefined` and maps `Some` to its value.
  *
  * @category Option
  * @since 3.10.0
@@ -8062,7 +8269,7 @@ export interface OptionFromUndefinedOr<S extends Top> extends decodeTo<Option<to
 export function OptionFromUndefinedOr<S extends Top>(schema: S): OptionFromUndefinedOr<S> {
   return UndefinedOr(schema).pipe(decodeTo(
     Option(toType(schema)),
-    Transformation.optionFromUndefinedOr()
+    SchemaTransformation.optionFromUndefinedOr()
   ))
 }
 
@@ -8081,13 +8288,10 @@ export interface OptionFromNullishOr<S extends Top> extends decodeTo<Option<toTy
  *
  * **Details**
  *
- * Decoding:
- * - `null` and `undefined` are decoded as `None`
- * - other values are decoded as `Some`
- *
- * Encoding:
- * - `None` is encoded as `null` or `undefined` depending on the provided `options.onNoneEncoding` (defaults to `undefined`)
- * - `Some` is encoded as the value
+ * Decoding maps `null` and `undefined` to `None` and all other values to
+ * `Some`. Encoding maps `None` to `null` or `undefined` depending on
+ * `options.onNoneEncoding`, which defaults to `undefined`, and maps `Some` to
+ * its value.
  *
  * @category Option
  * @since 3.10.0
@@ -8100,7 +8304,7 @@ export function OptionFromNullishOr<S extends Top>(
 ): OptionFromNullishOr<S> {
   return NullishOr(schema).pipe(decodeTo(
     Option(toType(schema)),
-    Transformation.optionFromNullishOr(options)
+    SchemaTransformation.optionFromNullishOr(options)
   ))
 }
 
@@ -8119,13 +8323,8 @@ export interface OptionFromOptionalKey<S extends Top> extends decodeTo<Option<to
  *
  * **Details**
  *
- * Decoding:
- * - a missing key is decoded as `None`
- * - a present value is decoded as `Some`
- *
- * Encoding:
- * - `None` is encoded as missing key
- * - `Some` is encoded as the value
+ * 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
  * @since 4.0.0
@@ -8133,7 +8332,7 @@ export interface OptionFromOptionalKey<S extends Top> extends decodeTo<Option<to
 export function OptionFromOptionalKey<S extends Top>(schema: S): OptionFromOptionalKey<S> {
   return optionalKey(schema).pipe(decodeTo(
     Option(toType(schema)),
-    Transformation.optionFromOptionalKey()
+    SchemaTransformation.optionFromOptionalKey()
   ))
 }
 
@@ -8148,19 +8347,14 @@ export interface OptionFromOptional<S extends Top> extends decodeTo<Option<toTyp
 }
 
 /**
- * Decodes an optional or `undefined` value `A` to an required `Option<A>`
+ * Decodes an optional or `undefined` value `A` to a required `Option<A>`
  * value.
  *
  * **Details**
  *
- * Decoding:
- * - a missing key is decoded as `None`
- * - a present key with an `undefined` value is decoded as `None`
- * - all other values are decoded as `Some`
- *
- * Encoding:
- * - `None` is encoded as missing key
- * - `Some` is encoded as the value
+ * Decoding maps a missing key or a present `undefined` value to `None`, and
+ * maps all other values to `Some`. Encoding maps `None` to a missing key and
+ * maps `Some` to its value.
  *
  * @category Option
  * @since 4.0.0
@@ -8168,7 +8362,7 @@ export interface OptionFromOptional<S extends Top> extends decodeTo<Option<toTyp
 export function OptionFromOptional<S extends Top>(schema: S): OptionFromOptional<S> {
   return optional(schema).pipe(decodeTo(
     Option(toType(schema)),
-    Transformation.optionFromOptional<any>()
+    SchemaTransformation.optionFromOptional<any>()
   ))
 }
 
@@ -8188,17 +8382,10 @@ export interface OptionFromOptionalNullOr<S extends Top> extends decodeTo<Option
  *
  * **Details**
  *
- * Decoding:
- * - a missing key is decoded as `None`
- * - a present key with an `undefined` value is decoded as `None`
- * - a present key with a `null` value is decoded as `None`
- * - all other values are decoded as `Some`
- *
- * Encoding (controlled by `options.onNoneEncoding`):
- * - `"omit"` (default): `None` is encoded as a missing key
- * - `null`: `None` is encoded as `null`
- * - `undefined`: `None` is encoded as `undefined`
- * - `Some` is always encoded as the value
+ * Decoding maps a missing key, `undefined`, or `null` to `None`, and maps all
+ * other values to `Some`. Encoding maps `Some` to its value. `None` is encoded
+ * according to `options.onNoneEncoding`: `"omit"` encodes a missing key,
+ * `null` encodes `null`, and `undefined` encodes `undefined`.
  *
  * @category Option
  * @since 4.0.0
@@ -8215,7 +8402,7 @@ export function OptionFromOptionalNullOr<S extends Top>(
     : undefined as S["Type"] | null | undefined
   return optional(NullOr(schema)).pipe(decodeTo(
     Option(toType(schema)),
-    Transformation.transformOptional<Option_.Option<S["Type"]>, S["Type"] | null | undefined>({
+    SchemaTransformation.transformOptional<Option_.Option<S["Type"]>, S["Type"] | null | undefined>({
       decode: (oe) => oe.pipe(Option_.filter(Predicate.isNotNullish), Option_.some),
       encode: onNoneEncoding === "omit"
         ? Option_.flatten
@@ -8276,18 +8463,20 @@ export function Result<A extends Top, E extends Top>(
     [success, failure],
     ([success, failure]) => (input, ast, options) => {
       if (!Result_.isResult(input)) {
-        return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)))
+        return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
       }
       switch (input._tag) {
         case "Success":
-          return Effect.mapBothEager(Parser.decodeEffect(success)(input.success, options), {
+          return Effect.mapBothEager(SchemaParser.decodeEffect(success)(input.success, options), {
             onSuccess: Result_.succeed,
-            onFailure: (issue) => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["success"], issue)])
+            onFailure: (issue) =>
+              new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["success"], issue)])
           })
         case "Failure":
-          return Effect.mapBothEager(Parser.decodeEffect(failure)(input.failure, options), {
+          return Effect.mapBothEager(SchemaParser.decodeEffect(failure)(input.failure, options), {
             onSuccess: Result_.fail,
-            onFailure: (issue) => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["failure"], issue)])
+            onFailure: (issue) =>
+              new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["failure"], issue)])
           })
       }
     },
@@ -8307,7 +8496,7 @@ export function Result<A extends Top, E extends Top>(
             Struct({ _tag: Literal("Success"), success }),
             Struct({ _tag: Literal("Failure"), failure })
           ]),
-          Transformation.transform({
+          SchemaTransformation.transform({
             decode: (e): Result_.Result<A["Encoded"], E["Encoded"]> =>
               e._tag === "Success" ? Result_.succeed(e.success) : Result_.fail(e.failure),
             encode: (r) =>
@@ -8379,43 +8568,44 @@ export function Redacted<S extends Top>(value: S, options?: {
   readonly disallowJsonEncode?: boolean | undefined
 }): Redacted<S> {
   const decodeLabel = typeof options?.label === "string"
-    ? Parser.decodeUnknownEffect(Literal(options.label))
+    ? SchemaParser.decodeUnknownEffect(Literal(options.label))
     : undefined
   const schema = declareConstructor<Redacted_.Redacted<S["Type"]>, Redacted_.Redacted<S["Encoded"]>>()(
     [value],
     ([value]) => (input, ast, poptions) => {
       if (Redacted_.isRedacted(input)) {
-        const label: Effect.Effect<void, Issue.Issue, never> = decodeLabel !== undefined
+        const label: Effect.Effect<void, SchemaIssue.Issue, never> = decodeLabel !== undefined
           ? Effect.mapErrorEager(
             decodeLabel(input.label, poptions),
-            (issue) => new Issue.Pointer(["label"], issue)
+            (issue) => new SchemaIssue.Pointer(["label"], issue)
           )
           : Effect.void
         return Effect.flatMapEager(
           label,
           () =>
             Effect.mapBothEager(
-              Parser.decodeUnknownEffect(value)(Redacted_.value(input), poptions),
+              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 Issue.Composite(ast, oinput, [
-                    new Issue.Pointer(["value"], new Issue.InvalidValue(oinput))
+                  return new SchemaIssue.Composite(ast, oinput, [
+                    new SchemaIssue.Pointer(["value"], new SchemaIssue.InvalidValue(oinput))
                   ])
                 }
               }
             )
         )
       }
-      return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)))
+      return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
     },
     {
       typeConstructor: {
-        _tag: "effect/Redacted"
+        _tag: "effect/Redacted",
+        options
       },
       generation: {
-        runtime: `Schema.Redacted(?)`,
+        runtime: options !== undefined ? `Schema.Redacted(?, ${format(options)})` : `Schema.Redacted(?)`,
         Type: `Redacted.Redacted<?>`,
         importDeclaration: `import * as Redacted from "effect/Redacted"`
       },
@@ -8424,13 +8614,13 @@ export function Redacted<S extends Top>(value: S, options?: {
         link<Redacted_.Redacted<S["Encoded"]>>()(
           redact(value),
           {
-            decode: Getter.transform((e) => Redacted_.make(e, { label: options?.label })),
+            decode: SchemaGetter.transform((e) => Redacted_.make(e, { label: options?.label })),
             encode: options?.disallowJsonEncode ?
-              Getter.forbidden((oe) =>
+              SchemaGetter.forbidden((oe) =>
                 "Cannot serialize Redacted" +
                 (Option_.isSome(oe) && typeof oe.value.label === "string" ? ` with label: "${oe.value.label}"` : "")
               ) :
-              Getter.transform(Redacted_.value)
+              SchemaGetter.transform(Redacted_.value)
           }
         ),
       toArbitrary: ([value]) => () => value.map((a) => Redacted_.make(a, { label: options?.label })),
@@ -8461,7 +8651,7 @@ export interface RedactedFromValue<S extends Top>
  * @since 4.0.0
  */
 export function redact<S extends Top>(schema: S): middlewareDecoding<S, S["DecodingServices"]> {
-  return schema.pipe(middlewareDecoding(Effect.mapErrorEager(Issue.redact)))
+  return schema.pipe(middlewareDecoding(Effect.mapErrorEager(SchemaIssue.redact)))
 }
 
 /**
@@ -8483,13 +8673,13 @@ export function RedactedFromValue<S extends Top>(value: S, options?: {
         disallowJsonEncode: options?.disallowEncode
       }),
       {
-        decode: Getter.transform((t) => Redacted_.make(t, { label: options?.label })),
+        decode: SchemaGetter.transform((t) => Redacted_.make(t, { label: options?.label })),
         encode: options?.disallowEncode ?
-          Getter.forbidden((oe) =>
+          SchemaGetter.forbidden((oe) =>
             "Cannot encode Redacted" +
             (Option_.isSome(oe) && typeof oe.value.label === "string" ? ` with label: "${oe.value.label}"` : "")
           ) :
-          Getter.transform(Redacted_.value)
+          SchemaGetter.transform(Redacted_.value)
       }
     )
   )
@@ -8542,8 +8732,8 @@ export type CauseReasonIso<E extends Top, D extends Top> = {
  *
  * **When to use**
  *
- * Use to validate, transform, or serialize individual `Cause.Reason` values
- * when typed failures and unexpected defects need separate schemas.
+ * Use when serializing or decoding individual cause reasons separately from a
+ * full failure cause, with distinct schemas for typed errors and defects.
  *
  * **Details**
  *
@@ -8561,24 +8751,25 @@ export function CauseReason<E extends Top, D extends Top>(error: E, defect: D):
     [error, defect],
     ([error, defect]) => (input, ast, options) => {
       if (!Cause_.isReason(input)) {
-        return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)))
+        return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
       }
       switch (input._tag) {
         case "Fail":
           return Effect.mapBothEager(
-            Parser.decodeUnknownEffect(error)(input.error, options),
+            SchemaParser.decodeUnknownEffect(error)(input.error, options),
             {
               onSuccess: Cause_.makeFailReason,
-              onFailure: (issue) => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["error"], issue)])
+              onFailure: (issue) =>
+                new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["error"], issue)])
             }
           )
         case "Die":
           return Effect.mapBothEager(
-            Parser.decodeUnknownEffect(defect)(input.defect, options),
+            SchemaParser.decodeUnknownEffect(defect)(input.defect, options),
             {
               onSuccess: Cause_.makeDieReason,
               onFailure: (issue) =>
-                new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["defect"], issue)])
+                new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["defect"], issue)])
             }
           )
         case "Interrupt":
@@ -8602,7 +8793,7 @@ export function CauseReason<E extends Top, D extends Top>(error: E, defect: D):
             Struct({ _tag: Literal("Die"), defect }),
             Struct({ _tag: Literal("Interrupt"), fiberId: UndefinedOr(Finite) })
           ]),
-          Transformation.transform({
+          SchemaTransformation.transform({
             decode: (e) => {
               switch (e._tag) {
                 case "Fail":
@@ -8727,11 +8918,12 @@ export function Cause<E extends Top, D extends Top>(error: E, defect: D): Cause<
       const failures = ArraySchema(CauseReason(error, defect))
       return (input, ast, options) => {
         if (!Cause_.isCause(input)) {
-          return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)))
+          return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
         }
-        return Effect.mapBothEager(Parser.decodeUnknownEffect(failures)(input.reasons, options), {
+        return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(failures)(input.reasons, options), {
           onSuccess: Cause_.fromReasons,
-          onFailure: (issue) => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["failures"], issue)])
+          onFailure: (issue) =>
+            new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["failures"], issue)])
         })
       }
     },
@@ -8748,7 +8940,7 @@ export function Cause<E extends Top, D extends Top>(error: E, defect: D): Cause<
       toCodec: ([error, defect]) =>
         link<Cause_.Cause<E["Encoded"]>>()(
           ArraySchema(CauseReason(error, defect)),
-          Transformation.transform({
+          SchemaTransformation.transform({
             decode: Cause_.fromReasons,
             encode: ({ reasons: failures }) => failures
           })
@@ -8815,7 +9007,7 @@ export const Error: Error = instanceOf(globalThis.Error, {
     Type: `globalThis.Error`
   },
   expected: "Error",
-  toCodecJson: () => link<globalThis.Error>()(ErrorJsonEncoded, Transformation.errorFromErrorJsonEncoded()),
+  toCodecJson: () => link<globalThis.Error>()(ErrorJsonEncoded, SchemaTransformation.errorFromErrorJsonEncoded()),
   toArbitrary: () => (fc) => fc.string().map((message) => new globalThis.Error(message))
 })
 
@@ -8844,7 +9036,7 @@ export const ErrorWithStack: Error = instanceOf(globalThis.Error, {
   toCodecJson: () =>
     link<globalThis.Error>()(
       ErrorJsonEncoded,
-      Transformation.errorFromErrorJsonEncoded({
+      SchemaTransformation.errorFromErrorJsonEncoded({
         includeStack: true
       })
     ),
@@ -8875,9 +9067,9 @@ export interface Defect extends
   readonly "Rebuild": Defect
 }
 
-const defectTransformation = new Transformation.Transformation(
-  Getter.passthrough(),
-  Getter.transform((u) => {
+const defectTransformation = new SchemaTransformation.Transformation(
+  SchemaGetter.passthrough(),
+  SchemaGetter.transform((u) => {
     try {
       return JSON.parse(JSON.stringify(u))
     } catch {
@@ -8900,7 +9092,7 @@ const defectTransformation = new Transformation.Transformation(
  * @since 3.10.0
  */
 export const Defect: Defect = Union([
-  ErrorJsonEncoded.pipe(decodeTo(Error, Transformation.errorFromErrorJsonEncoded())),
+  ErrorJsonEncoded.pipe(decodeTo(Error, SchemaTransformation.errorFromErrorJsonEncoded())),
   Any.pipe(decodeTo(
     Unknown.annotate({
       toCodecJson: () => link<unknown>()(Any, defectTransformation),
@@ -8919,7 +9111,7 @@ export const Defect: Defect = Union([
 export const DefectWithStack: Defect = Union([
   ErrorJsonEncoded.pipe(decodeTo(
     ErrorWithStack,
-    Transformation.errorFromErrorJsonEncoded({
+    SchemaTransformation.errorFromErrorJsonEncoded({
       includeStack: true
     })
   )),
@@ -8975,6 +9167,11 @@ export type ExitIso<A extends Top, E extends Top, D extends Top> = {
  * Creates a schema for `Exit` values using schemas for the success value, typed
  * failure, and unexpected defect channels.
  *
+ * **When to use**
+ *
+ * Use when serializing or validating an effect outcome where success, typed
+ * failure, and defects each need their own schema.
+ *
  * @category Exit
  * @since 3.10.0
  */
@@ -8989,25 +9186,25 @@ export function Exit<A extends Top, E extends Top, D extends Top>(value: A, erro
       const cause = Cause(error, defect)
       return (input, ast, options) => {
         if (!Exit_.isExit(input)) {
-          return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)))
+          return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
         }
         switch (input._tag) {
           case "Success":
             return Effect.mapBothEager(
-              Parser.decodeUnknownEffect(value)(input.value, options),
+              SchemaParser.decodeUnknownEffect(value)(input.value, options),
               {
                 onSuccess: Exit_.succeed,
                 onFailure: (issue) =>
-                  new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["value"], issue)])
+                  new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["value"], issue)])
               }
             )
           case "Failure":
             return Effect.mapBothEager(
-              Parser.decodeUnknownEffect(cause)(input.cause, options),
+              SchemaParser.decodeUnknownEffect(cause)(input.cause, options),
               {
                 onSuccess: Exit_.failCause,
                 onFailure: (issue) =>
-                  new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["cause"], issue)])
+                  new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["cause"], issue)])
               }
             )
         }
@@ -9029,7 +9226,7 @@ export function Exit<A extends Top, E extends Top, D extends Top>(value: A, erro
             Struct({ _tag: Literal("Success"), value }),
             Struct({ _tag: Literal("Failure"), cause: Cause(error, defect) })
           ]),
-          Transformation.transform({
+          SchemaTransformation.transform({
             decode: (e): Exit_.Exit<A["Encoded"], E["Encoded"]> =>
               e._tag === "Success" ? Exit_.succeed(e.value) : Exit_.failCause(e.cause),
             encode: (exit) =>
@@ -9119,15 +9316,15 @@ export function ReadonlyMap<Key extends Top, Value extends Top>(key: Key, value:
       return (input, ast, options) => {
         if (input instanceof globalThis.Map) {
           return Effect.mapBothEager(
-            Parser.decodeUnknownEffect(array)([...input], options),
+            SchemaParser.decodeUnknownEffect(array)([...input], options),
             {
               onSuccess: (array: ReadonlyArray<readonly [Key["Type"], Value["Type"]]>) => new globalThis.Map(array),
               onFailure: (issue) =>
-                new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["entries"], issue)])
+                new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["entries"], issue)])
             }
           )
         }
-        return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)))
+        return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
       }
     },
     {
@@ -9142,7 +9339,7 @@ export function ReadonlyMap<Key extends Top, Value extends Top>(key: Key, value:
       toCodec: ([key, value]) =>
         link<globalThis.Map<Key["Encoded"], Value["Encoded"]>>()(
           ArraySchema(Tuple([key, value])),
-          Transformation.transform({
+          SchemaTransformation.transform({
             decode: (e) => new globalThis.Map(e),
             encode: (map) => [...map.entries()]
           })
@@ -9214,15 +9411,15 @@ export function HashMap<Key extends Top, Value extends Top>(key: Key, value: Val
       return (input, ast, options) => {
         if (HashMap_.isHashMap(input)) {
           return Effect.mapBothEager(
-            Parser.decodeUnknownEffect(entries)(HashMap_.toEntries(input), options),
+            SchemaParser.decodeUnknownEffect(entries)(HashMap_.toEntries(input), options),
             {
               onSuccess: HashMap_.fromIterable,
               onFailure: (issue) =>
-                new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["entries"], issue)])
+                new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["entries"], issue)])
             }
           )
         }
-        return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)))
+        return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
       }
     },
     {
@@ -9238,7 +9435,7 @@ export function HashMap<Key extends Top, Value extends Top>(key: Key, value: Val
       toCodec: ([key, value]) =>
         link<HashMap_.HashMap<Key["Encoded"], Value["Encoded"]>>()(
           ArraySchema(Tuple([key, value])),
-          Transformation.transform({
+          SchemaTransformation.transform({
             decode: HashMap_.fromIterable,
             encode: HashMap_.toEntries
           })
@@ -9309,15 +9506,15 @@ export function ReadonlySet<Value extends Top>(value: Value): $ReadonlySet<Value
       return (input, ast, options) => {
         if (input instanceof globalThis.Set) {
           return Effect.mapBothEager(
-            Parser.decodeUnknownEffect(array)([...input], options),
+            SchemaParser.decodeUnknownEffect(array)([...input], options),
             {
               onSuccess: (array: ReadonlyArray<Value["Type"]>) => new globalThis.Set(array),
               onFailure: (issue) =>
-                new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["values"], issue)])
+                new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["values"], issue)])
             }
           )
         }
-        return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)))
+        return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
       }
     },
     {
@@ -9332,7 +9529,7 @@ export function ReadonlySet<Value extends Top>(value: Value): $ReadonlySet<Value
       toCodec: ([value]) =>
         link<globalThis.Set<Value["Encoded"]>>()(
           ArraySchema(value),
-          Transformation.transform({
+          SchemaTransformation.transform({
             decode: (e) => new globalThis.Set(e),
             encode: (set) => [...set.values()]
           })
@@ -9403,15 +9600,15 @@ export function HashSet<Value extends Top>(value: Value): HashSet<Value> {
       return (input, ast, options) => {
         if (HashSet_.isHashSet(input)) {
           return Effect.mapBothEager(
-            Parser.decodeUnknownEffect(values)(Arr.fromIterable(input), options),
+            SchemaParser.decodeUnknownEffect(values)(Arr.fromIterable(input), options),
             {
               onSuccess: HashSet_.fromIterable,
               onFailure: (issue) =>
-                new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["values"], issue)])
+                new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["values"], issue)])
             }
           )
         }
-        return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)))
+        return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
       }
     },
     {
@@ -9426,7 +9623,7 @@ export function HashSet<Value extends Top>(value: Value): HashSet<Value> {
       toCodec: ([value]) =>
         link<HashSet_.HashSet<Value["Encoded"]>>()(
           ArraySchema(value),
-          Transformation.transform({
+          SchemaTransformation.transform({
             decode: HashSet_.fromIterable,
             encode: Arr.fromIterable
           })
@@ -9504,15 +9701,15 @@ export function Chunk<Value extends Top>(value: Value): Chunk<Value> {
       return (input, ast, options) => {
         if (Chunk_.isChunk(input)) {
           return Effect.mapBothEager(
-            Parser.decodeUnknownEffect(values)(Arr.fromIterable(input), options),
+            SchemaParser.decodeUnknownEffect(values)(Arr.fromIterable(input), options),
             {
               onSuccess: Chunk_.fromIterable,
               onFailure: (issue) =>
-                new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["values"], issue)])
+                new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["values"], issue)])
             }
           )
         }
-        return Effect.fail(new Issue.InvalidType(ast, Option_.some(input)))
+        return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
       }
     },
     {
@@ -9527,7 +9724,7 @@ export function Chunk<Value extends Top>(value: Value): Chunk<Value> {
       toCodec: ([value]) =>
         link<Chunk_.Chunk<Value["Encoded"]>>()(
           ArraySchema(value),
-          Transformation.transform({
+          SchemaTransformation.transform({
             decode: Chunk_.fromIterable,
             encode: Arr.fromIterable
           })
@@ -9590,11 +9787,11 @@ export const RegExp: RegExp = instanceOf(
           source: String,
           flags: String
         }),
-        Transformation.transformOrFail({
+        SchemaTransformation.transformOrFail({
           decode: (e) =>
             Effect.try({
               try: () => new globalThis.RegExp(e.source, e.flags),
-              catch: (e) => new Issue.InvalidValue(Option_.some(e), { message: globalThis.String(e) })
+              catch: (e) => new SchemaIssue.InvalidValue(Option_.some(e), { message: globalThis.String(e) })
             }),
           encode: (regExp) =>
             Effect.succeed({
@@ -9667,7 +9864,7 @@ export const URL: URL = instanceOf(
     toCodecJson: () =>
       link<globalThis.URL>()(
         URLString,
-        Transformation.urlFromString
+        SchemaTransformation.urlFromString
       ),
     toArbitrary: () => (fc) => fc.webUrl().map((s) => new globalThis.URL(s)),
     toEquivalence: () => (a, b) => a.toString() === b.toString()
@@ -9698,7 +9895,7 @@ export interface URLFromString extends decodeTo<URL, String> {
  * @category URL
  * @since 4.0.0
  */
-export const URLFromString: URLFromString = URLString.pipe(decodeTo(URL, Transformation.urlFromString))
+export const URLFromString: URLFromString = URLString.pipe(decodeTo(URL, SchemaTransformation.urlFromString))
 
 /**
  * Type-level representation of {@link Date}.
@@ -9717,8 +9914,8 @@ const DateString = String.annotate({ expected: "a string in ISO 8601 format that
  *
  * **When to use**
  *
- * Use to validate in-memory values that must already be JavaScript `Date`
- * instances.
+ * Use to validate in-memory values that must already be JavaScript date
+ * objects.
  *
  * **Details**
  *
@@ -9754,7 +9951,7 @@ export const Date: Date = instanceOf(
     toCodecJson: () =>
       link<globalThis.Date>()(
         DateString,
-        Transformation.dateFromString
+        SchemaTransformation.dateFromString
       ),
     toArbitrary: () => (fc, ctx) => fc.date(ctx?.constraints?.date)
   }
@@ -9797,7 +9994,7 @@ export interface DateFromString extends decodeTo<Date, String> {
  * @category Date
  * @since 3.10.0
  */
-export const DateFromString: DateFromString = DateString.pipe(decodeTo(Date, Transformation.dateFromString))
+export const DateFromString: DateFromString = DateString.pipe(decodeTo(Date, SchemaTransformation.dateFromString))
 
 /**
  * Type-level representation of {@link DateValid}.
@@ -9873,7 +10070,7 @@ export const Duration: Duration = declare(
           Struct({ _tag: Literal("Nanos"), value: BigInt }),
           Struct({ _tag: Literal("Millis"), value: Int })
         ]),
-        Transformation.transform({
+        SchemaTransformation.transform({
           decode: (e) => {
             switch (e._tag) {
               case "Infinity":
@@ -9940,7 +10137,7 @@ export interface DurationFromString extends decodeTo<Duration, String> {
  * @since 4.0.0
  */
 export const DurationFromString: DurationFromString = DurationString.pipe(
-  decodeTo(Duration, Transformation.durationFromString)
+  decodeTo(Duration, SchemaTransformation.durationFromString)
 )
 
 /**
@@ -9973,7 +10170,7 @@ const bigint0 = globalThis.BigInt(0)
  * @since 3.10.0
  */
 export const DurationFromNanos: DurationFromNanos = BigInt.check(isGreaterThanOrEqualToBigInt(bigint0)).pipe(
-  decodeTo(Duration, Transformation.durationFromNanos)
+  decodeTo(Duration, SchemaTransformation.durationFromNanos)
 )
 
 /**
@@ -10005,7 +10202,7 @@ export interface DurationFromMillis extends decodeTo<Duration, Number> {
  * @since 3.10.0
  */
 export const DurationFromMillis: DurationFromMillis = Number.check(isGreaterThanOrEqualTo(0)).pipe(
-  decodeTo(Duration, Transformation.durationFromMillis)
+  decodeTo(Duration, SchemaTransformation.durationFromMillis)
 )
 
 /**
@@ -10025,7 +10222,7 @@ const BigDecimalString = String.annotate({ expected: "a string that will be deco
  *
  * **When to use**
  *
- * Use when values are already Effect decimal instances and need schema
+ * Use when you already have Effect decimal instances and need schema
  * validation, formatting, equivalence, and JSON string serialization.
  *
  * **Details**
@@ -10054,7 +10251,7 @@ export const BigDecimal: BigDecimal = declare(
     toCodecJson: () =>
       link<BigDecimal_.BigDecimal>()(
         BigDecimalString,
-        Transformation.bigDecimalFromString
+        SchemaTransformation.bigDecimalFromString
       ),
     toArbitrary: () => (fc) =>
       fc.tuple(fc.bigInt(), fc.integer({ min: 0, max: 20 }))
@@ -10102,7 +10299,7 @@ export interface BigDecimalFromString extends decodeTo<BigDecimal, String> {
  * @since 4.0.0
  */
 export const BigDecimalFromString: BigDecimalFromString = BigDecimalString.pipe(
-  decodeTo(BigDecimal, Transformation.bigDecimalFromString)
+  decodeTo(BigDecimal, SchemaTransformation.bigDecimalFromString)
 )
 
 /**
@@ -10222,8 +10419,8 @@ export function fromJsonString<S extends Top>(schema: S): fromJsonString<S> {
   return String.annotate({
     expected: "a string that will be decoded as JSON",
     contentMediaType: "application/json",
-    contentSchema: AST.toEncoded(schema.ast)
-  }).pipe(decodeTo(schema, Transformation.fromJsonString))
+    contentSchema: SchemaAST.toEncoded(schema.ast)
+  }).pipe(decodeTo(schema, SchemaTransformation.fromJsonString))
 }
 
 /**
@@ -10264,12 +10461,12 @@ export const File: File = instanceOf(globalThis.File, {
         name: String,
         lastModified: Number
       }),
-      Transformation.transformOrFail({
+      SchemaTransformation.transformOrFail({
         decode: (e) =>
           Result_.match(Encoding.decodeBase64(e.data), {
             onFailure: (error) =>
               Effect.fail(
-                new Issue.InvalidValue(Option_.some(e.data), {
+                new SchemaIssue.InvalidValue(Option_.some(e.data), {
                   message: error.message
                 })
               ),
@@ -10292,7 +10489,7 @@ export const File: File = instanceOf(globalThis.File, {
               }
             },
             catch: (e) =>
-              new Issue.InvalidValue(Option_.some(file), {
+              new SchemaIssue.InvalidValue(Option_.some(file), {
                 message: globalThis.String(e)
               })
           })
@@ -10341,7 +10538,7 @@ export const FormData: FormData = instanceOf(globalThis.FormData, {
           ])
         ])
       ),
-      Transformation.transformOrFail({
+      SchemaTransformation.transformOrFail({
         decode: (e) => {
           const out = new globalThis.FormData()
           for (const [key, entry] of e) {
@@ -10463,7 +10660,7 @@ export interface fromFormData<S extends Top> extends decodeTo<S, FormData> {
  * @since 4.0.0
  */
 export function fromFormData<S extends Top>(schema: S): fromFormData<S> {
-  return FormData.pipe(decodeTo(schema, Transformation.fromFormData))
+  return FormData.pipe(decodeTo(schema, SchemaTransformation.fromFormData))
 }
 
 /**
@@ -10498,7 +10695,7 @@ export const URLSearchParams: URLSearchParams = instanceOf(globalThis.URLSearchP
   toCodecJson: () =>
     link<globalThis.URLSearchParams>()(
       String.annotate({ expected: "a query string that will be decoded as URLSearchParams" }),
-      Transformation.transform({
+      SchemaTransformation.transform({
         decode: (e) => new globalThis.URLSearchParams(e),
         encode: (params) => params.toString()
       })
@@ -10596,7 +10793,7 @@ export interface fromURLSearchParams<S extends Top> extends decodeTo<S, URLSearc
  * @since 4.0.0
  */
 export function fromURLSearchParams<S extends Top>(schema: S): fromURLSearchParams<S> {
-  return URLSearchParams.pipe(decodeTo(schema, Transformation.fromURLSearchParams))
+  return URLSearchParams.pipe(decodeTo(schema, SchemaTransformation.fromURLSearchParams))
 }
 
 /**
@@ -10664,7 +10861,7 @@ export interface NumberFromString extends decodeTo<Finite, String> {
  */
 export const NumberFromString: NumberFromString = String.annotate({
   expected: "a string that will be decoded as a number"
-}).pipe(decodeTo(Number, Transformation.numberFromString))
+}).pipe(decodeTo(Number, SchemaTransformation.numberFromString))
 
 /**
  * Type-level representation of {@link FiniteFromString}.
@@ -10693,7 +10890,7 @@ export interface FiniteFromString extends decodeTo<Finite, String> {
  */
 export const FiniteFromString: FiniteFromString = String.annotate({
   expected: "a string that will be decoded as a finite number"
-}).pipe(decodeTo(Finite, Transformation.numberFromString))
+}).pipe(decodeTo(Finite, SchemaTransformation.numberFromString))
 
 /**
  * Type-level representation of {@link BigIntFromString}.
@@ -10733,8 +10930,8 @@ export interface BigIntFromString extends decodeTo<BigInt, String> {
  * @category BigInt
  * @since 4.0.0
  */
-export const BigIntFromString: BigIntFromString = make<String>(AST.bigIntString).pipe(
-  decodeTo(BigInt, Transformation.bigintFromString)
+export const BigIntFromString: BigIntFromString = make<String>(SchemaAST.bigIntString).pipe(
+  decodeTo(BigInt, SchemaTransformation.bigintFromString)
 )
 
 /**
@@ -10781,7 +10978,7 @@ export interface Trim extends decodeTo<Trimmed, String> {
  */
 export const Trim: Trim = String.annotate({
   expected: "a string that will be decoded as a trimmed string"
-}).pipe(decodeTo(Trimmed, Transformation.trim()))
+}).pipe(decodeTo(Trimmed, SchemaTransformation.trim()))
 
 /**
  * Type-level representation of {@link StringFromBase64}.
@@ -10810,7 +11007,7 @@ export interface StringFromBase64 extends decodeTo<String, String> {
 export const StringFromBase64: StringFromBase64 = String.annotate({
   expected: "a base64 encoded string that will be decoded as a UTF-8 string"
 }).pipe(
-  decodeTo(String, Transformation.stringFromBase64String)
+  decodeTo(String, SchemaTransformation.stringFromBase64String)
 )
 
 /**
@@ -10840,7 +11037,7 @@ export interface StringFromBase64Url extends decodeTo<String, String> {
 export const StringFromBase64Url: StringFromBase64Url = String.annotate({
   expected: "a base64 (URL) encoded string that will be decoded as a UTF-8 string"
 }).pipe(
-  decodeTo(String, Transformation.stringFromBase64UrlString)
+  decodeTo(String, SchemaTransformation.stringFromBase64UrlString)
 )
 
 /**
@@ -10870,7 +11067,7 @@ export interface StringFromHex extends decodeTo<String, String> {
 export const StringFromHex: StringFromHex = String.annotate({
   expected: "a hex encoded string that will be decoded as a UTF-8 string"
 }).pipe(
-  decodeTo(String, Transformation.stringFromHexString)
+  decodeTo(String, SchemaTransformation.stringFromHexString)
 )
 
 /**
@@ -10919,7 +11116,7 @@ export interface StringFromUriComponent extends decodeTo<String, String> {
 export const StringFromUriComponent: StringFromUriComponent = String.annotate({
   expected: "a URI component encoded string that will be decoded as a UTF-8 string"
 }).pipe(
-  decodeTo(String, Transformation.stringFromUriComponent)
+  decodeTo(String, SchemaTransformation.stringFromUriComponent)
 )
 
 /**
@@ -10981,7 +11178,7 @@ export interface BooleanFromBit extends decodeTo<Boolean, Literals<readonly [0,
 export const BooleanFromBit: BooleanFromBit = Literals([0, 1]).pipe(
   decodeTo(
     Boolean,
-    Transformation.transform({
+    SchemaTransformation.transform({
       decode: (bit) => bit === 1,
       encode: (bool) => bool ? 1 : 0
     })
@@ -11028,7 +11225,7 @@ export const Uint8Array: Uint8Array = instanceOf(globalThis.Uint8Array<ArrayBuff
   toCodecJson: () =>
     link<globalThis.Uint8Array<ArrayBufferLike>>()(
       Base64String,
-      Transformation.uint8ArrayFromBase64String
+      SchemaTransformation.uint8ArrayFromBase64String
     ),
   toArbitrary: () => (fc) => fc.uint8Array()
 })
@@ -11059,7 +11256,7 @@ export interface Uint8ArrayFromBase64 extends decodeTo<Uint8Array, String> {
  * @since 3.10.0
  */
 export const Uint8ArrayFromBase64: Uint8ArrayFromBase64 = Base64String.pipe(
-  decodeTo(Uint8Array, Transformation.uint8ArrayFromBase64String)
+  decodeTo(Uint8Array, SchemaTransformation.uint8ArrayFromBase64String)
 )
 
 /**
@@ -11091,8 +11288,8 @@ export const Uint8ArrayFromBase64Url: Uint8ArrayFromBase64Url = String.annotate(
   expected: "a base64 (URL) encoded string that will be decoded as a Uint8Array"
 }).pipe(
   decodeTo(Uint8Array, {
-    decode: Getter.decodeBase64Url(),
-    encode: Getter.encodeBase64Url()
+    decode: SchemaGetter.decodeBase64Url(),
+    encode: SchemaGetter.encodeBase64Url()
   })
 )
 
@@ -11125,8 +11322,8 @@ export const Uint8ArrayFromHex: Uint8ArrayFromHex = String.annotate({
   expected: "a hex encoded string that will be decoded as a Uint8Array"
 }).pipe(
   decodeTo(Uint8Array, {
-    decode: Getter.decodeHex(),
-    encode: Getter.encodeHex()
+    decode: SchemaGetter.decodeHex(),
+    encode: SchemaGetter.encodeHex()
   })
 )
 
@@ -11176,7 +11373,7 @@ export const DateTimeUtc: DateTimeUtc = declare(
     toCodecJson: () =>
       link<DateTime.Utc>()(
         String,
-        Transformation.dateTimeUtcFromString
+        SchemaTransformation.dateTimeUtcFromString
       ),
     toArbitrary: () => (fc, ctx) =>
       fc.date({ noInvalidDate: true, ...ctx?.constraints?.date }).map((date) => DateTime.fromDateUnsafe(date)),
@@ -11200,8 +11397,8 @@ export interface DateTimeUtcFromDate extends decodeTo<DateTimeUtc, Date> {
  *
  * **When to use**
  *
- * Use when a boundary provides valid JavaScript `Date` objects but the decoded
- * model should use `DateTime.Utc`.
+ * Use when you need to decode valid JavaScript `Date` objects into
+ * `DateTime.Utc` values.
  *
  * **Details**
  *
@@ -11221,8 +11418,8 @@ export interface DateTimeUtcFromDate extends decodeTo<DateTimeUtc, Date> {
  */
 export const DateTimeUtcFromDate: DateTimeUtcFromDate = DateValid.pipe(
   decodeTo(DateTimeUtc, {
-    decode: Getter.dateTimeUtcFromInput(),
-    encode: Getter.transform(DateTime.toDateUtc)
+    decode: SchemaGetter.dateTimeUtcFromInput(),
+    encode: SchemaGetter.transform(DateTime.toDateUtc)
   })
 )
 
@@ -11258,7 +11455,7 @@ export const DateTimeUtcFromString: DateTimeUtcFromString = String.annotate({
 }).pipe(
   decodeTo(
     DateTimeUtc,
-    Transformation.dateTimeUtcFromString
+    SchemaTransformation.dateTimeUtcFromString
   )
 )
 
@@ -11288,8 +11485,8 @@ export interface DateTimeUtcFromMillis extends decodeTo<instanceOf<DateTime.Utc>
  */
 export const DateTimeUtcFromMillis: DateTimeUtcFromMillis = Number.pipe(
   decodeTo(DateTimeUtc, {
-    decode: Getter.dateTimeUtcFromInput(),
-    encode: Getter.transform(DateTime.toEpochMillis)
+    decode: SchemaGetter.dateTimeUtcFromInput(),
+    encode: SchemaGetter.transform(DateTime.toEpochMillis)
   })
 )
 
@@ -11330,7 +11527,7 @@ export const TimeZoneOffset: TimeZoneOffset = declare(
     toCodecJson: () =>
       link<DateTime.TimeZone.Offset>()(
         Number,
-        Transformation.timeZoneOffsetFromNumber
+        SchemaTransformation.timeZoneOffsetFromNumber
       ),
     toArbitrary: () => (fc) =>
       fc.integer({ min: -12 * 60 * 60 * 1000, max: 14 * 60 * 60 * 1000 }).map((n) => DateTime.zoneMakeOffset(n)),
@@ -11378,7 +11575,7 @@ export const TimeZoneNamed: TimeZoneNamed = declare(
     toCodecJson: () =>
       link<DateTime.TimeZone.Named>()(
         TimeZoneNamedString,
-        Transformation.timeZoneNamedFromString
+        SchemaTransformation.timeZoneNamedFromString
       ),
     toArbitrary: () => (fc) =>
       fc.constantFrom(
@@ -11416,7 +11613,7 @@ export interface TimeZoneNamedFromString extends decodeTo<TimeZoneNamed, String>
  * @since 4.0.0
  */
 export const TimeZoneNamedFromString: TimeZoneNamedFromString = TimeZoneNamedString.pipe(
-  decodeTo(TimeZoneNamed, Transformation.timeZoneNamedFromString)
+  decodeTo(TimeZoneNamed, SchemaTransformation.timeZoneNamedFromString)
 )
 
 /**
@@ -11461,7 +11658,7 @@ export const TimeZone: TimeZone = declare(
     toCodecJson: () =>
       link<DateTime.TimeZone>()(
         TimeZoneString,
-        Transformation.timeZoneFromString
+        SchemaTransformation.timeZoneFromString
       ),
     toArbitrary: () => (fc) =>
       fc.oneof(
@@ -11502,7 +11699,7 @@ export interface TimeZoneFromString extends decodeTo<TimeZone, String> {
  * @since 4.0.0
  */
 export const TimeZoneFromString: TimeZoneFromString = TimeZoneString.pipe(
-  decodeTo(TimeZone, Transformation.timeZoneFromString)
+  decodeTo(TimeZone, SchemaTransformation.timeZoneFromString)
 )
 
 /**
@@ -11549,7 +11746,7 @@ export const DateTimeZoned: DateTimeZoned = declare(
     toCodecJson: () =>
       link<DateTime.Zoned>()(
         DateTimeZonedString,
-        Transformation.dateTimeZonedFromString
+        SchemaTransformation.dateTimeZonedFromString
       ),
     toArbitrary: () => (fc, ctx) =>
       fc.tuple(
@@ -11591,7 +11788,7 @@ export interface DateTimeZonedFromString extends decodeTo<DateTimeZoned, String>
  * @since 4.0.0
  */
 export const DateTimeZonedFromString: DateTimeZonedFromString = DateTimeZonedString.pipe(
-  decodeTo(DateTimeZoned, Transformation.dateTimeZonedFromString)
+  decodeTo(DateTimeZoned, SchemaTransformation.dateTimeZonedFromString)
 )
 
 // -----------------------------------------------------------------------------
@@ -11610,7 +11807,7 @@ export interface Class<Self, S extends Top & { readonly fields: Struct.Fields },
     S["Encoded"],
     S["DecodingServices"],
     S["EncodingServices"],
-    AST.Declaration,
+    SchemaAST.Declaration,
     decodeTo<declareConstructor<Self, S["Encoded"], readonly [S], S["Iso"]>, S>,
     RequiredKeys<S["~type.make.in"]> extends never ? void | S["~type.make.in"] : S["~type.make.in"],
     S["Iso"],
@@ -11702,32 +11899,32 @@ function makeClass<
     static readonly identifier = identifier
     static readonly fields = struct.fields
 
-    static get ast(): AST.Declaration {
+    static get ast(): SchemaAST.Declaration {
       return getClassSchema(this).ast
     }
     static pipe() {
       return Pipeable.pipeArguments(this, arguments)
     }
-    static rebuild(ast: AST.Declaration) {
+    static rebuild(ast: SchemaAST.Declaration) {
       return getClassSchema(this).rebuild(ast)
     }
     static make(input: S["~type.make.in"], options?: MakeOptions): Self {
       return new this(input, options)
     }
     static makeOption(input: S["~type.make.in"], options?: MakeOptions): Option_.Option<Self> {
-      return Parser.makeOption(getClassSchema(this) as any)(input ?? {}, options) as any
+      return SchemaParser.makeOption(getClassSchema(this) as any)(input ?? {}, options) as any
     }
     static makeEffect(input: S["~type.make.in"], options?: MakeOptions): Effect.Effect<Self, SchemaError> {
       return (getClassSchema(this) as any).makeEffect(input ?? {}, options)
     }
     static annotate(annotations: Annotations.Declaration<Self, readonly [S]>) {
-      return this.rebuild(AST.annotate(this.ast, annotations))
+      return this.rebuild(SchemaAST.annotate(this.ast, annotations))
     }
     static annotateKey(annotations: Annotations.Key<Self>) {
-      return this.rebuild(AST.annotateKey(this.ast, annotations))
+      return this.rebuild(SchemaAST.annotateKey(this.ast, annotations))
     }
-    static check(...checks: readonly [AST.Check<Self>, ...Array<AST.Check<Self>>]) {
-      return this.rebuild(AST.appendChecks(this.ast, checks))
+    static check(...checks: readonly [SchemaAST.Check<Self>, ...Array<SchemaAST.Check<Self>>]) {
+      return this.rebuild(SchemaAST.appendChecks(this.ast, checks))
     }
     static extend<Extended>(
       identifier: string
@@ -11740,7 +11937,7 @@ function makeClass<
         return makeClass(
           this,
           identifier,
-          makeStruct(AST.struct(fields, struct.ast.checks, { identifier }), fields),
+          makeStruct(SchemaAST.struct(fields, struct.ast.checks, { identifier }), fields),
           annotations,
           proto
         )
@@ -11764,9 +11961,9 @@ function makeClass<
 }
 
 function getClassTransformation(self: new(...args: ReadonlyArray<any>) => any) {
-  return new Transformation.Transformation<any, any, never, never>(
-    Getter.transform((input) => new self(input)),
-    Getter.passthrough()
+  return new SchemaTransformation.Transformation<any, any, never, never>(
+    SchemaGetter.transform((input) => new self(input)),
+    SchemaGetter.passthrough()
   )
 }
 
@@ -11786,22 +11983,22 @@ function getClassSchemaFactory<S extends Top>(
     if (memo === undefined) {
       const transformation = getClassTransformation(self)
       const to = make<declareConstructor<Self, S["Encoded"], readonly [S]>>(
-        new AST.Declaration(
+        new SchemaAST.Declaration(
           [from.ast],
           () => (input, ast) => {
             return input instanceof self ||
                 Predicate.hasProperty(input, getClassTypeId(identifier)) ?
               Effect.succeed(input) :
-              Effect.fail(new Issue.InvalidType(ast, Option_.some(input)))
+              Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)))
           },
           {
             identifier,
-            [AST.ClassTypeId]: ([from]: readonly [AST.AST]) => new AST.Link(from, transformation),
-            toCodec: ([from]: readonly [Codec<S["Encoded"]>]) => new AST.Link(from.ast, transformation),
+            [SchemaAST.ClassTypeId]: ([from]: readonly [SchemaAST.AST]) => new SchemaAST.Link(from, transformation),
+            toCodec: ([from]: readonly [Codec<S["Encoded"]>]) => new SchemaAST.Link(from.ast, transformation),
             toArbitrary: ([from]: readonly [FastCheck.Arbitrary<S["Type"]>]) => () =>
               from.map((args) => new self(args)),
             toFormatter: ([from]: readonly [Formatter<S["Type"]>]) => (t: Self) => `${self.identifier}(${from(t)})`,
-            "~sentinels": AST.collectSentinels(from.ast),
+            "~sentinels": SchemaAST.collectSentinels(from.ast),
             ...annotations
           }
         )
@@ -11826,9 +12023,8 @@ type MissingSelfGeneric<Usage extends string> =
  *
  * **When to use**
  *
- * Use to define a schema-backed data class when you want validated
- * construction, schema-derived decoding/encoding, and class-style methods or
- * inheritance.
+ * Use when you need a schema-backed data class with validated construction,
+ * schema-derived decoding/encoding, and class-style methods or inheritance.
  *
  * **Details**
  *
@@ -11887,9 +12083,8 @@ export const Class: {
    *
    * **When to use**
    *
-   * Use to define a schema-backed data class when you want validated
-   * construction, schema-derived decoding/encoding, and class-style methods or
-   * inheritance.
+   * Use when you need a schema-backed data class with validated construction,
+   * schema-derived decoding/encoding, and class-style methods or inheritance.
    *
    * **Details**
    *
@@ -11948,9 +12143,8 @@ export const Class: {
      *
      * **When to use**
      *
-     * Use to define a schema-backed data class when you want validated
-     * construction, schema-derived decoding/encoding, and class-style methods or
-     * inheritance.
+     * Use when you need a schema-backed data class with validated construction,
+     * schema-derived decoding/encoding, and class-style methods or inheritance.
      *
      * **Details**
      *
@@ -12012,9 +12206,8 @@ export const Class: {
      *
      * **When to use**
      *
-     * Use to define a schema-backed data class when you want validated
-     * construction, schema-derived decoding/encoding, and class-style methods or
-     * inheritance.
+     * Use when you need a schema-backed data class with validated construction,
+     * schema-derived decoding/encoding, and class-style methods or inheritance.
      *
      * **Details**
      *
@@ -12595,18 +12788,18 @@ export function overrideToFormatter<S extends Top>(toFormatter: () => Formatter<
  */
 export function toFormatter<T>(schema: Schema<T>, options?: {
   readonly onBefore?:
-    | ((ast: AST.AST, recur: (ast: AST.AST) => Formatter<any>) => Formatter<any> | undefined)
+    | ((ast: SchemaAST.AST, recur: (ast: SchemaAST.AST) => Formatter<any>) => Formatter<any> | undefined)
     | undefined
 }): Formatter<T> {
   return recur(schema.ast)
 
-  function recur(ast: AST.AST): Formatter<T> {
+  function recur(ast: SchemaAST.AST): Formatter<T> {
     // ---------------------------------------------
     // handle annotation
     // ---------------------------------------------
     const annotation = InternalAnnotations.resolve(ast)?.["toFormatter"]
     if (typeof annotation === "function") {
-      return annotation(AST.isDeclaration(ast) ? ast.typeParameters.map(recur) : [])
+      return annotation(SchemaAST.isDeclaration(ast) ? ast.typeParameters.map(recur) : [])
     }
     // ---------------------------------------------
     // handle onBefore
@@ -12623,7 +12816,7 @@ export function toFormatter<T>(schema: Schema<T>, options?: {
     return on(ast)
   }
 
-  function on(ast: AST.AST): Formatter<any> {
+  function on(ast: SchemaAST.AST): Formatter<any> {
     switch (ast._tag) {
       default:
         return format
@@ -12642,7 +12835,7 @@ export function toFormatter<T>(schema: Schema<T>, options?: {
           // ---------------------------------------------
           for (; i < elements.length; i++) {
             if (t.length < i + 1) {
-              if (AST.isOptional(ast.elements[i])) {
+              if (SchemaAST.isOptional(ast.elements[i])) {
                 continue
               }
             } else {
@@ -12685,7 +12878,7 @@ export function toFormatter<T>(schema: Schema<T>, options?: {
             const ps = ast.propertySignatures[i]
             const name = ps.name
             visited.add(name)
-            if (AST.isOptional(ps.type) && !Object.hasOwn(t, name)) {
+            if (SchemaAST.isOptional(ps.type) && !Object.hasOwn(t, name)) {
               continue
             }
             out.push(`${formatPropertyKey(name)}: ${propertySignatures[i](t[name])}`)
@@ -12694,7 +12887,7 @@ export function toFormatter<T>(schema: Schema<T>, options?: {
           // handle index signatures
           // ---------------------------------------------
           for (let i = 0; i < indexSignatures.length; i++) {
-            const keys = AST.getIndexSignatureKeys(t, ast.indexSignatures[i].parameter)
+            const keys = SchemaAST.getIndexSignatureKeys(t, ast.indexSignatures[i].parameter)
             for (const key of keys) {
               if (visited.has(key)) {
                 continue
@@ -12708,10 +12901,10 @@ export function toFormatter<T>(schema: Schema<T>, options?: {
         }
       }
       case "Union": {
-        const getCandidates = (t: any) => AST.getCandidates(t, ast.types)
+        const getCandidates = (t: any) => SchemaAST.getCandidates(t, ast.types)
         return (t) => {
           const candidates = getCandidates(t)
-          const refinements = candidates.map(Parser._is)
+          const refinements = candidates.map(SchemaParser._is)
           for (let i = 0; i < candidates.length; i++) {
             const is = refinements[i]
             if (is(t)) {
@@ -12722,7 +12915,7 @@ export function toFormatter<T>(schema: Schema<T>, options?: {
         }
       }
       case "Suspend": {
-        const get = AST.memoizeThunk(() => recur(ast.thunk()))
+        const get = SchemaAST.memoizeThunk(() => recur(ast.thunk()))
         return (t) => get()(t)
       }
     }
@@ -12739,8 +12932,8 @@ export function toFormatter<T>(schema: Schema<T>, options?: {
  *
  * **When to use**
  *
- * Use when the default structural equivalence derived by {@link toEquivalence}
- * is not appropriate for a type.
+ * Use when you need a custom equivalence instead of the default structural
+ * equivalence derived by {@link toEquivalence}.
  *
  * @category instances
  * @since 4.0.0
@@ -12903,28 +13096,28 @@ export function toCodecJson<T, E, RD, RE>(schema: Codec<T, E, RD, RE>): Codec<T,
   return make(toCodecJsonTop(schema.ast))
 }
 
-const toCodecJsonTop = AST.toCodec((ast) => {
+const toCodecJsonTop = SchemaAST.toCodec((ast) => {
   const out = toCodecJsonBase(ast, toCodecJsonTop)
-  return out !== ast && AST.isOptional(ast) ? AST.optionalKeyLastLink(out) : out
+  return out !== ast && SchemaAST.isOptional(ast) ? SchemaAST.optionalKeyLastLink(out) : out
 })
 
-function toCodecJsonBase(ast: AST.AST, recur: (ast: AST.AST) => AST.AST): AST.AST {
+function toCodecJsonBase(ast: SchemaAST.AST, recur: (ast: SchemaAST.AST) => SchemaAST.AST): SchemaAST.AST {
   switch (ast._tag) {
     case "Declaration": {
       const getLink = ast.annotations?.toCodecJson ?? ast.annotations?.toCodec
       if (Predicate.isFunction(getLink)) {
-        const tps = AST.isDeclaration(ast)
-          ? ast.typeParameters.map((tp) => InternalSchema.make(AST.toEncoded(tp)))
+        const tps = SchemaAST.isDeclaration(ast)
+          ? ast.typeParameters.map((tp) => InternalSchema.make(SchemaAST.toEncoded(tp)))
           : []
         const link = getLink(tps)
         const to = recur(link.to)
-        return AST.replaceEncoding(ast, to === link.to ? [link] : [new AST.Link(to, link.transformation)])
+        return SchemaAST.replaceEncoding(ast, to === link.to ? [link] : [new SchemaAST.Link(to, link.transformation)])
       }
-      return AST.replaceEncoding(ast, [AST.unknownToNull])
+      return SchemaAST.replaceEncoding(ast, [SchemaAST.unknownToNull])
     }
     case "Unknown":
     case "ObjectKeyword":
-      return AST.replaceEncoding(ast, [AST.unknownToJson])
+      return SchemaAST.replaceEncoding(ast, [SchemaAST.unknownToJson])
     case "Undefined":
     case "Void":
     case "Literal":
@@ -12943,7 +13136,7 @@ function toCodecJsonBase(ast: AST.AST, recur: (ast: AST.AST) => AST.AST): AST.AS
     case "Union": {
       const sortedTypes = InternalSchema.jsonReorder(ast.types)
       if (sortedTypes !== ast.types) {
-        return new AST.Union(
+        return new SchemaAST.Union(
           sortedTypes,
           ast.mode,
           ast.annotations,
@@ -12970,22 +13163,22 @@ function toCodecJsonBase(ast: AST.AST, recur: (ast: AST.AST) => AST.AST): AST.AS
  * @since 4.0.0
  */
 export function toCodecIso<S extends Top>(schema: S): Codec<S["Type"], S["Iso"]> {
-  return make(toCodecIsoTop(AST.toType(schema.ast)))
+  return make(toCodecIsoTop(SchemaAST.toType(schema.ast)))
 }
 
-const toCodecIsoTop = memoize((ast: AST.AST): AST.AST => {
+const toCodecIsoTop = memoize((ast: SchemaAST.AST): SchemaAST.AST => {
   const out = toCodecIsoBase(ast, toCodecIsoTop)
-  return out !== ast && AST.isOptional(ast) ? AST.optionalKeyLastLink(out) : out
+  return out !== ast && SchemaAST.isOptional(ast) ? SchemaAST.optionalKeyLastLink(out) : out
 })
 
-function toCodecIsoBase(ast: AST.AST, recur: (ast: AST.AST) => AST.AST): AST.AST {
+function toCodecIsoBase(ast: SchemaAST.AST, recur: (ast: SchemaAST.AST) => SchemaAST.AST): SchemaAST.AST {
   switch (ast._tag) {
     case "Declaration": {
       const getLink = ast.annotations?.toCodecIso ?? ast.annotations?.toCodec
       if (Predicate.isFunction(getLink)) {
         const link = getLink(ast.typeParameters.map((tp) => InternalSchema.make(tp)))
         const to = recur(link.to)
-        return AST.replaceEncoding(ast, to === link.to ? [link] : [new AST.Link(to, link.transformation)])
+        return SchemaAST.replaceEncoding(ast, to === link.to ? [link] : [new SchemaAST.Link(to, link.transformation)])
       }
       return ast
     }
@@ -13165,7 +13358,7 @@ const xml = {
   }
 }
 
-function getStringTreePriority(ast: AST.AST): number {
+function getStringTreePriority(ast: SchemaAST.AST): number {
   switch (ast._tag) {
     case "Null":
     case "Boolean":
@@ -13182,30 +13375,30 @@ function getStringTreePriority(ast: AST.AST): number {
 const treeReorder = InternalSchema.makeReorder(getStringTreePriority)
 
 function serializerTree(
-  ast: AST.AST,
-  recur: (ast: AST.AST) => AST.AST,
-  onMissingAnnotation: (ast: AST.AST) => AST.AST
-): AST.AST {
+  ast: SchemaAST.AST,
+  recur: (ast: SchemaAST.AST) => SchemaAST.AST,
+  onMissingAnnotation: (ast: SchemaAST.AST) => SchemaAST.AST
+): SchemaAST.AST {
   switch (ast._tag) {
     case "Declaration": {
       const getLink = ast.annotations?.toCodecJson ?? ast.annotations?.toCodec
       if (Predicate.isFunction(getLink)) {
-        const tps = AST.isDeclaration(ast)
-          ? ast.typeParameters.map((tp) => make(recur(AST.toEncoded(tp))))
+        const tps = SchemaAST.isDeclaration(ast)
+          ? ast.typeParameters.map((tp) => make(recur(SchemaAST.toEncoded(tp))))
           : []
         const link = getLink(tps)
         const to = recur(link.to)
-        return AST.replaceEncoding(ast, to === link.to ? [link] : [new AST.Link(to, link.transformation)])
+        return SchemaAST.replaceEncoding(ast, to === link.to ? [link] : [new SchemaAST.Link(to, link.transformation)])
       }
       return onMissingAnnotation(ast)
     }
     case "Null":
-      return AST.replaceEncoding(ast, [nullToString])
+      return SchemaAST.replaceEncoding(ast, [nullToString])
     case "Boolean":
-      return AST.replaceEncoding(ast, [booleanToString])
+      return SchemaAST.replaceEncoding(ast, [booleanToString])
     case "Unknown":
     case "ObjectKeyword":
-      return AST.replaceEncoding(ast, [AST.unknownToStringTree])
+      return SchemaAST.replaceEncoding(ast, [SchemaAST.unknownToStringTree])
     case "Enum":
     case "Number":
     case "Literal":
@@ -13222,7 +13415,7 @@ function serializerTree(
     case "Union": {
       const sortedTypes = treeReorder(ast.types)
       if (sortedTypes !== ast.types) {
-        return new AST.Union(
+        return new SchemaAST.Union(
           sortedTypes,
           ast.mode,
           ast.annotations,
@@ -13241,75 +13434,75 @@ function serializerTree(
   return ast
 }
 
-const nullToString = new AST.Link(
-  new AST.Literal("null"),
-  new Transformation.Transformation(
-    Getter.transform(() => null),
-    Getter.transform(() => "null")
+const nullToString = new SchemaAST.Link(
+  new SchemaAST.Literal("null"),
+  new SchemaTransformation.Transformation(
+    SchemaGetter.transform(() => null),
+    SchemaGetter.transform(() => "null")
   )
 )
 
-const booleanToString = new AST.Link(
-  new AST.Union([new AST.Literal("true"), new AST.Literal("false")], "anyOf"),
-  new Transformation.Transformation(
-    Getter.transform((s) => s === "true"),
-    Getter.String()
+const booleanToString = new SchemaAST.Link(
+  new SchemaAST.Union([new SchemaAST.Literal("true"), new SchemaAST.Literal("false")], "anyOf"),
+  new SchemaTransformation.Transformation(
+    SchemaGetter.transform((s) => s === "true"),
+    SchemaGetter.String()
   )
 )
 
-const serializerStringTree = AST.toCodec((ast) => {
-  const out = serializerTree(ast, serializerStringTree, (ast) => AST.replaceEncoding(ast, [unknownToUndefined]))
-  if (out !== ast && AST.isOptional(ast)) {
-    return AST.optionalKeyLastLink(out)
+const serializerStringTree = SchemaAST.toCodec((ast) => {
+  const out = serializerTree(ast, serializerStringTree, (ast) => SchemaAST.replaceEncoding(ast, [unknownToUndefined]))
+  if (out !== ast && SchemaAST.isOptional(ast)) {
+    return SchemaAST.optionalKeyLastLink(out)
   }
   return out
 })
 
-const unknownToUndefined = new AST.Link(
-  AST.undefined,
-  new Transformation.Transformation(
-    Getter.passthrough(),
-    Getter.transform(() => undefined)
+const unknownToUndefined = new SchemaAST.Link(
+  SchemaAST.undefined,
+  new SchemaTransformation.Transformation(
+    SchemaGetter.passthrough(),
+    SchemaGetter.transform(() => undefined)
   )
 )
 
-const serializerStringTreeKeepDeclarations = AST.toCodec((ast) => {
+const serializerStringTreeKeepDeclarations = SchemaAST.toCodec((ast) => {
   const out = serializerTree(ast, serializerStringTreeKeepDeclarations, identity)
-  if (out !== ast && AST.isOptional(ast)) {
-    return AST.optionalKeyLastLink(out)
+  if (out !== ast && SchemaAST.isOptional(ast)) {
+    return SchemaAST.optionalKeyLastLink(out)
   }
   return out
 })
 
 const SERIALIZER_ENSURE_ARRAY = "~effect/Schema/SERIALIZER_ENSURE_ARRAY"
 
-const toCodecEnsureArray = AST.toCodec((ast) => {
-  if (AST.isUnion(ast) && ast.annotations?.[SERIALIZER_ENSURE_ARRAY]) {
+const toCodecEnsureArray = SchemaAST.toCodec((ast) => {
+  if (SchemaAST.isUnion(ast) && ast.annotations?.[SERIALIZER_ENSURE_ARRAY]) {
     return ast
   }
   const out = onSerializerEnsureArray(ast)
-  if (AST.isArrays(out)) {
-    const ensure = new AST.Union(
+  if (SchemaAST.isArrays(out)) {
+    const ensure = new SchemaAST.Union(
       [
         out,
-        AST.decodeTo(
-          AST.string,
+        SchemaAST.decodeTo(
+          SchemaAST.string,
           out,
-          new Transformation.Transformation(
-            Getter.split(),
-            Getter.passthrough()
+          new SchemaTransformation.Transformation(
+            SchemaGetter.split(),
+            SchemaGetter.passthrough()
           )
         )
       ],
       "anyOf",
       { [SERIALIZER_ENSURE_ARRAY]: true }
     )
-    return AST.isOptional(ast) ? AST.optionalKey(ensure) : ensure
+    return SchemaAST.isOptional(ast) ? SchemaAST.optionalKey(ensure) : ensure
   }
   return out
 })
 
-function onSerializerEnsureArray(ast: AST.AST): AST.AST {
+function onSerializerEnsureArray(ast: SchemaAST.AST): SchemaAST.AST {
   switch (ast._tag) {
     default:
       return ast
@@ -13335,7 +13528,7 @@ function onSerializerEnsureArray(ast: AST.AST): AST.AST {
  */
 export function toIso<S extends Top>(schema: S): Optic_.Iso<S["Type"], S["Iso"]> {
   const serializer = toCodecIso(schema)
-  return Optic_.makeIso(Parser.encodeSync(serializer), Parser.decodeSync(serializer))
+  return Optic_.makeIso(SchemaParser.encodeSync(serializer), SchemaParser.decodeSync(serializer))
 }
 
 /**
@@ -13406,14 +13599,14 @@ export interface overrideToCodecIso<S extends Top, Iso> extends
 export function overrideToCodecIso<S extends Top, Iso>(
   to: Codec<Iso>,
   transformation: {
-    readonly decode: Getter.Getter<S["Type"], Iso>
-    readonly encode: Getter.Getter<Iso, S["Type"]>
+    readonly decode: SchemaGetter.Getter<S["Type"], Iso>
+    readonly encode: SchemaGetter.Getter<Iso, S["Type"]>
   }
 ) {
   return (schema: S): overrideToCodecIso<S, Iso> => {
     return make(
-      AST.annotate(schema.ast, {
-        toCodecIso: () => new AST.Link(to.ast, Transformation.make(transformation))
+      SchemaAST.annotate(schema.ast, {
+        toCodecIso: () => new SchemaAST.Link(to.ast, SchemaTransformation.make(transformation))
       }),
       { schema }
     )
@@ -13434,8 +13627,8 @@ export function overrideToCodecIso<S extends Top, Iso>(
  */
 export function toDifferJsonPatch<T, E>(schema: Codec<T, E>): Differ<T, JsonPatch.JsonPatch> {
   const serializer = toCodecJson(schema)
-  const get = Parser.encodeSync(serializer)
-  const set = Parser.decodeSync(serializer)
+  const get = SchemaParser.encodeSync(serializer)
+  const set = SchemaParser.decodeSync(serializer)
   return {
     empty: [],
     diff: (oldValue, newValue) => JsonPatch.get(get(oldValue), get(newValue)),
@@ -13535,7 +13728,7 @@ export interface JsonObject {
  * @category schemas
  * @since 4.0.0
  */
-export const Json: Codec<Json> = make(AST.Json)
+export const Json: Codec<Json> = make(SchemaAST.Json)
 
 /**
  * Recursive TypeScript type for mutable JSON values: `null`, `number`,
@@ -13571,7 +13764,7 @@ export interface MutableJsonObject {
  * @category schemas
  * @since 4.0.0
  */
-export const MutableJson: Codec<MutableJson> = make(AST.MutableJson)
+export const MutableJson: Codec<MutableJson> = make(SchemaAST.MutableJson)
 
 // -----------------------------------------------------------------------------
 // Annotations
@@ -13761,7 +13954,7 @@ export declare namespace Annotations {
      * filter/refinement instead.
      */
     readonly identifier?: string | undefined
-    readonly parseOptions?: AST.ParseOptions | undefined
+    readonly parseOptions?: SchemaAST.ParseOptions | undefined
     /**
      * Optional metadata used to identify or extend the filter with custom data.
      */
@@ -13817,19 +14010,20 @@ export declare namespace Annotations {
     extends Bottom<T, TypeParameters>
   {
     readonly toCodec?:
-      | ((typeParameters: TypeParameters.Encoded<TypeParameters>) => AST.Link)
+      | ((typeParameters: TypeParameters.Encoded<TypeParameters>) => SchemaAST.Link)
       | undefined
     readonly toCodecJson?:
-      | ((typeParameters: TypeParameters.Encoded<TypeParameters>) => AST.Link)
+      | ((typeParameters: TypeParameters.Encoded<TypeParameters>) => SchemaAST.Link)
       | undefined
     readonly toCodecIso?:
-      | ((typeParameters: TypeParameters.Type<TypeParameters>) => AST.Link)
+      | ((typeParameters: TypeParameters.Type<TypeParameters>) => SchemaAST.Link)
       | undefined
     readonly toArbitrary?: ToArbitrary.Declaration<T, TypeParameters> | undefined
     readonly toEquivalence?: ToEquivalence.Declaration<T, TypeParameters> | undefined
     readonly toFormatter?: ToFormatter.Declaration<T, TypeParameters> | undefined
     readonly typeConstructor?: {
       readonly _tag: string
+      readonly [key: string]: unknown
     } | undefined
     readonly generation?: {
       readonly runtime: string
@@ -13838,11 +14032,11 @@ export declare namespace Annotations {
       readonly importDeclaration?: string | undefined
     } | undefined
     /**
-     * Used to collect sentinels from a Declaration AST.
+     * Used to collect sentinels from a Declaration SchemaAST.
      *
      * @internal
      */
-    readonly "~sentinels"?: ReadonlyArray<AST.Sentinel> | undefined
+    readonly "~sentinels"?: ReadonlyArray<SchemaAST.Sentinel> | undefined
   }
 
   /**
@@ -14262,7 +14456,7 @@ export declare namespace Annotations {
     }
     readonly isPropertyNames: {
       readonly _tag: "isPropertyNames"
-      readonly propertyNames: AST.AST
+      readonly propertyNames: SchemaAST.AST
     }
     // Arrays Meta
     readonly isUnique: {