effect 4.0.0-beta.85 → 4.0.0-beta.86

package/dist/Schema.d.ts

@@ -102,24 +102,18 @@ export interface MakeOptions {
 }
 /**
  * The fully-parameterized base interface for all schemas. Exposes all 14 type
- * parameters controlling type inference, mutability, optionality, services,
- * and transformation behavior.
+ * parameters controlling type inference, mutability, optionality, services, and
+ * transformation behavior.
  *
  * **When to use**
  *
- * Use when you are writing advanced generic schema utilities or performing schema
- *   introspection.
- * - In user code, prefer {@link Schema}, {@link Codec}, {@link Decoder}, or
- *   {@link Encoder} instead.
- *
- * @see {@link Top} — the existential "any schema" type (erased type params)
- * @see {@link Schema} — tracks only the decoded Type
- * @see {@link Codec} — tracks Type + Encoded
+ * Use when you are writing advanced generic schema utilities or performing
+ *   schema introspection.
  *
  * @category models
  * @since 4.0.0
  */
-export interface Bottom<out T, out E, out RD, out RE, out Ast extends SchemaAST.AST, out Rebuild extends Top, out TypeMakeIn = T, out Iso = T, in out TypeParameters extends ReadonlyArray<Top> = readonly [], out TypeMake = TypeMakeIn, out TypeMutability extends Mutability = "readonly", out TypeOptionality extends Optionality = "required", out TypeConstructorDefault extends ConstructorDefault = "no-default", out EncodedMutability extends Mutability = "readonly", out EncodedOptionality extends Optionality = "required"> extends Pipeable.Pipeable {
+export interface Bottom<out T, out E, out RD, out RE, out Ast extends SchemaAST.AST, out Rebuild extends Top, out TypeMakeIn = T, out Iso = T, in out TypeParameters extends ReadonlyArray<Constraint> = readonly [], out TypeMake = TypeMakeIn, out TypeMutability extends Mutability = "readonly", out TypeOptionality extends Optionality = "required", out TypeConstructorDefault extends ConstructorDefault = "no-default", out EncodedMutability extends Mutability = "readonly", out EncodedOptionality extends Optionality = "required"> extends Pipeable.Pipeable {
     readonly [TypeId]: typeof TypeId;
     readonly "ast": Ast;
     readonly "Rebuild": Rebuild;
@@ -202,13 +196,40 @@ export interface Bottom<out T, out E, out RD, out RE, out Ast extends SchemaAST.
      */
     makeEffect(input: this["~type.make.in"], options?: MakeOptions): Effect.Effect<this["Type"], SchemaError>;
 }
+/**
+ * Lazy `Bottom` variant for schema implementations that compute their public
+ * views on demand.
+ *
+ * **When to use**
+ *
+ * Use as an implementation base for schema interfaces that must expose
+ * `Bottom` behavior without forcing TypeScript to eagerly evaluate expensive
+ * `Type`, `Encoded`, or service views.
+ *
+ * **Details**
+ *
+ * The laziness is purely type-level; runtime behavior is unchanged.
+ * `BottomLazy` keeps the structural operations inherited from `Bottom`, but
+ * erases the expensive schema views to `unknown`. Concrete schema interfaces can
+ * then redeclare the precise views they expose. This keeps wide schemas such as
+ * `Struct` and `Union` cheaper when generic code reads a single view, while
+ * preserving their exact public types.
+ *
+ * @see {@link Bottom} for the fully parameterized schema interface when every
+ * view must be supplied directly.
+ *
+ * @category utility types
+ * @since 4.0.0
+ */
+export interface BottomLazy<out Ast extends SchemaAST.AST, out Rebuild extends Top, in out TypeParameters extends ReadonlyArray<Constraint> = readonly [], out TypeMutability extends Mutability = "readonly", out TypeOptionality extends Optionality = "required", out TypeConstructorDefault extends ConstructorDefault = "no-default", out EncodedMutability extends Mutability = "readonly", out EncodedOptionality extends Optionality = "required"> extends Bottom<unknown, unknown, unknown, unknown, Ast, Rebuild, unknown, unknown, TypeParameters, unknown, TypeMutability, TypeOptionality, TypeConstructorDefault, EncodedMutability, EncodedOptionality> {
+}
 /**
  * Type-level representation returned by {@link declareConstructor}.
  *
  * @category constructors
  * @since 4.0.0
  */
-export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<Top>, Iso = T> extends Bottom<T, E, TypeParameters[number]["DecodingServices"], TypeParameters[number]["EncodingServices"], SchemaAST.Declaration, declareConstructor<T, E, TypeParameters, Iso>, T, Iso, TypeParameters> {
+export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<Constraint>, Iso = T> extends Bottom<T, E, TypeParameters[number]["DecodingServices"], TypeParameters[number]["EncodingServices"], SchemaAST.Declaration, declareConstructor<T, E, TypeParameters, Iso>, T, Iso, TypeParameters> {
 }
 /**
  * Creates a schema for a **parametric** type (a generic container such as
@@ -243,7 +264,7 @@ export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<T
  * const isBox = (u: unknown): u is Box<unknown> =>
  *   typeof u === "object" && u !== null && "value" in u
  *
- * const Box = <A extends Schema.Top>(item: A) =>
+ * const Box = <A extends Schema.Constraint>(item: A) =>
  *   Schema.declareConstructor<Box<A["Type"]>, Box<A["Encoded"]>>()(
  *     [item],
  *     ([itemCodec]) =>
@@ -264,7 +285,7 @@ export interface declareConstructor<T, E, TypeParameters extends ReadonlyArray<T
  * @category constructors
  * @since 4.0.0
  */
-export declare function declareConstructor<T, E = T, Iso = T>(): <const TypeParameters extends ReadonlyArray<Top>>(typeParameters: TypeParameters, run: (typeParameters: { readonly [K in keyof TypeParameters]: Codec<TypeParameters[K]["Type"], TypeParameters[K]["Encoded"]>; }) => (u: unknown, self: SchemaAST.Declaration, options: SchemaAST.ParseOptions) => Effect.Effect<T, SchemaIssue.Issue>, annotations?: Annotations.Declaration<T, TypeParameters>) => declareConstructor<T, E, TypeParameters, Iso>;
+export declare function declareConstructor<T, E = T, Iso = T>(): <const TypeParameters extends ReadonlyArray<Constraint>>(typeParameters: TypeParameters, run: (typeParameters: { readonly [K in keyof TypeParameters]: Codec<TypeParameters[K]["Type"], TypeParameters[K]["Encoded"]>; }) => (u: unknown, self: SchemaAST.Declaration, options: SchemaAST.ParseOptions) => Effect.Effect<T, SchemaIssue.Issue>, annotations?: Annotations.Declaration<T, TypeParameters>) => declareConstructor<T, E, TypeParameters, Iso>;
 /**
  * Type-level representation returned by {@link declare}.
  *
@@ -439,8 +460,8 @@ export declare function annotateKey<S extends Top>(annotations: Annotations.Key<
  * In user code prefer the narrower interfaces:
  * - {@link Schema}`<T>` — when you only care about the decoded type
  * - {@link Codec}`<T, E, RD, RE>` — when you need the encoded type and service requirements
- * - {@link Decoder}`<T, RD>` — for decode-only APIs
- * - {@link Encoder}`<E, RE>` — for encode-only APIs
+ * - {@link ConstraintDecoder}`<T, RD>` — for decode-only APIs
+ * - {@link ConstraintEncoder}`<E, RE>` — for encode-only APIs
  *
  * @category models
  * @since 4.0.0
@@ -448,6 +469,121 @@ export declare function annotateKey<S extends Top>(annotations: Annotations.Key<
 export interface Top extends Bottom<unknown, unknown, unknown, unknown, SchemaAST.AST, Top, unknown, unknown, any, // this is because TypeParameters is invariant
 unknown, Mutability, Optionality, ConstructorDefault, Mutability, Optionality> {
 }
+/**
+ * Lightweight structural constraint for APIs that accept schema values but only
+ * read their data and type-level views.
+ *
+ * **When to use**
+ *
+ * Use when you need to constrain a generic value to be a schema, but the API
+ * only reads properties such as `ast`, `Type`, `Encoded`, service
+ * requirements, constructor input views, or modifier flags.
+ *
+ * **Details**
+ *
+ * `Constraint` keeps the schema type identifier and the property surface needed
+ * by schema constructors, while avoiding the full `Bottom` protocol. Use
+ * {@link Top} when an API calls schema methods such as `annotate`, `check`,
+ * `rebuild`, `make`, or `makeEffect`.
+ *
+ * @see {@link Top} for the complete schema protocol.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface Constraint {
+    readonly [TypeId]: typeof TypeId;
+    readonly "ast": SchemaAST.AST;
+    readonly "Type": unknown;
+    readonly "Encoded": unknown;
+    readonly "DecodingServices": unknown;
+    readonly "EncodingServices": unknown;
+    readonly "~type.parameters": any;
+    readonly "~type.make.in": unknown;
+    readonly "~type.make": unknown;
+    readonly "Iso": unknown;
+    readonly "~type.optionality": Optionality;
+    readonly "~type.mutability": Mutability;
+    readonly "~type.constructor.default": ConstructorDefault;
+    readonly "~encoded.optionality": Optionality;
+    readonly "~encoded.mutability": Mutability;
+}
+/**
+ * Lightweight structural constraint for APIs that need codec type views but do
+ * not need the full schema protocol.
+ *
+ * **When to use**
+ *
+ * Use when you need to preserve decoded type, encoded type, and service
+ * requirements for a schema value, but the API does not call schema methods
+ * such as `annotate`, `check`, `rebuild`, `make`, or `makeEffect`.
+ *
+ * @see {@link Constraint} for the generic lightweight schema constraint.
+ * @see {@link Codec} for the full schema protocol with codec type views.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface ConstraintCodec<out T, out E = T, out RD = never, out RE = never> extends Constraint {
+    readonly "Type": T;
+    readonly "Encoded": E;
+    readonly "DecodingServices": RD;
+    readonly "EncodingServices": RE;
+}
+/**
+ * Lightweight structural constraint for APIs that need decoder type views but
+ * do not need the full schema protocol.
+ *
+ * **When to use**
+ *
+ * Use when you need to preserve a schema's decoded type and decoding services,
+ * but the API does not constrain the encoded type, encoding services, or call
+ * schema methods such as `annotate`, `check`, `rebuild`, `make`, or
+ * `makeEffect`.
+ *
+ * @see {@link ConstraintCodec} for APIs that need both decoded and encoded codec views.
+ * @see {@link Codec} for the full schema protocol with codec type views.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface ConstraintDecoder<out T, out RD = never> extends ConstraintCodec<T, unknown, RD, unknown> {
+}
+/**
+ * Lightweight structural constraint for APIs that need encoder type views but
+ * do not need the full schema protocol.
+ *
+ * **When to use**
+ *
+ * Use when you need to preserve a schema's encoded type and encoding services,
+ * but the API does not constrain the decoded type, decoding services, or call
+ * schema methods such as `annotate`, `check`, `rebuild`, `make`, or
+ * `makeEffect`.
+ *
+ * @see {@link ConstraintCodec} for APIs that need both decoded and encoded codec views.
+ * @see {@link Codec} for the full schema protocol with codec type views.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface ConstraintEncoder<out E, out RE = never> extends ConstraintCodec<unknown, E, unknown, RE> {
+}
+/**
+ * Lightweight structural constraint for APIs that need schema views and the
+ * rebuilt schema type, but do not call the full schema protocol.
+ *
+ * **When to use**
+ *
+ * Use when an API needs to read `Rebuild` in addition to the schema views
+ * exposed by {@link Constraint}, but does not call methods such as `annotate`,
+ * `check`, `rebuild`, `make`, or `makeEffect`.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface ConstraintRebuildable extends Constraint {
+    readonly "Rebuild": Constraint;
+}
 /**
  * Namespace of type-level helpers for {@link Schema}.
  *
@@ -470,7 +606,9 @@ export declare namespace Schema {
      * @category utility types
      * @since 3.10.0
      */
-    type Type<S> = S extends Top ? S["Type"] : never;
+    type Type<S> = S extends {
+        readonly "Type": infer T;
+    } ? T : never;
 }
 /**
  * A typed view of a schema that tracks only the decoded (output) type `T`.
@@ -528,7 +666,9 @@ export declare namespace Codec {
      * @category utility types
      * @since 3.10.0
      */
-    type Encoded<S> = S extends Top ? S["Encoded"] : never;
+    type Encoded<S> = S extends {
+        readonly "Encoded": infer E;
+    } ? E : never;
     /**
      * Extracts the Effect services required during *decoding* from a schema.
      *
@@ -545,7 +685,9 @@ export declare namespace Codec {
      * @category utility types
      * @since 4.0.0
      */
-    type DecodingServices<S> = S extends Top ? S["DecodingServices"] : never;
+    type DecodingServices<S> = S extends {
+        readonly "DecodingServices": infer R;
+    } ? R : never;
     /**
      * Extracts the Effect services required during *encoding* from a schema.
      *
@@ -562,7 +704,9 @@ export declare namespace Codec {
      * @category utility types
      * @since 4.0.0
      */
-    type EncodingServices<S> = S extends Top ? S["EncodingServices"] : never;
+    type EncodingServices<S> = S extends {
+        readonly "EncodingServices": infer R;
+    } ? R : never;
 }
 /**
  * A schema that additionally supports optic (lens/prism) operations.
@@ -599,8 +743,8 @@ export interface Optic<out T, out Iso> extends Schema<T> {
  * Most concrete schemas produced by this module implement `Codec`.
  *
  * For APIs that only need one direction, prefer the narrower views:
- * - {@link Decoder}`<T, RD>` — decode-only
- * - {@link Encoder}`<E, RE>` — encode-only
+ * - {@link ConstraintDecoder}`<T, RD>` — decode-only
+ * - {@link ConstraintEncoder}`<E, RE>` — encode-only
  * - {@link Schema}`<T>` — type-only (no encoded representation)
  *
  * **Example** (Accepting a codec that decodes to `number` from `string`)
@@ -627,58 +771,6 @@ export interface Codec<out T, out E = T, out RD = never, out RE = never> extends
     readonly "EncodingServices": RE;
     readonly "Rebuild": Codec<T, E, RD, RE>;
 }
-/**
- * A {@link Codec} view for APIs that only *decode* (parse/validate) values.
- *
- * **Details**
- *
- * Use `Decoder<T, RD>` to accept "any schema that can decode to `T`" without
- * constraining or depending on the encoded representation (`Encoded` is
- * `unknown`) or encoding services.
- *
- * **Example** (Accepting schemas that only need to decode)
- *
- * ```ts
- * import { Schema } from "effect"
- *
- * declare function validate<T>(decoder: Schema.Decoder<T>): (input: unknown) => T
- *
- * validate(Schema.String)          // ok
- * validate(Schema.NumberFromString) // ok
- * ```
- *
- * @category models
- * @since 4.0.0
- */
-export interface Decoder<out T, out RD = never> extends Codec<T, unknown, RD, unknown> {
-    readonly "Rebuild": Decoder<T, RD>;
-}
-/**
- * A {@link Codec} view for APIs that only *encode* values.
- *
- * **Details**
- *
- * Use `Encoder<E, RE>` to accept "any schema that can encode to `E`" without
- * constraining or depending on the decoded `Type` (`Type` is `unknown`) or
- * decoding services.
- *
- * **Example** (Accepting schemas that only need to encode)
- *
- * ```ts
- * import { Schema } from "effect"
- *
- * declare function serialize<E>(encoder: Schema.Encoder<E>): (value: unknown) => E
- *
- * serialize(Schema.String)          // ok — encodes to string
- * serialize(Schema.NumberFromString) // ok — encodes number to string
- * ```
- *
- * @category models
- * @since 4.0.0
- */
-export interface Encoder<out E, out RE = never> extends Codec<unknown, E, unknown, RE> {
-    readonly "Rebuild": Encoder<E, RE>;
-}
 /**
  * Returns a codec widened to the full {@link Codec} interface, prompting
  * TypeScript to infer all four type parameters (`T`, `E`, `RD`, `RE`).
@@ -822,7 +914,7 @@ export declare function isSchemaError(u: unknown): u is SchemaError;
  * @category Standard Schema
  * @since 4.0.0
  */
