effect 4.0.0-beta.74 → 4.0.0-beta.76

package/dist/Schema.js

@@ -31,7 +31,7 @@
  * - Type guard: {@link is}
  * - Assertion: {@link asserts}
  * - Add constraints: `.check(...)` with filters like {@link isMinLength},
- *   {@link isGreaterThan}, {@link isPattern}, {@link isUUID}
+ *   {@link isGreaterThan}, {@link isPattern}, {@link isUUID}, {@link isGUID}
  * - Transform between schemas: {@link decodeTo}, {@link encodeTo}
  * - Add a default for missing keys: {@link withDecodingDefault}, {@link withDecodingDefaultKey}
  * - Create branded types: {@link brand}
@@ -118,11 +118,11 @@ import * as Record_ from "./Record.js";
 import * as Redacted_ from "./Redacted.js";
 import * as Result_ from "./Result.js";
 import * as Scheduler from "./Scheduler.js";
-import * as AST from "./SchemaAST.js";
-import * as Getter from "./SchemaGetter.js";
-import * as Issue from "./SchemaIssue.js";
-import * as Parser from "./SchemaParser.js";
-import * as Transformation from "./SchemaTransformation.js";
+import * as SchemaAST from "./SchemaAST.js";
+import * as SchemaGetter from "./SchemaGetter.js";
+import * as SchemaIssue from "./SchemaIssue.js";
+import * as SchemaParser from "./SchemaParser.js";
+import * as SchemaTransformation from "./SchemaTransformation.js";
 import * as Struct_ from "./Struct.js";
 import * as FastCheck from "./testing/FastCheck.js";
 const TypeId = InternalSchema.TypeId;
@@ -131,6 +131,11 @@ const TypeId = InternalSchema.TypeId;
  * `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`,
@@ -160,7 +165,7 @@ const TypeId = InternalSchema.TypeId;
  *     ([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),
@@ -177,7 +182,7 @@ const TypeId = InternalSchema.TypeId;
  */
 export function declareConstructor() {
   return (typeParameters, run, annotations) => {
-    return make(new AST.Declaration(typeParameters.map(AST.getAST), typeParameters => run(typeParameters.map(ast => make(ast))), annotations));
+    return make(new SchemaAST.Declaration(typeParameters.map(SchemaAST.getAST), typeParameters => run(typeParameters.map(ast => make(ast))), annotations));
   };
 }
 /**
@@ -185,10 +190,10 @@ export function declareConstructor() {
  * 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)
  *
@@ -212,7 +217,7 @@ export function declareConstructor() {
  * @since 3.10.0
  */
 export function declare(is, annotations) {
-  return declareConstructor()([], () => (input, ast) => is(input) ? Effect.succeed(input) : Effect.fail(new Issue.InvalidType(ast, Option_.some(input))), annotations);
+  return declareConstructor()([], () => (input, ast) => is(input) ? Effect.succeed(input) : Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input))), annotations);
 }
 /**
  * Returns a schema widened to the fully-parameterized {@link Bottom} interface,
@@ -342,7 +347,7 @@ export function annotateEncoded(annotations) {
  */
 export function annotateKey(annotations) {
   return self => {
-    return self.rebuild(AST.annotateKey(self.ast, annotations));
+    return self.rebuild(SchemaAST.annotateKey(self.ast, annotations));
   };
 }
 /**
@@ -380,7 +385,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.
@@ -500,12 +505,12 @@ function makeStandardResult(exit) {
  * @since 4.0.0
  */
 export function toStandardSchemaV1(self, options) {
-  const decodeUnknownEffect = Parser.decodeUnknownEffect(self);
+  const decodeUnknownEffect = SchemaParser.decodeUnknownEffect(self);
   const parseOptions = {
     errors: "all",
     ...options?.parseOptions
   };
-  const formatter = Issue.makeFormatterStandardSchemaV1(options);
+  const formatter = SchemaIssue.makeFormatterStandardSchemaV1(options);
   const validate = value => {
     const scheduler = new Scheduler.MixedScheduler();
     const fiber = Effect.runFork(Effect.match(decodeUnknownEffect(value, parseOptions), {
@@ -629,7 +634,7 @@ export function toStandardJSONSchemaV1(self) {
  * @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
  * the schema.
@@ -637,7 +642,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**
  *
@@ -667,14 +672,15 @@ export const is = Parser.is;
  * @category guards
  * @since 4.0.0
  */
-export const asserts = Parser.asserts;
+export const asserts = SchemaParser.asserts;
 /**
  * Decodes an `unknown` input against a schema, returning an `Effect` that
  * succeeds with the decoded value or fails with a {@link SchemaError}.
  *
  * **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**
  *
@@ -683,11 +689,13 @@ export const asserts = Parser.asserts;
  * 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(schema, options) {
-  const parser = Parser.decodeUnknownEffect(schema, options);
+  const parser = SchemaParser.decodeUnknownEffect(schema, options);
   return (input, options) => {
     return Effect.mapErrorEager(parser(input, options), issue => new SchemaError(issue));
   };
@@ -699,7 +707,8 @@ export function decodeUnknownEffect(schema, options) {
  *
  * **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**
  *
@@ -707,6 +716,8 @@ export function decodeUnknownEffect(schema, options) {
  * 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
  */
@@ -718,8 +729,8 @@ export const decodeEffect = decodeUnknownEffect;
  *
  * **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**
  *
@@ -729,11 +740,13 @@ export const decodeEffect = decodeUnknownEffect;
  * 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(schema, options) {
-  const parser = Parser.decodeUnknownExit(schema, options);
+  const parser = SchemaParser.decodeUnknownExit(schema, options);
   return (input, options) => {
     return Exit_.mapError(parser(input, options), issue => new SchemaError(issue));
   };
@@ -745,8 +758,8 @@ export function decodeUnknownExit(schema, 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**
  *
@@ -755,6 +768,8 @@ export function decodeUnknownExit(schema, 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
  */
@@ -765,20 +780,21 @@ export const decodeExit = decodeUnknownExit;
  *
  * **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 = SchemaParser.decodeUnknownOption;
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema,
  * returning an `Option` that is `Some` with the decoded value on success or
@@ -786,7 +802,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**
  *
@@ -797,35 +814,43 @@ export const decodeUnknownOption = Parser.decodeUnknownOption;
  * @category decoding
  * @since 3.10.0
  */
-export const decodeOption = Parser.decodeOption;
+export const decodeOption = 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(schema, options) {
+  const parser = SchemaParser.decodeUnknownResult(schema, options);
+  return (input, options) => {
+    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**
  *
@@ -833,36 +858,49 @@ 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 = 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(schema, options) {
+  const parser = decodeUnknownEffect(schema, options);
+  return (input, options) => {
+    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**
  *
@@ -870,22 +908,24 @@ 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 = 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
@@ -908,19 +948,25 @@ 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(schema, options) {
+  const parser = decodeUnknownEffect(schema, options);
+  return (input, options) => {
+    return Effect.runSync(parser(input, options));
+  };
+}
 /**
  * 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**
  *
@@ -929,21 +975,24 @@ 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 = decodeUnknownSync;
 /**
  * Encodes an `unknown` input against a schema, returning an `Effect` that
  * succeeds with the encoded value or fails with a {@link SchemaError}.
  *
  * **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.
@@ -959,11 +1008,13 @@ 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(schema, options) {
-  const parser = Parser.encodeUnknownEffect(schema, options);
+  const parser = SchemaParser.encodeUnknownEffect(schema, options);
   return (input, options) => {
     return Effect.mapErrorEager(parser(input, options), issue => new SchemaError(issue));
   };
@@ -975,7 +1026,8 @@ export function encodeUnknownEffect(schema, options) {
  *
  * **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**
  *
@@ -983,6 +1035,8 @@ export function encodeUnknownEffect(schema, options) {
  * 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
  */
@@ -994,21 +1048,23 @@ export const encodeEffect = encodeUnknownEffect;
  *
  * **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(schema, options) {
-  const parser = Parser.encodeUnknownExit(schema, options);
+  const parser = SchemaParser.encodeUnknownExit(schema, options);
   return (input, options) => {
     return Exit_.mapError(parser(input, options), issue => new SchemaError(issue));
   };
@@ -1020,8 +1076,8 @@ export function encodeUnknownExit(schema, 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**
  *
@@ -1030,6 +1086,8 @@ export function encodeUnknownExit(schema, 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
  */
@@ -1040,20 +1098,21 @@ export const encodeExit = encodeUnknownExit;
  *
  * **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 = SchemaParser.encodeUnknownOption;
 /**
  * Encodes a typed input (the schema's `Type`) against a schema, returning an
  * `Option` that is `Some` with the encoded value on success or `None` on
@@ -1061,7 +1120,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**
  *
@@ -1072,34 +1132,42 @@ export const encodeUnknownOption = Parser.encodeUnknownOption;
  * @category encoding
  * @since 3.10.0
  */
-export const encodeOption = Parser.encodeOption;
+export const encodeOption = 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(schema, options) {
+  const parser = SchemaParser.encodeUnknownResult(schema, options);
+  return (input, options) => {
+    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**
  *
@@ -1107,28 +1175,38 @@ 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 = 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(schema, options) {
+  const parser = encodeUnknownEffect(schema, options);
+  return (input, options) => {
+    return Effect.runPromise(parser(input, options));
+  };
+}
 /**
  * Encodes a typed input (the schema's `Type`) against a schema, returning a
  * `Promise` that resolves with the encoded value or rejects with a
@@ -1136,7 +1214,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**
  *
@@ -1144,39 +1223,48 @@ 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 = encodeUnknownPromise;
 /**
  * Encodes an `unknown` input against a schema synchronously, throwing a
  * {@link SchemaError} on failure.
  *
  * **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(schema, options) {
+  const parser = encodeUnknownEffect(schema, options);
+  return (input, options) => {
+    return Effect.runSync(parser(input, options));
+  };
+}
 /**
  * Encodes a typed input (the schema's `Type`) against a schema synchronously,
  * throwing a {@link SchemaError} on failure.
  *
  * **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**
  *
@@ -1184,10 +1272,12 @@ 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 = encodeUnknownSync;
 /**
  * Creates a schema from an AST (Abstract Syntax Tree) node.
  *
@@ -1263,7 +1353,7 @@ export function isSchema(u) {
  * @category combinators
  * @since 4.0.0
  */
-export const optionalKey = /*#__PURE__*/Struct_.lambda(schema => make(AST.optionalKey(schema.ast), {
+export const optionalKey = /*#__PURE__*/Struct_.lambda(schema => make(SchemaAST.optionalKey(schema.ast), {
   schema
 }));
 /**
@@ -1331,7 +1421,7 @@ export const required = /*#__PURE__*/Struct_.lambda(self => self.schema.members[
  * @category combinators
  * @since 4.0.0
  */
-export const mutableKey = /*#__PURE__*/Struct_.lambda(schema => make(AST.mutableKey(schema.ast), {
+export const mutableKey = /*#__PURE__*/Struct_.lambda(schema => make(SchemaAST.mutableKey(schema.ast), {
   schema
 }));
 /**
@@ -1353,7 +1443,7 @@ export const readonlyKey = /*#__PURE__*/Struct_.lambda(self => self.schema);
  * @category transforming
  * @since 4.0.0
  */
-export const toType = /*#__PURE__*/Struct_.lambda(schema => make(AST.toType(schema.ast), {
+export const toType = /*#__PURE__*/Struct_.lambda(schema => make(SchemaAST.toType(schema.ast), {
   schema
 }));
 /**
@@ -1363,7 +1453,7 @@ export const toType = /*#__PURE__*/Struct_.lambda(schema => make(AST.toType(sche
  * @category transforming
  * @since 4.0.0
  */
-export const toEncoded = /*#__PURE__*/Struct_.lambda(schema => make(AST.toEncoded(schema.ast), {
+export const toEncoded = /*#__PURE__*/Struct_.lambda(schema => make(SchemaAST.toEncoded(schema.ast), {
   schema
 }));
 const FlipTypeId = "~effect/Schema/flip";
@@ -1372,9 +1462,9 @@ function isFlip$(schema) {
 }
 export function flip(schema) {
   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), {
+  return make(SchemaAST.flip(schema.ast), {
     [FlipTypeId]: FlipTypeId,
     schema
   });
@@ -1398,24 +1488,29 @@ export function flip(schema) {
  * @since 3.10.0
  */
 export function Literal(literal) {
-  const out = make(new AST.Literal(literal), {
+  const out = make(new SchemaAST.Literal(literal), {
     literal,
     transform(to) {
       return out.pipe(decodeTo(Literal(to), {
-        decode: Getter.transform(() => to),
-        encode: Getter.transform(() => literal)
+        decode: SchemaGetter.transform(() => to),
+        encode: SchemaGetter.transform(() => literal)
       }));
     }
   });
   return out;
 }
 function templateLiteralFromParts(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
@@ -1486,7 +1581,7 @@ export function TemplateLiteralParser(parts) {
  * @since 4.0.0
  */
 export function Enum(enums) {
-  return make(new AST.Enum(Object.keys(enums).filter(key => typeof enums[enums[key]] !== "number").map(key => [key, enums[key]])), {
+  return make(new SchemaAST.Enum(Object.keys(enums).filter(key => typeof enums[enums[key]] !== "number").map(key => [key, enums[key]])), {
     enums
   });
 }
@@ -1496,7 +1591,7 @@ export function Enum(enums) {
  * @category schemas
  * @since 3.10.0
  */
-export const Never = /*#__PURE__*/make(AST.never);
+export const Never = /*#__PURE__*/make(SchemaAST.never);
 /**
  * Schema for the `any` type. Accepts any value without validation.
  *
@@ -1504,15 +1599,20 @@ export const Never = /*#__PURE__*/make(AST.never);
  * @category schemas
  * @since 3.10.0
  */
-export const Any = /*#__PURE__*/make(AST.any);
+export const Any = /*#__PURE__*/make(SchemaAST.any);
 /**
  * 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 = /*#__PURE__*/make(AST.unknown);
+export const Unknown = /*#__PURE__*/make(SchemaAST.unknown);
 /**
  * Schema for the `null` literal. Validates that the input is strictly `null`.
  *
@@ -1520,7 +1620,7 @@ export const Unknown = /*#__PURE__*/make(AST.unknown);
  * @category schemas
  * @since 3.10.0
  */
-export const Null = /*#__PURE__*/make(AST.null);
+export const Null = /*#__PURE__*/make(SchemaAST.null);
 /**
  * Schema for the `undefined` literal. Validates that the input is strictly `undefined`.
  *
@@ -1528,14 +1628,14 @@ export const Null = /*#__PURE__*/make(AST.null);
  * @category schemas
  * @since 3.10.0
  */
-export const Undefined = /*#__PURE__*/make(AST.undefined);
+export const Undefined = /*#__PURE__*/make(SchemaAST.undefined);
 /**
  * Schema for `string` values. Validates that the input is `typeof` `"string"`.
  *
  * @category schemas
  * @since 4.0.0
  */
-export const String = /*#__PURE__*/make(AST.string);
+export const String = /*#__PURE__*/make(SchemaAST.string);
 /**
  * Schema for `number` values, including `NaN`, `Infinity`, and `-Infinity`.
  *
@@ -1550,7 +1650,7 @@ export const String = /*#__PURE__*/make(AST.string);
  * @category schemas
  * @since 4.0.0
  */
-export const Number = /*#__PURE__*/make(AST.number);
+export const Number = /*#__PURE__*/make(SchemaAST.number);
 /**
  * Schema for `boolean` values. Validates that the input is `typeof` `"boolean"`.
  *
@@ -1563,7 +1663,7 @@ export const Number = /*#__PURE__*/make(AST.number);
  * @category boolean
  * @since 4.0.0
  */
-export const Boolean = /*#__PURE__*/make(AST.boolean);
+export const Boolean = /*#__PURE__*/make(SchemaAST.boolean);
 /**
  * Schema for `symbol` values. Validates that the input is `typeof` `"symbol"`.
  *
@@ -1571,7 +1671,7 @@ export const Boolean = /*#__PURE__*/make(AST.boolean);
  * @category schemas
  * @since 4.0.0
  */
-export const Symbol = /*#__PURE__*/make(AST.symbol);
+export const Symbol = /*#__PURE__*/make(SchemaAST.symbol);
 /**
  * Schema for `bigint` values. Validates that the input is `typeof` `"bigint"`.
  *
@@ -1585,14 +1685,14 @@ export const Symbol = /*#__PURE__*/make(AST.symbol);
  * @category schemas
  * @since 4.0.0
  */
-export const BigInt = /*#__PURE__*/make(AST.bigInt);
+export const BigInt = /*#__PURE__*/make(SchemaAST.bigInt);
 /**
  * Schema for the `void` type. Accepts `undefined` as the encoded value.
  *
  * @category schemas
  * @since 3.10.0
  */
-export const Void = /*#__PURE__*/make(AST.void);
+export const Void = /*#__PURE__*/make(SchemaAST.void);
 /**
  * Schema for the `object` type. Validates that the input is a non-null object or function
  * (i.e. `typeof value === "object" && value !== null || typeof value === "function"`).
@@ -1600,7 +1700,7 @@ export const Void = /*#__PURE__*/make(AST.void);
  * @category schemas
  * @since 4.0.0
  */
-export const ObjectKeyword = /*#__PURE__*/make(AST.objectKeyword);
+export const ObjectKeyword = /*#__PURE__*/make(SchemaAST.objectKeyword);
 /**
  * Creates a schema for a specific symbol. Only that exact symbol satisfies the schema.
  *
@@ -1618,14 +1718,14 @@ export const ObjectKeyword = /*#__PURE__*/make(AST.objectKeyword);
  * @since 4.0.0
  */
 export function UniqueSymbol(symbol) {
-  return make(new AST.UniqueSymbol(symbol));
+  return make(new SchemaAST.UniqueSymbol(symbol));
 }
 function makeStruct(ast, fields) {
   return make(ast, {
     fields,
     mapFields(f, options) {
       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);
     }
   });
 }
@@ -1663,15 +1763,15 @@ function makeStruct(ast, fields) {
  * @since 3.10.0
  */
 export function Struct(fields) {
-  return makeStruct(AST.struct(fields, undefined), fields);
+  return makeStruct(SchemaAST.struct(fields, undefined), fields);
 }
 /**
  * Adds fields to a struct schema through a struct-mapping 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**
  *
@@ -1734,7 +1834,7 @@ export function encodeKeys(mapping) {
         fields[k] = encoded;
       }
     }
-    return Struct(fields).pipe(decodeTo(self, Transformation.transform({
+    return Struct(fields).pipe(decodeTo(self, SchemaTransformation.transform({
       decode: Struct_.renameKeys(reverseMapping),
       encode: Struct_.renameKeys(mapping)
     })));
@@ -1780,7 +1880,7 @@ derive) {
       ...f,
       ...fields
     });
-    return self.pipe(decodeTo(to, Transformation.transform({
+    return self.pipe(decodeTo(to, SchemaTransformation.transform({
       decode: input => {
         const out = {
           ...input
@@ -1828,8 +1928,8 @@ derive) {
  * @since 3.10.0
  */
 export function Record(key, value, options) {
-  const keyValueCombiner = options?.keyValueCombiner?.decode || options?.keyValueCombiner?.encode ? new AST.KeyValueCombiner(options.keyValueCombiner.decode, options.keyValueCombiner.encode) : undefined;
-  return make(AST.record(key.ast, value.ast, keyValueCombiner), {
+  const keyValueCombiner = options?.keyValueCombiner?.decode || options?.keyValueCombiner?.encode ? new SchemaAST.KeyValueCombiner(options.keyValueCombiner.decode, options.keyValueCombiner.encode) : undefined;
+  return make(SchemaAST.record(key.ast, value.ast, keyValueCombiner), {
     key,
     value
   });
@@ -1845,10 +1945,10 @@ export function Record(key, value, options) {
  *
  * 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
  * ```
  *
@@ -1856,7 +1956,7 @@ export function Record(key, value, options) {
  * @since 4.0.0
  */
 export function StructWithRest(schema, records) {
-  return make(AST.structWithRest(schema.ast, records.map(AST.getAST)), {
+  return make(SchemaAST.structWithRest(schema.ast, records.map(SchemaAST.getAST)), {
     schema,
     records
   });
@@ -1866,7 +1966,7 @@ function makeTuple(ast, elements) {
     elements,
     mapElements(f, options) {
       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);
     }
   });
 }
@@ -1889,7 +1989,7 @@ function makeTuple(ast, elements) {
  * @since 3.10.0
  */
 export function Tuple(elements) {
-  return makeTuple(AST.tuple(elements), elements);
+  return makeTuple(SchemaAST.tuple(elements), elements);
 }
 /**
  * Extends a fixed-length tuple schema with a variadic rest segment.
@@ -1922,7 +2022,7 @@ export function Tuple(elements) {
  * @since 4.0.0
  */
 export function TupleWithRest(schema, rest) {
-  return make(AST.tupleWithRest(schema.ast, rest.map(AST.getAST)), {
+  return make(SchemaAST.tupleWithRest(schema.ast, rest.map(SchemaAST.getAST)), {
     schema,
     rest
   });
@@ -1931,7 +2031,7 @@ export function TupleWithRest(schema, rest) {
  * @category constructors
  * @since 4.0.0
  */
-const ArraySchema = /*#__PURE__*/Struct_.lambda(schema => make(new AST.Arrays(false, [], [schema.ast]), {
+const ArraySchema = /*#__PURE__*/Struct_.lambda(schema => make(new SchemaAST.Arrays(false, [], [schema.ast]), {
   value: schema
 }));
 export {
@@ -1972,7 +2072,7 @@ ArraySchema as Array };
  * @category constructors
  * @since 3.10.0
  */
-export const NonEmptyArray = /*#__PURE__*/Struct_.lambda(schema => make(new AST.Arrays(false, [schema.ast], [schema.ast]), {
+export const NonEmptyArray = /*#__PURE__*/Struct_.lambda(schema => make(new SchemaAST.Arrays(false, [schema.ast], [schema.ast]), {
   value: schema
 }));
 /**
@@ -2002,7 +2102,7 @@ export const NonEmptyArray = /*#__PURE__*/Struct_.lambda(schema => make(new AST.
  * @since 3.10.0
  */
 export function ArrayEnsure(schema) {
-  return Union([schema, ArraySchema(schema)]).pipe(decodeTo(ArraySchema(toType(schema)), Transformation.transform({
+  return Union([schema, ArraySchema(schema)]).pipe(decodeTo(ArraySchema(toType(schema)), SchemaTransformation.transform({
     decode: Arr.ensure,
     encode: array => array.length === 1 ? array[0] : array
   })));
@@ -2039,7 +2139,7 @@ export function UniqueArray(item) {
  * @since 3.10.0
  */
 export const mutable = /*#__PURE__*/Struct_.lambda(schema => {
-  return make(new AST.Arrays(true, schema.ast.elements, schema.ast.rest), {
+  return make(new SchemaAST.Arrays(true, schema.ast.elements, schema.ast.rest), {
     schema
   });
 });
@@ -2048,7 +2148,7 @@ function makeUnion(ast, members) {
     members,
     mapMembers(f, options) {
       const members = f(this.members);
-      return makeUnion(AST.union(members, this.ast.mode, options?.unsafePreserveChecks ? this.ast.checks : undefined), members);
+      return makeUnion(SchemaAST.union(members, this.ast.mode, options?.unsafePreserveChecks ? this.ast.checks : undefined), members);
     }
   });
 }
@@ -2077,7 +2177,7 @@ function makeUnion(ast, members) {
  * @since 3.10.0
  */
 export function Union(members, options) {
-  return makeUnion(AST.union(members, options?.mode ?? "anyOf", undefined), members);
+  return makeUnion(SchemaAST.union(members, options?.mode ?? "anyOf", undefined), members);
 }
 /**
  * Creates a union schema from an array of literal values.
@@ -2097,7 +2197,7 @@ export function Union(members, options) {
  */
 export function Literals(literals) {
   const members = literals.map(Literal);
-  return make(AST.union(members, "anyOf", undefined), {
+  return make(SchemaAST.union(members, "anyOf", undefined), {
     literals,
     members,
     mapMembers(f) {
@@ -2157,7 +2257,7 @@ export const NullishOr = /*#__PURE__*/Struct_.lambda(self => Union([self, Null,
  * @since 3.10.0
  */
 export function suspend(f) {
-  return make(new AST.Suspend(() => f().ast));
+  return make(new SchemaAST.Suspend(() => f().ast));
 }
 /**
  * Attaches one or more filter checks to a schema without changing the
@@ -2195,7 +2295,7 @@ export function check(...checks) {
  * @since 3.10.0
  */
 export function refine(refinement, annotations) {
-  return schema => make(AST.appendChecks(schema.ast, [AST.makeFilterByGuard(refinement, annotations)]), {
+  return schema => make(SchemaAST.appendChecks(schema.ast, [SchemaAST.makeFilterByGuard(refinement, annotations)]), {
     schema
   });
 }
@@ -2219,7 +2319,7 @@ export function refine(refinement, annotations) {
  * @since 3.10.0
  */
 export function brand(identifier) {
-  return schema => make(AST.brand(schema.ast, identifier), {
+  return schema => make(SchemaAST.brand(schema.ast, identifier), {
     schema,
     identifier
   });
@@ -2262,7 +2362,7 @@ export function fromBrand(identifier, ctor) {
  * @since 4.0.0
  */
 export function middlewareDecoding(decode) {
-  return schema => make(AST.middlewareDecoding(schema.ast, new Transformation.Middleware(decode, identity)), {
+  return schema => make(SchemaAST.middlewareDecoding(schema.ast, new SchemaTransformation.Middleware(decode, identity)), {
     schema
   });
 }
@@ -2292,7 +2392,7 @@ export function middlewareDecoding(decode) {
  * @since 4.0.0
  */
 export function middlewareEncoding(encode) {
-  return schema => make(AST.middlewareEncoding(schema.ast, new Transformation.Middleware(identity, encode)), {
+  return schema => make(SchemaAST.middlewareEncoding(schema.ast, new SchemaTransformation.Middleware(identity, encode)), {
     schema
   });
 }
@@ -2326,7 +2426,8 @@ export function catchDecoding(f) {
  *
  * **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**
  *
@@ -2363,7 +2464,8 @@ export function catchEncoding(f) {
  *
  * **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**
  *
@@ -2382,7 +2484,7 @@ export function catchEncodingWithContext(f) {
 }
 export function decodeTo(to, transformation) {
   return from => {
-    return make(AST.decodeTo(from.ast, to.ast, transformation ? Transformation.make(transformation) : Transformation.passthrough()), {
+    return make(SchemaAST.decodeTo(from.ast, to.ast, transformation ? SchemaTransformation.make(transformation) : SchemaTransformation.passthrough()), {
       from,
       to
     });
@@ -2391,23 +2493,26 @@ export function decodeTo(to, transformation) {
 /**
  * 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)
  *
@@ -2499,7 +2604,7 @@ export function withConstructorDefault(
 // `S["~type.make.in"]` instead of `S["Type"]` is intentional here because
 // it makes easier to define the default value if there are nested defaults
 defaultValue) {
-  return schema => make(AST.withConstructorDefault(schema.ast, Effect.mapErrorEager(defaultValue, e => e.issue)), {
+  return schema => make(SchemaAST.withConstructorDefault(schema.ast, Effect.mapErrorEager(defaultValue, e => e.issue)), {
     schema
   });
 }
@@ -2538,10 +2643,10 @@ defaultValue) {
  * @since 4.0.0
  */
 export function withDecodingDefaultKey(defaultValue, options) {
-  const encode = options?.encodingStrategy === "omit" ? Getter.omit() : Getter.passthrough();
+  const encode = options?.encodingStrategy === "omit" ? SchemaGetter.omit() : SchemaGetter.passthrough();
   return self => {
     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
     }));
   };
@@ -2578,6 +2683,11 @@ export function withDecodingDefaultTypeKey(defaultValue, options) {
  * 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
@@ -2608,10 +2718,10 @@ export function withDecodingDefaultTypeKey(defaultValue, options) {
  * @since 3.10.0
  */
 export function withDecodingDefault(defaultValue, options) {
-  const encode = options?.encodingStrategy === "omit" ? Getter.omit() : Getter.passthrough();
+  const encode = options?.encodingStrategy === "omit" ? SchemaGetter.omit() : SchemaGetter.passthrough();
   return self => {
     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
     }));
   };
@@ -2621,6 +2731,11 @@ export function withDecodingDefault(defaultValue, options) {
  * 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
@@ -2795,10 +2910,10 @@ export function toTaggedUnion(tag) {
     });
     function walk(schema) {
       const ast = schema.ast;
-      if (AST.isUnion(ast) && "members" in schema && globalThis.Array.isArray(schema.members) && schema.members.every(isSchema)) {
+      if (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)) {
@@ -2920,7 +3035,7 @@ export function instanceOf(constructor, annotations) {
   return declare(u => u instanceof constructor, annotations);
 }
 /**
- * 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
@@ -2928,7 +3043,7 @@ export function instanceOf(constructor, annotations) {
  */
 export function link() {
   return (encodeTo, transformation) => {
-    return new AST.Link(encodeTo.ast, Transformation.make(transformation));
+    return new SchemaAST.Link(encodeTo.ast, SchemaTransformation.make(transformation));
   };
 }
 // -----------------------------------------------------------------------------
@@ -2992,16 +3107,16 @@ export function link() {
  * @category constructors
  * @since 4.0.0
  */
-export const makeFilter = AST.makeFilter;
+export const makeFilter = SchemaAST.makeFilter;
 /**
- * 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(checks, annotations = undefined) {
-  return new AST.FilterGroup(checks, annotations);
+  return new SchemaAST.FilterGroup(checks, annotations);
 }
 const TRIMMED_PATTERN = "^\\S[\\s\\S]*\\S$|^\\S$|^$";
 /**
@@ -3054,7 +3169,7 @@ export function isTrimmed(annotations) {
  * @category String checks
  * @since 4.0.0
  */
-export const isPattern = AST.isPattern;
+export const isPattern = SchemaAST.isPattern;
 /**
  * Validates that a string represents a finite number.
  *
@@ -3073,7 +3188,7 @@ export const isPattern = AST.isPattern;
  * @category String checks
  * @since 4.0.0
  */
-export const isStringFinite = AST.isStringFinite;
+export const isStringFinite = SchemaAST.isStringFinite;
 /**
  * Validates that a string is a signed base-10 integer literal for Effect's
  * BigInt string encoding.
@@ -3091,7 +3206,7 @@ export const isStringFinite = AST.isStringFinite;
  * @category String checks
  * @since 4.0.0
  */
-export const isStringBigInt = AST.isStringBigInt;
+export const isStringBigInt = SchemaAST.isStringBigInt;
 /**
  * Validates that a string has the `Symbol(description)` format used by Effect's
  * symbol string encoding.
@@ -3104,9 +3219,9 @@ export const isStringBigInt = AST.isStringBigInt;
  * @category String checks
  * @since 4.0.0
  */
-export const isStringSymbol = AST.isStringSymbol;
+export const isStringSymbol = SchemaAST.isStringSymbol;
 /**
- * Returns a RegExp for validating an RFC 4122 UUID.
+ * Returns a RegExp for validating an RFC 9562 / RFC 4122 UUID.
  *
  * Optionally specify a version 1-8. If no version is specified (`undefined`), all versions are supported.
  */
@@ -3114,15 +3229,24 @@ const getUUIDRegExp = version => {
   if (version) {
     return new globalThis.RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
   }
-  return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000)$/;
+  return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|[fF]{8}-[fF]{4}-[fF]{4}-[fF]{4}-[fF]{12})$/;
 };
 /**
- * Validates that a string is a valid Universally Unique Identifier (UUID).
- * Optionally specify a version (1-8) to validate against a specific UUID version.
- * If no version is specified (`undefined`), all versions are supported.
+ * Validates that a string is a strict Universally Unique Identifier (UUID).
+ *
+ * **When to use**
+ *
+ * Use when you need UUID semantics, including version and RFC variant bits,
+ * rather than only the dashed hexadecimal shape.
  *
  * **Details**
  *
+ * Without a version argument, this accepts UUID versions 1 through 8, the nil
+ * UUID (`00000000-0000-0000-0000-000000000000`), and the max UUID
+ * (`ffffffff-ffff-ffff-ffff-ffffffffffff`). With a version argument, this
+ * accepts only UUIDs with that version and RFC variant bits; nil and max UUIDs
+ * are not versioned UUIDs and do not match version-specific checks.
+ *
  * JSON Schema:
  *
  * This check corresponds to a `pattern` constraint in JSON Schema that matches
@@ -3133,6 +3257,7 @@ const getUUIDRegExp = version => {
  * When generating test data with fast-check, this applies a `patterns`
  * constraint to ensure generated strings match the UUID pattern.
  *
+ * @see {@link isGUID} for shape-only GUID validation.
  * @category String checks
  * @since 4.0.0
  */
@@ -3148,6 +3273,41 @@ export function isUUID(version, annotations) {
     ...annotations
   });
 }
+const GUID_REGEXP = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
+/**
+ * Validates that a string has the GUID / UUID textual shape.
+ *
+ * **When to use**
+ *
+ * Use when you need to accept dashed hexadecimal identifiers without enforcing
+ * UUID version or variant bits.
+ *
+ * **Details**
+ *
+ * This check accepts strings in the `8-4-4-4-12` hexadecimal form. JSON Schema
+ * output includes the corresponding `pattern` constraint and intentionally does
+ * not include `format: "uuid"` because GUID validation is looser than UUID
+ * validation.
+ *
+ * Arbitrary:
+ *
+ * When generating test data with fast-check, this applies a `patterns`
+ * constraint to ensure generated strings match the GUID pattern.
+ *
+ * @see {@link isUUID} for strict UUID validation.
+ * @category String checks
+ * @since 4.0.0
+ */
+export function isGUID(annotations) {
+  return isPattern(GUID_REGEXP, {
+    expected: "a GUID",
+    meta: {
+      _tag: "isGUID",
+      regExp: GUID_REGEXP
+    },
+    ...annotations
+  });
+}
 /**
  * Validates that a string is a valid ULID (Universally Unique Lexicographically
  * Sortable Identifier).
@@ -3836,7 +3996,7 @@ export function isInt(annotations) {
  * @since 4.0.0
  */
 export function isInt32(annotations) {
-  return new AST.FilterGroup([isInt(annotations), isBetween({
+  return new SchemaAST.FilterGroup([isInt(annotations), isBetween({
     minimum: -2147483648,
     maximum: 2147483647
   })], {
@@ -3864,7 +4024,7 @@ export function isInt32(annotations) {
  * @since 4.0.0
  */
 export function isUint32(annotations) {
-  return new AST.FilterGroup([isInt(), isBetween({
+  return new SchemaAST.FilterGroup([isInt(), isBetween({
     minimum: 0,
     maximum: 4294967295
   })], {
@@ -4306,7 +4466,7 @@ export function isMinLength(minLength, annotations) {
       _tag: "isMinLength",
       minLength
     },
-    [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
     toArbitraryConstraint: {
       string: {
         minLength
@@ -4368,7 +4528,7 @@ export function isMaxLength(maxLength, annotations) {
       _tag: "isMaxLength",
       maxLength
     },
-    [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
     toArbitraryConstraint: {
       string: {
         maxLength
@@ -4410,7 +4570,7 @@ export function isLengthBetween(minimum, maximum, annotations) {
       minimum,
       maximum
     },
-    [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
     toArbitraryConstraint: {
       string: {
         minLength: minimum,
@@ -4452,7 +4612,7 @@ export function isMinSize(minSize, annotations) {
       _tag: "isMinSize",
       minSize
     },
-    [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
     toArbitraryConstraint: {
       array: {
         minLength: minSize
@@ -4489,7 +4649,7 @@ export function isMaxSize(maxSize, annotations) {
       _tag: "isMaxSize",
       maxSize
     },
-    [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
     toArbitraryConstraint: {
       array: {
         maxLength: maxSize
@@ -4528,7 +4688,7 @@ export function isSizeBetween(minimum, maximum, annotations) {
       minimum,
       maximum
     },
-    [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
     toArbitraryConstraint: {
       array: {
         minLength: minimum,
@@ -4567,7 +4727,7 @@ export function isMinProperties(minProperties, annotations) {
       _tag: "isMinProperties",
       minProperties
     },
-    [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
     toArbitraryConstraint: {
       array: {
         minLength: minProperties
@@ -4604,7 +4764,7 @@ export function isMaxProperties(maxProperties, annotations) {
       _tag: "isMaxProperties",
       maxProperties
     },
-    [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
     toArbitraryConstraint: {
       array: {
         maxLength: maxProperties
@@ -4643,7 +4803,7 @@ export function isPropertiesLengthBetween(minimum, maximum, annotations) {
       minimum,
       maximum
     },
-    [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
     toArbitraryConstraint: {
       array: {
         minLength: minimum,
@@ -4671,19 +4831,19 @@ export function isPropertiesLengthBetween(minimum, maximum, annotations) {
  */
 export function isPropertyNames(keySchema, annotations) {
   const propertyNames = toEncoded(keySchema);
-  const parser = Parser._issue(propertyNames.ast);
+  const parser = SchemaParser._issue(propertyNames.ast);
   return makeFilter((input, ast, options) => {
     const keys = Reflect.ownKeys(input);
     const issues = [];
     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;
   }, {
@@ -4692,7 +4852,7 @@ export function isPropertyNames(keySchema, annotations) {
       _tag: "isPropertyNames",
       propertyNames: propertyNames.ast
     },
-    [AST.STRUCTURAL_ANNOTATION_KEY]: true,
+    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
     ...annotations
   });
 }
@@ -4766,12 +4926,12 @@ export function Option(value) {
       if (Option_.isNone(input)) {
         return Effect.succeedNone;
       }
-      return Effect.mapBothEager(Parser.decodeUnknownEffect(value)(input.value, options), {
+      return Effect.mapBothEager(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: {
       _tag: "effect/Option"
@@ -4787,7 +4947,7 @@ export function Option(value) {
       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",
@@ -4817,97 +4977,75 @@ export function Option(value) {
  *
  * **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
  */
 export function OptionFromNullOr(schema) {
-  return NullOr(schema).pipe(decodeTo(Option(toType(schema)), Transformation.optionFromNullOr()));
+  return NullOr(schema).pipe(decodeTo(Option(toType(schema)), SchemaTransformation.optionFromNullOr()));
 }
 /**
- * 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
  */
 export function OptionFromUndefinedOr(schema) {
-  return UndefinedOr(schema).pipe(decodeTo(Option(toType(schema)), Transformation.optionFromUndefinedOr()));
+  return UndefinedOr(schema).pipe(decodeTo(Option(toType(schema)), SchemaTransformation.optionFromUndefinedOr()));
 }
 /**
  * Decodes a nullish value `T` to a required `Option<T>` value.
  *
  * **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
  */
 export function OptionFromNullishOr(schema, options) {
-  return NullishOr(schema).pipe(decodeTo(Option(toType(schema)), Transformation.optionFromNullishOr(options)));
+  return NullishOr(schema).pipe(decodeTo(Option(toType(schema)), SchemaTransformation.optionFromNullishOr(options)));
 }
 /**
  * Decodes an optional value `A` to a required `Option<A>` value.
  *
  * **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
  */
 export function OptionFromOptionalKey(schema) {
-  return optionalKey(schema).pipe(decodeTo(Option(toType(schema)), Transformation.optionFromOptionalKey()));
+  return optionalKey(schema).pipe(decodeTo(Option(toType(schema)), SchemaTransformation.optionFromOptionalKey()));
 }
 /**
- * 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
  */
 export function OptionFromOptional(schema) {
-  return optional(schema).pipe(decodeTo(Option(toType(schema)), Transformation.optionFromOptional()));
+  return optional(schema).pipe(decodeTo(Option(toType(schema)), SchemaTransformation.optionFromOptional()));
 }
 /**
  * Decodes an optional or `null` or `undefined` value `A` to a required `Option<A>`
@@ -4915,17 +5053,10 @@ export function OptionFromOptional(schema) {
  *
  * **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
@@ -4933,7 +5064,7 @@ export function OptionFromOptional(schema) {
 export function OptionFromOptionalNullOr(schema, options) {
   const onNoneEncoding = options === undefined ? "omit" : options.onNoneEncoding;
   const noneValue = onNoneEncoding === null ? null : undefined;
-  return optional(NullOr(schema)).pipe(decodeTo(Option(toType(schema)), Transformation.transformOptional({
+  return optional(NullOr(schema)).pipe(decodeTo(Option(toType(schema)), SchemaTransformation.transformOptional({
     decode: oe => oe.pipe(Option_.filter(Predicate.isNotNullish), Option_.some),
     encode: onNoneEncoding === "omit" ? Option_.flatten : ot => Option_.some(Option_.getOrElse(Option_.flatten(ot), () => noneValue))
   })));
@@ -4947,18 +5078,18 @@ export function OptionFromOptionalNullOr(schema, options) {
 export function Result(success, failure) {
   const schema = declareConstructor()([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)])
         });
     }
   }, {
@@ -4977,7 +5108,7 @@ export function Result(success, failure) {
     }), Struct({
       _tag: Literal("Failure"),
       failure
-    })]), Transformation.transform({
+    })]), SchemaTransformation.transform({
       decode: e => e._tag === "Success" ? Result_.succeed(e.success) : Result_.fail(e.failure),
       encode: r => Result_.isSuccess(r) ? {
         _tag: "Success",
@@ -5028,35 +5159,36 @@ export function Result(success, failure) {
  * @since 3.10.0
  */
 export function Redacted(value, options) {
-  const decodeLabel = typeof options?.label === "string" ? Parser.decodeUnknownEffect(Literal(options.label)) : undefined;
+  const decodeLabel = typeof options?.label === "string" ? SchemaParser.decodeUnknownEffect(Literal(options.label)) : undefined;
   const schema = declareConstructor()([value], ([value]) => (input, ast, poptions) => {
     if (Redacted_.isRedacted(input)) {
-      const label = decodeLabel !== undefined ? Effect.mapErrorEager(decodeLabel(input.label, poptions), issue => new Issue.Pointer(["label"], issue)) : Effect.void;
-      return Effect.flatMapEager(label, () => Effect.mapBothEager(Parser.decodeUnknownEffect(value)(Redacted_.value(input), poptions), {
+      const label = decodeLabel !== undefined ? Effect.mapErrorEager(decodeLabel(input.label, poptions), issue => new SchemaIssue.Pointer(["label"], issue)) : Effect.void;
+      return Effect.flatMapEager(label, () => Effect.mapBothEager(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"`
     },
     expected: "Redacted",
     toCodecJson: ([value]) => link()(redact(value), {
-      decode: Getter.transform(e => Redacted_.make(e, {
+      decode: SchemaGetter.transform(e => Redacted_.make(e, {
         label: options?.label
       })),
-      encode: options?.disallowJsonEncode ? Getter.forbidden(oe => "Cannot serialize Redacted" + (Option_.isSome(oe) && typeof oe.value.label === "string" ? ` with label: "${oe.value.label}"` : "")) : Getter.transform(Redacted_.value)
+      encode: options?.disallowJsonEncode ? SchemaGetter.forbidden(oe => "Cannot serialize Redacted" + (Option_.isSome(oe) && typeof oe.value.label === "string" ? ` with label: "${oe.value.label}"` : "")) : SchemaGetter.transform(Redacted_.value)
     }),
     toArbitrary: ([value]) => () => value.map(a => Redacted_.make(a, {
       label: options?.label
@@ -5076,7 +5208,7 @@ export function Redacted(value, options) {
  * @since 4.0.0
  */
 export function redact(schema) {
-  return schema.pipe(middlewareDecoding(Effect.mapErrorEager(Issue.redact)));
+  return schema.pipe(middlewareDecoding(Effect.mapErrorEager(SchemaIssue.redact)));
 }
 /**
  * Decodes a value and wraps it in `Redacted<A>`. Unlike {@link Redacted} which
@@ -5091,10 +5223,10 @@ export function RedactedFromValue(value, options) {
     label: options?.label,
     disallowJsonEncode: options?.disallowEncode
   }), {
-    decode: Getter.transform(t => Redacted_.make(t, {
+    decode: SchemaGetter.transform(t => Redacted_.make(t, {
       label: options?.label
     })),
-    encode: options?.disallowEncode ? Getter.forbidden(oe => "Cannot encode Redacted" + (Option_.isSome(oe) && typeof oe.value.label === "string" ? ` with label: "${oe.value.label}"` : "")) : Getter.transform(Redacted_.value)
+    encode: options?.disallowEncode ? SchemaGetter.forbidden(oe => "Cannot encode Redacted" + (Option_.isSome(oe) && typeof oe.value.label === "string" ? ` with label: "${oe.value.label}"` : "")) : SchemaGetter.transform(Redacted_.value)
   }));
 }
 /**
@@ -5103,8 +5235,8 @@ export function RedactedFromValue(value, options) {
  *
  * **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**
  *
@@ -5120,18 +5252,18 @@ export function RedactedFromValue(value, options) {
 export function CauseReason(error, defect) {
   const schema = declareConstructor()([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), {
+        return Effect.mapBothEager(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), {
+        return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(defect)(input.defect, options), {
           onSuccess: Cause_.makeDieReason,
-          onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["defect"], issue)])
+          onFailure: issue => new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["defect"], issue)])
         });
       case "Interrupt":
         return Effect.succeed(input);
@@ -5155,7 +5287,7 @@ export function CauseReason(error, defect) {
     }), Struct({
       _tag: Literal("Interrupt"),
       fiberId: UndefinedOr(Finite)
-    })]), Transformation.transform({
+    })]), SchemaTransformation.transform({
       decode: e => {
         switch (e._tag) {
           case "Fail":
@@ -5238,11 +5370,11 @@ export function Cause(error, defect) {
     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)])
       });
     };
   }, {
@@ -5255,7 +5387,7 @@ export function Cause(error, defect) {
       importDeclaration: `import * as Cause from "effect/Cause"`
     },
     expected: "Cause",
-    toCodec: ([error, defect]) => link()(ArraySchema(CauseReason(error, defect)), Transformation.transform({
+    toCodec: ([error, defect]) => link()(ArraySchema(CauseReason(error, defect)), SchemaTransformation.transform({
       decode: Cause_.fromReasons,
       encode: ({
         reasons: failures
@@ -5283,103 +5415,128 @@ function causeToFormatter(error, defect) {
   const causeReason = causeReasonToFormatter(error, defect);
   return t => `Cause([${t.reasons.map(causeReason).join(", ")}])`;
 }
-const ErrorJsonEncoded = /*#__PURE__*/Struct({
-  message: String,
-  name: /*#__PURE__*/optionalKey(String),
-  stack: /*#__PURE__*/optionalKey(String)
-});
+const getErrorOptionsKey = options => (options?.includeStack === true ? 1 : 0) | (options?.excludeCause === true ? 2 : 0);
+const getErrorOptions = key => {
+  switch (key) {
+    case 0:
+      return undefined;
+    case 1:
+      return {
+        includeStack: true
+      };
+    case 2:
+      return {
+        excludeCause: true
+      };
+    case 3:
+      return {
+        includeStack: true,
+        excludeCause: true
+      };
+  }
+};
+const errorSchemaCache = [];
 /**
  * Schema for JavaScript `Error` objects.
  *
  * **Details**
  *
  * Default JSON serializer:
- * Encodes an `Error` as an object with `message` and optional `name` properties,
- * and decodes that object back into an `Error`. The stack trace is omitted from
- * the encoded form for security.
  *
- * @category schemas
+ * Encodes an `Error` as an object with `message`, optional `name`, and optional
+ * `cause` properties, and decodes that object back into an `Error`. Stack
+ * traces are omitted by default for security. Pass `{ includeStack: true }` to
+ * include stack traces, or `{ excludeCause: true }` to omit causes.
+ *
+ * @category constructors
  * @since 4.0.0
  */
-export const Error = /*#__PURE__*/instanceOf(globalThis.Error, {
-  typeConstructor: {
-    _tag: "Error"
-  },
-  generation: {
-    runtime: `Schema.Error`,
-    Type: `globalThis.Error`
-  },
-  expected: "Error",
-  toCodecJson: () => link()(ErrorJsonEncoded, Transformation.errorFromErrorJsonEncoded()),
-  toArbitrary: () => fc => fc.string().map(message => new globalThis.Error(message))
-});
+export function Error(options) {
+  const key = getErrorOptionsKey(options);
+  const cached = errorSchemaCache[key];
+  if (cached !== undefined) {
+    return cached;
+  }
+  const normalizedOptions = getErrorOptions(key);
+  const schema = instanceOf(globalThis.Error, {
+    typeConstructor: {
+      _tag: "Error",
+      ...(normalizedOptions === undefined ? {} : {
+        options: normalizedOptions
+      })
+    },
+    generation: {
+      runtime: normalizedOptions !== undefined ? `Schema.Error(${format(normalizedOptions)})` : `Schema.Error()`,
+      Type: `globalThis.Error`
+    },
+    expected: "Error",
+    toCodecJson: () => link()(JsonError, SchemaTransformation.errorFromJsonError(normalizedOptions)),
+    toArbitrary: () => fc => fc.string().map(message => new globalThis.Error(message))
+  });
+  errorSchemaCache[key] = schema;
+  return schema;
+}
+const defectSchemaCache = [];
 /**
- * Schema for JavaScript `Error` objects that preserves stack traces in the JSON
+ * Schema for unexpected defect values represented as `unknown` with a JSON
  * encoded form.
  *
+ * **When to use**
+ *
+ * Use when you need a schema for `Cause` defects or other unexpected failures
+ * whose runtime value may be any value.
+ *
  * **Details**
  *
- * Default JSON serializer:
- * Encodes an `Error` as an object with `message`, optional `name`, and optional
- * `stack` properties, and decodes that object back into an `Error`.
+ * The encoded side is {@link Json}. During decoding, JSON objects with a string
+ * `message` property are decoded into JavaScript `Error` values, preserving a
+ * non-default `name` and any string `stack`. Other JSON values decode
+ * unchanged.
  *
- * @category schemas
- * @since 4.0.0
- */
-export const ErrorWithStack = /*#__PURE__*/instanceOf(globalThis.Error, {
-  typeConstructor: {
-    _tag: "ErrorWithStack"
-  },
-  generation: {
-    runtime: `Schema.ErrorWithStack`,
-    Type: `globalThis.Error`
-  },
-  expected: "Error",
-  toCodecJson: () => link()(ErrorJsonEncoded, Transformation.errorFromErrorJsonEncoded({
-    includeStack: true
-  })),
-  toArbitrary: () => fc => fc.string().map(message => new globalThis.Error(message))
-});
-const defectTransformation = /*#__PURE__*/new Transformation.Transformation(/*#__PURE__*/Getter.passthrough(), /*#__PURE__*/Getter.transform(u => {
-  try {
-    return JSON.parse(JSON.stringify(u));
-  } catch {
-    return format(u);
-  }
-}));
-/**
- * Schema for defect values, accepting either JavaScript `Error` values encoded
- * with `message` and optional `name`, or arbitrary unknown defect values.
+ * During encoding, JavaScript `Error` values encode to JSON objects with
+ * `name`, `message`, and optional `cause` properties. Pass
+ * `{ includeStack: true }` to include string stack traces in encoded `Error`
+ * defects, or `{ excludeCause: true }` to omit causes. Other values are
+ * serialized through Effect's JSON formatter and then parsed back into JSON
+ * when possible.
  *
- * **Details**
+ * **Gotchas**
  *
- * Default JSON serializer:
- * Unknown defects are serialized with `JSON.stringify` when possible and fall
- * back to Effect's formatted representation when JSON serialization fails.
+ * This schema is for carrying defects across JSON boundaries, not for
+ * preserving every JavaScript value exactly. Some values cannot round-trip
+ * unchanged:
  *
- * @category constructors
- * @since 3.10.0
- */
-export const Defect = /*#__PURE__*/Union([/*#__PURE__*/ErrorJsonEncoded.pipe(/*#__PURE__*/decodeTo(Error, /*#__PURE__*/Transformation.errorFromErrorJsonEncoded())), /*#__PURE__*/Any.pipe(/*#__PURE__*/decodeTo(/*#__PURE__*/Unknown.annotate({
-  toCodecJson: () => link()(Any, defectTransformation),
-  toArbitrary: () => fc => fc.json()
-}), defectTransformation))]);
-/**
- * Schema for defects that also includes stack traces in the encoded form.
+ * - A non-`Error` object such as `{ message: "boom" }` encodes as an
+ *   error-shaped JSON object and decodes back as an `Error`.
+ * - JSON serialization normalizes unsupported values. For example,
+ *   `undefined` array elements encode as `null`, unsupported object properties
+ *   are omitted, and circular references are dropped.
+ * - Values that cannot be represented as JSON fall back to Effect's formatted
+ *   string representation.
  *
- * @category Defect
+ * @see {@link Error} for a schema that only accepts JavaScript `Error` values.
+ * @category constructors
  * @since 4.0.0
  */
-export const DefectWithStack = /*#__PURE__*/Union([/*#__PURE__*/ErrorJsonEncoded.pipe(/*#__PURE__*/decodeTo(ErrorWithStack, /*#__PURE__*/Transformation.errorFromErrorJsonEncoded({
-  includeStack: true
-}))), /*#__PURE__*/Any.pipe(/*#__PURE__*/decodeTo(/*#__PURE__*/Unknown.annotate({
-  toCodecJson: () => link()(Any, defectTransformation),
-  toArbitrary: () => fc => fc.json()
-}), defectTransformation))]);
+export function Defect(options) {
+  const key = getErrorOptionsKey(options);
+  const cached = defectSchemaCache[key];
+  if (cached !== undefined) {
+    return cached;
+  }
+  const schema = Json.pipe(decodeTo(Unknown, SchemaTransformation.defectFromJson(getErrorOptions(key))));
+  defectSchemaCache[key] = schema;
+  return schema;
+}
 /**
  * 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
  */
@@ -5388,18 +5545,18 @@ export function Exit(value, error, defect) {
     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), {
+          return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(value)(input.value, options), {
             onSuccess: Exit_.succeed,
-            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)])
           });
         case "Failure":
-          return Effect.mapBothEager(Parser.decodeUnknownEffect(cause)(input.cause, options), {
+          return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(cause)(input.cause, options), {
             onSuccess: Exit_.failCause,
-            onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["cause"], issue)])
+            onFailure: issue => new SchemaIssue.Composite(ast, Option_.some(input), [new SchemaIssue.Pointer(["cause"], issue)])
           });
       }
     };
@@ -5419,7 +5576,7 @@ export function Exit(value, error, defect) {
     }), Struct({
       _tag: Literal("Failure"),
       cause: Cause(error, defect)
-    })]), Transformation.transform({
+    })]), SchemaTransformation.transform({
       decode: e => e._tag === "Success" ? Exit_.succeed(e.value) : Exit_.failCause(e.cause),
       encode: exit => Exit_.isSuccess(exit) ? {
         _tag: "Success",
@@ -5475,12 +5632,12 @@ export function ReadonlyMap(key, value) {
     const array = ArraySchema(Tuple([key, value]));
     return (input, ast, options) => {
       if (input instanceof globalThis.Map) {
-        return Effect.mapBothEager(Parser.decodeUnknownEffect(array)([...input], options), {
+        return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(array)([...input], options), {
           onSuccess: array => new globalThis.Map(array),
-          onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["entries"], issue)])
+          onFailure: 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)));
     };
   }, {
     typeConstructor: {
@@ -5491,7 +5648,7 @@ export function ReadonlyMap(key, value) {
       Type: `globalThis.ReadonlyMap<?, ?>`
     },
     expected: "ReadonlyMap",
-    toCodec: ([key, value]) => link()(ArraySchema(Tuple([key, value])), Transformation.transform({
+    toCodec: ([key, value]) => link()(ArraySchema(Tuple([key, value])), SchemaTransformation.transform({
       decode: e => new globalThis.Map(e),
       encode: map => [...map.entries()]
     })),
@@ -5527,12 +5684,12 @@ export function HashMap(key, value) {
     const entries = ArraySchema(Tuple([key, value]));
     return (input, ast, options) => {
       if (HashMap_.isHashMap(input)) {
-        return Effect.mapBothEager(Parser.decodeUnknownEffect(entries)(HashMap_.toEntries(input), options), {
+        return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(entries)(HashMap_.toEntries(input), options), {
           onSuccess: HashMap_.fromIterable,
-          onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["entries"], issue)])
+          onFailure: 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)));
     };
   }, {
     typeConstructor: {
@@ -5544,7 +5701,7 @@ export function HashMap(key, value) {
       importDeclaration: `import * as HashMap from "effect/HashMap"`
     },
     expected: "HashMap",
-    toCodec: ([key, value]) => link()(ArraySchema(Tuple([key, value])), Transformation.transform({
+    toCodec: ([key, value]) => link()(ArraySchema(Tuple([key, value])), SchemaTransformation.transform({
       decode: HashMap_.fromIterable,
       encode: HashMap_.toEntries
     })),
@@ -5580,12 +5737,12 @@ export function ReadonlySet(value) {
     const array = ArraySchema(value);
     return (input, ast, options) => {
       if (input instanceof globalThis.Set) {
-        return Effect.mapBothEager(Parser.decodeUnknownEffect(array)([...input], options), {
+        return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(array)([...input], options), {
           onSuccess: array => new globalThis.Set(array),
-          onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["values"], issue)])
+          onFailure: 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)));
     };
   }, {
     typeConstructor: {
@@ -5596,7 +5753,7 @@ export function ReadonlySet(value) {
       Type: `globalThis.ReadonlySet<?>`
     },
     expected: "ReadonlySet",
-    toCodec: ([value]) => link()(ArraySchema(value), Transformation.transform({
+    toCodec: ([value]) => link()(ArraySchema(value), SchemaTransformation.transform({
       decode: e => new globalThis.Set(e),
       encode: set => [...set.values()]
     })),
@@ -5631,12 +5788,12 @@ export function HashSet(value) {
     const values = ArraySchema(value);
     return (input, ast, options) => {
       if (HashSet_.isHashSet(input)) {
-        return Effect.mapBothEager(Parser.decodeUnknownEffect(values)(Arr.fromIterable(input), options), {
+        return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(values)(Arr.fromIterable(input), options), {
           onSuccess: HashSet_.fromIterable,
-          onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["values"], issue)])
+          onFailure: 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)));
     };
   }, {
     typeConstructor: {
@@ -5647,7 +5804,7 @@ export function HashSet(value) {
       Type: `HashSet.HashSet<?>`
     },
     expected: "HashSet",
-    toCodec: ([value]) => link()(ArraySchema(value), Transformation.transform({
+    toCodec: ([value]) => link()(ArraySchema(value), SchemaTransformation.transform({
       decode: HashSet_.fromIterable,
       encode: Arr.fromIterable
     })),
@@ -5682,12 +5839,12 @@ export function Chunk(value) {
     const values = ArraySchema(value);
     return (input, ast, options) => {
       if (Chunk_.isChunk(input)) {
-        return Effect.mapBothEager(Parser.decodeUnknownEffect(values)(Arr.fromIterable(input), options), {
+        return Effect.mapBothEager(SchemaParser.decodeUnknownEffect(values)(Arr.fromIterable(input), options), {
           onSuccess: Chunk_.fromIterable,
-          onFailure: issue => new Issue.Composite(ast, Option_.some(input), [new Issue.Pointer(["values"], issue)])
+          onFailure: 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)));
     };
   }, {
     typeConstructor: {
@@ -5698,7 +5855,7 @@ export function Chunk(value) {
       Type: `Chunk.Chunk<?>`
     },
     expected: "Chunk",
-    toCodec: ([value]) => link()(ArraySchema(value), Transformation.transform({
+    toCodec: ([value]) => link()(ArraySchema(value), SchemaTransformation.transform({
       decode: Chunk_.fromIterable,
       encode: Arr.fromIterable
     })),
@@ -5744,10 +5901,10 @@ export const RegExp = /*#__PURE__*/instanceOf(globalThis.RegExp, {
   toCodecJson: () => link()(Struct({
     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), {
+      catch: e => new SchemaIssue.InvalidValue(Option_.some(e), {
         message: globalThis.String(e)
       })
     }),
@@ -5787,7 +5944,7 @@ export const URL = /*#__PURE__*/instanceOf(globalThis.URL, {
     Type: `globalThis.URL`
   },
   expected: "URL",
-  toCodecJson: () => link()(URLString, Transformation.urlFromString),
+  toCodecJson: () => link()(URLString, SchemaTransformation.urlFromString),
   toArbitrary: () => fc => fc.webUrl().map(s => new globalThis.URL(s)),
   toEquivalence: () => (a, b) => a.toString() === b.toString()
 });
@@ -5805,7 +5962,7 @@ export const URL = /*#__PURE__*/instanceOf(globalThis.URL, {
  * @category URL
  * @since 4.0.0
  */
-export const URLFromString = /*#__PURE__*/URLString.pipe(/*#__PURE__*/decodeTo(URL, Transformation.urlFromString));
+export const URLFromString = /*#__PURE__*/URLString.pipe(/*#__PURE__*/decodeTo(URL, SchemaTransformation.urlFromString));
 const DateString = /*#__PURE__*/String.annotate({
   expected: "a string in ISO 8601 format that will be decoded as a Date"
 });
@@ -5814,8 +5971,8 @@ const DateString = /*#__PURE__*/String.annotate({
  *
  * **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**
  *
@@ -5846,7 +6003,7 @@ export const Date = /*#__PURE__*/instanceOf(globalThis.Date, {
     Type: `globalThis.Date`
   },
   expected: "Date",
-  toCodecJson: () => link()(DateString, Transformation.dateFromString),
+  toCodecJson: () => link()(DateString, SchemaTransformation.dateFromString),
   toArbitrary: () => (fc, ctx) => fc.date(ctx?.constraints?.date)
 });
 /**
@@ -5876,7 +6033,7 @@ export const Date = /*#__PURE__*/instanceOf(globalThis.Date, {
  * @category Date
  * @since 3.10.0
  */
-export const DateFromString = /*#__PURE__*/DateString.pipe(/*#__PURE__*/decodeTo(Date, Transformation.dateFromString));
+export const DateFromString = /*#__PURE__*/DateString.pipe(/*#__PURE__*/decodeTo(Date, SchemaTransformation.dateFromString));
 /**
  * Schema for **valid** JavaScript `Date` objects.
  *
@@ -5930,7 +6087,7 @@ export const Duration = /*#__PURE__*/declare(Duration_.isDuration, {
   }), Struct({
     _tag: Literal("Millis"),
     value: Int
-  })]), Transformation.transform({
+  })]), SchemaTransformation.transform({
     decode: e => {
       switch (e._tag) {
         case "Infinity":
@@ -5988,7 +6145,7 @@ const DurationString = /*#__PURE__*/String.annotate({
  * @category Duration
  * @since 4.0.0
  */
-export const DurationFromString = /*#__PURE__*/DurationString.pipe(/*#__PURE__*/decodeTo(Duration, Transformation.durationFromString));
+export const DurationFromString = /*#__PURE__*/DurationString.pipe(/*#__PURE__*/decodeTo(Duration, SchemaTransformation.durationFromString));
 const bigint0 = /*#__PURE__*/globalThis.BigInt(0);
 /**
  * Schema that decodes a non-negative `bigint` into a
@@ -6007,7 +6164,7 @@ const bigint0 = /*#__PURE__*/globalThis.BigInt(0);
  * @category Duration
  * @since 3.10.0
  */
-export const DurationFromNanos = /*#__PURE__*/BigInt.check(isGreaterThanOrEqualToBigInt(bigint0)).pipe(/*#__PURE__*/decodeTo(Duration, Transformation.durationFromNanos));
+export const DurationFromNanos = /*#__PURE__*/BigInt.check(isGreaterThanOrEqualToBigInt(bigint0)).pipe(/*#__PURE__*/decodeTo(Duration, SchemaTransformation.durationFromNanos));
 /**
  * Schema that decodes a non-negative (possibly infinite)
  * integer into a `Duration`, treating the integer value as the duration in
@@ -6026,7 +6183,7 @@ export const DurationFromNanos = /*#__PURE__*/BigInt.check(isGreaterThanOrEqualT
  * @category Duration
  * @since 3.10.0
  */
-export const DurationFromMillis = /*#__PURE__*/Number.check(isGreaterThanOrEqualTo(0)).pipe(/*#__PURE__*/decodeTo(Duration, Transformation.durationFromMillis));
+export const DurationFromMillis = /*#__PURE__*/Number.check(isGreaterThanOrEqualTo(0)).pipe(/*#__PURE__*/decodeTo(Duration, SchemaTransformation.durationFromMillis));
 const BigDecimalString = /*#__PURE__*/String.annotate({
   expected: "a string that will be decoded as a BigDecimal"
 });
@@ -6035,7 +6192,7 @@ const BigDecimalString = /*#__PURE__*/String.annotate({
  *
  * **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**
@@ -6059,7 +6216,7 @@ export const BigDecimal = /*#__PURE__*/declare(BigDecimal_.isBigDecimal, {
     importDeclaration: `import * as BigDecimal from "effect/BigDecimal"`
   },
   expected: "BigDecimal",
-  toCodecJson: () => link()(BigDecimalString, Transformation.bigDecimalFromString),
+  toCodecJson: () => link()(BigDecimalString, SchemaTransformation.bigDecimalFromString),
   toArbitrary: () => fc => fc.tuple(fc.bigInt(), fc.integer({
     min: 0,
     max: 20
@@ -6094,7 +6251,7 @@ export const BigDecimal = /*#__PURE__*/declare(BigDecimal_.isBigDecimal, {
  * @category BigDecimal
  * @since 4.0.0
  */
-export const BigDecimalFromString = /*#__PURE__*/BigDecimalString.pipe(/*#__PURE__*/decodeTo(BigDecimal, Transformation.bigDecimalFromString));
+export const BigDecimalFromString = /*#__PURE__*/BigDecimalString.pipe(/*#__PURE__*/decodeTo(BigDecimal, SchemaTransformation.bigDecimalFromString));
 /**
  * Schema that decodes a JSON-encoded string into an `unknown` value.
  *
@@ -6191,8 +6348,8 @@ export function fromJsonString(schema) {
   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));
 }
 /**
  * Schema for JavaScript `File` objects.
@@ -6219,9 +6376,9 @@ export const File = /*#__PURE__*/instanceOf(globalThis.File, {
     type: String,
     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), {
+      onFailure: error => Effect.fail(new SchemaIssue.InvalidValue(Option_.some(e.data), {
         message: error.message
       })),
       onSuccess: bytes => {
@@ -6242,7 +6399,7 @@ export const File = /*#__PURE__*/instanceOf(globalThis.File, {
           lastModified: file.lastModified
         };
       },
-      catch: e => new Issue.InvalidValue(Option_.some(file), {
+      catch: e => new SchemaIssue.InvalidValue(Option_.some(file), {
         message: globalThis.String(e)
       })
     })
@@ -6274,7 +6431,7 @@ export const FormData = /*#__PURE__*/instanceOf(globalThis.FormData, {
   }), Struct({
     _tag: tag("File"),
     value: File
-  })])])), Transformation.transformOrFail({
+  })])])), SchemaTransformation.transformOrFail({
     decode: e => {
       const out = new globalThis.FormData();
       for (const [key, entry] of e) {
@@ -6388,7 +6545,7 @@ export const FormData = /*#__PURE__*/instanceOf(globalThis.FormData, {
  * @since 4.0.0
  */
 export function fromFormData(schema) {
-  return FormData.pipe(decodeTo(schema, Transformation.fromFormData));
+  return FormData.pipe(decodeTo(schema, SchemaTransformation.fromFormData));
 }
 /**
  * Schema for JavaScript `URLSearchParams` objects.
@@ -6411,7 +6568,7 @@ export const URLSearchParams = /*#__PURE__*/instanceOf(globalThis.URLSearchParam
   expected: "URLSearchParams",
   toCodecJson: () => link()(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()
   }))
@@ -6497,7 +6654,7 @@ export const URLSearchParams = /*#__PURE__*/instanceOf(globalThis.URLSearchParam
  * @since 4.0.0
  */
 export function fromURLSearchParams(schema) {
-  return URLSearchParams.pipe(decodeTo(schema, Transformation.fromURLSearchParams));
+  return URLSearchParams.pipe(decodeTo(schema, SchemaTransformation.fromURLSearchParams));
 }
 /**
  * Schema for finite numbers, rejecting `NaN`, `Infinity`, and `-Infinity`.
@@ -6532,7 +6689,7 @@ export const Int = /*#__PURE__*/Number.check(/*#__PURE__*/isInt());
  */
 export const NumberFromString = /*#__PURE__*/String.annotate({
   expected: "a string that will be decoded as a number"
-}).pipe(/*#__PURE__*/decodeTo(Number, Transformation.numberFromString));
+}).pipe(/*#__PURE__*/decodeTo(Number, SchemaTransformation.numberFromString));
 /**
  * Schema that parses a string into a finite number.
  *
@@ -6550,7 +6707,7 @@ export const NumberFromString = /*#__PURE__*/String.annotate({
  */
 export const FiniteFromString = /*#__PURE__*/String.annotate({
   expected: "a string that will be decoded as a finite number"
-}).pipe(/*#__PURE__*/decodeTo(Finite, Transformation.numberFromString));
+}).pipe(/*#__PURE__*/decodeTo(Finite, SchemaTransformation.numberFromString));
 /**
  * Schema that parses a string into a `bigint`.
  *
@@ -6579,7 +6736,7 @@ export const FiniteFromString = /*#__PURE__*/String.annotate({
  * @category BigInt
  * @since 4.0.0
  */
-export const BigIntFromString = /*#__PURE__*/make(AST.bigIntString).pipe(/*#__PURE__*/decodeTo(BigInt, Transformation.bigintFromString));
+export const BigIntFromString = /*#__PURE__*/make(SchemaAST.bigIntString).pipe(/*#__PURE__*/decodeTo(BigInt, SchemaTransformation.bigintFromString));
 /**
  * Schema for strings that contains no leading or trailing whitespaces.
  *
@@ -6603,7 +6760,7 @@ export const Trimmed = /*#__PURE__*/String.check(/*#__PURE__*/isTrimmed());
  */
 export const Trim = /*#__PURE__*/String.annotate({
   expected: "a string that will be decoded as a trimmed string"
-}).pipe(/*#__PURE__*/decodeTo(Trimmed, /*#__PURE__*/Transformation.trim()));
+}).pipe(/*#__PURE__*/decodeTo(Trimmed, /*#__PURE__*/SchemaTransformation.trim()));
 /**
  * Decodes a base64 (RFC4648) encoded string into a UTF-8 string.
  *
@@ -6620,7 +6777,7 @@ export const Trim = /*#__PURE__*/String.annotate({
  */
 export const StringFromBase64 = /*#__PURE__*/String.annotate({
   expected: "a base64 encoded string that will be decoded as a UTF-8 string"
-}).pipe(/*#__PURE__*/decodeTo(String, Transformation.stringFromBase64String));
+}).pipe(/*#__PURE__*/decodeTo(String, SchemaTransformation.stringFromBase64String));
 /**
  * Decodes a base64 (URL) encoded string into a UTF-8 string.
  *
@@ -6637,7 +6794,7 @@ export const StringFromBase64 = /*#__PURE__*/String.annotate({
  */
 export const StringFromBase64Url = /*#__PURE__*/String.annotate({
   expected: "a base64 (URL) encoded string that will be decoded as a UTF-8 string"
-}).pipe(/*#__PURE__*/decodeTo(String, Transformation.stringFromBase64UrlString));
+}).pipe(/*#__PURE__*/decodeTo(String, SchemaTransformation.stringFromBase64UrlString));
 /**
  * Decodes a hex encoded string into a UTF-8 string.
  *
@@ -6654,7 +6811,7 @@ export const StringFromBase64Url = /*#__PURE__*/String.annotate({
  */
 export const StringFromHex = /*#__PURE__*/String.annotate({
   expected: "a hex encoded string that will be decoded as a UTF-8 string"
-}).pipe(/*#__PURE__*/decodeTo(String, Transformation.stringFromHexString));
+}).pipe(/*#__PURE__*/decodeTo(String, SchemaTransformation.stringFromHexString));
 /**
  * Decodes a URI component encoded string into a UTF-8 string.
  * Can be used to store data in a URL.
@@ -6690,7 +6847,7 @@ export const StringFromHex = /*#__PURE__*/String.annotate({
  */
 export const StringFromUriComponent = /*#__PURE__*/String.annotate({
   expected: "a URI component encoded string that will be decoded as a UTF-8 string"
-}).pipe(/*#__PURE__*/decodeTo(String, Transformation.stringFromUriComponent));
+}).pipe(/*#__PURE__*/decodeTo(String, SchemaTransformation.stringFromUriComponent));
 /**
  * Schema for property keys accepted by Effect schemas: finite `number`,
  * `symbol`, or `string`.
@@ -6737,7 +6894,7 @@ export const StandardSchemaV1FailureResult = /*#__PURE__*/Struct({
  * @category boolean
  * @since 4.0.0
  */
-export const BooleanFromBit = /*#__PURE__*/Literals([0, 1]).pipe(/*#__PURE__*/decodeTo(Boolean, /*#__PURE__*/Transformation.transform({
+export const BooleanFromBit = /*#__PURE__*/Literals([0, 1]).pipe(/*#__PURE__*/decodeTo(Boolean, /*#__PURE__*/SchemaTransformation.transform({
   decode: bit => bit === 1,
   encode: bool => bool ? 1 : 0
 })));
@@ -6767,7 +6924,7 @@ export const Uint8Array = /*#__PURE__*/instanceOf(globalThis.Uint8Array, {
     Type: `globalThis.Uint8Array`
   },
   expected: "Uint8Array",
-  toCodecJson: () => link()(Base64String, Transformation.uint8ArrayFromBase64String),
+  toCodecJson: () => link()(Base64String, SchemaTransformation.uint8ArrayFromBase64String),
   toArbitrary: () => fc => fc.uint8Array()
 });
 /**
@@ -6785,7 +6942,7 @@ export const Uint8Array = /*#__PURE__*/instanceOf(globalThis.Uint8Array, {
  * @category Uint8Array
  * @since 3.10.0
  */
-export const Uint8ArrayFromBase64 = /*#__PURE__*/Base64String.pipe(/*#__PURE__*/decodeTo(Uint8Array, Transformation.uint8ArrayFromBase64String));
+export const Uint8ArrayFromBase64 = /*#__PURE__*/Base64String.pipe(/*#__PURE__*/decodeTo(Uint8Array, SchemaTransformation.uint8ArrayFromBase64String));
 /**
  * Schema that decodes a base64 (URL) encoded string into a
  * `Uint8Array`.
@@ -6804,8 +6961,8 @@ export const Uint8ArrayFromBase64 = /*#__PURE__*/Base64String.pipe(/*#__PURE__*/
 export const Uint8ArrayFromBase64Url = /*#__PURE__*/String.annotate({
   expected: "a base64 (URL) encoded string that will be decoded as a Uint8Array"
 }).pipe(/*#__PURE__*/decodeTo(Uint8Array, {
-  decode: /*#__PURE__*/Getter.decodeBase64Url(),
-  encode: /*#__PURE__*/Getter.encodeBase64Url()
+  decode: /*#__PURE__*/SchemaGetter.decodeBase64Url(),
+  encode: /*#__PURE__*/SchemaGetter.encodeBase64Url()
 }));
 /**
  * Schema that decodes a hex encoded string into a
@@ -6825,8 +6982,8 @@ export const Uint8ArrayFromBase64Url = /*#__PURE__*/String.annotate({
 export const Uint8ArrayFromHex = /*#__PURE__*/String.annotate({
   expected: "a hex encoded string that will be decoded as a Uint8Array"
 }).pipe(/*#__PURE__*/decodeTo(Uint8Array, {
-  decode: /*#__PURE__*/Getter.decodeHex(),
-  encode: /*#__PURE__*/Getter.encodeHex()
+  decode: /*#__PURE__*/SchemaGetter.decodeHex(),
+  encode: /*#__PURE__*/SchemaGetter.encodeHex()
 }));
 /**
  * Schema for `DateTime.Utc` values.
@@ -6859,7 +7016,7 @@ export const DateTimeUtc = /*#__PURE__*/declare(u => DateTime.isDateTime(u) && D
     importDeclaration: `import * as DateTime from "effect/DateTime"`
   },
   expected: "DateTime.Utc",
-  toCodecJson: () => link()(String, Transformation.dateTimeUtcFromString),
+  toCodecJson: () => link()(String, SchemaTransformation.dateTimeUtcFromString),
   toArbitrary: () => (fc, ctx) => fc.date({
     noInvalidDate: true,
     ...ctx?.constraints?.date
@@ -6872,8 +7029,8 @@ export const DateTimeUtc = /*#__PURE__*/declare(u => DateTime.isDateTime(u) && D
  *
  * **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**
  *
@@ -6892,8 +7049,8 @@ export const DateTimeUtc = /*#__PURE__*/declare(u => DateTime.isDateTime(u) && D
  * @since 3.12.0
  */
 export const DateTimeUtcFromDate = /*#__PURE__*/DateValid.pipe(/*#__PURE__*/decodeTo(DateTimeUtc, {
-  decode: /*#__PURE__*/Getter.dateTimeUtcFromInput(),
-  encode: /*#__PURE__*/Getter.transform(DateTime.toDateUtc)
+  decode: /*#__PURE__*/SchemaGetter.dateTimeUtcFromInput(),
+  encode: /*#__PURE__*/SchemaGetter.transform(DateTime.toDateUtc)
 }));
 /**
  * Schema that decodes a date-time string into a `DateTime.Utc`.
@@ -6914,7 +7071,7 @@ export const DateTimeUtcFromDate = /*#__PURE__*/DateValid.pipe(/*#__PURE__*/deco
  */
 export const DateTimeUtcFromString = /*#__PURE__*/String.annotate({
   expected: "a string that will be decoded as a DateTime.Utc"
-}).pipe(/*#__PURE__*/decodeTo(DateTimeUtc, Transformation.dateTimeUtcFromString));
+}).pipe(/*#__PURE__*/decodeTo(DateTimeUtc, SchemaTransformation.dateTimeUtcFromString));
 /**
  * Schema that decodes a number into a `DateTime.Utc`.
  *
@@ -6930,8 +7087,8 @@ export const DateTimeUtcFromString = /*#__PURE__*/String.annotate({
  * @since 4.0.0
  */
 export const DateTimeUtcFromMillis = /*#__PURE__*/Number.pipe(/*#__PURE__*/decodeTo(DateTimeUtc, {
-  decode: /*#__PURE__*/Getter.dateTimeUtcFromInput(),
-  encode: /*#__PURE__*/Getter.transform(DateTime.toEpochMillis)
+  decode: /*#__PURE__*/SchemaGetter.dateTimeUtcFromInput(),
+  encode: /*#__PURE__*/SchemaGetter.transform(DateTime.toEpochMillis)
 }));
 /**
  * Schema for `DateTime.TimeZone.Offset` values.
@@ -6955,7 +7112,7 @@ export const TimeZoneOffset = /*#__PURE__*/declare(DateTime.isTimeZoneOffset, {
     importDeclaration: `import * as DateTime from "effect/DateTime"`
   },
   expected: "DateTime.TimeZone.Offset",
-  toCodecJson: () => link()(Number, Transformation.timeZoneOffsetFromNumber),
+  toCodecJson: () => link()(Number, SchemaTransformation.timeZoneOffsetFromNumber),
   toArbitrary: () => fc => fc.integer({
     min: -12 * 60 * 60 * 1000,
     max: 14 * 60 * 60 * 1000
@@ -6988,7 +7145,7 @@ export const TimeZoneNamed = /*#__PURE__*/declare(DateTime.isTimeZoneNamed, {
     importDeclaration: `import * as DateTime from "effect/DateTime"`
   },
   expected: "DateTime.TimeZone.Named",
-  toCodecJson: () => link()(TimeZoneNamedString, Transformation.timeZoneNamedFromString),
+  toCodecJson: () => link()(TimeZoneNamedString, SchemaTransformation.timeZoneNamedFromString),
   toArbitrary: () => fc => fc.constantFrom(...["UTC", "Europe/London", "America/New_York", "Asia/Tokyo", "Australia/Sydney"].map(DateTime.zoneMakeNamedUnsafe)),
   toFormatter: () => tz => DateTime.zoneToString(tz),
   toEquivalence: () => (a, b) => a.id === b.id
@@ -7007,7 +7164,7 @@ export const TimeZoneNamed = /*#__PURE__*/declare(DateTime.isTimeZoneNamed, {
  * @category DateTime
  * @since 4.0.0
  */
-export const TimeZoneNamedFromString = /*#__PURE__*/TimeZoneNamedString.pipe(/*#__PURE__*/decodeTo(TimeZoneNamed, Transformation.timeZoneNamedFromString));
+export const TimeZoneNamedFromString = /*#__PURE__*/TimeZoneNamedString.pipe(/*#__PURE__*/decodeTo(TimeZoneNamed, SchemaTransformation.timeZoneNamedFromString));
 const TimeZoneString = /*#__PURE__*/String.annotate({
   expected: "a time zone string (IANA identifier or offset like +03:00)"
 });
@@ -7034,7 +7191,7 @@ export const TimeZone = /*#__PURE__*/declare(DateTime.isTimeZone, {
     importDeclaration: `import * as DateTime from "effect/DateTime"`
   },
   expected: "DateTime.TimeZone",
-  toCodecJson: () => link()(TimeZoneString, Transformation.timeZoneFromString),
+  toCodecJson: () => link()(TimeZoneString, SchemaTransformation.timeZoneFromString),
   toArbitrary: () => fc => fc.oneof(fc.integer({
     min: -12 * 60 * 60 * 1000,
     max: 14 * 60 * 60 * 1000
@@ -7056,7 +7213,7 @@ export const TimeZone = /*#__PURE__*/declare(DateTime.isTimeZone, {
  * @category DateTime
  * @since 4.0.0
  */
-export const TimeZoneFromString = /*#__PURE__*/TimeZoneString.pipe(/*#__PURE__*/decodeTo(TimeZone, Transformation.timeZoneFromString));
+export const TimeZoneFromString = /*#__PURE__*/TimeZoneString.pipe(/*#__PURE__*/decodeTo(TimeZone, SchemaTransformation.timeZoneFromString));
 const DateTimeZonedString = /*#__PURE__*/String.annotate({
   expected: "a zoned DateTime string (e.g. 2024-01-01T00:00:00.000+00:00[Europe/London])"
 });
@@ -7085,7 +7242,7 @@ export const DateTimeZoned = /*#__PURE__*/declare(u => DateTime.isDateTime(u) &&
     importDeclaration: `import * as DateTime from "effect/DateTime"`
   },
   expected: "DateTime.Zoned",
-  toCodecJson: () => link()(DateTimeZonedString, Transformation.dateTimeZonedFromString),
+  toCodecJson: () => link()(DateTimeZonedString, SchemaTransformation.dateTimeZonedFromString),
   toArbitrary: () => (fc, ctx) => fc.tuple(fc.date({
     noInvalidDate: true,
     min: new globalThis.Date(-8640000000000000 + 14 * 60 * 60 * 1000),
@@ -7111,7 +7268,7 @@ export const DateTimeZoned = /*#__PURE__*/declare(u => DateTime.isDateTime(u) &&
  * @category DateTime
  * @since 4.0.0
  */
-export const DateTimeZonedFromString = /*#__PURE__*/DateTimeZonedString.pipe(/*#__PURE__*/decodeTo(DateTimeZoned, Transformation.dateTimeZonedFromString));
+export const DateTimeZonedFromString = /*#__PURE__*/DateTimeZonedString.pipe(/*#__PURE__*/decodeTo(DateTimeZoned, SchemaTransformation.dateTimeZonedFromString));
 const immerable = /*#__PURE__*/globalThis.Symbol.for("immer-draftable");
 function makeClass(Inherited, identifier, struct, annotations, proto) {
   const getClassSchema = getClassSchemaFactory(struct, identifier, annotations);
@@ -7148,19 +7305,19 @@ function makeClass(Inherited, identifier, struct, annotations, proto) {
       return new this(input, options);
     }
     static makeOption(input, options) {
-      return Parser.makeOption(getClassSchema(this))(input ?? {}, options);
+      return SchemaParser.makeOption(getClassSchema(this))(input ?? {}, options);
     }
     static makeEffect(input, options) {
       return getClassSchema(this).makeEffect(input ?? {}, options);
     }
     static annotate(annotations) {
-      return this.rebuild(AST.annotate(this.ast, annotations));
+      return this.rebuild(SchemaAST.annotate(this.ast, annotations));
     }
     static annotateKey(annotations) {
-      return this.rebuild(AST.annotateKey(this.ast, annotations));
+      return this.rebuild(SchemaAST.annotateKey(this.ast, annotations));
     }
     static check(...checks) {
-      return this.rebuild(AST.appendChecks(this.ast, checks));
+      return this.rebuild(SchemaAST.appendChecks(this.ast, checks));
     }
     static extend(identifier) {
       return (newFields, annotations) => {
@@ -7168,7 +7325,7 @@ function makeClass(Inherited, identifier, struct, annotations, proto) {
           ...struct.fields,
           ...newFields
         };
-        return makeClass(this, identifier, makeStruct(AST.struct(fields, struct.ast.checks, {
+        return makeClass(this, identifier, makeStruct(SchemaAST.struct(fields, struct.ast.checks, {
           identifier
         }), fields), annotations, proto);
       };
@@ -7183,7 +7340,7 @@ function makeClass(Inherited, identifier, struct, annotations, proto) {
   return out;
 }
 function getClassTransformation(self) {
-  return new Transformation.Transformation(Getter.transform(input => new self(input)), Getter.passthrough());
+  return new SchemaTransformation.Transformation(SchemaGetter.transform(input => new self(input)), SchemaGetter.passthrough());
 }
 function getClassTypeId(identifier) {
   return `~effect/Schema/Class/${identifier}`;
@@ -7193,15 +7350,15 @@ function getClassSchemaFactory(from, identifier, annotations) {
   return self => {
     if (memo === undefined) {
       const transformation = getClassTransformation(self);
-      const to = make(new AST.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)));
+      const to = make(new SchemaAST.Declaration([from.ast], () => (input, ast) => {
+        return input instanceof self || Predicate.hasProperty(input, getClassTypeId(identifier)) ? Effect.succeed(input) : Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)));
       }, {
         identifier,
-        [AST.ClassTypeId]: ([from]) => new AST.Link(from, transformation),
-        toCodec: ([from]) => new AST.Link(from.ast, transformation),
+        [SchemaAST.ClassTypeId]: ([from]) => new SchemaAST.Link(from, transformation),
+        toCodec: ([from]) => new SchemaAST.Link(from.ast, transformation),
         toArbitrary: ([from]) => () => from.map(args => new self(args)),
         toFormatter: ([from]) => t => `${self.identifier}(${from(t)})`,
-        "~sentinels": AST.collectSentinels(from.ast),
+        "~sentinels": SchemaAST.collectSentinels(from.ast),
         ...annotations
       }));
       memo = from.pipe(decodeTo(to, transformation));
@@ -7219,9 +7376,8 @@ function isStruct(schema) {
  *
  * **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**
  *
@@ -7473,7 +7629,7 @@ export function toFormatter(schema, options) {
     // ---------------------------------------------
     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
@@ -7509,7 +7665,7 @@ export function toFormatter(schema, 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 {
@@ -7552,7 +7708,7 @@ export function toFormatter(schema, 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])}`);
@@ -7561,7 +7717,7 @@ export function toFormatter(schema, 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;
@@ -7575,10 +7731,10 @@ export function toFormatter(schema, options) {
         }
       case "Union":
         {
-          const getCandidates = t => AST.getCandidates(t, ast.types);
+          const getCandidates = t => 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)) {
@@ -7590,7 +7746,7 @@ export function toFormatter(schema, options) {
         }
       case "Suspend":
         {
-          const get = AST.memoizeThunk(() => recur(ast.thunk()));
+          const get = SchemaAST.memoizeThunk(() => recur(ast.thunk()));
           return t => get()(t);
         }
     }
@@ -7605,8 +7761,8 @@ export function toFormatter(schema, 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
@@ -7686,9 +7842,9 @@ export function toJsonSchemaDocument(schema, options) {
 export function toCodecJson(schema) {
   return make(toCodecJsonTop(schema.ast));
 }
-const toCodecJsonTop = /*#__PURE__*/AST.toCodec(ast => {
+const toCodecJsonTop = /*#__PURE__*/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, recur) {
   switch (ast._tag) {
@@ -7696,16 +7852,16 @@ function toCodecJsonBase(ast, recur) {
       {
         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":
@@ -7728,7 +7884,7 @@ function toCodecJsonBase(ast, recur) {
       {
         const sortedTypes = InternalSchema.jsonReorder(ast.types);
         if (sortedTypes !== ast.types) {
-          return new AST.Union(sortedTypes, ast.mode, ast.annotations, ast.checks, ast.encoding, ast.context).recur(recur);
+          return new SchemaAST.Union(sortedTypes, ast.mode, ast.annotations, ast.checks, ast.encoding, ast.context).recur(recur);
         }
         return ast.recur(recur);
       }
@@ -7747,11 +7903,11 @@ function toCodecJsonBase(ast, recur) {
  * @since 4.0.0
  */
 export function toCodecIso(schema) {
-  return make(toCodecIsoTop(AST.toType(schema.ast)));
+  return make(toCodecIsoTop(SchemaAST.toType(schema.ast)));
 }
 const toCodecIsoTop = /*#__PURE__*/memoize(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, recur) {
   switch (ast._tag) {
@@ -7761,7 +7917,7 @@ function toCodecIsoBase(ast, recur) {
         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;
       }
@@ -7905,20 +8061,20 @@ function serializerTree(ast, recur, onMissingAnnotation) {
       {
         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":
@@ -7939,7 +8095,7 @@ function serializerTree(ast, recur, onMissingAnnotation) {
       {
         const sortedTypes = treeReorder(ast.types);
         if (sortedTypes !== ast.types) {
-          return new AST.Union(sortedTypes, ast.mode, ast.annotations, ast.checks, ast.encoding, ast.context).recur(recur);
+          return new SchemaAST.Union(sortedTypes, ast.mode, ast.annotations, ast.checks, ast.encoding, ast.context).recur(recur);
         }
         return ast.recur(recur);
       }
@@ -7950,34 +8106,34 @@ function serializerTree(ast, recur, onMissingAnnotation) {
   // `Schema.Any` is used as an escape hatch
   return ast;
 }
-const nullToString = /*#__PURE__*/new AST.Link(/*#__PURE__*/new AST.Literal("null"), /*#__PURE__*/new Transformation.Transformation(/*#__PURE__*/Getter.transform(() => null), /*#__PURE__*/Getter.transform(() => "null")));
-const booleanToString = /*#__PURE__*/new AST.Link(/*#__PURE__*/new AST.Union([/*#__PURE__*/new AST.Literal("true"), /*#__PURE__*/new AST.Literal("false")], "anyOf"), /*#__PURE__*/new Transformation.Transformation(/*#__PURE__*/Getter.transform(s => s === "true"), /*#__PURE__*/Getter.String()));
-const serializerStringTree = /*#__PURE__*/AST.toCodec(ast => {
-  const out = serializerTree(ast, serializerStringTree, ast => AST.replaceEncoding(ast, [unknownToUndefined]));
-  if (out !== ast && AST.isOptional(ast)) {
-    return AST.optionalKeyLastLink(out);
+const nullToString = /*#__PURE__*/new SchemaAST.Link(/*#__PURE__*/new SchemaAST.Literal("null"), /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(() => null), /*#__PURE__*/SchemaGetter.transform(() => "null")));
+const booleanToString = /*#__PURE__*/new SchemaAST.Link(/*#__PURE__*/new SchemaAST.Union([/*#__PURE__*/new SchemaAST.Literal("true"), /*#__PURE__*/new SchemaAST.Literal("false")], "anyOf"), /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(s => s === "true"), /*#__PURE__*/SchemaGetter.String()));
+const serializerStringTree = /*#__PURE__*/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 = /*#__PURE__*/new AST.Link(AST.undefined, /*#__PURE__*/new Transformation.Transformation(/*#__PURE__*/Getter.passthrough(), /*#__PURE__*/Getter.transform(() => undefined)));
-const serializerStringTreeKeepDeclarations = /*#__PURE__*/AST.toCodec(ast => {
+const unknownToUndefined = /*#__PURE__*/new SchemaAST.Link(SchemaAST.undefined, /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.passthrough(), /*#__PURE__*/SchemaGetter.transform(() => undefined)));
+const serializerStringTreeKeepDeclarations = /*#__PURE__*/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 = /*#__PURE__*/AST.toCodec(ast => {
-  if (AST.isUnion(ast) && ast.annotations?.[SERIALIZER_ENSURE_ARRAY]) {
+const toCodecEnsureArray = /*#__PURE__*/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([out, AST.decodeTo(AST.string, out, new Transformation.Transformation(Getter.split(), Getter.passthrough()))], "anyOf", {
+  if (SchemaAST.isArrays(out)) {
+    const ensure = new SchemaAST.Union([out, SchemaAST.decodeTo(SchemaAST.string, out, 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;
 });
@@ -8005,7 +8161,7 @@ function onSerializerEnsureArray(ast) {
  */
 export function toIso(schema) {
   const serializer = toCodecIso(schema);
-  return Optic_.makeIso(Parser.encodeSync(serializer), Parser.decodeSync(serializer));
+  return Optic_.makeIso(SchemaParser.encodeSync(serializer), SchemaParser.decodeSync(serializer));
 }
 /**
  * Returns an identity `Iso` over the schema's source (`Type`) side.
@@ -8044,8 +8200,8 @@ export function toIsoFocus(_) {
  */
 export function overrideToCodecIso(to, transformation) {
   return schema => {
-    return make(AST.annotate(schema.ast, {
-      toCodecIso: () => new AST.Link(to.ast, Transformation.make(transformation))
+    return make(SchemaAST.annotate(schema.ast, {
+      toCodecIso: () => new SchemaAST.Link(to.ast, SchemaTransformation.make(transformation))
     }), {
       schema
     });
@@ -8064,8 +8220,8 @@ export function overrideToCodecIso(to, transformation) {
  */
 export function toDifferJsonPatch(schema) {
   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)),
@@ -8105,7 +8261,13 @@ export function Tree(node) {
  * @category schemas
  * @since 4.0.0
  */
-export const Json = /*#__PURE__*/make(AST.Json);
+export const Json = /*#__PURE__*/make(SchemaAST.Json);
+const JsonError = /*#__PURE__*/Struct({
+  message: String,
+  name: /*#__PURE__*/optionalKey(String),
+  stack: /*#__PURE__*/optionalKey(String),
+  cause: /*#__PURE__*/optionalKey(Json)
+});
 /**
  * Schema that accepts any mutable JSON-compatible value. See {@link Json} for
  * the immutable variant.
@@ -8113,7 +8275,7 @@ export const Json = /*#__PURE__*/make(AST.Json);
  * @category schemas
  * @since 4.0.0
  */
-export const MutableJson = /*#__PURE__*/make(AST.MutableJson);
+export const MutableJson = /*#__PURE__*/make(SchemaAST.MutableJson);
 // -----------------------------------------------------------------------------
 // Annotations
 // -----------------------------------------------------------------------------