-export declare function toStandardSchemaV1<S extends Decoder<unknown>>(self: S, options?: {
+export declare function toStandardSchemaV1<S extends ConstraintDecoder<unknown>>(self: S, options?: {
     readonly leafHook?: SchemaIssue.LeafHook | undefined;
     readonly checkHook?: SchemaIssue.CheckHook | undefined;
     readonly parseOptions?: SchemaAST.ParseOptions | undefined;
@@ -837,7 +929,7 @@ export declare function toStandardSchemaV1<S extends Decoder<unknown>>(self: S,
  * @category Standard Schema
  * @since 4.0.0
  */
-export declare function toStandardJSONSchemaV1<S extends Top>(self: S): StandardJSONSchemaV1<S["Encoded"], S["Type"]> & S;
+export declare function toStandardJSONSchemaV1<S extends Constraint>(self: S): StandardJSONSchemaV1<S["Encoded"], S["Type"]> & S;
 /**
  * Creates a type guard function that checks if a value conforms to a given
  * schema.
@@ -919,7 +1011,7 @@ export declare const is: typeof SchemaParser.is;
  * @category guards
  * @since 4.0.0
  */
-export declare const asserts: <S extends Top, I>(schema: S, input: I) => asserts input is I & S["Type"];
+export declare const asserts: <S extends Constraint, I>(schema: S, input: I) => asserts input is I & S["Type"];
 /**
  * Decodes an `unknown` input against a schema, returning an `Effect` that
  * succeeds with the decoded value or fails with a {@link SchemaError}.
@@ -941,7 +1033,7 @@ export declare const asserts: <S extends Top, I>(schema: S, input: I) => asserts
  * @category decoding
  * @since 4.0.0
  */
-export declare function decodeUnknownEffect<S extends Top>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]>;
+export declare function decodeUnknownEffect<S extends Constraint>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]>;
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema,
  * returning an `Effect` that succeeds with the decoded value or fails with a
@@ -963,7 +1055,7 @@ export declare function decodeUnknownEffect<S extends Top>(schema: S, options?:
  * @category decoding
  * @since 4.0.0
  */
-export declare const decodeEffect: <S extends Top>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]>;
+export declare const decodeEffect: <S extends Constraint>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Effect.Effect<S["Type"], SchemaError, S["DecodingServices"]>;
 /**
  * Decodes an `unknown` input against a schema synchronously, returning an
  * `Exit` that is either a `Success` with the decoded value or a `Failure`.
@@ -994,7 +1086,7 @@ export declare const decodeEffect: <S extends Top>(schema: S, options?: SchemaAS
  * @category decoding
  * @since 4.0.0
  */
-export declare function decodeUnknownExit<S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
+export declare function decodeUnknownExit<S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema
  * synchronously, returning an `Exit` that is either a `Success` with the decoded
@@ -1025,7 +1117,7 @@ export declare function decodeUnknownExit<S extends Decoder<unknown>>(schema: S,
  * @category decoding
  * @since 4.0.0
  */
-export declare const decodeExit: <S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
+export declare const decodeExit: <S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Exit_.Exit<S["Type"], SchemaError>;
 /**
  * Decodes an `unknown` input against a schema, returning an `Option` that is
  * `Some` with the decoded value on success or `None` for schema mismatches.
@@ -1052,7 +1144,7 @@ export declare const decodeExit: <S extends Decoder<unknown>>(schema: S, options
  * @category decoding
  * @since 3.10.0
  */
-export declare const decodeUnknownOption: <S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: unknown, options?: SchemaAST.ParseOptions) => Option_.Option<S["Type"]>;
+export declare const decodeUnknownOption: <S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: unknown, options?: SchemaAST.ParseOptions) => Option_.Option<S["Type"]>;
 /**
  * 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
@@ -1078,7 +1170,7 @@ export declare const decodeUnknownOption: <S extends Decoder<unknown>>(schema: S
  * @category decoding
  * @since 3.10.0
  */
-export declare const decodeOption: <S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Option_.Option<S["Type"]>;
+export declare const decodeOption: <S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Option_.Option<S["Type"]>;
 /**
  * Decodes an `unknown` input against a schema, returning a `Result` that
  * succeeds with the decoded value or fails with a {@link SchemaError} for schema
@@ -1108,7 +1200,7 @@ export declare const decodeOption: <S extends Decoder<unknown>>(schema: S, optio
  * @category decoding
  * @since 4.0.0
  */
-export declare function decodeUnknownResult<S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Result_.Result<S["Type"], SchemaError>;
+export declare function decodeUnknownResult<S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Result_.Result<S["Type"], SchemaError>;
 /**
  * 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
@@ -1137,7 +1229,7 @@ export declare function decodeUnknownResult<S extends Decoder<unknown>>(schema:
  * @category decoding
  * @since 4.0.0
  */
-export declare const decodeResult: <S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Result_.Result<S["Type"], SchemaError>;
+export declare const decodeResult: <S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Result_.Result<S["Type"], SchemaError>;
 /**
  * Decodes an `unknown` input against a schema, returning a `Promise` that
  * resolves with the decoded value or rejects with a {@link SchemaError} for
@@ -1165,7 +1257,7 @@ export declare const decodeResult: <S extends Decoder<unknown>>(schema: S, optio
  * @category decoding
  * @since 3.10.0
  */
-export declare function decodeUnknownPromise<S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Promise<S["Type"]>;
+export declare function decodeUnknownPromise<S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Promise<S["Type"]>;
 /**
  * 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
@@ -1193,7 +1285,7 @@ export declare function decodeUnknownPromise<S extends Decoder<unknown>>(schema:
  * @category decoding
  * @since 3.10.0
  */
-export declare const decodePromise: <S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Promise<S["Type"]>;
+export declare const decodePromise: <S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => Promise<S["Type"]>;
 /**
  * Decodes an `unknown` input against a schema synchronously, returning the
  * decoded value or throwing a {@link SchemaError} for schema mismatches.
@@ -1238,7 +1330,7 @@ export declare const decodePromise: <S extends Decoder<unknown>>(schema: S, opti
  * @category decoding
  * @since 4.0.0
  */
-export declare function decodeUnknownSync<S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => S["Type"];
+export declare function decodeUnknownSync<S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => S["Type"];
 /**
  * Decodes a typed input (the schema's `Encoded` type) against a schema
  * synchronously, returning the decoded value or throwing a {@link SchemaError}
@@ -1265,7 +1357,7 @@ export declare function decodeUnknownSync<S extends Decoder<unknown>>(schema: S,
  * @category decoding
  * @since 4.0.0
  */
-export declare const decodeSync: <S extends Decoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => S["Type"];
+export declare const decodeSync: <S extends ConstraintDecoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Encoded"], options?: SchemaAST.ParseOptions) => S["Type"];
 /**
  * Encodes an `unknown` input against a schema, returning an `Effect` that
  * succeeds with the encoded value or fails with a {@link SchemaError}.
@@ -1298,7 +1390,7 @@ export declare const decodeSync: <S extends Decoder<unknown>>(schema: S, options
  * @category encoding
  * @since 4.0.0
  */
-export declare function encodeUnknownEffect<S extends Top>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Effect.Effect<S["Encoded"], SchemaError, S["EncodingServices"]>;
+export declare function encodeUnknownEffect<S extends Constraint>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Effect.Effect<S["Encoded"], SchemaError, S["EncodingServices"]>;
 /**
  * Encodes a typed input (the schema's `Type`) against a schema, returning an
  * `Effect` that succeeds with the encoded value or fails with a
@@ -1320,7 +1412,7 @@ export declare function encodeUnknownEffect<S extends Top>(schema: S, options?:
  * @category encoding
  * @since 4.0.0
  */
-export declare const encodeEffect: <S extends Top>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Effect.Effect<S["Encoded"], SchemaError, S["EncodingServices"]>;
+export declare const encodeEffect: <S extends Constraint>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Effect.Effect<S["Encoded"], SchemaError, S["EncodingServices"]>;
 /**
  * Encodes an `unknown` input against a schema synchronously, returning an
  * `Exit` that is either a `Success` with the encoded value or a `Failure`.
@@ -1350,7 +1442,7 @@ export declare const encodeEffect: <S extends Top>(schema: S, options?: SchemaAS
  * @category encoding
  * @since 4.0.0
  */
-export declare function encodeUnknownExit<S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
+export declare function encodeUnknownExit<S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
 /**
  * Encodes a typed input (the schema's `Type`) against a schema synchronously,
  * returning an `Exit` that is either a `Success` with the encoded value or a
@@ -1381,7 +1473,7 @@ export declare function encodeUnknownExit<S extends Encoder<unknown>>(schema: S,
  * @category encoding
  * @since 4.0.0
  */
-export declare const encodeExit: <S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
+export declare const encodeExit: <S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Exit_.Exit<S["Encoded"], SchemaError>;
 /**
  * Encodes an `unknown` input against a schema, returning an `Option` that is
  * `Some` with the encoded value on success or `None` for schema mismatches.
@@ -1408,7 +1500,7 @@ export declare const encodeExit: <S extends Encoder<unknown>>(schema: S, options
  * @category encoding
  * @since 3.10.0
  */
-export declare const encodeUnknownOption: <S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: unknown, options?: SchemaAST.ParseOptions) => Option_.Option<S["Encoded"]>;
+export declare const encodeUnknownOption: <S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: unknown, options?: SchemaAST.ParseOptions) => Option_.Option<S["Encoded"]>;
 /**
  * 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` for schema
@@ -1434,7 +1526,7 @@ export declare const encodeUnknownOption: <S extends Encoder<unknown>>(schema: S
  * @category encoding
  * @since 3.10.0
  */
-export declare const encodeOption: <S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Option_.Option<S["Encoded"]>;
+export declare const encodeOption: <S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Option_.Option<S["Encoded"]>;
 /**
  * Encodes an `unknown` input against a schema, returning a `Result` that
  * succeeds with the encoded value or fails with a {@link SchemaError} for schema
@@ -1463,7 +1555,7 @@ export declare const encodeOption: <S extends Encoder<unknown>>(schema: S, optio
  * @category encoding
  * @since 4.0.0
  */
-export declare function encodeUnknownResult<S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Result_.Result<S["Encoded"], SchemaError>;
+export declare function encodeUnknownResult<S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Result_.Result<S["Encoded"], SchemaError>;
 /**
  * Encodes a typed input (the schema's `Type`) against a schema, returning a
  * `Result` that succeeds with the encoded value or fails with a
@@ -1492,7 +1584,7 @@ export declare function encodeUnknownResult<S extends Encoder<unknown>>(schema:
  * @category encoding
  * @since 4.0.0
  */
-export declare const encodeResult: <S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Result_.Result<S["Encoded"], SchemaError>;
+export declare const encodeResult: <S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Result_.Result<S["Encoded"], SchemaError>;
 /**
  * Encodes an `unknown` input against a schema, returning a `Promise` that
  * resolves with the encoded value or rejects with a {@link SchemaError} for
@@ -1519,7 +1611,7 @@ export declare const encodeResult: <S extends Encoder<unknown>>(schema: S, optio
  * @category encoding
  * @since 3.10.0
  */
-export declare function encodeUnknownPromise<S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Promise<S["Encoded"]>;
+export declare function encodeUnknownPromise<S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => Promise<S["Encoded"]>;
 /**
  * Encodes a typed input (the schema's `Type`) against a schema, returning a
  * `Promise` that resolves with the encoded value or rejects with a
@@ -1547,7 +1639,7 @@ export declare function encodeUnknownPromise<S extends Encoder<unknown>>(schema:
  * @category encoding
  * @since 3.10.0
  */
-export declare const encodePromise: <S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Promise<S["Encoded"]>;
+export declare const encodePromise: <S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => Promise<S["Encoded"]>;
 /**
  * Encodes an `unknown` input against a schema synchronously, throwing a
  * {@link SchemaError} for schema mismatches.
@@ -1574,7 +1666,7 @@ export declare const encodePromise: <S extends Encoder<unknown>>(schema: S, opti
  * @category encoding
  * @since 4.0.0
  */
-export declare function encodeUnknownSync<S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => S["Encoded"];
+export declare function encodeUnknownSync<S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions): (input: unknown, options?: SchemaAST.ParseOptions) => S["Encoded"];
 /**
  * Encodes a typed input (the schema's `Type`) against a schema synchronously,
  * throwing a {@link SchemaError} for schema mismatches.
@@ -1599,7 +1691,7 @@ export declare function encodeUnknownSync<S extends Encoder<unknown>>(schema: S,
  * @category encoding
  * @since 4.0.0
  */
-export declare const encodeSync: <S extends Encoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => S["Encoded"];
+export declare const encodeSync: <S extends ConstraintEncoder<unknown>>(schema: S, options?: SchemaAST.ParseOptions) => (input: S["Type"], options?: SchemaAST.ParseOptions) => S["Encoded"];
 /**
  * Creates a schema from an AST (Abstract Syntax Tree) node.
  *
@@ -1617,7 +1709,7 @@ export declare const encodeSync: <S extends Encoder<unknown>>(schema: S, options
  * @category constructors
  * @since 3.10.0
  */
-export declare const make: <S extends Top>(ast: S["ast"], options?: object) => S;
+export declare const make: <S extends Constraint>(ast: S["ast"], options?: object) => S;
 /**
  * Transforms a schema into a class that can be extended with `extends`. The
  * resulting class inherits the full schema API (e.g. `annotate`) and can define
@@ -1655,12 +1747,19 @@ export declare function isSchema(u: unknown): u is Top;
  * @category models
  * @since 4.0.0
  */
-export interface optionalKey<S extends Top> extends Bottom<S["Type"], S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], optionalKey<S>, S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], "optional", S["~type.constructor.default"], S["~encoded.mutability"], "optional"> {
+export interface optionalKey<S extends Constraint> extends BottomLazy<S["ast"], optionalKey<S>, S["~type.parameters"], S["~type.mutability"], "optional", S["~type.constructor.default"], S["~encoded.mutability"], "optional"> {
+    readonly "Type": S["Type"];
+    readonly "Encoded": S["Encoded"];
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": S["~type.make.in"];
+    readonly "~type.make": S["~type.make"];
+    readonly "Iso": S["Iso"];
     readonly schema: S;
 }
 interface optionalKeyLambda extends Lambda {
-    <S extends Top>(self: S): optionalKey<S>;
-    readonly "~lambda.out": this["~lambda.in"] extends Top ? optionalKey<this["~lambda.in"]> : never;
+    <S extends Constraint>(self: S): optionalKey<S>;
+    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? optionalKey<this["~lambda.in"]> : never;
 }
 /**
  * Creates an exact optional key schema for struct fields. Unlike `optional`,
@@ -1686,8 +1785,8 @@ interface optionalKeyLambda extends Lambda {
  */
 export declare const optionalKey: optionalKeyLambda;
 interface requiredKeyLambda extends Lambda {
-    <S extends Top>(self: optionalKey<S>): S;
-    readonly "~lambda.out": this["~lambda.in"] extends optionalKey<Top> ? this["~lambda.in"]["schema"] : "Error: schema not eligible for requiredKey";
+    <S extends Constraint>(self: optionalKey<S>): S;
+    readonly "~lambda.out": this["~lambda.in"] extends optionalKey<Constraint> ? this["~lambda.in"]["schema"] : "Error: schema not eligible for requiredKey";
 }
 /**
  * Reverses `optionalKey` and returns the inner required schema.
@@ -1707,12 +1806,12 @@ export declare const requiredKey: requiredKeyLambda;
  * @category models
  * @since 3.10.0
  */
-export interface optional<S extends Top> extends optionalKey<UndefinedOr<S>> {
+export interface optional<S extends Constraint> extends optionalKey<UndefinedOr<S>> {
     readonly "Rebuild": optional<S>;
 }
 interface optionalLambda extends Lambda {
-    <S extends Top>(self: S): optional<S>;
-    readonly "~lambda.out": this["~lambda.in"] extends Top ? optional<this["~lambda.in"]> : never;
+    <S extends Constraint>(self: S): optional<S>;
+    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? optional<this["~lambda.in"]> : never;
 }
 /**
  * Marks a struct field as optional, allowing the key to be absent or
@@ -1745,8 +1844,8 @@ interface optionalLambda extends Lambda {
  */
 export declare const optional: optionalLambda;
 interface requiredLambda extends Lambda {
-    <S extends Top>(self: optional<S>): S;
-    readonly "~lambda.out": this["~lambda.in"] extends optional<Top> ? this["~lambda.in"]["schema"]["members"][0] : "Error: schema not eligible for required";
+    <S extends Constraint>(self: optional<S>): S;
+    readonly "~lambda.out": this["~lambda.in"] extends optional<Constraint> ? this["~lambda.in"]["schema"]["members"][0] : "Error: schema not eligible for required";
 }
 /**
  * Reverses `optional` and returns the inner schema.
@@ -1770,12 +1869,19 @@ export declare const required: requiredLambda;
  * @category models
  * @since 4.0.0
  */
-export interface mutableKey<S extends Top> extends Bottom<S["Type"], S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], mutableKey<S>, S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], "mutable", S["~type.optionality"], S["~type.constructor.default"], "mutable", S["~encoded.optionality"]> {
+export interface mutableKey<S extends Constraint> extends BottomLazy<S["ast"], mutableKey<S>, S["~type.parameters"], "mutable", S["~type.optionality"], S["~type.constructor.default"], "mutable", S["~encoded.optionality"]> {
+    readonly "Type": S["Type"];
+    readonly "Encoded": S["Encoded"];
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": S["~type.make.in"];
+    readonly "~type.make": S["~type.make"];
+    readonly "Iso": S["Iso"];
     readonly schema: S;
 }
 interface mutableKeyLambda extends Lambda {
-    <S extends Top>(self: S): mutableKey<S>;
-    readonly "~lambda.out": this["~lambda.in"] extends Top ? mutableKey<this["~lambda.in"]> : never;
+    <S extends Constraint>(self: S): mutableKey<S>;
+    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? mutableKey<this["~lambda.in"]> : never;
 }
 /**
  * Makes a struct field mutable (removes the `readonly` modifier on the property).
@@ -1786,8 +1892,8 @@ interface mutableKeyLambda extends Lambda {
  */
 export declare const mutableKey: mutableKeyLambda;
 interface readonlyKeyLambda extends Lambda {
-    <S extends Top>(self: mutableKey<S>): S;
-    readonly "~lambda.out": this["~lambda.in"] extends mutableKey<Top> ? this["~lambda.in"]["schema"] : "Error: schema not eligible for readonlyKey";
+    <S extends Constraint>(self: mutableKey<S>): S;
+    readonly "~lambda.out": this["~lambda.in"] extends mutableKey<Constraint> ? this["~lambda.in"]["schema"] : "Error: schema not eligible for readonlyKey";
 }
 /**
  * Reverses `mutableKey` and returns the inner readonly schema.
@@ -1807,11 +1913,18 @@ export declare const readonlyKey: readonlyKeyLambda;
  * @category transforming
  * @since 4.0.0
  */
-export interface toType<S extends Top> extends Bottom<S["Type"], S["Type"], never, never, S["ast"], toType<S>, S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+export interface toType<S extends Constraint> extends BottomLazy<S["ast"], toType<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+    readonly "Type": S["Type"];
+    readonly "Encoded": S["Type"];
+    readonly "DecodingServices": never;
+    readonly "EncodingServices": never;
+    readonly "~type.make.in": S["~type.make.in"];
+    readonly "~type.make": S["~type.make"];
+    readonly "Iso": S["Iso"];
 }
 interface toTypeLambda extends Lambda {
-    <S extends Top>(self: S): toType<S>;
-    readonly "~lambda.out": this["~lambda.in"] extends Top ? toType<this["~lambda.in"]> : never;
+    <S extends Constraint>(self: S): toType<S>;
+    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? toType<this["~lambda.in"]> : never;
 }
 /**
  * Extracts the type-side schema: sets `Encoded` to equal the decoded `Type`,
@@ -1827,11 +1940,18 @@ export declare const toType: toTypeLambda;
  * @category transforming
  * @since 4.0.0
  */
-export interface toEncoded<S extends Top> extends Bottom<S["Encoded"], S["Encoded"], never, never, SchemaAST.AST, toEncoded<S>, S["Encoded"], S["Encoded"], ReadonlyArray<Top>, S["Encoded"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+export interface toEncoded<S extends Constraint> extends BottomLazy<SchemaAST.AST, toEncoded<S>, ReadonlyArray<Constraint>, S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+    readonly "Type": S["Encoded"];
+    readonly "Encoded": S["Encoded"];
+    readonly "DecodingServices": never;
+    readonly "EncodingServices": never;
+    readonly "~type.make.in": S["Encoded"];
+    readonly "~type.make": S["Encoded"];
+    readonly "Iso": S["Encoded"];
 }
 interface toEncodedLambda extends Lambda {
-    <S extends Top>(self: S): toEncoded<S>;
-    readonly "~lambda.out": this["~lambda.in"] extends Top ? toEncoded<this["~lambda.in"]> : never;
+    <S extends Constraint>(self: S): toEncoded<S>;
+    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? toEncoded<this["~lambda.in"]> : never;
 }
 /**
  * Extracts the encoded-side schema: sets `Type` to equal the `Encoded`,
@@ -1848,7 +1968,14 @@ declare const FlipTypeId = "~effect/Schema/flip";
  * @category transforming
  * @since 4.0.0
  */
-export interface flip<S extends Top> extends Bottom<S["Encoded"], S["Type"], S["EncodingServices"], S["DecodingServices"], SchemaAST.AST, flip<S>, S["Encoded"], S["Encoded"], ReadonlyArray<Top>, S["Encoded"], S["~encoded.mutability"], S["~encoded.optionality"], ConstructorDefault, S["~type.mutability"], S["~type.optionality"]> {
+export interface flip<S extends Top> extends BottomLazy<SchemaAST.AST, flip<S>, ReadonlyArray<Constraint>, S["~encoded.mutability"], S["~encoded.optionality"], ConstructorDefault, S["~type.mutability"], S["~type.optionality"]> {
+    readonly "Type": S["Encoded"];
+    readonly "Encoded": S["Type"];
+    readonly "DecodingServices": S["EncodingServices"];
+    readonly "EncodingServices": S["DecodingServices"];
+    readonly "~type.make.in": S["Encoded"];
+    readonly "~type.make": S["Encoded"];
+    readonly "Iso": S["Encoded"];
     readonly [FlipTypeId]: typeof FlipTypeId;
     readonly schema: S;
 }
@@ -1923,7 +2050,7 @@ export declare namespace TemplateLiteral {
      * @category utility types
      * @since 4.0.0
      */
-    interface SchemaPart extends Top {
+    interface SchemaPart extends Constraint {
         readonly Encoded: string | number | bigint;
     }
     /**
@@ -1948,7 +2075,9 @@ export declare namespace TemplateLiteral {
      * @since 4.0.0
      */
     type Parts = ReadonlyArray<Part>;
-    type AppendType<Template extends string, Next> = Next extends LiteralPart ? `${Template}${Next}` : Next extends Codec<unknown, infer E extends LiteralPart, unknown, unknown> ? `${Template}${E}` : never;
+    type AppendType<Template extends string, Next> = Next extends LiteralPart ? `${Template}${Next}` : Next extends {
+        readonly Encoded: infer E extends LiteralPart;
+    } ? `${Template}${E}` : never;
     /**
      * Computes the encoded string literal type produced by concatenating the encoded
      * forms of all template literal parts.
@@ -2024,7 +2153,14 @@ export declare namespace TemplateLiteralParser {
  * @category models
  * @since 3.10.0
  */
-export interface TemplateLiteralParser<Parts extends TemplateLiteral.Parts> extends Bottom<TemplateLiteralParser.Type<Parts>, TemplateLiteral.Encoded<Parts>, never, never, SchemaAST.Arrays, TemplateLiteralParser<Parts>> {
+export interface TemplateLiteralParser<Parts extends TemplateLiteral.Parts> extends BottomLazy<SchemaAST.Arrays, TemplateLiteralParser<Parts>> {
+    readonly "Type": TemplateLiteralParser.Type<Parts>;
+    readonly "Encoded": TemplateLiteral.Encoded<Parts>;
+    readonly "DecodingServices": never;
+    readonly "EncodingServices": never;
+    readonly "~type.make.in": TemplateLiteralParser.Type<Parts>;
+    readonly "~type.make": TemplateLiteralParser.Type<Parts>;
+    readonly "Iso": TemplateLiteralParser.Type<Parts>;
     readonly parts: Parts;
 }
 /**
@@ -2351,7 +2487,7 @@ export declare namespace Struct {
      * @since 3.10.0
      */
     type Fields = {
-        readonly [x: PropertyKey]: Top;
+        readonly [x: PropertyKey]: Constraint;
     };
     type TypeOptionalKeys<Fields extends Struct.Fields> = {
         [K in keyof Fields]: Fields[K] extends {
@@ -2363,15 +2499,28 @@ export declare namespace Struct {
             readonly "~type.mutability": "mutable";
         } ? K : never;
     }[keyof Fields];
-    type Type_<F extends Fields, O extends keyof F = TypeOptionalKeys<F>, M extends keyof F = TypeMutableKeys<F>> = {
-        readonly [K in keyof F as K extends M | O ? never : K]: F[K]["Type"];
-    } & {
-        readonly [K in keyof F as K extends O ? K extends M ? never : K : never]?: F[K]["Type"];
-    } & {
-        -readonly [K in keyof F as K extends M ? K extends O ? never : K : never]: F[K]["Type"];
-    } & {
-        -readonly [K in keyof F as K extends M & O ? K : never]?: F[K]["Type"];
+    type SetOptional<A, K extends keyof A> = Omit<A, K> & Partial<Pick<A, K>>;
+    type Mutable<A> = {
+        -readonly [K in keyof A]: A[K];
+    };
+    type SetMutable<A, K extends keyof A> = Omit<A, K> & Mutable<Pick<A, K>>;
+    type Side = "Type" | "Iso" | "Encoded";
+    type EncodedOptionalKeys<Fields extends Struct.Fields> = {
+        [K in keyof Fields]: Fields[K] extends {
+            readonly "~encoded.optionality": "optional";
+        } ? K : never;
+    }[keyof Fields];
+    type EncodedMutableKeys<Fields extends Struct.Fields> = {
+        [K in keyof Fields]: Fields[K] extends {
+            readonly "~encoded.mutability": "mutable";
+        } ? K : never;
+    }[keyof Fields];
+    type SideOptionalKeys<F extends Fields, S extends Side> = S extends "Encoded" ? EncodedOptionalKeys<F> : TypeOptionalKeys<F>;
+    type SideMutableKeys<F extends Fields, S extends Side> = S extends "Encoded" ? EncodedMutableKeys<F> : TypeMutableKeys<F>;
+    type ReadonlySide<F extends Fields, S extends Side> = {
+        readonly [K in keyof F]: F[K][S];
     };
+    type View<F extends Fields, S extends Side, O extends keyof F = SideOptionalKeys<F, S>, M extends keyof F = SideMutableKeys<F, S>> = [O | M] extends [never] ? ReadonlySide<F, S> : [M] extends [never] ? Simplify<SetOptional<ReadonlySide<F, S>, O>> : [O] extends [never] ? Simplify<SetMutable<ReadonlySide<F, S>, M>> : Simplify<SetMutable<SetOptional<ReadonlySide<F, S>, O>, Extract<keyof SetOptional<ReadonlySide<F, S>, O>, M>>>;
     /**
      * Computes the decoded object type for a struct field map.
      *
@@ -2383,16 +2532,7 @@ export declare namespace Struct {
      * @category utility types
      * @since 3.10.0
      */
-    type Type<F extends Fields> = Simplify<Type_<F>>;
-    type Iso_<F extends Fields, O extends keyof F = TypeOptionalKeys<F>, M extends keyof F = TypeMutableKeys<F>> = {
-        readonly [K in keyof F as K extends M | O ? never : K]: F[K]["Iso"];
-    } & {
-        readonly [K in keyof F as K extends O ? K extends M ? never : K : never]?: F[K]["Iso"];
-    } & {
-        -readonly [K in keyof F as K extends M ? K extends O ? never : K : never]: F[K]["Iso"];
-    } & {
-        -readonly [K in keyof F as K extends M & O ? K : never]?: F[K]["Iso"];
-    };
+    type Type<F extends Fields> = View<F, "Type">;
     /**
      * Computes the iso object type for a struct field map from each field schema's
      * `Iso` type.
@@ -2405,26 +2545,7 @@ export declare namespace Struct {
      * @category utility types
      * @since 4.0.0
      */
-    type Iso<F extends Fields> = Simplify<Iso_<F>>;
-    type EncodedOptionalKeys<Fields extends Struct.Fields> = {
-        [K in keyof Fields]: Fields[K] extends {
-            readonly "~encoded.optionality": "optional";
-        } ? K : never;
-    }[keyof Fields];
-    type EncodedMutableKeys<Fields extends Struct.Fields> = {
-        [K in keyof Fields]: Fields[K] extends {
-            readonly "~encoded.mutability": "mutable";
-        } ? K : never;
-    }[keyof Fields];
-    type Encoded_<F extends Fields, O extends keyof F = EncodedOptionalKeys<F>, M extends keyof F = EncodedMutableKeys<F>> = {
-        readonly [K in keyof F as K extends M | O ? never : K]: F[K]["Encoded"];
-    } & {
-        readonly [K in keyof F as K extends O ? K extends M ? never : K : never]?: F[K]["Encoded"];
-    } & {
-        -readonly [K in keyof F as K extends M ? K extends O ? never : K : never]: F[K]["Encoded"];
-    } & {
-        -readonly [K in keyof F as K extends M & O ? K : never]?: F[K]["Encoded"];
-    };
+    type Iso<F extends Fields> = View<F, "Iso">;
     /**
      * Computes the encoded object type for a struct field map.
      *
@@ -2437,7 +2558,7 @@ export declare namespace Struct {
      * @category utility types
      * @since 3.10.0
      */
-    type Encoded<F extends Fields> = Simplify<Encoded_<F>>;
+    type Encoded<F extends Fields> = View<F, "Encoded">;
     /**
      * Union of all decoding service requirements needed by the schemas in a struct
      * field map.
@@ -2463,11 +2584,10 @@ export declare namespace Struct {
             readonly "~type.constructor.default": "with-default";
         } ? K : never;
     }[keyof Fields];
-    type MakeIn_<F extends Fields, O = TypeOptionalKeys<F> | TypeConstructorDefaultedKeys<F>> = {
-        readonly [K in keyof F as K extends O ? never : K]: F[K]["~type.make"];
-    } & {
-        readonly [K in keyof F as K extends O ? K : never]?: F[K]["~type.make"];
+    type ReadonlyMakeIn<F extends Fields> = {
+        readonly [K in keyof F]: F[K]["~type.make"];
     };
+    type MakeInView<F extends Fields, O extends keyof F = TypeOptionalKeys<F> | TypeConstructorDefaultedKeys<F>> = [O] extends [never] ? ReadonlyMakeIn<F> : Simplify<SetOptional<ReadonlyMakeIn<F>, O>>;
     /**
      * Computes the input object type accepted when constructing a struct value.
      *
@@ -2479,7 +2599,7 @@ export declare namespace Struct {
      * @category utility types
      * @since 4.0.0
      */
-    type MakeIn<F extends Fields> = Simplify<MakeIn_<F>>;
+    type MakeIn<F extends Fields> = MakeInView<F>;
 }
 /**
  * Type-level representation returned by {@link Struct}.
@@ -2487,7 +2607,14 @@ export declare namespace Struct {
  * @category models
  * @since 3.10.0
  */
-export interface Struct<Fields extends Struct.Fields> extends Bottom<Struct.Type<Fields>, Struct.Encoded<Fields>, Struct.DecodingServices<Fields>, Struct.EncodingServices<Fields>, SchemaAST.Objects, Struct<Fields>, Struct.MakeIn<Fields>, Struct.Iso<Fields>> {
+export interface Struct<Fields extends Struct.Fields> extends BottomLazy<SchemaAST.Objects, Struct<Fields>> {
+    readonly "Type": Struct.Type<Fields>;
+    readonly "Encoded": Struct.Encoded<Fields>;
+    readonly "DecodingServices": Struct.DecodingServices<Fields>;
+    readonly "EncodingServices": Struct.EncodingServices<Fields>;
+    readonly "~type.make.in": Struct.MakeIn<Fields>;
+    readonly "~type.make": Struct.MakeIn<Fields>;
+    readonly "Iso": Struct.Iso<Fields>;
     /**
      * The field definitions of this struct. Spread them into a new struct to
      * reuse fields across schemas.
@@ -2602,7 +2729,7 @@ export declare function fieldsAssign<const NewFields extends Struct.Fields>(fiel
  * @category transforming
  * @since 4.0.0
  */
-export interface encodeKeys<S extends Top & {
+export interface encodeKeys<S extends Constraint & {
     readonly fields: Struct.Fields;
 }, M extends {
     readonly [K in keyof S["fields"]]?: PropertyKey;
@@ -2638,7 +2765,7 @@ export interface encodeKeys<S extends Top & {
  * @category transforming
  * @since 4.0.0
  */
-export declare function encodeKeys<S extends Top & {
+export declare function encodeKeys<S extends Constraint & {
     readonly fields: Struct.Fields;
 }, const M extends {
     readonly [K in keyof S["fields"]]?: PropertyKey;
@@ -2721,7 +2848,7 @@ export declare namespace Record {
      * @category utility types
      * @since 3.10.0
      */
-    type Type<Key extends Record.Key, Value extends Top> = Value extends {
+    type Type<Key extends Record.Key, Value extends Constraint> = Value extends {
         readonly "~type.optionality": "optional";
     } ? Value extends {
         readonly "~type.mutability": "mutable";
@@ -2743,7 +2870,7 @@ export declare namespace Record {
      * @category utility types
      * @since 4.0.0
      */
-    type Iso<Key extends Record.Key, Value extends Top> = Value extends {
+    type Iso<Key extends Record.Key, Value extends Constraint> = Value extends {
         readonly "~type.optionality": "optional";
     } ? Value extends {
         readonly "~type.mutability": "mutable";
@@ -2770,7 +2897,7 @@ export declare namespace Record {
      * @category utility types
      * @since 3.10.0
      */
-    type Encoded<Key extends Record.Key, Value extends Top> = Value extends {
+    type Encoded<Key extends Record.Key, Value extends Constraint> = Value extends {
         readonly "~encoded.optionality": "optional";
     } ? Value extends {
         readonly "~encoded.mutability": "mutable";
@@ -2792,7 +2919,7 @@ export declare namespace Record {
      * @category utility types
      * @since 4.0.0
      */
-    type DecodingServices<Key extends Record.Key, Value extends Top> = Key["DecodingServices"] | Value["DecodingServices"];
+    type DecodingServices<Key extends Record.Key, Value extends Constraint> = Key["DecodingServices"] | Value["DecodingServices"];
     /**
      * Union of the encoding service requirements of a record's key schema and value
      * schema.
@@ -2800,7 +2927,7 @@ export declare namespace Record {
      * @category utility types
      * @since 4.0.0
      */
-    type EncodingServices<Key extends Record.Key, Value extends Top> = Key["EncodingServices"] | Value["EncodingServices"];
+    type EncodingServices<Key extends Record.Key, Value extends Constraint> = Key["EncodingServices"] | Value["EncodingServices"];
     /**
      * Computes the input object type accepted when constructing a record value.
      *
@@ -2813,7 +2940,7 @@ export declare namespace Record {
      * @category utility types
      * @since 4.0.0
      */
-    type MakeIn<Key extends Record.Key, Value extends Top> = Value extends {
+    type MakeIn<Key extends Record.Key, Value extends Constraint> = Value extends {
         readonly "~encoded.optionality": "optional";
     } ? Value extends {
         readonly "~encoded.mutability": "mutable";
@@ -2835,7 +2962,14 @@ export declare namespace Record {
  * @category models
  * @since 4.0.0
  */
-export interface $Record<Key extends Record.Key, Value extends Top> extends Bottom<Record.Type<Key, Value>, Record.Encoded<Key, Value>, Record.DecodingServices<Key, Value>, Record.EncodingServices<Key, Value>, SchemaAST.Objects, $Record<Key, Value>, Simplify<Record.MakeIn<Key, Value>>, Record.Iso<Key, Value>> {
+export interface $Record<Key extends Record.Key, Value extends Constraint> extends BottomLazy<SchemaAST.Objects, $Record<Key, Value>> {
+    readonly "Type": Record.Type<Key, Value>;
+    readonly "Encoded": Record.Encoded<Key, Value>;
+    readonly "DecodingServices": Record.DecodingServices<Key, Value>;
+    readonly "EncodingServices": Record.EncodingServices<Key, Value>;
+    readonly "~type.make.in": Simplify<Record.MakeIn<Key, Value>>;
+    readonly "~type.make": Simplify<Record.MakeIn<Key, Value>>;
+    readonly "Iso": Record.Iso<Key, Value>;
     readonly key: Key;
     readonly value: Value;
 }
@@ -2871,7 +3005,7 @@ export interface $Record<Key extends Record.Key, Value extends Top> extends Bott
  * @category constructors
  * @since 3.10.0
  */
-export declare function Record<Key extends Record.Key, Value extends Top>(key: Key, value: Value, options?: {
+export declare function Record<Key extends Record.Key, Value extends Constraint>(key: Key, value: Value, options?: {
     readonly keyValueCombiner: {
         readonly decode?: Combiner.Combiner<readonly [Key["Type"], Value["Type"]]> | undefined;
         readonly encode?: Combiner.Combiner<readonly [Key["Encoded"], Value["Encoded"]]> | undefined;
@@ -2895,7 +3029,7 @@ export declare namespace StructWithRest {
      * @category utility types
      * @since 4.0.0
      */
-    type Objects = Top & {
+    type Objects = Constraint & {
         readonly ast: SchemaAST.Objects;
     };
     /**
@@ -2905,7 +3039,7 @@ export declare namespace StructWithRest {
      * @category utility types
      * @since 3.10.0
      */
-    type Records = ReadonlyArray<$Record<Record.Key, Top>>;
+    type Records = ReadonlyArray<$Record<Record.Key, Constraint>>;
     type MergeTuple<T extends ReadonlyArray<unknown>> = T extends readonly [infer Head, ...infer Tail] ? Head & MergeTuple<Tail> : {};
     type Intersect<S extends Objects, Records extends StructWithRest.Records, Side extends "Type" | "Iso" | "Encoded" | "~type.make"> = S[Side] & MergeTuple<{
         readonly [K in keyof Records]: Records[K][Side];
@@ -2968,16 +3102,43 @@ export declare namespace StructWithRest {
     type IncompatibleSideKeys<S extends Objects, Records extends StructWithRest.Records, Side extends "Type" | "Encoded" | "Iso" | "~type.make"> = {
         [I in keyof Records]: Records[I][Side] extends object ? IncompatibleKeys<S[Side], Records[I][Side]> : never;
     }[number];
+    type IncompatibleRecords<S extends Objects, Records extends StructWithRest.Records> = IncompatibleSideKeys<S, Records, "Type"> | IncompatibleSideKeys<S, Records, "Encoded"> | IncompatibleSideKeys<S, Records, "Iso"> | IncompatibleSideKeys<S, Records, "~type.make">;
     /**
-     * Validates that the records are compatible with the struct.
+     * Checks whether fixed fields are compatible with the rest record schemas.
+     *
+     * **Details**
+     *
+     * Returns `true` when all fixed fields can also satisfy the matching rest
+     * index signatures. Returns a diagnostic object when TypeScript would make
+     * the resulting intersection too narrow for one or more fixed keys.
+     *
+     * **Example** (Checking record compatibility)
+     *
+     * ```ts
+     * import { Schema } from "effect"
+     *
+     * const user = Schema.Struct({ id: Schema.String })
+     * const stringExtras = [Schema.Record(Schema.String, Schema.String)] as const
+     *
+     * type UserCheck = Schema.StructWithRest.ValidateRecords<typeof user, typeof stringExtras>
+     *
+     * const userCheck: UserCheck = true
+     * void userCheck
+     *
+     * const counter = Schema.Struct({ count: Schema.NumberFromString })
+     *
+     * type CounterCheck = Schema.StructWithRest.ValidateRecords<typeof counter, typeof stringExtras>
+     * //    ^? { "incompatible index signatures": "count" }
+     *
+     * const counterCheck = null as unknown as CounterCheck
+     * void counterCheck
+     * ```
      *
      * @category utility types
      * @since 4.0.0
      */
-    type ValidateRecords<S extends Objects, Records extends StructWithRest.Records> = [
-        IncompatibleSideKeys<S, Records, "Type"> | IncompatibleSideKeys<S, Records, "Encoded"> | IncompatibleSideKeys<S, Records, "Iso"> | IncompatibleSideKeys<S, Records, "~type.make">
-    ] extends [never] ? unknown : {
-        "incompatible index signatures": IncompatibleSideKeys<S, Records, "Type"> | IncompatibleSideKeys<S, Records, "Encoded"> | IncompatibleSideKeys<S, Records, "Iso"> | IncompatibleSideKeys<S, Records, "~type.make">;
+    type ValidateRecords<S extends Objects, Records extends StructWithRest.Records> = [IncompatibleRecords<S, Records>] extends [never] ? true : {
+        "incompatible index signatures": IncompatibleRecords<S, Records>;
     };
 }
 /**
@@ -2986,7 +3147,14 @@ export declare namespace StructWithRest {
  * @category models
  * @since 4.0.0
  */
-export interface StructWithRest<S extends StructWithRest.Objects, Records extends StructWithRest.Records> extends Bottom<Simplify<StructWithRest.Type<S, Records>>, Simplify<StructWithRest.Encoded<S, Records>>, StructWithRest.DecodingServices<S, Records>, StructWithRest.EncodingServices<S, Records>, SchemaAST.Objects, StructWithRest<S, Records>, Simplify<StructWithRest.MakeIn<S, Records>>, Simplify<StructWithRest.Iso<S, Records>>> {
+export interface StructWithRest<S extends StructWithRest.Objects, Records extends StructWithRest.Records> extends BottomLazy<SchemaAST.Objects, StructWithRest<S, Records>> {
+    readonly "Type": Simplify<StructWithRest.Type<S, Records>>;
+    readonly "Encoded": Simplify<StructWithRest.Encoded<S, Records>>;
+    readonly "DecodingServices": StructWithRest.DecodingServices<S, Records>;
+    readonly "EncodingServices": StructWithRest.EncodingServices<S, Records>;
+    readonly "~type.make.in": Simplify<StructWithRest.MakeIn<S, Records>>;
+    readonly "~type.make": Simplify<StructWithRest.MakeIn<S, Records>>;
+    readonly "Iso": Simplify<StructWithRest.Iso<S, Records>>;
     readonly schema: S;
     readonly records: Records;
 }
@@ -2994,6 +3162,13 @@ export interface StructWithRest<S extends StructWithRest.Objects, Records extend
  * Extends a struct schema with one or more record (index-signature) schemas,
  * producing a schema whose decoded type intersects the struct and all records.
  *
+ * **Gotchas**
+ *
+ * TypeScript index signatures also apply to fixed keys. `StructWithRest` does
+ * not reject incompatible fixed fields at the call site; use
+ * `StructWithRest.ValidateRecords` when you want an explicit type-level
+ * compatibility check.
+ *
  * **Example** (Defining structs with string-indexed extra keys)
  *
  * ```ts
@@ -3011,7 +3186,7 @@ export interface StructWithRest<S extends StructWithRest.Objects, Records extend
  * @category constructors
  * @since 4.0.0
  */
-export declare function StructWithRest<const S extends StructWithRest.Objects, const Records extends StructWithRest.Records>(schema: S, records: Records & StructWithRest.ValidateRecords<S, Records>): StructWithRest<S, Records>;
+export declare function StructWithRest<const S extends StructWithRest.Objects, const Records extends StructWithRest.Records>(schema: S, records: Records): StructWithRest<S, Records>;
 /**
  * Namespace for `Tuple` type utilities.
  *
@@ -3032,7 +3207,7 @@ export declare namespace Tuple {
      * @category utility types
      * @since 3.10.0
      */
-    type Elements = ReadonlyArray<Top>;
+    type Elements = ReadonlyArray<Constraint>;
     type Type_<Elements, Out extends ReadonlyArray<any> = readonly []> = Elements extends readonly [infer Head, ...infer Tail] ? Head extends {
         readonly "Type": infer T;
     } ? Head extends {
@@ -3122,7 +3297,14 @@ export declare namespace Tuple {
  * @category models
  * @since 3.10.0
  */
-export interface Tuple<Elements extends Tuple.Elements> extends Bottom<Tuple.Type<Elements>, Tuple.Encoded<Elements>, Tuple.DecodingServices<Elements>, Tuple.EncodingServices<Elements>, SchemaAST.Arrays, Tuple<Elements>, Tuple.MakeIn<Elements>, Tuple.Iso<Elements>> {
+export interface Tuple<Elements extends Tuple.Elements> extends BottomLazy<SchemaAST.Arrays, Tuple<Elements>> {
+    readonly "Type": Tuple.Type<Elements>;
+    readonly "Encoded": Tuple.Encoded<Elements>;
+    readonly "DecodingServices": Tuple.DecodingServices<Elements>;
+    readonly "EncodingServices": Tuple.EncodingServices<Elements>;
+    readonly "~type.make.in": Tuple.MakeIn<Elements>;
+    readonly "~type.make": Tuple.MakeIn<Elements>;
+    readonly "Iso": Tuple.Iso<Elements>;
     readonly elements: Elements;
     /**
      * Returns a new tuple with the elements modified by the provided function.
@@ -3162,7 +3344,7 @@ export interface Tuple<Elements extends Tuple.Elements> extends Bottom<Tuple.Typ
  * @category constructors
  * @since 3.10.0
  */
-export declare function Tuple<const Elements extends ReadonlyArray<Top>>(elements: Elements): Tuple<Elements>;
+export declare function Tuple<const Elements extends ReadonlyArray<Constraint>>(elements: Elements): Tuple<Elements>;
 /**
  * Namespace for `TupleWithRest` type utilities.
  *
@@ -3183,7 +3365,7 @@ export declare namespace TupleWithRest {
      * @category utility types
      * @since 3.10.0
      */
-    type TupleType = Top & {
+    type TupleType = Constraint & {
         readonly Type: ReadonlyArray<unknown>;
         readonly Encoded: ReadonlyArray<unknown>;
         readonly ast: SchemaAST.Arrays;
@@ -3201,7 +3383,7 @@ export declare namespace TupleWithRest {
      * @category utility types
      * @since 3.10.0
      */
-    type Rest = readonly [Top, ...Array<Top>];
+    type Rest = readonly [Constraint, ...Array<Constraint>];
     /**
      * Computes the decoded tuple type for a `TupleWithRest`.
      *
@@ -3214,7 +3396,7 @@ export declare namespace TupleWithRest {
      * @category utility types
      * @since 3.10.0
      */
-    type Type<T extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Top, ...infer Tail extends ReadonlyArray<Top>] ? Readonly<[
+    type Type<T extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Constraint, ...infer Tail extends ReadonlyArray<Constraint>] ? Readonly<[
         ...T,
         ...Array<Head["Type"]>,
         ...{
@@ -3233,7 +3415,7 @@ export declare namespace TupleWithRest {
      * @category utility types
      * @since 4.0.0
      */
-    type Iso<T extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Top, ...infer Tail extends ReadonlyArray<Top>] ? Readonly<[
+    type Iso<T extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Constraint, ...infer Tail extends ReadonlyArray<Constraint>] ? Readonly<[
         ...T,
         ...Array<Head["Iso"]>,
         ...{
@@ -3252,7 +3434,7 @@ export declare namespace TupleWithRest {
      * @category utility types
      * @since 3.10.0
      */
-    type Encoded<E extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Top, ...infer Tail extends ReadonlyArray<Top>] ? readonly [
+    type Encoded<E extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Constraint, ...infer Tail extends ReadonlyArray<Constraint>] ? readonly [
         ...E,
         ...Array<Head["Encoded"]>,
         ...{
@@ -3271,7 +3453,7 @@ export declare namespace TupleWithRest {
      * @category utility types
      * @since 4.0.0
      */
-    type MakeIn<M extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Top, ...infer Tail extends ReadonlyArray<Top>] ? readonly [
+    type MakeIn<M extends ReadonlyArray<unknown>, Rest extends TupleWithRest.Rest> = Rest extends readonly [infer Head extends Constraint, ...infer Tail extends ReadonlyArray<Constraint>] ? readonly [
         ...M,
         ...Array<Head["~type.make"]>,
         ...{
@@ -3285,7 +3467,14 @@ export declare namespace TupleWithRest {
  * @category models
  * @since 4.0.0
  */
-export interface TupleWithRest<S extends TupleWithRest.TupleType, Rest extends TupleWithRest.Rest> extends Bottom<TupleWithRest.Type<S["Type"], Rest>, TupleWithRest.Encoded<S["Encoded"], Rest>, S["DecodingServices"] | Rest[number]["DecodingServices"], S["EncodingServices"] | Rest[number]["EncodingServices"], SchemaAST.Arrays, TupleWithRest<S, Rest>, TupleWithRest.MakeIn<S["~type.make"], Rest>, TupleWithRest.Iso<S["Iso"], Rest>> {
+export interface TupleWithRest<S extends TupleWithRest.TupleType, Rest extends TupleWithRest.Rest> extends BottomLazy<SchemaAST.Arrays, TupleWithRest<S, Rest>> {
+    readonly "Type": TupleWithRest.Type<S["Type"], Rest>;
+    readonly "Encoded": TupleWithRest.Encoded<S["Encoded"], Rest>;
+    readonly "DecodingServices": S["DecodingServices"] | Rest[number]["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"] | Rest[number]["EncodingServices"];
+    readonly "~type.make.in": TupleWithRest.MakeIn<S["~type.make"], Rest>;
+    readonly "~type.make": TupleWithRest.MakeIn<S["~type.make"], Rest>;
+    readonly "Iso": TupleWithRest.Iso<S["Iso"], Rest>;
     readonly schema: S;
     readonly rest: Rest;
 }
@@ -3326,12 +3515,19 @@ export declare function TupleWithRest<S extends Tuple<Tuple.Elements>, const Res
  * @category models
  * @since 4.0.0
  */
-export interface $Array<S extends Top> extends Bottom<ReadonlyArray<S["Type"]>, ReadonlyArray<S["Encoded"]>, S["DecodingServices"], S["EncodingServices"], SchemaAST.Arrays, $Array<S>, ReadonlyArray<S["~type.make"]>, ReadonlyArray<S["Iso"]>> {
+export interface $Array<S extends Constraint> extends BottomLazy<SchemaAST.Arrays, $Array<S>> {
+    readonly "Type": ReadonlyArray<S["Type"]>;
+    readonly "Encoded": ReadonlyArray<S["Encoded"]>;
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": ReadonlyArray<S["~type.make"]>;
+    readonly "~type.make": ReadonlyArray<S["~type.make"]>;
+    readonly "Iso": ReadonlyArray<S["Iso"]>;
     readonly value: S;
 }
 interface ArrayLambda extends Lambda {
-    <S extends Top>(self: S): $Array<S>;
-    readonly "~lambda.out": this["~lambda.in"] extends Top ? $Array<this["~lambda.in"]> : never;
+    <S extends Constraint>(self: S): $Array<S>;
+    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? $Array<this["~lambda.in"]> : never;
 }
 /**
  * @category constructors
@@ -3364,12 +3560,19 @@ ArraySchema as Array };
  * @category models
  * @since 3.10.0
  */
-export interface NonEmptyArray<S extends Top> extends Bottom<readonly [S["Type"], ...Array<S["Type"]>], readonly [S["Encoded"], ...Array<S["Encoded"]>], S["DecodingServices"], S["EncodingServices"], SchemaAST.Arrays, NonEmptyArray<S>, readonly [S["~type.make"], ...Array<S["~type.make"]>], readonly [S["Iso"], ...Array<S["Iso"]>]> {
+export interface NonEmptyArray<S extends Constraint> extends BottomLazy<SchemaAST.Arrays, NonEmptyArray<S>> {
+    readonly "Type": readonly [S["Type"], ...Array<S["Type"]>];
+    readonly "Encoded": readonly [S["Encoded"], ...Array<S["Encoded"]>];
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": readonly [S["~type.make"], ...Array<S["~type.make"]>];
+    readonly "~type.make": readonly [S["~type.make"], ...Array<S["~type.make"]>];
+    readonly "Iso": readonly [S["Iso"], ...Array<S["Iso"]>];
     readonly value: S;
 }
 interface NonEmptyArrayLambda extends Lambda {
-    <S extends Top>(self: S): NonEmptyArray<S>;
-    readonly "~lambda.out": this["~lambda.in"] extends Top ? NonEmptyArray<this["~lambda.in"]> : never;
+    <S extends Constraint>(self: S): NonEmptyArray<S>;
+    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? NonEmptyArray<this["~lambda.in"]> : never;
 }
 /**
  * Defines a non-empty `ReadonlyArray` schema — at least one element required.
@@ -3396,7 +3599,7 @@ export declare const NonEmptyArray: NonEmptyArrayLambda;
  * @category constructors
  * @since 3.10.0
  */
-export interface ArrayEnsure<S extends Top> extends decodeTo<$Array<toType<S>>, Union<readonly [S, $Array<S>]>> {
+export interface ArrayEnsure<S extends Constraint> extends decodeTo<$Array<toType<S>>, Union<readonly [S, $Array<S>]>> {
     readonly "Rebuild": ArrayEnsure<S>;
 }
 /**
@@ -3425,14 +3628,14 @@ export interface ArrayEnsure<S extends Top> extends decodeTo<$Array<toType<S>>,
  * @category constructors
  * @since 3.10.0
  */
-export declare function ArrayEnsure<S extends Top>(schema: S): ArrayEnsure<S>;
+export declare function ArrayEnsure<S extends Constraint>(schema: S): ArrayEnsure<S>;
 /**
  * Type-level representation returned by {@link UniqueArray}.
  *
  * @category models
  * @since 4.0.0
  */
-export interface UniqueArray<S extends Top> extends $Array<S> {
+export interface UniqueArray<S extends Constraint> extends $Array<S> {
     readonly "Rebuild": UniqueArray<S>;
 }
 /**
@@ -3446,23 +3649,30 @@ export interface UniqueArray<S extends Top> extends $Array<S> {
  * @category constructors
  * @since 4.0.0
  */
-export declare function UniqueArray<S extends Top>(item: S): UniqueArray<S>;
+export declare function UniqueArray<S extends Constraint>(item: S): UniqueArray<S>;
 /**
  * Type-level representation returned by {@link mutable}.
  *
  * @category transforming
  * @since 3.10.0
  */
-export interface mutable<S extends Top & {
+export interface mutable<S extends Constraint & {
     readonly "ast": SchemaAST.Arrays;
-}> extends Bottom<Mutable<S["Type"]>, Mutable<S["Encoded"]>, S["DecodingServices"], S["EncodingServices"], S["ast"], mutable<S>, S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+}> extends BottomLazy<S["ast"], mutable<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+    readonly "Type": Mutable<S["Type"]>;
+    readonly "Encoded": Mutable<S["Encoded"]>;
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": S["~type.make.in"];
+    readonly "~type.make": S["~type.make"];
+    readonly "Iso": S["Iso"];
     readonly schema: S;
 }
 interface mutableLambda extends Lambda {
-    <S extends Top & {
+    <S extends Constraint & {
         readonly "ast": SchemaAST.Arrays;
     }>(self: S): mutable<S>;
-    readonly "~lambda.out": this["~lambda.in"] extends Top & {
+    readonly "~lambda.out": this["~lambda.in"] extends Constraint & {
         readonly "ast": SchemaAST.Arrays;
     } ? mutable<this["~lambda.in"]> : "Error: schema not eligible for mutable";
 }
@@ -3490,21 +3700,30 @@ export declare const mutable: mutableLambda;
  * @category models
  * @since 3.10.0
  */
-export interface Union<Members extends ReadonlyArray<Top>> extends Bottom<{
-    [K in keyof Members]: Members[K]["Type"];
-}[number], {
-    [K in keyof Members]: Members[K]["Encoded"];
-}[number], {
-    [K in keyof Members]: Members[K]["DecodingServices"];
-}[number], {
-    [K in keyof Members]: Members[K]["EncodingServices"];
-}[number], SchemaAST.Union<{
+export interface Union<Members extends ReadonlyArray<Constraint>> extends BottomLazy<SchemaAST.Union<{
     [K in keyof Members]: Members[K]["ast"];
-}[number]>, Union<Members>, {
-    [K in keyof Members]: Members[K]["~type.make"];
-}[number], {
-    [K in keyof Members]: Members[K]["Iso"];
-}[number]> {
+}[number]>, Union<Members>> {
+    readonly "Type": {
+        [K in keyof Members]: Members[K]["Type"];
+    }[number];
+    readonly "Encoded": {
+        [K in keyof Members]: Members[K]["Encoded"];
+    }[number];
+    readonly "DecodingServices": {
+        [K in keyof Members]: Members[K]["DecodingServices"];
+    }[number];
+    readonly "EncodingServices": {
+        [K in keyof Members]: Members[K]["EncodingServices"];
+    }[number];
+    readonly "~type.make.in": {
+        [K in keyof Members]: Members[K]["~type.make"];
+    }[number];
+    readonly "~type.make": {
+        [K in keyof Members]: Members[K]["~type.make"];
+    }[number];
+    readonly "Iso": {
+        [K in keyof Members]: Members[K]["Iso"];
+    }[number];
     readonly members: Members;
     /**
      * Returns a new union with the members modified by the provided function.
@@ -3522,7 +3741,7 @@ export interface Union<Members extends ReadonlyArray<Top>> extends Bottom<{
      *   use this option if you have verified that your refinements remain correct
      *   after the transformation.
      */
-    mapMembers<To extends ReadonlyArray<Top>>(f: (members: Members) => To, options?: {
+    mapMembers<To extends ReadonlyArray<Constraint>>(f: (members: Members) => To, options?: {
         readonly unsafePreserveChecks?: boolean | undefined;
     } | undefined): Union<Simplify<Readonly<To>>>;
 }
@@ -3550,7 +3769,7 @@ export interface Union<Members extends ReadonlyArray<Top>> extends Bottom<{
  * @category constructors
  * @since 3.10.0
  */
-export declare function Union<const Members extends ReadonlyArray<Top>>(members: Members, options?: {
+export declare function Union<const Members extends ReadonlyArray<Constraint>>(members: Members, options?: {
     mode?: "anyOf" | "oneOf";
 }): Union<Members>;
 /**
@@ -3567,7 +3786,7 @@ export interface Literals<L extends ReadonlyArray<SchemaAST.LiteralValue>> exten
     /**
      * Map over the members of the union.
      */
-    mapMembers<To extends ReadonlyArray<Top>>(f: (members: this["members"]) => To): Union<Simplify<Readonly<To>>>;
+    mapMembers<To extends ReadonlyArray<Constraint>>(f: (members: this["members"]) => To): Union<Simplify<Readonly<To>>>;
     pick<const L2 extends ReadonlyArray<L[number]>>(literals: L2): Literals<L2>;
     transform<const L2 extends {
         readonly [I in keyof L]: SchemaAST.LiteralValue;
@@ -3598,12 +3817,12 @@ export declare function Literals<const L extends ReadonlyArray<SchemaAST.Literal
  * @category models
  * @since 3.10.0
  */
-export interface NullOr<S extends Top> extends Union<readonly [S, Null]> {
+export interface NullOr<S extends Constraint> extends Union<readonly [S, Null]> {
     readonly "Rebuild": NullOr<S>;
 }
 interface NullOrLambda extends Lambda {
-    <S extends Top>(self: S): NullOr<S>;
-    readonly "~lambda.out": this["~lambda.in"] extends Top ? NullOr<this["~lambda.in"]> : never;
+    <S extends Constraint>(self: S): NullOr<S>;
+    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? NullOr<this["~lambda.in"]> : never;
 }
 /**
  * Creates a union schema of `S | null`.
@@ -3618,12 +3837,12 @@ export declare const NullOr: NullOrLambda;
  * @category models
  * @since 3.10.0
  */
-export interface UndefinedOr<S extends Top> extends Union<readonly [S, Undefined]> {
+export interface UndefinedOr<S extends Constraint> extends Union<readonly [S, Undefined]> {
     readonly "Rebuild": UndefinedOr<S>;
 }
 interface UndefinedOrLambda extends Lambda {
-    <S extends Top>(self: S): UndefinedOr<S>;
-    readonly "~lambda.out": this["~lambda.in"] extends Top ? UndefinedOr<this["~lambda.in"]> : never;
+    <S extends Constraint>(self: S): UndefinedOr<S>;
+    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? UndefinedOr<this["~lambda.in"]> : never;
 }
 /**
  * Creates a union schema of `S | undefined`.
@@ -3638,12 +3857,12 @@ export declare const UndefinedOr: UndefinedOrLambda;
  * @category models
  * @since 3.10.0
  */
-export interface NullishOr<S extends Top> extends Union<readonly [S, Null, Undefined]> {
+export interface NullishOr<S extends Constraint> extends Union<readonly [S, Null, Undefined]> {
     readonly "Rebuild": NullishOr<S>;
 }
 interface NullishOrLambda extends Lambda {
-    <S extends Top>(self: S): NullishOr<S>;
-    readonly "~lambda.out": this["~lambda.in"] extends Top ? NullishOr<this["~lambda.in"]> : never;
+    <S extends Constraint>(self: S): NullishOr<S>;
+    readonly "~lambda.out": this["~lambda.in"] extends Constraint ? NullishOr<this["~lambda.in"]> : never;
 }
 /**
  * Creates a union schema of `S | null | undefined`.
@@ -3658,7 +3877,14 @@ export declare const NullishOr: NullishOrLambda;
  * @category models
  * @since 3.10.0
  */
-export interface suspend<S extends Top> extends Bottom<S["Type"], S["Encoded"], S["DecodingServices"], S["EncodingServices"], SchemaAST.Suspend, suspend<S>, S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+export interface suspend<S extends Constraint> extends BottomLazy<SchemaAST.Suspend, suspend<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+    readonly "Type": S["Type"];
+    readonly "Encoded": S["Encoded"];
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": S["~type.make.in"];
+    readonly "~type.make": S["~type.make"];
+    readonly "Iso": S["Iso"];
 }
 /**
  * Creates a suspended schema that defers evaluation until needed. This is
@@ -3684,7 +3910,7 @@ export interface suspend<S extends Top> extends Bottom<S["Type"], S["Encoded"],
  * @category constructors
  * @since 3.10.0
  */
-export declare function suspend<S extends Top>(f: () => S): suspend<S>;
+export declare function suspend<S extends Constraint>(f: () => S): suspend<S>;
 /**
  * Attaches one or more filter checks to a schema without changing the
  * TypeScript type.
@@ -3709,7 +3935,14 @@ export declare function check<S extends Top>(...checks: readonly [SchemaAST.Chec
  * @category filtering
  * @since 3.10.0
  */
-export interface refine<T extends S["Type"], S extends Top> extends Bottom<T, S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], refine<T, S>, S["~type.make.in"], T, S["~type.parameters"], T, S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+export interface refine<T extends S["Type"], S extends Constraint> extends BottomLazy<S["ast"], refine<T, S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+    readonly "Type": T;
+    readonly "Encoded": S["Encoded"];
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": S["~type.make.in"];
+    readonly "~type.make": T;
+    readonly "Iso": T;
     readonly schema: S;
 }
 /**
@@ -3727,7 +3960,7 @@ export interface refine<T extends S["Type"], S extends Top> extends Bottom<T, S[
  * @category filtering
  * @since 3.10.0
  */
-export declare function refine<S extends Top, T extends S["Type"]>(refinement: (value: S["Type"]) => value is T, annotations?: Annotations.Filter): (schema: S) => refine<T, S>;
+export declare function refine<S extends Constraint, T extends S["Type"]>(refinement: (value: S["Type"]) => value is T, annotations?: Annotations.Filter): (schema: S) => refine<T, S>;
 type DistributeBrands<B> = UnionToIntersection<B extends infer U extends string ? Brand.Brand<U> : never>;
 /**
  * Type-level representation returned by {@link brand}.
@@ -3735,7 +3968,14 @@ type DistributeBrands<B> = UnionToIntersection<B extends infer U extends string
  * @category branding
  * @since 3.10.0
  */
-export interface brand<S extends Top, B> extends Bottom<S["Type"] & DistributeBrands<B>, S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], brand<S, B>, S["~type.make.in"], S["Type"] & DistributeBrands<B>, S["~type.parameters"], S["Type"] & DistributeBrands<B>, S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+export interface brand<S extends Constraint, B> extends BottomLazy<S["ast"], brand<S, B>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+    readonly "Type": S["Type"] & DistributeBrands<B>;
+    readonly "Encoded": S["Encoded"];
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": S["~type.make.in"];
+    readonly "~type.make": S["Type"] & DistributeBrands<B>;
+    readonly "Iso": S["Type"] & DistributeBrands<B>;
     readonly schema: S;
     readonly identifier: string;
 }
@@ -3758,7 +3998,7 @@ export interface brand<S extends Top, B> extends Bottom<S["Type"] & DistributeBr
  * @category branding
  * @since 3.10.0
  */
-export declare function brand<B extends string>(identifier: B): <S extends Top>(schema: S) => brand<S["Rebuild"], B>;
+export declare function brand<B extends string>(identifier: B): <S extends ConstraintRebuildable>(schema: S) => brand<S["Rebuild"], B>;
 /**
  * Creates a branded schema from a {@link Brand.Constructor}, applying the
  * constructor's checks and brand tag to the underlying schema.
@@ -3775,7 +4015,14 @@ export declare function fromBrand<A extends Brand.Brand<any>>(identifier: string
  * @category decoding
  * @since 4.0.0
  */
-export interface middlewareDecoding<S extends Top, RD> extends Bottom<S["Type"], S["Encoded"], RD, S["EncodingServices"], S["ast"], middlewareDecoding<S, RD>, S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+export interface middlewareDecoding<S extends Constraint, RD> extends BottomLazy<S["ast"], middlewareDecoding<S, RD>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+    readonly "Type": S["Type"];
+    readonly "Encoded": S["Encoded"];
+    readonly "DecodingServices": RD;
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": S["~type.make.in"];
+    readonly "~type.make": S["~type.make"];
+    readonly "Iso": S["Iso"];
     readonly schema: S;
 }
 /**
@@ -3803,14 +4050,21 @@ export interface middlewareDecoding<S extends Top, RD> extends Bottom<S["Type"],
  * @category decoding
  * @since 4.0.0
  */
-export declare function middlewareDecoding<S extends Top, RD>(decode: (effect: Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue, S["DecodingServices"]>, options: SchemaAST.ParseOptions) => Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue, RD>): (schema: S) => middlewareDecoding<S, RD>;
+export declare function middlewareDecoding<S extends Constraint, RD>(decode: (effect: Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue, S["DecodingServices"]>, options: SchemaAST.ParseOptions) => Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue, RD>): (schema: S) => middlewareDecoding<S, RD>;
 /**
  * Type-level representation returned by {@link middlewareEncoding}.
  *
  * @category encoding
  * @since 4.0.0
  */
-export interface middlewareEncoding<S extends Top, RE> extends Bottom<S["Type"], S["Encoded"], S["DecodingServices"], RE, S["ast"], middlewareEncoding<S, RE>, S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+export interface middlewareEncoding<S extends Constraint, RE> extends BottomLazy<S["ast"], middlewareEncoding<S, RE>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+    readonly "Type": S["Type"];
+    readonly "Encoded": S["Encoded"];
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": RE;
+    readonly "~type.make.in": S["~type.make.in"];
+    readonly "~type.make": S["~type.make"];
+    readonly "Iso": S["Iso"];
     readonly schema: S;
 }
 /**
@@ -3838,7 +4092,7 @@ export interface middlewareEncoding<S extends Top, RE> extends Bottom<S["Type"],
  * @category encoding
  * @since 4.0.0
  */
-export declare function middlewareEncoding<S extends Top, RE>(encode: (effect: Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue, S["EncodingServices"]>, options: SchemaAST.ParseOptions) => Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue, RE>): (schema: S) => middlewareEncoding<S, RE>;
+export declare function middlewareEncoding<S extends Constraint, RE>(encode: (effect: Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue, S["EncodingServices"]>, options: SchemaAST.ParseOptions) => Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue, RE>): (schema: S) => middlewareEncoding<S, RE>;
 /**
  * Recovers from a decoding error by providing a fallback value.
  *
@@ -3861,7 +4115,7 @@ export declare function middlewareEncoding<S extends Top, RE>(encode: (effect: E
  * @category error handling
  * @since 4.0.0
  */
-export declare function catchDecoding<S extends Top>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue>): (self: S) => S["Rebuild"];
+export declare function catchDecoding<S extends Constraint>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue>): (self: S) => middlewareDecoding<S, S["DecodingServices"]>;
 /**
  * Recovers from a decoding error with a handler that may require Effect services.
  *
@@ -3882,7 +4136,7 @@ export declare function catchDecoding<S extends Top>(f: (issue: SchemaIssue.Issu
  * @category error handling
  * @since 4.0.0
  */
-export declare function catchDecodingWithContext<S extends Top, R = never>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue, R>): (self: S) => middlewareDecoding<S, S["DecodingServices"] | R>;
+export declare function catchDecodingWithContext<S extends Constraint, R = never>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Type"]>, SchemaIssue.Issue, R>): (self: S) => middlewareDecoding<S, S["DecodingServices"] | R>;
 /**
  * Recovers from an encoding error by providing a fallback value.
  *
@@ -3895,7 +4149,7 @@ export declare function catchDecodingWithContext<S extends Top, R = never>(f: (i
  * @category error handling
  * @since 4.0.0
  */
-export declare function catchEncoding<S extends Top>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue>): (self: S) => S["Rebuild"];
+export declare function catchEncoding<S extends Constraint>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue>): (self: S) => middlewareEncoding<S, S["EncodingServices"]>;
 /**
  * Recovers from an encoding error with a handler that may require Effect services.
  *
@@ -3916,14 +4170,21 @@ export declare function catchEncoding<S extends Top>(f: (issue: SchemaIssue.Issu
  * @category error handling
  * @since 4.0.0
  */
-export declare function catchEncodingWithContext<S extends Top, R = never>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue, R>): (self: S) => middlewareEncoding<S, S["EncodingServices"] | R>;
+export declare function catchEncodingWithContext<S extends Constraint, R = never>(f: (issue: SchemaIssue.Issue) => Effect.Effect<Option_.Option<S["Encoded"]>, SchemaIssue.Issue, R>): (self: S) => middlewareEncoding<S, S["EncodingServices"] | R>;
 /**
  * Type-level representation returned by {@link decodeTo}.
  *
  * @category transforming
  * @since 4.0.0
  */
-export interface decodeTo<To extends Top, From extends Top, RD = never, RE = never> extends Bottom<To["Type"], From["Encoded"], To["DecodingServices"] | From["DecodingServices"] | RD, To["EncodingServices"] | From["EncodingServices"] | RE, To["ast"], decodeTo<To, From, RD, RE>, To["~type.make.in"], To["Iso"], To["~type.parameters"], To["~type.make"], To["~type.mutability"], To["~type.optionality"], To["~type.constructor.default"], From["~encoded.mutability"], From["~encoded.optionality"]> {
+export interface decodeTo<To extends Constraint, From extends Constraint, RD = never, RE = never> extends BottomLazy<To["ast"], decodeTo<To, From, RD, RE>, To["~type.parameters"], To["~type.mutability"], To["~type.optionality"], To["~type.constructor.default"], From["~encoded.mutability"], From["~encoded.optionality"]> {
+    readonly "Type": To["Type"];
+    readonly "Encoded": From["Encoded"];
+    readonly "DecodingServices": To["DecodingServices"] | From["DecodingServices"] | RD;
+    readonly "EncodingServices": To["EncodingServices"] | From["EncodingServices"] | RE;
+    readonly "~type.make.in": To["~type.make.in"];
+    readonly "~type.make": To["~type.make"];
+    readonly "Iso": To["Iso"];
     readonly from: From;
     readonly to: To;
 }
@@ -3933,7 +4194,7 @@ export interface decodeTo<To extends Top, From extends Top, RD = never, RE = nev
  * @category transforming
  * @since 3.10.0
  */
-export interface compose<To extends Top, From extends Top> extends decodeTo<To, From> {
+export interface compose<To extends Constraint, From extends Constraint> extends decodeTo<To, From> {
 }
 /**
  * Creates a schema that transforms from a source schema to a target schema.
@@ -3983,8 +4244,8 @@ export interface compose<To extends Top, From extends Top> extends decodeTo<To,
  * @category transforming
  * @since 4.0.0
  */
-export declare function decodeTo<To extends Top>(to: To): <From extends Top>(from: From) => compose<To, From>;
-export declare function decodeTo<To extends Top, From extends Top, RD = never, RE = never>(to: To, transformation: {
+export declare function decodeTo<To extends Constraint>(to: To): <From extends Constraint>(from: From) => compose<To, From>;
+export declare function decodeTo<To extends Constraint, From extends Constraint, RD = never, RE = never>(to: To, transformation: {
     readonly decode: SchemaGetter.Getter<NoInfer<To["Encoded"]>, NoInfer<From["Type"]>, RD>;
     readonly encode: SchemaGetter.Getter<NoInfer<From["Type"]>, NoInfer<To["Encoded"]>, RE>;
 }): (from: From) => decodeTo<To, From, RD, RE>;
@@ -4031,7 +4292,7 @@ export declare function decodeTo<To extends Top, From extends Top, RD = never, R
  * @category transforming
  * @since 3.10.0
  */
-export declare function decode<S extends Top, RD = never, RE = never>(transformation: {
+export declare function decode<S extends Constraint, RD = never, RE = never>(transformation: {
     readonly decode: SchemaGetter.Getter<S["Type"], S["Type"], RD>;
     readonly encode: SchemaGetter.Getter<S["Type"], S["Type"], RE>;
 }): (self: S) => decodeTo<toType<S>, S, RD, RE>;
@@ -4064,8 +4325,8 @@ export declare function decode<S extends Top, RD = never, RE = never>(transforma
  * @category transforming
  * @since 4.0.0
  */
-export declare function encodeTo<To extends Top>(to: To): <From extends Top>(from: From) => decodeTo<From, To>;
-export declare function encodeTo<To extends Top, From extends Top, RD = never, RE = never>(to: To, transformation: {
+export declare function encodeTo<To extends Constraint>(to: To): <From extends Constraint>(from: From) => decodeTo<From, To>;
+export declare function encodeTo<To extends Constraint, From extends Constraint, RD = never, RE = never>(to: To, transformation: {
     readonly decode: SchemaGetter.Getter<NoInfer<From["Encoded"]>, NoInfer<To["Type"]>, RD>;
     readonly encode: SchemaGetter.Getter<NoInfer<To["Type"]>, NoInfer<From["Encoded"]>, RE>;
 }): (from: From) => decodeTo<From, To, RD, RE>;
@@ -4094,7 +4355,7 @@ export declare function encodeTo<To extends Top, From extends Top, RD = never, R
  * @category transforming
  * @since 3.10.0
  */
-export declare function encode<S extends Top, RD = never, RE = never>(transformation: {
+export declare function encode<S extends Constraint, RD = never, RE = never>(transformation: {
     readonly decode: SchemaGetter.Getter<S["Encoded"], S["Encoded"], RD>;
     readonly encode: SchemaGetter.Getter<S["Encoded"], S["Encoded"], RE>;
 }): (self: S) => decodeTo<S, toEncoded<S>, RD, RE>;
@@ -4117,7 +4378,14 @@ export interface WithoutConstructorDefault {
  * @category constructors
  * @since 3.10.0
  */
-export interface withConstructorDefault<S extends Top & WithoutConstructorDefault> extends Bottom<S["Type"], S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], withConstructorDefault<S>, S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], "with-default", S["~encoded.mutability"], S["~encoded.optionality"]> {
+export interface withConstructorDefault<S extends Constraint & WithoutConstructorDefault> extends BottomLazy<S["ast"], withConstructorDefault<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], "with-default", S["~encoded.mutability"], S["~encoded.optionality"]> {
+    readonly "Type": S["Type"];
+    readonly "Encoded": S["Encoded"];
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": S["~type.make.in"];
+    readonly "~type.make": S["~type.make"];
+    readonly "Iso": S["Iso"];
     readonly schema: S;
 }
 /**
@@ -4147,14 +4415,14 @@ export interface withConstructorDefault<S extends Top & WithoutConstructorDefaul
  * @category constructors
  * @since 3.10.0
  */
-export declare function withConstructorDefault<S extends Top & WithoutConstructorDefault>(defaultValue: Effect.Effect<S["~type.make.in"], SchemaError>): (schema: S) => withConstructorDefault<S>;
+export declare function withConstructorDefault<S extends Constraint & WithoutConstructorDefault>(defaultValue: Effect.Effect<S["~type.make.in"], SchemaError>): (schema: S) => withConstructorDefault<S>;
 /**
  * Type-level representation returned by {@link withDecodingDefaultKey}.
  *
  * @category decoding
  * @since 4.0.0
  */
-export interface withDecodingDefaultKey<S extends Top, R = never> extends decodeTo<S, optionalKey<toEncoded<S>>, R> {
+export interface withDecodingDefaultKey<S extends Constraint, R = never> extends decodeTo<S, optionalKey<toEncoded<S>>, R> {
     readonly "Rebuild": withDecodingDefaultKey<S, R>;
 }
 /**
@@ -4206,14 +4474,14 @@ export type DecodingDefaultOptions = {
  * @category decoding
  * @since 4.0.0
  */
-export declare function withDecodingDefaultKey<S extends Top, R = never>(defaultValue: Effect.Effect<S["Encoded"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefaultKey<S, R>;
+export declare function withDecodingDefaultKey<S extends Constraint, R = never>(defaultValue: Effect.Effect<S["Encoded"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefaultKey<S, R>;
 /**
  * Type-level representation returned by {@link withDecodingDefaultTypeKey}.
  *
  * @category decoding
  * @since 4.0.0
  */
-export interface withDecodingDefaultTypeKey<S extends Top, R = never> extends decodeTo<withDecodingDefaultKey<toType<S>, R>, optionalKey<S>> {
+export interface withDecodingDefaultTypeKey<S extends Constraint, R = never> extends decodeTo<withDecodingDefaultKey<toType<S>, R>, optionalKey<S>> {
     readonly "Rebuild": withDecodingDefaultTypeKey<S, R>;
 }
 /**
@@ -4238,14 +4506,14 @@ export interface withDecodingDefaultTypeKey<S extends Top, R = never> extends de
  * @category decoding
  * @since 4.0.0
  */
-export declare function withDecodingDefaultTypeKey<S extends Top, R = never>(defaultValue: Effect.Effect<S["Type"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefaultTypeKey<S, R>;
+export declare function withDecodingDefaultTypeKey<S extends Constraint, R = never>(defaultValue: Effect.Effect<S["Type"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefaultTypeKey<S, R>;
 /**
  * Type-level representation returned by {@link withDecodingDefault}.
  *
  * @category decoding
  * @since 3.10.0
  */
-export interface withDecodingDefault<S extends Top, R = never> extends decodeTo<S, optional<toEncoded<S>>, R> {
+export interface withDecodingDefault<S extends Constraint, R = never> extends decodeTo<S, optional<toEncoded<S>>, R> {
     readonly "Rebuild": withDecodingDefault<S, R>;
 }
 /**
@@ -4287,14 +4555,14 @@ export interface withDecodingDefault<S extends Top, R = never> extends decodeTo<
  * @category decoding
  * @since 3.10.0
  */
-export declare function withDecodingDefault<S extends Top, R = never>(defaultValue: Effect.Effect<S["Encoded"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefault<S, R>;
+export declare function withDecodingDefault<S extends Constraint, R = never>(defaultValue: Effect.Effect<S["Encoded"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefault<S, R>;
 /**
  * Type-level representation returned by {@link withDecodingDefaultType}.
  *
  * @category decoding
  * @since 4.0.0
  */
-export interface withDecodingDefaultType<S extends Top, R = never> extends decodeTo<withDecodingDefault<toType<S>, R>, optional<S>> {
+export interface withDecodingDefaultType<S extends Constraint, R = never> extends decodeTo<withDecodingDefault<toType<S>, R>, optional<S>> {
     readonly "Rebuild": withDecodingDefaultType<S, R>;
 }
 /**
@@ -4324,7 +4592,7 @@ export interface withDecodingDefaultType<S extends Top, R = never> extends decod
  * @category decoding
  * @since 4.0.0
  */
-export declare function withDecodingDefaultType<S extends Top, R = never>(defaultValue: Effect.Effect<S["Type"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefaultType<S, R>;
+export declare function withDecodingDefaultType<S extends Constraint, R = never>(defaultValue: Effect.Effect<S["Type"], SchemaError, R>, options?: DecodingDefaultOptions): (self: S) => withDecodingDefaultType<S, R>;
 /**
  * Type-level representation returned by {@link tag}.
  *
@@ -4449,11 +4717,11 @@ export declare function TaggedStruct<const Tag extends SchemaAST.LiteralValue, c
  * Recursively flatten any nested Schema.Union members into a single tuple of leaf schemas.
  */
 type Flatten<Schemas> = Schemas extends readonly [infer Head, ...infer Tail] ? Head extends Union<infer Inner> ? [...Flatten<Inner>, ...Flatten<Tail>] : [Head, ...Flatten<Tail>] : [];
-type TaggedUnionUtils<Tag extends PropertyKey, Members extends ReadonlyArray<Top & {
+type TaggedUnionUtils<Tag extends PropertyKey, Members extends ReadonlyArray<Constraint & {
     readonly Type: {
         readonly [K in Tag]: PropertyKey;
     };
-}>, Flattened extends ReadonlyArray<Top & {
+}>, Flattened extends ReadonlyArray<Constraint & {
     readonly Type: {
         readonly [K in Tag]: PropertyKey;
     };
@@ -4482,7 +4750,7 @@ type TaggedUnionUtils<Tag extends PropertyKey, Members extends ReadonlyArray<Top
  * @category combinators
  * @since 4.0.0
  */
-export type toTaggedUnion<Tag extends PropertyKey, Members extends ReadonlyArray<Top & {
+export type toTaggedUnion<Tag extends PropertyKey, Members extends ReadonlyArray<Constraint & {
     readonly Type: {
         readonly [K in Tag]: PropertyKey;
     };
@@ -4511,7 +4779,7 @@ export type toTaggedUnion<Tag extends PropertyKey, Members extends ReadonlyArray
  * @category combinators
  * @since 4.0.0
  */
-export declare function toTaggedUnion<const Tag extends PropertyKey>(tag: Tag): <const Members extends ReadonlyArray<Top & {
+export declare function toTaggedUnion<const Tag extends PropertyKey>(tag: Tag): <const Members extends ReadonlyArray<Constraint & {
     readonly Type: { readonly [K in Tag]: PropertyKey; };
 }>>(self: Union<Members>) => toTaggedUnion<Tag, Members>;
 /**
@@ -4520,17 +4788,28 @@ export declare function toTaggedUnion<const Tag extends PropertyKey>(tag: Tag):
  * @category models
  * @since 4.0.0
  */
-export interface TaggedUnion<Cases extends Record<string, Top>> extends Bottom<{
-    [K in keyof Cases]: Cases[K]["Type"];
-}[keyof Cases], {
-    [K in keyof Cases]: Cases[K]["Encoded"];
-}[keyof Cases], {
-    [K in keyof Cases]: Cases[K]["DecodingServices"];
-}[keyof Cases], {
-    [K in keyof Cases]: Cases[K]["EncodingServices"];
-}[keyof Cases], SchemaAST.Union<SchemaAST.Objects>, TaggedUnion<Cases>, {
-    [K in keyof Cases]: Cases[K]["~type.make"];
-}[keyof Cases]> {
+export interface TaggedUnion<Cases extends Record<string, Constraint>> extends BottomLazy<SchemaAST.Union<SchemaAST.Objects>, TaggedUnion<Cases>> {
+    readonly "Type": {
+        [K in keyof Cases]: Cases[K]["Type"];
+    }[keyof Cases];
+    readonly "Encoded": {
+        [K in keyof Cases]: Cases[K]["Encoded"];
+    }[keyof Cases];
+    readonly "DecodingServices": {
+        [K in keyof Cases]: Cases[K]["DecodingServices"];
+    }[keyof Cases];
+    readonly "EncodingServices": {
+        [K in keyof Cases]: Cases[K]["EncodingServices"];
+    }[keyof Cases];
+    readonly "~type.make.in": {
+        [K in keyof Cases]: Cases[K]["~type.make"];
+    }[keyof Cases];
+    readonly "~type.make": {
+        [K in keyof Cases]: Cases[K]["~type.make"];
+    }[keyof Cases];
+    readonly "Iso": {
+        [K in keyof Cases]: Cases[K]["Type"];
+    }[keyof Cases];
     readonly cases: Cases;
     readonly isAnyOf: <const Keys>(keys: ReadonlyArray<Keys>) => (value: Cases[keyof Cases]["Type"]) => value is Extract<Cases[keyof Cases]["Type"], {
         _tag: Keys;
@@ -4582,7 +4861,14 @@ export declare function TaggedUnion<const CasesByTag extends Record<string, Stru
  * @category models
  * @since 4.0.0
  */
-export interface Opaque<Self, S extends Top, Brand> extends Bottom<Self, S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], S["Rebuild"], S["~type.make.in"], S["Iso"], S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+export interface Opaque<Self, S extends Top, Brand> extends BottomLazy<S["ast"], S["Rebuild"], S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+    readonly "Type": Self;
+    readonly "Encoded": S["Encoded"];
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": S["~type.make.in"];
+    readonly "~type.make": S["~type.make"];
+    readonly "Iso": S["Iso"];
     new (_: never): S["Type"] & Brand;
 }
 /**
@@ -4645,7 +4931,7 @@ export declare function instanceOf<C extends abstract new (...args: any) => any,
  * @category transforming
  * @since 4.0.0
  */
-export declare function link<T>(): <To extends Top>(encodeTo: To, transformation: {
+export declare function link<T>(): <To extends Constraint>(encodeTo: To, transformation: {
     readonly decode: SchemaGetter.Getter<T, NoInfer<To["Type"]>>;
     readonly encode: SchemaGetter.Getter<NoInfer<To["Type"]>, T>;
 }) => SchemaAST.Link;
@@ -5835,7 +6121,7 @@ export declare function isPropertiesLengthBetween(minimum: number, maximum: numb
  * @category Object checks
  * @since 4.0.0
  */
-export declare function isPropertyNames(keySchema: Top, annotations?: Annotations.Filter): SchemaAST.Filter<object>;
+export declare function isPropertyNames(keySchema: Constraint, annotations?: Annotations.Filter): SchemaAST.Filter<object>;
 /**
  * Validates that all items in an array are unique according to Effect equality.
  *
@@ -5905,7 +6191,7 @@ export declare const Char: Char;
  * @category Option
  * @since 3.10.0
  */
-export interface Option<A extends Top> extends declareConstructor<Option_.Option<A["Type"]>, Option_.Option<A["Encoded"]>, readonly [A], OptionIso<A>> {
+export interface Option<A extends Constraint> extends declareConstructor<Option_.Option<A["Type"]>, Option_.Option<A["Encoded"]>, readonly [A], OptionIso<A>> {
     readonly "Rebuild": Option<A>;
     readonly value: A;
 }
@@ -5920,7 +6206,7 @@ export interface Option<A extends Top> extends declareConstructor<Option_.Option
  * @category Option
  * @since 4.0.0
  */
-export type OptionIso<A extends Top> = {
+export type OptionIso<A extends Constraint> = {
     readonly _tag: "None";
 } | {
     readonly _tag: "Some";
@@ -5932,14 +6218,14 @@ export type OptionIso<A extends Top> = {
  * @category Option
  * @since 3.10.0
  */
-export declare function Option<A extends Top>(value: A): Option<A>;
+export declare function Option<A extends Constraint>(value: A): Option<A>;
 /**
  * Type-level representation returned by {@link OptionFromNullOr}.
  *
  * @category Option
  * @since 3.10.0
  */
-export interface OptionFromNullOr<S extends Top> extends decodeTo<Option<toType<S>>, NullOr<S>> {
+export interface OptionFromNullOr<S extends Constraint> extends decodeTo<Option<toType<S>>, NullOr<S>> {
     readonly "Rebuild": OptionFromNullOr<S>;
 }
 /**
@@ -5953,14 +6239,14 @@ export interface OptionFromNullOr<S extends Top> extends decodeTo<Option<toType<
  * @category Option
  * @since 3.10.0
  */
-export declare function OptionFromNullOr<S extends Top>(schema: S): OptionFromNullOr<S>;
+export declare function OptionFromNullOr<S extends Constraint>(schema: S): OptionFromNullOr<S>;
 /**
  * Type-level representation returned by {@link OptionFromUndefinedOr}.
  *
  * @category Option
  * @since 3.10.0
  */
-export interface OptionFromUndefinedOr<S extends Top> extends decodeTo<Option<toType<S>>, UndefinedOr<S>> {
+export interface OptionFromUndefinedOr<S extends Constraint> extends decodeTo<Option<toType<S>>, UndefinedOr<S>> {
     readonly "Rebuild": OptionFromUndefinedOr<S>;
 }
 /**
@@ -5975,14 +6261,14 @@ export interface OptionFromUndefinedOr<S extends Top> extends decodeTo<Option<to
  * @category Option
  * @since 3.10.0
  */
-export declare function OptionFromUndefinedOr<S extends Top>(schema: S): OptionFromUndefinedOr<S>;
+export declare function OptionFromUndefinedOr<S extends Constraint>(schema: S): OptionFromUndefinedOr<S>;
 /**
  * Type-level representation returned by {@link OptionFromNullishOr}.
  *
  * @category Option
  * @since 3.10.0
  */
-export interface OptionFromNullishOr<S extends Top> extends decodeTo<Option<toType<S>>, NullishOr<S>> {
+export interface OptionFromNullishOr<S extends Constraint> extends decodeTo<Option<toType<S>>, NullishOr<S>> {
     readonly "Rebuild": OptionFromNullishOr<S>;
 }
 /**
@@ -5998,7 +6284,7 @@ export interface OptionFromNullishOr<S extends Top> extends decodeTo<Option<toTy
  * @category Option
  * @since 3.10.0
  */
-export declare function OptionFromNullishOr<S extends Top>(schema: S, options?: {
+export declare function OptionFromNullishOr<S extends Constraint>(schema: S, options?: {
     onNoneEncoding: null | undefined;
 }): OptionFromNullishOr<S>;
 /**
@@ -6007,7 +6293,7 @@ export declare function OptionFromNullishOr<S extends Top>(schema: S, options?:
  * @category Option
  * @since 4.0.0
  */
-export interface OptionFromOptionalKey<S extends Top> extends decodeTo<Option<toType<S>>, optionalKey<S>> {
+export interface OptionFromOptionalKey<S extends Constraint> extends decodeTo<Option<toType<S>>, optionalKey<S>> {
     readonly "Rebuild": OptionFromOptionalKey<S>;
 }
 /**
@@ -6021,14 +6307,14 @@ export interface OptionFromOptionalKey<S extends Top> extends decodeTo<Option<to
  * @category Option
  * @since 4.0.0
  */
-export declare function OptionFromOptionalKey<S extends Top>(schema: S): OptionFromOptionalKey<S>;
+export declare function OptionFromOptionalKey<S extends Constraint>(schema: S): OptionFromOptionalKey<S>;
 /**
  * Type-level representation returned by {@link OptionFromOptional}.
  *
  * @category Option
  * @since 4.0.0
  */
-export interface OptionFromOptional<S extends Top> extends decodeTo<Option<toType<S>>, optional<S>> {
+export interface OptionFromOptional<S extends Constraint> extends decodeTo<Option<toType<S>>, optional<S>> {
     readonly "Rebuild": OptionFromOptional<S>;
 }
 /**
@@ -6044,14 +6330,14 @@ export interface OptionFromOptional<S extends Top> extends decodeTo<Option<toTyp
  * @category Option
  * @since 4.0.0
  */
-export declare function OptionFromOptional<S extends Top>(schema: S): OptionFromOptional<S>;
+export declare function OptionFromOptional<S extends Constraint>(schema: S): OptionFromOptional<S>;
 /**
  * Type-level representation returned by {@link OptionFromOptionalNullOr}.
  *
  * @category Option
  * @since 4.0.0
  */
-export interface OptionFromOptionalNullOr<S extends Top> extends decodeTo<Option<toType<S>>, optional<NullOr<S>>> {
+export interface OptionFromOptionalNullOr<S extends Constraint> extends decodeTo<Option<toType<S>>, optional<NullOr<S>>> {
     readonly "Rebuild": OptionFromOptionalNullOr<S>;
 }
 /**
@@ -6068,7 +6354,7 @@ export interface OptionFromOptionalNullOr<S extends Top> extends decodeTo<Option
  * @category Option
  * @since 4.0.0
  */
-export declare function OptionFromOptionalNullOr<S extends Top>(schema: S, options?: {
+export declare function OptionFromOptionalNullOr<S extends Constraint>(schema: S, options?: {
     readonly onNoneEncoding: "omit" | null | undefined;
 }): OptionFromOptionalNullOr<S>;
 /**
@@ -6077,7 +6363,7 @@ export declare function OptionFromOptionalNullOr<S extends Top>(schema: S, optio
  * @category schemas
  * @since 4.0.0
  */
-export interface Result<A extends Top, E extends Top> extends declareConstructor<Result_.Result<A["Type"], E["Type"]>, Result_.Result<A["Encoded"], E["Encoded"]>, readonly [A, E], ResultIso<A, E>> {
+export interface Result<A extends Constraint, E extends Constraint> extends declareConstructor<Result_.Result<A["Type"], E["Type"]>, Result_.Result<A["Encoded"], E["Encoded"]>, readonly [A, E], ResultIso<A, E>> {
     readonly "Rebuild": Result<A, E>;
     readonly success: A;
     readonly failure: E;
@@ -6093,7 +6379,7 @@ export interface Result<A extends Top, E extends Top> extends declareConstructor
  * @category schemas
  * @since 4.0.0
  */
-export type ResultIso<A extends Top, E extends Top> = {
+export type ResultIso<A extends Constraint, E extends Constraint> = {
     readonly _tag: "Success";
     readonly success: A["Iso"];
 } | {
@@ -6106,14 +6392,14 @@ export type ResultIso<A extends Top, E extends Top> = {
  * @category schemas
  * @since 4.0.0
  */
-export declare function Result<A extends Top, E extends Top>(success: A, failure: E): Result<A, E>;
+export declare function Result<A extends Constraint, E extends Constraint>(success: A, failure: E): Result<A, E>;
 /**
  * Type-level representation returned by {@link Redacted}.
  *
  * @category Redacted
  * @since 3.10.0
  */
-export interface Redacted<S extends Top> extends declareConstructor<Redacted_.Redacted<S["Type"]>, Redacted_.Redacted<S["Encoded"]>, readonly [S]> {
+export interface Redacted<S extends Constraint> extends declareConstructor<Redacted_.Redacted<S["Type"]>, Redacted_.Redacted<S["Encoded"]>, readonly [S]> {
     readonly "Rebuild": Redacted<S>;
     readonly value: S;
 }
@@ -6137,10 +6423,11 @@ export interface Redacted<S extends Top> extends declareConstructor<Redacted_.Re
  *   into JSON, it will fail with an error. This is useful when the wrapped schema is
  *   sensitive and should not be exposed in JSON.
  *
+ * @see {@link RedactedFromValue} for decoding raw values and wrapping them in `Redacted`.
  * @category Redacted
  * @since 3.10.0
  */
-export declare function Redacted<S extends Top>(value: S, options?: {
+export declare function Redacted<S extends Constraint>(value: S, options?: {
     readonly label?: string | undefined;
     readonly disallowJsonEncode?: boolean | undefined;
 }): Redacted<S>;
@@ -6150,7 +6437,7 @@ export declare function Redacted<S extends Top>(value: S, options?: {
  * @category Redacted
  * @since 4.0.0
  */
-export interface RedactedFromValue<S extends Top> extends decodeTo<Redacted<toType<S>>, middlewareDecoding<S, S["DecodingServices"]>> {
+export interface RedactedFromValue<S extends Constraint> extends decodeTo<Redacted<toType<S>>, middlewareDecoding<S, S["DecodingServices"]>> {
     readonly "Rebuild": RedactedFromValue<S>;
 }
 /**
@@ -6160,16 +6447,17 @@ export interface RedactedFromValue<S extends Top> extends decodeTo<Redacted<toTy
  * @category Redacted
  * @since 4.0.0
  */
-export declare function redact<S extends Top>(schema: S): middlewareDecoding<S, S["DecodingServices"]>;
+export declare function redact<S extends Constraint>(schema: S): middlewareDecoding<S, S["DecodingServices"]>;
 /**
  * Decodes a value and wraps it in `Redacted<A>`. Unlike {@link Redacted} which
  * expects the input to already be a `Redacted` instance, this schema decodes
  * the raw value and wraps it.
  *
+ * @see {@link Redacted} for schemas whose input is already a `Redacted` value.
  * @category Redacted
  * @since 4.0.0
  */
-export declare function RedactedFromValue<S extends Top>(value: S, options?: {
+export declare function RedactedFromValue<S extends Constraint>(value: S, options?: {
     readonly label?: string | undefined;
     readonly disallowEncode?: boolean | undefined;
 }): RedactedFromValue<S>;
@@ -6179,7 +6467,7 @@ export declare function RedactedFromValue<S extends Top>(value: S, options?: {
  * @category CauseReason
  * @since 4.0.0
  */
-export interface CauseReason<E extends Top, D extends Top> extends declareConstructor<Cause_.Reason<E["Type"]>, Cause_.Reason<E["Encoded"]>, readonly [E, D], CauseReasonIso<E, D>> {
+export interface CauseReason<E extends Constraint, D extends Constraint> extends declareConstructor<Cause_.Reason<E["Type"]>, Cause_.Reason<E["Encoded"]>, readonly [E, D], CauseReasonIso<E, D>> {
     readonly "Rebuild": CauseReason<E, D>;
     readonly error: E;
     readonly defect: D;
@@ -6195,7 +6483,7 @@ export interface CauseReason<E extends Top, D extends Top> extends declareConstr
  * @category CauseReason
  * @since 4.0.0
  */
-export type CauseReasonIso<E extends Top, D extends Top> = {
+export type CauseReasonIso<E extends Constraint, D extends Constraint> = {
     readonly _tag: "Fail";
     readonly error: E["Iso"];
 } | {
@@ -6225,14 +6513,14 @@ export type CauseReasonIso<E extends Top, D extends Top> = {
  * @category CauseReason
  * @since 4.0.0
  */
-export declare function CauseReason<E extends Top, D extends Top>(error: E, defect: D): CauseReason<E, D>;
+export declare function CauseReason<E extends Constraint, D extends Constraint>(error: E, defect: D): CauseReason<E, D>;
 /**
  * Type-level representation returned by {@link Cause}.
  *
  * @category Cause
  * @since 3.10.0
  */
-export interface Cause<E extends Top, D extends Top> extends declareConstructor<Cause_.Cause<E["Type"]>, Cause_.Cause<E["Encoded"]>, readonly [E, D], CauseIso<E, D>> {
+export interface Cause<E extends Constraint, D extends Constraint> extends declareConstructor<Cause_.Cause<E["Type"]>, Cause_.Cause<E["Encoded"]>, readonly [E, D], CauseIso<E, D>> {
     readonly "Rebuild": Cause<E, D>;
     readonly error: E;
     readonly defect: D;
@@ -6252,7 +6540,7 @@ export interface Cause<E extends Top, D extends Top> extends declareConstructor<
  * @category Cause
  * @since 4.0.0
  */
-export type CauseIso<E extends Top, D extends Top> = ReadonlyArray<CauseReasonIso<E, D>>;
+export type CauseIso<E extends Constraint, D extends Constraint> = ReadonlyArray<CauseReasonIso<E, D>>;
 /**
  * Creates a schema for `Cause` values using separate schemas for typed failures
  * and unexpected defects.
@@ -6274,7 +6562,7 @@ export type CauseIso<E extends Top, D extends Top> = ReadonlyArray<CauseReasonIs
  * @category Cause
  * @since 3.10.0
  */
-export declare function Cause<E extends Top, D extends Top>(error: E, defect: D): Cause<E, D>;
+export declare function Cause<E extends Constraint, D extends Constraint>(error: E, defect: D): Cause<E, D>;
 /**
  * Type-level representation of {@link Error}.
  *
@@ -6378,7 +6666,7 @@ export declare function Defect(options?: ErrorOptions): Defect;
  * @category Exit
  * @since 3.10.0
  */
-export interface Exit<A extends Top, E extends Top, D extends Top> extends declareConstructor<Exit_.Exit<A["Type"], E["Type"]>, Exit_.Exit<A["Encoded"], E["Encoded"]>, readonly [A, E, D], ExitIso<A, E, D>> {
+export interface Exit<A extends Constraint, E extends Constraint, D extends Constraint> extends declareConstructor<Exit_.Exit<A["Type"], E["Type"]>, Exit_.Exit<A["Encoded"], E["Encoded"]>, readonly [A, E, D], ExitIso<A, E, D>> {
     readonly "Rebuild": Exit<A, E, D>;
     readonly value: A;
     readonly error: E;
@@ -6395,7 +6683,7 @@ export interface Exit<A extends Top, E extends Top, D extends Top> extends decla
  * @category Exit
  * @since 4.0.0
  */
-export type ExitIso<A extends Top, E extends Top, D extends Top> = {
+export type ExitIso<A extends Constraint, E extends Constraint, D extends Constraint> = {
     readonly _tag: "Success";
     readonly value: A["Iso"];
 } | {
@@ -6414,14 +6702,14 @@ export type ExitIso<A extends Top, E extends Top, D extends Top> = {
  * @category Exit
  * @since 3.10.0
  */
-export declare function Exit<A extends Top, E extends Top, D extends Top>(value: A, error: E, defect: D): Exit<A, E, D>;
+export declare function Exit<A extends Constraint, E extends Constraint, D extends Constraint>(value: A, error: E, defect: D): Exit<A, E, D>;
 /**
  * Type-level representation returned by {@link ReadonlyMap}.
  *
  * @category ReadonlyMap
  * @since 4.0.0
  */
-export interface $ReadonlyMap<Key extends Top, Value extends Top> extends declareConstructor<globalThis.ReadonlyMap<Key["Type"], Value["Type"]>, globalThis.ReadonlyMap<Key["Encoded"], Value["Encoded"]>, readonly [Key, Value], ReadonlyMapIso<Key, Value>> {
+export interface $ReadonlyMap<Key extends Constraint, Value extends Constraint> extends declareConstructor<globalThis.ReadonlyMap<Key["Type"], Value["Type"]>, globalThis.ReadonlyMap<Key["Encoded"], Value["Encoded"]>, readonly [Key, Value], ReadonlyMapIso<Key, Value>> {
     readonly "Rebuild": $ReadonlyMap<Key, Value>;
     readonly key: Key;
     readonly value: Value;
@@ -6433,7 +6721,7 @@ export interface $ReadonlyMap<Key extends Top, Value extends Top> extends declar
  * @category ReadonlyMap
  * @since 4.0.0
  */
-export type ReadonlyMapIso<Key extends Top, Value extends Top> = ReadonlyArray<readonly [Key["Iso"], Value["Iso"]]>;
+export type ReadonlyMapIso<Key extends Constraint, Value extends Constraint> = ReadonlyArray<readonly [Key["Iso"], Value["Iso"]]>;
 /**
  * Schema for readonly maps whose keys and values conform to the provided
  * schemas.
@@ -6441,14 +6729,14 @@ export type ReadonlyMapIso<Key extends Top, Value extends Top> = ReadonlyArray<r
  * @category ReadonlyMap
  * @since 3.10.0
  */
-export declare function ReadonlyMap<Key extends Top, Value extends Top>(key: Key, value: Value): $ReadonlyMap<Key, Value>;
+export declare function ReadonlyMap<Key extends Constraint, Value extends Constraint>(key: Key, value: Value): $ReadonlyMap<Key, Value>;
 /**
  * Type-level representation returned by {@link HashMap}.
  *
  * @category HashMap
  * @since 3.10.0
  */
-export interface HashMap<Key extends Top, Value extends Top> extends declareConstructor<HashMap_.HashMap<Key["Type"], Value["Type"]>, HashMap_.HashMap<Key["Encoded"], Value["Encoded"]>, readonly [Key, Value], HashMapIso<Key, Value>> {
+export interface HashMap<Key extends Constraint, Value extends Constraint> extends declareConstructor<HashMap_.HashMap<Key["Type"], Value["Type"]>, HashMap_.HashMap<Key["Encoded"], Value["Encoded"]>, readonly [Key, Value], HashMapIso<Key, Value>> {
     readonly "Rebuild": HashMap<Key, Value>;
     readonly key: Key;
     readonly value: Value;
@@ -6460,21 +6748,21 @@ export interface HashMap<Key extends Top, Value extends Top> extends declareCons
  * @category HashMap
  * @since 4.0.0
  */
-export type HashMapIso<Key extends Top, Value extends Top> = ReadonlyArray<readonly [Key["Iso"], Value["Iso"]]>;
+export type HashMapIso<Key extends Constraint, Value extends Constraint> = ReadonlyArray<readonly [Key["Iso"], Value["Iso"]]>;
 /**
  * Schema for hash maps whose keys and values conform to the provided schemas.
  *
  * @category HashMap
  * @since 3.10.0
  */
-export declare function HashMap<Key extends Top, Value extends Top>(key: Key, value: Value): HashMap<Key, Value>;
+export declare function HashMap<Key extends Constraint, Value extends Constraint>(key: Key, value: Value): HashMap<Key, Value>;
 /**
  * Type-level representation returned by {@link ReadonlySet}.
  *
  * @category ReadonlySet
  * @since 4.0.0
  */
-export interface $ReadonlySet<Value extends Top> extends declareConstructor<globalThis.ReadonlySet<Value["Type"]>, globalThis.ReadonlySet<Value["Encoded"]>, readonly [Value], ReadonlySetIso<Value>> {
+export interface $ReadonlySet<Value extends Constraint> extends declareConstructor<globalThis.ReadonlySet<Value["Type"]>, globalThis.ReadonlySet<Value["Encoded"]>, readonly [Value], ReadonlySetIso<Value>> {
     readonly "Rebuild": $ReadonlySet<Value>;
     readonly value: Value;
 }
@@ -6485,21 +6773,21 @@ export interface $ReadonlySet<Value extends Top> extends declareConstructor<glob
  * @category ReadonlySet
  * @since 4.0.0
  */
-export type ReadonlySetIso<Value extends Top> = ReadonlyArray<Value["Iso"]>;
+export type ReadonlySetIso<Value extends Constraint> = ReadonlyArray<Value["Iso"]>;
 /**
  * Schema for readonly sets whose values conform to the provided element schema.
  *
  * @category ReadonlySet
  * @since 3.10.0
  */
-export declare function ReadonlySet<Value extends Top>(value: Value): $ReadonlySet<Value>;
+export declare function ReadonlySet<Value extends Constraint>(value: Value): $ReadonlySet<Value>;
 /**
  * Type-level representation returned by {@link HashSet}.
  *
  * @category HashSet
  * @since 3.10.0
  */
-export interface HashSet<Value extends Top> extends declareConstructor<HashSet_.HashSet<Value["Type"]>, HashSet_.HashSet<Value["Encoded"]>, readonly [Value], HashSetIso<Value>> {
+export interface HashSet<Value extends Constraint> extends declareConstructor<HashSet_.HashSet<Value["Type"]>, HashSet_.HashSet<Value["Encoded"]>, readonly [Value], HashSetIso<Value>> {
     readonly "Rebuild": HashSet<Value>;
     readonly value: Value;
 }
@@ -6510,21 +6798,21 @@ export interface HashSet<Value extends Top> extends declareConstructor<HashSet_.
  * @category HashSet
  * @since 4.0.0
  */
-export type HashSetIso<Value extends Top> = ReadonlyArray<Value["Iso"]>;
+export type HashSetIso<Value extends Constraint> = ReadonlyArray<Value["Iso"]>;
 /**
  * Schema for hash sets whose values conform to the provided element schema.
  *
  * @category HashSet
  * @since 3.10.0
  */
-export declare function HashSet<Value extends Top>(value: Value): HashSet<Value>;
+export declare function HashSet<Value extends Constraint>(value: Value): HashSet<Value>;
 /**
  * Type-level representation returned by {@link Chunk}.
  *
  * @category Chunk
  * @since 3.10.0
  */
-export interface Chunk<Value extends Top> extends declareConstructor<Chunk_.Chunk<Value["Type"]>, Chunk_.Chunk<Value["Encoded"]>, readonly [Value], ChunkIso<Value>> {
+export interface Chunk<Value extends Constraint> extends declareConstructor<Chunk_.Chunk<Value["Type"]>, Chunk_.Chunk<Value["Encoded"]>, readonly [Value], ChunkIso<Value>> {
     readonly "Rebuild": Chunk<Value>;
     readonly value: Value;
 }
@@ -6542,14 +6830,14 @@ export interface Chunk<Value extends Top> extends declareConstructor<Chunk_.Chun
  * @category Chunk
  * @since 4.0.0
  */
-export type ChunkIso<Value extends Top> = ReadonlyArray<Value["Iso"]>;
+export type ChunkIso<Value extends Constraint> = ReadonlyArray<Value["Iso"]>;
 /**
  * Schema for chunks whose values conform to the provided element schema.
  *
  * @category Chunk
  * @since 3.10.0
  */
-export declare function Chunk<Value extends Top>(value: Value): Chunk<Value>;
+export declare function Chunk<Value extends Constraint>(value: Value): Chunk<Value>;
 /**
  * Type-level representation of {@link RegExp}.
  *
@@ -6930,7 +7218,7 @@ export declare const UnknownFromJsonString: UnknownFromJsonString;
  * @category models
  * @since 4.0.0
  */
-export interface fromJsonString<S extends Top> extends decodeTo<S, String> {
+export interface fromJsonString<S extends Constraint> extends decodeTo<S, String> {
     readonly "Rebuild": fromJsonString<S>;
 }
 /**
@@ -6999,7 +7287,7 @@ export interface fromJsonString<S extends Top> extends decodeTo<S, String> {
  * @category constructors
  * @since 4.0.0
  */
-export declare function fromJsonString<S extends Top>(schema: S): fromJsonString<S>;
+export declare function fromJsonString<S extends Constraint>(schema: S): fromJsonString<S>;
 /**
  * Type-level representation of {@link File}.
  *
@@ -7048,7 +7336,7 @@ export declare const FormData: FormData;
  * @category FormData
  * @since 4.0.0
  */
-export interface fromFormData<S extends Top> extends decodeTo<S, FormData> {
+export interface fromFormData<S extends Constraint> extends decodeTo<S, FormData> {
     readonly "Rebuild": fromFormData<S>;
 }
 /**
@@ -7067,10 +7355,8 @@ export interface fromFormData<S extends Top> extends decodeTo<S, FormData> {
  *
  * You can express nested values using bracket notation.
  *
- * If you want to decode values that are not strings, use
- * `Schema.toCodecStringTree` with the `keepDeclarations: true` option.
- * This serializer preserves values such as numbers and `Blob` objects when
- * compatible with the schema.
+ * If you want to decode string fields into non-string primitive values, use
+ * `Schema.toCodecStringTree`.
  *
  * **Example** (Decoding a flat structure)
  *
@@ -7124,8 +7410,7 @@ export interface fromFormData<S extends Top> extends decodeTo<S, FormData> {
  *   Schema.toCodecStringTree(
  *     Schema.Struct({
  *       a: Schema.Int
- *     }),
- *     { keepDeclarations: true }
+ *     })
  *   )
  * )
  *
@@ -7139,7 +7424,7 @@ export interface fromFormData<S extends Top> extends decodeTo<S, FormData> {
  * @category decoding
  * @since 4.0.0
  */
-export declare function fromFormData<S extends Top>(schema: S): fromFormData<S>;
+export declare function fromFormData<S extends Constraint>(schema: S): fromFormData<S>;
 /**
  * Type-level representation of {@link URLSearchParams}.
  *
@@ -7166,7 +7451,7 @@ export declare const URLSearchParams: URLSearchParams;
  * @category search params
  * @since 4.0.0
  */
-export interface fromURLSearchParams<S extends Top> extends decodeTo<S, URLSearchParams> {
+export interface fromURLSearchParams<S extends Constraint> extends decodeTo<S, URLSearchParams> {
     readonly "Rebuild": fromURLSearchParams<S>;
 }
 /**
@@ -7249,7 +7534,7 @@ export interface fromURLSearchParams<S extends Top> extends decodeTo<S, URLSearc
  * @category decoding
  * @since 4.0.0
  */
-export declare function fromURLSearchParams<S extends Top>(schema: S): fromURLSearchParams<S>;
+export declare function fromURLSearchParams<S extends Constraint>(schema: S): fromURLSearchParams<S>;
 /**
  * Type-level representation of {@link Finite}.
  *
@@ -7966,9 +8251,16 @@ export declare const DateTimeZonedFromString: DateTimeZonedFromString;
  * @category models
  * @since 3.10.0
  */
-export interface Class<Self, S extends Top & {
+export interface Class<Self, S extends Constraint & {
     readonly fields: Struct.Fields;
-}, Inherited> extends Bottom<Self, S["Encoded"], S["DecodingServices"], S["EncodingServices"], SchemaAST.Declaration, decodeTo<declareConstructor<Self, S["Encoded"], readonly [S], S["Iso"]>, S>, RequiredKeys<S["~type.make.in"]> extends never ? void | S["~type.make.in"] : S["~type.make.in"], S["Iso"], readonly [S], Self, S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+}, Inherited> extends BottomLazy<SchemaAST.Declaration, decodeTo<declareConstructor<Self, S["Encoded"], readonly [S], S["Iso"]>, S>, readonly [S], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+    readonly "Type": Self;
+    readonly "Encoded": S["Encoded"];
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": RequiredKeys<S["~type.make.in"]> extends never ? void | S["~type.make.in"] : S["~type.make.in"];
+    readonly "~type.make": Self;
+    readonly "Iso": S["Iso"];
     new (...args: {} extends S["~type.make.in"] ? [props?: S["~type.make.in"], options?: MakeOptions] : [props: S["~type.make.in"], options?: MakeOptions]): S["Type"] & Inherited;
     readonly identifier: string;
     readonly fields: S["fields"];
@@ -8626,7 +8918,7 @@ export type LazyArbitrary<T> = (fc: typeof FastCheck) => FastCheck.Arbitrary<T>;
  * @category Arbitrary
  * @since 4.0.0
  */
-export declare function toArbitraryLazy<S extends Top>(schema: S): LazyArbitrary<S["Type"]>;
+export declare function toArbitraryLazy<S extends Constraint>(schema: S): LazyArbitrary<S["Type"]>;
 /**
  * Derives a `fast-check` `Arbitrary` from a schema for property-based
  * testing. The derived arbitrary generates values that satisfy the schema.
@@ -8656,8 +8948,8 @@ export declare function toArbitraryLazy<S extends Top>(schema: S): LazyArbitrary
  * @category Arbitrary
  * @since 4.0.0
  */
-export declare function toArbitrary<S extends Top>(schema: S): FastCheck.Arbitrary<S["Type"]>;
-export declare function toArbitrary<S extends Top>(schema: S, options: {
+export declare function toArbitrary<S extends Constraint>(schema: S): FastCheck.Arbitrary<S["Type"]>;
+export declare function toArbitrary<S extends Constraint>(schema: S, options: {
     readonly report: true;
 }): Annotations.ToArbitrary.WithReport<FastCheck.Arbitrary<S["Type"]>>;
 /**
@@ -8686,9 +8978,9 @@ export declare function overrideToFormatter<S extends Top>(toFormatter: () => Fo
  * @category Formatter
  * @since 4.0.0
  */
-export declare function toFormatter<T>(schema: Schema<T>, options?: {
+export declare function toFormatter<S extends Constraint>(schema: S, options?: {
     readonly onBefore?: ((ast: SchemaAST.AST, recur: (ast: SchemaAST.AST) => Formatter<any>) => Formatter<any> | undefined) | undefined;
-}): Formatter<T>;
+}): Formatter<S["Type"]>;
 /**
  * Overrides the equivalence derivation for a schema by supplying a custom
  * `Equivalence`.
@@ -8730,7 +9022,7 @@ export declare function toEquivalence<T>(schema: Schema<T>): Equivalence.Equival
  * @category Representation
  * @since 4.0.0
  */
-export declare function toRepresentation(schema: Top): SchemaRepresentation.Document;
+export declare function toRepresentation(schema: Constraint): SchemaRepresentation.Document;
 /**
  * Options for {@link toJsonSchemaDocument}.
  *
@@ -8823,7 +9115,22 @@ export interface ToJsonSchemaOptions {
  * @category converting
  * @since 4.0.0
  */
-export declare function toJsonSchemaDocument(schema: Top, options?: ToJsonSchemaOptions): JsonSchema.Document<"draft-2020-12">;
+export declare function toJsonSchemaDocument(schema: Constraint, options?: ToJsonSchemaOptions): JsonSchema.Document<"draft-2020-12">;
+/**
+ * Type-level representation returned by {@link toCodecJson}.
+ *
+ * @category Canonical Codecs
+ * @since 4.0.0
+ */
+export interface toCodecJson<S extends Constraint> extends BottomLazy<S["ast"], toCodecJson<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+    readonly "Type": S["Type"];
+    readonly "Encoded": Json;
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": S["~type.make.in"];
+    readonly "~type.make": S["~type.make"];
+    readonly "Iso": S["Iso"];
+}
 /**
  * Derives a canonical JSON codec from a schema. The encoded form is `Json`, and
  * decoding produces the schema's `Type`.
@@ -8831,7 +9138,7 @@ export declare function toJsonSchemaDocument(schema: Top, options?: ToJsonSchema
  * @category Canonical Codecs
  * @since 4.0.0
  */
-export declare function toCodecJson<T, E, RD, RE>(schema: Codec<T, E, RD, RE>): Codec<T, Json, RD, RE>;
+export declare function toCodecJson<S extends Constraint>(schema: S): toCodecJson<S>;
 /**
  * Derives an isomorphism codec from a schema. The encoded form is the
  * schema's `Iso` type — the intermediate representation used for round-tripping.
@@ -8839,7 +9146,7 @@ export declare function toCodecJson<T, E, RD, RE>(schema: Codec<T, E, RD, RE>):
  * @category Canonical Codecs
  * @since 4.0.0
  */
-export declare function toCodecIso<S extends Top>(schema: S): Codec<S["Type"], S["Iso"]>;
+export declare function toCodecIso<S extends Constraint>(schema: S): Codec<S["Type"], S["Iso"]>;
 /**
  * A {@link Tree} of `string | undefined` nodes. Leaf values are either a
  * string representation or `undefined` for opaque/declaration types.
@@ -8848,6 +9155,21 @@ export declare function toCodecIso<S extends Top>(schema: S): Codec<S["Type"], S
  * @since 4.0.0
  */
 export type StringTree = Tree<string | undefined>;
+/**
+ * Type-level representation returned by {@link toCodecStringTree}.
+ *
+ * @category Canonical Codecs
+ * @since 4.0.0
+ */
+export interface toCodecStringTree<S extends Constraint> extends BottomLazy<S["ast"], toCodecStringTree<S>, ReadonlyArray<Constraint>, S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+    readonly "Type": S["Type"];
+    readonly "Encoded": StringTree;
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": S["~type.make.in"];
+    readonly "~type.make": S["~type.make"];
+    readonly "Iso": S["Iso"];
+}
 /**
  * Converts a schema to the StringTree canonical codec, where every leaf value
  * becomes a string while preserving the original structure.
@@ -8857,21 +9179,44 @@ export type StringTree = Tree<string | undefined>;
  * Declarations are converted to `undefined` (unless they have a
  * `toCodecJson` or `toCodec` annotation).
  *
- * Options:
+ * @category Canonical Codecs
+ * @since 4.0.0
+ */
+export declare function toCodecStringTree<S extends Constraint>(schema: S): toCodecStringTree<S>;
+/**
+ * Type-level representation returned by {@link toCodecArrayFromSingle}.
  *
- * - `keepDeclarations`: if `true`, it **does not** convert declarations to
- *   `undefined` but instead keeps them as they are (unless they have a
- *   `toCodecJson` or `toCodec` annotation).
+ * @category Canonical Codecs
+ * @since 4.0.0
+ */
+export interface toCodecArrayFromSingle<S extends Constraint> extends BottomLazy<S["ast"], toCodecArrayFromSingle<S>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+    readonly "Type": S["Type"];
+    readonly "Encoded": S["Encoded"];
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": S["~type.make.in"];
+    readonly "~type.make": S["~type.make"];
+    readonly "Iso": S["Iso"];
+}
+/**
+ * Allows array schemas to decode from either an array input or a single value
+ * input.
  *
- *    Defaults to `false`.
+ * **When to use**
+ *
+ * Use when you need to accept transport formats that may represent a
+ * single-item array as a bare value, such as query-string or form-data adapters.
+ *
+ * **Gotchas**
+ *
+ * This combinator is intentionally not part of `toCodecStringTree`; it adds a
+ * decoding convenience rather than a canonical StringTree representation. It
+ * does not parse comma-separated strings.
  *
  * @category Canonical Codecs
  * @since 4.0.0
  */
-export declare function toCodecStringTree<T, E, RD, RE>(schema: Codec<T, E, RD, RE>): Codec<T, StringTree, RD, RE>;
-export declare function toCodecStringTree<T, E, RD, RE>(schema: Codec<T, E, RD, RE>, options: {
-    readonly keepDeclarations: true;
-}): Codec<T, unknown, RD, RE>;
+export declare function toCodecArrayFromSingle<S extends Constraint>(schema: S): toCodecArrayFromSingle<S>;
 type XmlEncoderOptions = {
     /** Root element name for the returned XML string. Default: "root" */
     readonly rootName?: string | undefined;
@@ -8904,28 +9249,35 @@ export declare function toEncoderXml<T, E, RD, RE>(codec: Codec<T, E, RD, RE>, o
  * @category Optic
  * @since 4.0.0
  */
-export declare function toIso<S extends Top>(schema: S): Optic_.Iso<S["Type"], S["Iso"]>;
+export declare function toIso<S extends Constraint>(schema: S): Optic_.Iso<S["Type"], S["Iso"]>;
 /**
  * Returns an identity `Iso` over the schema's source (`Type`) side.
  *
  * @category Optic
  * @since 4.0.0
  */
-export declare function toIsoSource<S extends Top>(_: S): Optic_.Iso<S["Type"], S["Type"]>;
+export declare function toIsoSource<S extends Constraint>(_: S): Optic_.Iso<S["Type"], S["Type"]>;
 /**
  * Returns an identity `Iso` over the schema's focus (`Iso`) side.
  *
  * @category Optic
  * @since 4.0.0
  */
-export declare function toIsoFocus<S extends Top>(_: S): Optic_.Iso<S["Iso"], S["Iso"]>;
+export declare function toIsoFocus<S extends Constraint>(_: S): Optic_.Iso<S["Iso"], S["Iso"]>;
 /**
  * Type-level representation returned by {@link overrideToCodecIso}.
  *
  * @category Optic
  * @since 4.0.0
  */
-export interface overrideToCodecIso<S extends Top, Iso> extends Bottom<S["Type"], S["Encoded"], S["DecodingServices"], S["EncodingServices"], S["ast"], overrideToCodecIso<S, Iso>, S["~type.make.in"], Iso, S["~type.parameters"], S["~type.make"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+export interface overrideToCodecIso<S extends Constraint, Iso> extends BottomLazy<S["ast"], overrideToCodecIso<S, Iso>, S["~type.parameters"], S["~type.mutability"], S["~type.optionality"], S["~type.constructor.default"], S["~encoded.mutability"], S["~encoded.optionality"]> {
+    readonly "Type": S["Type"];
+    readonly "Encoded": S["Encoded"];
+    readonly "DecodingServices": S["DecodingServices"];
+    readonly "EncodingServices": S["EncodingServices"];
+    readonly "~type.make.in": S["~type.make.in"];
+    readonly "~type.make": S["~type.make"];
+    readonly "Iso": Iso;
     readonly schema: S;
 }
 /**
@@ -8945,7 +9297,7 @@ export interface overrideToCodecIso<S extends Top, Iso> extends Bottom<S["Type"]
  * @category Optic
  * @since 4.0.0
  */
-export declare function overrideToCodecIso<S extends Top, Iso>(to: Codec<Iso>, transformation: {
+export declare function overrideToCodecIso<S extends Constraint, Iso>(to: Codec<Iso>, transformation: {
     readonly decode: SchemaGetter.Getter<S["Type"], Iso>;
     readonly encode: SchemaGetter.Getter<Iso, S["Type"]>;
 }): (schema: S) => overrideToCodecIso<S, Iso>;
@@ -8984,7 +9336,7 @@ export interface TreeRecord<A> {
  * @category Tree
  * @since 4.0.0
  */
-export declare function Tree<S extends Top>(node: S): Union<readonly [S, $Array<suspend<Codec<Tree<S["Type"]>, Tree<S["Encoded"]>, S["DecodingServices"], S["EncodingServices"]>>>, $Record<String, suspend<Codec<Tree<S["Type"]>, Tree<S["Encoded"]>, S["DecodingServices"], S["EncodingServices"]>>>]>;
+export declare function Tree<S extends Constraint>(node: S): Union<readonly [S, $Array<suspend<Codec<Tree<S["Type"]>, Tree<S["Encoded"]>, S["DecodingServices"], S["EncodingServices"]>>>, $Record<String, suspend<Codec<Tree<S["Type"]>, Tree<S["Encoded"]>, S["DecodingServices"], S["EncodingServices"]>>>]>;
 /**
  * Recursive TypeScript type for any valid immutable JSON value: `null`,
  * `number`, `boolean`, `string`, a readonly array of `Json` values, or a
@@ -9070,7 +9422,7 @@ export declare const MutableJson: Codec<MutableJson>;
  * @category Schema Resolvers
  * @since 4.0.0
  */
-export declare function resolveAnnotations<S extends Top>(schema: S): Annotations.Bottom<S["Type"], S["~type.parameters"]> | undefined;
+export declare function resolveAnnotations<S extends Constraint>(schema: S): Annotations.Bottom<S["Type"], S["~type.parameters"]> | undefined;
 /**
  * Resolves the context (key-level) annotations from a schema. Context
  * annotations are those attached via `annotateKey` and live on the AST's
@@ -9079,7 +9431,7 @@ export declare function resolveAnnotations<S extends Top>(schema: S): Annotation
  * @category Schema Resolvers
  * @since 4.0.0
  */
-export declare function resolveAnnotationsKey<S extends Top>(schema: S): Annotations.Key<S["Type"]> | undefined;
+export declare function resolveAnnotationsKey<S extends Constraint>(schema: S): Annotations.Key<S["Type"]> | undefined;
 /**
  * The `Annotations` namespace groups all annotation interfaces used to attach
  * metadata to schemas. Annotations control documentation, validation messages,
@@ -9201,7 +9553,7 @@ export declare namespace Annotations {
      * @category models
      * @since 4.0.0
      */
-    interface Bottom<T, TypeParameters extends ReadonlyArray<Top>> extends Documentation<T> {
+    interface Bottom<T, TypeParameters extends ReadonlyArray<Constraint>> extends Documentation<T> {
         /**
          * Complete message to use when this schema node reports an issue.
          *
@@ -9258,7 +9610,7 @@ export declare namespace Annotations {
          * @category utility types
          * @since 4.0.0
          */
-        type Type<TypeParameters extends ReadonlyArray<Top>> = {
+        type Type<TypeParameters extends ReadonlyArray<Constraint>> = {
             readonly [K in keyof TypeParameters]: Codec<TypeParameters[K]["Type"]>;
         };
         /**
@@ -9267,7 +9619,7 @@ export declare namespace Annotations {
          * @category utility types
          * @since 4.0.0
          */
-        type Encoded<TypeParameters extends ReadonlyArray<Top>> = {
+        type Encoded<TypeParameters extends ReadonlyArray<Constraint>> = {
             readonly [K in keyof TypeParameters]: Codec<TypeParameters[K]["Encoded"]>;
         };
     }
@@ -9281,7 +9633,7 @@ export declare namespace Annotations {
      * @category models
      * @since 4.0.0
      */
-    interface Declaration<T, TypeParameters extends ReadonlyArray<Top> = readonly []> extends Bottom<T, TypeParameters> {
+    interface Declaration<T, TypeParameters extends ReadonlyArray<Constraint> = readonly []> extends Bottom<T, TypeParameters> {
         readonly toCodec?: ((typeParameters: TypeParameters.Encoded<TypeParameters>) => SchemaAST.Link) | undefined;
         readonly toCodecJson?: ((typeParameters: TypeParameters.Encoded<TypeParameters>) => SchemaAST.Link) | undefined;
         readonly toCodecIso?: ((typeParameters: TypeParameters.Type<TypeParameters>) => SchemaAST.Link) | undefined;
@@ -9376,7 +9728,7 @@ export declare namespace Annotations {
          * @since 4.0.0
          */
         interface Filter {
-            readonly constraint?: Constraint | undefined;
+            readonly constraint?: GenerationConstraint | undefined;
             readonly candidate?: Candidate | undefined;
         }
         /**
@@ -9422,10 +9774,10 @@ export declare namespace Annotations {
          *
          * **Details**
          *
-         * `Constraint` is a generation hint for the current schema AST node, not a
-         * self-describing validation contract. Each generator consumes the fields it
-         * understands for the current node and ignores the rest; final schema
-         * filters still validate every generated value.
+         * `GenerationConstraint` is a generation hint for the current schema AST
+         * node, not a self-describing validation contract. Each generator consumes
+         * the fields it understands for the current node and ignores the rest;
+         * final schema filters still validate every generated value.
          *
          * `minLength` and `maxLength` represent node-local cardinality: string
          * length for strings, array length for arrays, final own-property count for
@@ -9438,7 +9790,7 @@ export declare namespace Annotations {
          * @category models
          * @since 4.0.0
          */
-        interface Constraint {
+        interface GenerationConstraint {
             readonly minLength?: number | undefined;
             readonly maxLength?: number | undefined;
             readonly patterns?: readonly [string, ...Array<string>];
@@ -9479,7 +9831,7 @@ export declare namespace Annotations {
          * @since 4.0.0
          */
         interface Context {
-            readonly constraint?: ToArbitrary.Constraint | undefined;
+            readonly constraint?: ToArbitrary.GenerationConstraint | undefined;
             readonly recursion?: ToArbitrary.Recursion | undefined;
         }
         /**
@@ -9541,7 +9893,7 @@ export declare namespace Annotations {
          * @category models
          * @since 4.0.0
          */
-        interface Declaration<T, TypeParameters extends ReadonlyArray<Top>> {
+        interface Declaration<T, TypeParameters extends ReadonlyArray<Constraint>> {
             (typeParameters: {
                 readonly [K in keyof TypeParameters]: TypeParameter<TypeParameters[K]["Type"]>;
             }): (fc: typeof FastCheck, context: Context) => Output<T>;
@@ -9612,7 +9964,7 @@ export declare namespace Annotations {
          * @category models
          * @since 4.0.0
          */
-        interface Declaration<T, TypeParameters extends ReadonlyArray<Top>> {
+        interface Declaration<T, TypeParameters extends ReadonlyArray<Constraint>> {
             (typeParameters: {
                 readonly [K in keyof TypeParameters]: Formatter<TypeParameters[K]["Type"]>;
             }): Formatter<T>;
@@ -9635,7 +9987,7 @@ export declare namespace Annotations {
          * @category models
          * @since 4.0.0
          */
-        interface Declaration<T, TypeParameters extends ReadonlyArray<Top>> {
+        interface Declaration<T, TypeParameters extends ReadonlyArray<Constraint>> {
             (typeParameters: {
                 readonly [K in keyof TypeParameters]: Equivalence.Equivalence<TypeParameters[K]["Type"]>;
             }): Equivalence.Equivalence<T>;