effect 3.13.2 → 3.13.4

package/dist/esm/Schema.js

@@ -34,7 +34,6 @@ import * as option_ from "./Option.js";
 import * as ParseResult from "./ParseResult.js";
 import { pipeArguments } from "./Pipeable.js";
 import * as Predicate from "./Predicate.js";
-import * as record_ from "./Record.js";
 import * as redacted_ from "./Redacted.js";
 import * as Request from "./Request.js";
 import * as scheduler_ from "./Scheduler.js";
@@ -51,23 +50,25 @@ export const TypeId = /*#__PURE__*/Symbol.for("effect/Schema");
  * @category constructors
  * @since 3.10.0
  */
-export const make = ast => class SchemaClass {
-  [TypeId] = variance;
-  static ast = ast;
-  static annotations(annotations) {
-    return make(mergeSchemaAnnotations(this.ast, annotations));
-  }
-  static pipe() {
-    return pipeArguments(this, arguments);
-  }
-  static toString() {
-    return String(ast);
-  }
-  static Type;
-  static Encoded;
-  static Context;
-  static [TypeId] = variance;
-};
+export function make(ast) {
+  return class SchemaClass {
+    [TypeId] = variance;
+    static ast = ast;
+    static annotations(annotations) {
+      return make(mergeSchemaAnnotations(this.ast, annotations));
+    }
+    static pipe() {
+      return pipeArguments(this, arguments);
+    }
+    static toString() {
+      return String(ast);
+    }
+    static Type;
+    static Encoded;
+    static Context;
+    static [TypeId] = variance;
+  };
+}
 const variance = {
   /* c8 ignore next */
   _A: _ => _,
@@ -186,7 +187,9 @@ const mergeSchemaAnnotations = (ast, annotations) => AST.annotations(ast, toASTA
 /**
  * @since 3.10.0
  */
-export const asSchema = schema => schema;
+export function asSchema(schema) {
+  return schema;
+}
 /**
  * @category formatting
  * @since 3.10.0
@@ -399,13 +402,17 @@ export const validatePromise = (schema, options) => {
  * @since 3.10.0
  */
 export const isSchema = u => Predicate.hasProperty(u, TypeId) && Predicate.isObject(u[TypeId]);
-const getDefaultLiteralAST = literals => AST.isMembers(literals) ? AST.Union.make(AST.mapMembers(literals, literal => new AST.Literal(literal))) : new AST.Literal(literals[0]);
-const makeLiteralClass = (literals, ast = getDefaultLiteralAST(literals)) => class LiteralClass extends make(ast) {
-  static annotations(annotations) {
-    return makeLiteralClass(this.literals, mergeSchemaAnnotations(this.ast, annotations));
-  }
-  static literals = [...literals];
-};
+function getDefaultLiteralAST(literals) {
+  return AST.isMembers(literals) ? AST.Union.make(AST.mapMembers(literals, literal => new AST.Literal(literal))) : new AST.Literal(literals[0]);
+}
+function makeLiteralClass(literals, ast = getDefaultLiteralAST(literals)) {
+  return class LiteralClass extends make(ast) {
+    static annotations(annotations) {
+      return makeLiteralClass(this.literals, mergeSchemaAnnotations(this.ast, annotations));
+    }
+    static literals = [...literals];
+  };
+}
 export function Literal(...literals) {
   return array_.isNonEmptyReadonlyArray(literals) ? makeLiteralClass(literals) : Never;
 }
@@ -560,21 +567,29 @@ export const TemplateLiteralParser = (...params) => {
   }
   return class TemplateLiteralParserClass extends transformOrFail(from, to, {
     strict: false,
-    decode: (s, _, ast) => {
-      const match = re.exec(s);
-      return match ? ParseResult.succeed(match.slice(1, params.length + 1)) : ParseResult.fail(new ParseResult.Type(ast, s, `${re.source}: no match for ${JSON.stringify(s)}`));
+    decode: (i, _, ast) => {
+      const match = re.exec(i);
+      return match ? ParseResult.succeed(match.slice(1, params.length + 1)) : ParseResult.fail(new ParseResult.Type(ast, i, `${re.source}: no match for ${JSON.stringify(i)}`));
     },
     encode: tuple => ParseResult.succeed(tuple.join(""))
   }) {
     static params = params.slice();
   };
 };
-const declareConstructor = (typeParameters, options, annotations) => make(new AST.Declaration(typeParameters.map(tp => tp.ast), (...typeParameters) => options.decode(...typeParameters.map(make)), (...typeParameters) => options.encode(...typeParameters.map(make)), toASTAnnotations(annotations)));
+const declareConstructor = (typeParameters, options, annotations) => makeDeclareClass(typeParameters, new AST.Declaration(typeParameters.map(tp => tp.ast), (...typeParameters) => options.decode(...typeParameters.map(make)), (...typeParameters) => options.encode(...typeParameters.map(make)), toASTAnnotations(annotations)));
 const declarePrimitive = (is, annotations) => {
   const decodeUnknown = () => (input, _, ast) => is(input) ? ParseResult.succeed(input) : ParseResult.fail(new ParseResult.Type(ast, input));
   const encodeUnknown = decodeUnknown;
-  return make(new AST.Declaration([], decodeUnknown, encodeUnknown, toASTAnnotations(annotations)));
+  return makeDeclareClass([], new AST.Declaration([], decodeUnknown, encodeUnknown, toASTAnnotations(annotations)));
 };
+function makeDeclareClass(typeParameters, ast) {
+  return class DeclareClass extends make(ast) {
+    static annotations(annotations) {
+      return makeDeclareClass(this.typeParameters, mergeSchemaAnnotations(this.ast, annotations));
+    }
+    static typeParameters = [...typeParameters];
+  };
+}
 /**
  * The constraint `R extends Schema.Context<P[number]>` enforces dependencies solely from `typeParameters`.
  * This ensures that when you call `Schema.to` or `Schema.from`, you receive a schema with a `never` context.
@@ -602,16 +617,19 @@ export const BrandSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Brand");
  * @category constructors
  * @since 3.10.0
  */
-export const fromBrand = (constructor, annotations) => self => makeBrandClass(new AST.Refinement(self.ast, function predicate(a, _, ast) {
-  const either = constructor.either(a);
-  return either_.isLeft(either) ? option_.some(new ParseResult.Type(ast, a, either.left.map(v => v.message).join(", "))) : option_.none();
-}, toASTAnnotations({
-  schemaId: BrandSchemaId,
-  [BrandSchemaId]: {
-    constructor
-  },
-  ...annotations
-})));
+export const fromBrand = (constructor, annotations) => self => {
+  const out = makeBrandClass(self, new AST.Refinement(self.ast, function predicate(a, _, ast) {
+    const either = constructor.either(a);
+    return either_.isLeft(either) ? option_.some(new ParseResult.Type(ast, a, either.left.map(v => v.message).join(", "))) : option_.none();
+  }, toASTAnnotations({
+    schemaId: BrandSchemaId,
+    [BrandSchemaId]: {
+      constructor
+    },
+    ...annotations
+  })));
+  return out;
+};
 /**
  * @category schema id
  * @since 3.10.0
@@ -701,12 +719,14 @@ Object$ as Object,
  */
 String$ as String };
 const getDefaultUnionAST = members => AST.Union.make(members.map(m => m.ast));
-const makeUnionClass = (members, ast = getDefaultUnionAST(members)) => class UnionClass extends make(ast) {
-  static annotations(annotations) {
-    return makeUnionClass(this.members, mergeSchemaAnnotations(this.ast, annotations));
-  }
-  static members = [...members];
-};
+function makeUnionClass(members, ast = getDefaultUnionAST(members)) {
+  return class UnionClass extends make(ast) {
+    static annotations(annotations) {
+      return makeUnionClass(this.members, mergeSchemaAnnotations(this.ast, annotations));
+    }
+    static members = [...members];
+  };
+}
 export function Union(...members) {
   return AST.isMembers(members) ? makeUnionClass(members) : array_.isNonEmptyReadonlyArray(members) ? members[0] : Never;
 }
@@ -758,22 +778,26 @@ class ElementImpl {
   }
 }
 const getDefaultTupleTypeAST = (elements, rest) => new AST.TupleType(elements.map(el => isSchema(el) ? new AST.OptionalType(el.ast, false) : el.ast), rest.map(el => isSchema(el) ? new AST.Type(el.ast) : el.ast), true);
-const makeTupleTypeClass = (elements, rest, ast = getDefaultTupleTypeAST(elements, rest)) => class TupleTypeClass extends make(ast) {
-  static annotations(annotations) {
-    return makeTupleTypeClass(this.elements, this.rest, mergeSchemaAnnotations(this.ast, annotations));
-  }
-  static elements = [...elements];
-  static rest = [...rest];
-};
+function makeTupleTypeClass(elements, rest, ast = getDefaultTupleTypeAST(elements, rest)) {
+  return class TupleTypeClass extends make(ast) {
+    static annotations(annotations) {
+      return makeTupleTypeClass(this.elements, this.rest, mergeSchemaAnnotations(this.ast, annotations));
+    }
+    static elements = [...elements];
+    static rest = [...rest];
+  };
+}
 export function Tuple(...args) {
   return Array.isArray(args[0]) ? makeTupleTypeClass(args[0], args.slice(1)) : makeTupleTypeClass(args, []);
 }
-const makeArrayClass = (value, ast) => class ArrayClass extends makeTupleTypeClass([], [value], ast) {
-  static annotations(annotations) {
-    return makeArrayClass(this.value, mergeSchemaAnnotations(this.ast, annotations));
-  }
-  static value = value;
-};
+function makeArrayClass(value, ast) {
+  return class ArrayClass extends makeTupleTypeClass([], [value], ast) {
+    static annotations(annotations) {
+      return makeArrayClass(this.value, mergeSchemaAnnotations(this.ast, annotations));
+    }
+    static value = value;
+  };
+}
 const Array$ = value => makeArrayClass(value);
 export {
 /**
@@ -781,12 +805,14 @@ export {
  * @since 3.10.0
  */
 Array$ as Array };
-const makeNonEmptyArrayClass = (value, ast) => class NonEmptyArrayClass extends makeTupleTypeClass([value], [value], ast) {
-  static annotations(annotations) {
-    return makeNonEmptyArrayClass(this.value, mergeSchemaAnnotations(this.ast, annotations));
-  }
-  static value = value;
-};
+function makeNonEmptyArrayClass(value, ast) {
+  return class NonEmptyArrayClass extends makeTupleTypeClass([value], [value], ast) {
+    static annotations(annotations) {
+      return makeNonEmptyArrayClass(this.value, mergeSchemaAnnotations(this.ast, annotations));
+    }
+    static value = value;
+  };
+}
 /**
  * @category constructors
  * @since 3.10.0
@@ -796,26 +822,24 @@ export const NonEmptyArray = value => makeNonEmptyArrayClass(value);
  * @category constructors
  * @since 3.10.0
  */
-export const ArrayEnsure = value => {
-  const value_ = asSchema(value);
-  return class ArrayEnsureClass extends transform(Union(value_, Array$(value_)), Array$(typeSchema(value_)), {
+export function ArrayEnsure(value) {
+  return transform(Union(value, Array$(value)), Array$(typeSchema(asSchema(value))), {
     strict: true,
-    decode: array_.ensure,
-    encode: arr => arr.length === 1 ? arr[0] : arr
-  }) {};
-};
+    decode: i => array_.ensure(i),
+    encode: a => a.length === 1 ? a[0] : a
+  });
+}
 /**
  * @category constructors
  * @since 3.10.0
  */
-export const NonEmptyArrayEnsure = value => {
-  const value_ = asSchema(value);
-  return class NonEmptyArrayEnsureClass extends transform(Union(value_, NonEmptyArray(value_)), NonEmptyArray(typeSchema(value_)), {
+export function NonEmptyArrayEnsure(value) {
+  return transform(Union(value, NonEmptyArray(value)), NonEmptyArray(typeSchema(asSchema(value))), {
     strict: true,
-    decode: array_.ensure,
-    encode: arr => arr.length === 1 ? arr[0] : arr
-  }) {};
-};
+    decode: i => array_.isNonEmptyReadonlyArray(i) ? i : array_.of(i),
+    encode: a => a.length === 1 ? a[0] : a
+  });
+}
 const formatPropertySignatureToken = isOptional => isOptional ? "\"?:\"" : "\":\"";
 /**
  * @category PropertySignature
@@ -1402,22 +1426,26 @@ export const omit = (...keys) => self => make(AST.omit(self.ast, keys));
 export const pluck = /*#__PURE__*/dual(2, (schema, key) => {
   const ps = AST.getPropertyKeyIndexedAccess(AST.typeAST(schema.ast), key);
   const value = make(ps.isOptional ? AST.orUndefined(ps.type) : ps.type);
-  return transform(schema.pipe(pick(key)), value, {
+  const out = transform(schema.pipe(pick(key)), value, {
     strict: true,
-    decode: a => a[key],
-    encode: ak => ps.isOptional && ak === undefined ? {} : {
-      [key]: ak
+    decode: i => i[key],
+    encode: a => ps.isOptional && a === undefined ? {} : {
+      [key]: a
     }
   });
+  return out;
 });
-const makeBrandClass = ast => class BrandClass extends make(ast) {
-  static annotations(annotations) {
-    return makeBrandClass(mergeSchemaAnnotations(this.ast, annotations));
-  }
-  static make = (a, options) => {
-    return getDisableValidationMakeOption(options) ? a : ParseResult.validateSync(this)(a);
+function makeBrandClass(from, ast) {
+  return class BrandClass extends make(ast) {
+    static annotations(annotations) {
+      return makeBrandClass(this.from, mergeSchemaAnnotations(this.ast, annotations));
+    }
+    static make = (a, options) => {
+      return getDisableValidationMakeOption(options) ? a : ParseResult.validateSync(this)(a);
+    };
+    static from = from;
   };
-};
+}
 /**
  * Returns a nominal branded schema by applying a brand to a given schema.
  *
@@ -1448,7 +1476,7 @@ export const brand = (brand, annotations) => self => {
     [AST.BrandAnnotationId]: annotation,
     ...annotations
   }));
-  return makeBrandClass(ast);
+  return makeBrandClass(self, ast);
 };
 /**
  * @category combinators
@@ -1647,7 +1675,7 @@ export const extend = /*#__PURE__*/dual(2, (self, that) => make(extendAST(self.a
  * @category combinators
  * @since 3.10.0
  */
-export const compose = /*#__PURE__*/dual(args => isSchema(args[1]), (from, to) => make(AST.compose(from.ast, to.ast)));
+export const compose = /*#__PURE__*/dual(args => isSchema(args[1]), (from, to) => makeTransformationClass(from, to, AST.compose(from.ast, to.ast)));
 /**
  * @category constructors
  * @since 3.10.0
@@ -1658,17 +1686,19 @@ export const suspend = f => make(new AST.Suspend(() => f().ast));
  * @category symbol
  */
 export const RefineSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Refine");
-const makeRefineClass = (from, filter, ast) => class RefineClass extends make(ast) {
-  static annotations(annotations) {
-    return makeRefineClass(this.from, this.filter, mergeSchemaAnnotations(this.ast, annotations));
-  }
-  static [RefineSchemaId] = from;
-  static from = from;
-  static filter = filter;
-  static make = (a, options) => {
-    return getDisableValidationMakeOption(options) ? a : ParseResult.validateSync(this)(a);
+function makeRefineClass(from, filter, ast) {
+  return class RefineClass extends make(ast) {
+    static annotations(annotations) {
+      return makeRefineClass(this.from, this.filter, mergeSchemaAnnotations(this.ast, annotations));
+    }
+    static [RefineSchemaId] = from;
+    static from = from;
+    static filter = filter;
+    static make = (a, options) => {
+      return getDisableValidationMakeOption(options) ? a : ParseResult.validateSync(this)(a);
+    };
   };
-};
+}
 const fromFilterPredicateReturnTypeItem = (item, ast, input) => {
   if (Predicate.isBoolean(item)) {
     return item ? option_.none() : option_.some(new ParseResult.Type(ast, input));
@@ -1712,19 +1742,21 @@ export function filter(predicate, annotations) {
  */
 export const filterEffect = /*#__PURE__*/dual(2, (self, f) => transformOrFail(self, typeSchema(self), {
   strict: true,
-  decode: (a, options, ast) => ParseResult.flatMap(f(a, options, ast), filterReturnType => option_.match(toFilterParseIssue(filterReturnType, ast, a), {
-    onNone: () => ParseResult.succeed(a),
+  decode: (i, options, ast) => ParseResult.flatMap(f(i, options, ast), filterReturnType => option_.match(toFilterParseIssue(filterReturnType, ast, i), {
+    onNone: () => ParseResult.succeed(i),
     onSome: ParseResult.fail
   })),
-  encode: ParseResult.succeed
+  encode: a => ParseResult.succeed(a)
 }));
-const makeTransformationClass = (from, to, ast) => class TransformationClass extends make(ast) {
-  static annotations(annotations) {
-    return makeTransformationClass(this.from, this.to, mergeSchemaAnnotations(this.ast, annotations));
-  }
-  static from = from;
-  static to = to;
-};
+function makeTransformationClass(from, to, ast) {
+  return class TransformationClass extends make(ast) {
+    static annotations(annotations) {
+      return makeTransformationClass(this.from, this.to, mergeSchemaAnnotations(this.ast, annotations));
+    }
+    static from = from;
+    static to = to;
+  };
+}
 /**
  * Create a new `Schema` by transforming the input and output of an existing `Schema`
  * using the provided decoding functions.
@@ -1760,11 +1792,13 @@ export const transform = /*#__PURE__*/dual(args => isSchema(args[0]) && isSchema
  * @category constructors
  * @since 3.10.0
  */
-export const transformLiteral = (from, to) => transform(Literal(from), Literal(to), {
-  strict: true,
-  decode: () => to,
-  encode: () => from
-});
+export function transformLiteral(from, to) {
+  return transform(Literal(from), Literal(to), {
+    strict: true,
+    decode: () => to,
+    encode: () => from
+  });
+}
 export function transformLiterals(...pairs) {
   return Union(...pairs.map(([from, to]) => transformLiteral(from, to)));
 }
@@ -1876,6 +1910,41 @@ export const minLength = (minLength, annotations) => self => self.pipe(filter(a
   },
   ...annotations
 }));
+/**
+ * @category schema id
+ * @since 3.10.0
+ */
+export const LengthSchemaId = schemaId_.LengthSchemaId;
+/**
+ * @category string filters
+ * @since 3.10.0
+ */
+export const length = (length, annotations) => self => {
+  const minLength = Predicate.isObject(length) ? Math.max(0, Math.floor(length.min)) : Math.max(0, Math.floor(length));
+  const maxLength = Predicate.isObject(length) ? Math.max(minLength, Math.floor(length.max)) : minLength;
+  if (minLength !== maxLength) {
+    return self.pipe(filter(a => a.length >= minLength && a.length <= maxLength, {
+      schemaId: LengthSchemaId,
+      title: `length({ min: ${minLength}, max: ${maxLength})`,
+      description: `a string at least ${minLength} character(s) and at most ${maxLength} character(s) long`,
+      jsonSchema: {
+        minLength,
+        maxLength
+      },
+      ...annotations
+    }));
+  }
+  return self.pipe(filter(a => a.length === minLength, {
+    schemaId: LengthSchemaId,
+    title: `length(${minLength})`,
+    description: minLength === 1 ? `a single character` : `a string ${minLength} character(s) long`,
+    jsonSchema: {
+      minLength,
+      maxLength: minLength
+    },
+    ...annotations
+  }));
+};
 /**
  * @category schema id
  * @since 3.10.0
@@ -2007,19 +2076,19 @@ export class Lowercased extends /*#__PURE__*/String$.pipe( /*#__PURE__*/lowercas
  * @category schema id
  * @since 3.10.0
  */
-export const CapitalizedSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Capitalized");
+export const UppercasedSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Uppercased");
 /**
- * Verifies that a string is capitalized.
+ * Verifies that a string is uppercased.
  *
  * @category string filters
  * @since 3.10.0
  */
-export const capitalized = annotations => self => self.pipe(filter(a => a[0]?.toUpperCase() === a[0], {
-  schemaId: CapitalizedSchemaId,
-  title: "capitalized",
-  description: "a capitalized string",
+export const uppercased = annotations => self => self.pipe(filter(a => a === a.toUpperCase(), {
+  schemaId: UppercasedSchemaId,
+  title: "uppercased",
+  description: "an uppercase string",
   jsonSchema: {
-    pattern: "^[^a-z]?.*$"
+    pattern: "^[^a-z]*$"
   },
   ...annotations
 }));
@@ -2027,26 +2096,26 @@ export const capitalized = annotations => self => self.pipe(filter(a => a[0]?.to
  * @category string constructors
  * @since 3.10.0
  */
-export class Capitalized extends /*#__PURE__*/String$.pipe( /*#__PURE__*/capitalized({
-  identifier: "Capitalized"
+export class Uppercased extends /*#__PURE__*/String$.pipe( /*#__PURE__*/uppercased({
+  identifier: "Uppercased"
 })) {}
 /**
  * @category schema id
  * @since 3.10.0
  */
-export const UncapitalizedSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Uncapitalized");
+export const CapitalizedSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Capitalized");
 /**
- * Verifies that a string is uncapitalized.
+ * Verifies that a string is capitalized.
  *
  * @category string filters
  * @since 3.10.0
  */
-export const uncapitalized = annotations => self => self.pipe(filter(a => a[0]?.toLowerCase() === a[0], {
-  schemaId: UncapitalizedSchemaId,
-  title: "uncapitalized",
-  description: "a uncapitalized string",
+export const capitalized = annotations => self => self.pipe(filter(a => a[0]?.toUpperCase() === a[0], {
+  schemaId: CapitalizedSchemaId,
+  title: "capitalized",
+  description: "a capitalized string",
   jsonSchema: {
-    pattern: "^[^A-Z]?.*$"
+    pattern: "^[^a-z]?.*$"
   },
   ...annotations
 }));
@@ -2054,26 +2123,26 @@ export const uncapitalized = annotations => self => self.pipe(filter(a => a[0]?.
  * @category string constructors
  * @since 3.10.0
  */
-export class Uncapitalized extends /*#__PURE__*/String$.pipe( /*#__PURE__*/uncapitalized({
-  identifier: "Uncapitalized"
+export class Capitalized extends /*#__PURE__*/String$.pipe( /*#__PURE__*/capitalized({
+  identifier: "Capitalized"
 })) {}
 /**
  * @category schema id
  * @since 3.10.0
  */
-export const UppercasedSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Uppercased");
+export const UncapitalizedSchemaId = /*#__PURE__*/Symbol.for("effect/SchemaId/Uncapitalized");
 /**
- * Verifies that a string is uppercased.
+ * Verifies that a string is uncapitalized.
  *
  * @category string filters
  * @since 3.10.0
  */
-export const uppercased = annotations => self => self.pipe(filter(a => a === a.toUpperCase(), {
-  schemaId: UppercasedSchemaId,
-  title: "uppercased",
-  description: "an uppercase string",
+export const uncapitalized = annotations => self => self.pipe(filter(a => a[0]?.toLowerCase() === a[0], {
+  schemaId: UncapitalizedSchemaId,
+  title: "uncapitalized",
+  description: "a uncapitalized string",
   jsonSchema: {
-    pattern: "^[^a-z]*$"
+    pattern: "^[^A-Z]?.*$"
   },
   ...annotations
 }));
@@ -2081,44 +2150,9 @@ export const uppercased = annotations => self => self.pipe(filter(a => a === a.t
  * @category string constructors
  * @since 3.10.0
  */
-export class Uppercased extends /*#__PURE__*/String$.pipe( /*#__PURE__*/uppercased({
-  identifier: "Uppercased"
+export class Uncapitalized extends /*#__PURE__*/String$.pipe( /*#__PURE__*/uncapitalized({
+  identifier: "Uncapitalized"
 })) {}
-/**
- * @category schema id
- * @since 3.10.0
- */
-export const LengthSchemaId = schemaId_.LengthSchemaId;
-/**
- * @category string filters
- * @since 3.10.0
- */
-export const length = (length, annotations) => self => {
-  const minLength = Predicate.isObject(length) ? Math.max(0, Math.floor(length.min)) : Math.max(0, Math.floor(length));
-  const maxLength = Predicate.isObject(length) ? Math.max(minLength, Math.floor(length.max)) : minLength;
-  if (minLength !== maxLength) {
-    return self.pipe(filter(a => a.length >= minLength && a.length <= maxLength, {
-      schemaId: LengthSchemaId,
-      title: `length({ min: ${minLength}, max: ${maxLength})`,
-      description: `a string at least ${minLength} character(s) and at most ${maxLength} character(s) long`,
-      jsonSchema: {
-        minLength,
-        maxLength
-      },
-      ...annotations
-    }));
-  }
-  return self.pipe(filter(a => a.length === minLength, {
-    schemaId: LengthSchemaId,
-    title: `length(${minLength})`,
-    description: minLength === 1 ? `a single character` : `a string ${minLength} character(s) long`,
-    jsonSchema: {
-      minLength,
-      maxLength: minLength
-    },
-    ...annotations
-  }));
-};
 /**
  * A schema representing a single character.
  *
@@ -2147,7 +2181,7 @@ export class Lowercase extends /*#__PURE__*/transform(String$.annotations({
   description: "a string that will be converted to lowercase"
 }), Lowercased, {
   strict: true,
-  decode: s => s.toLowerCase(),
+  decode: i => i.toLowerCase(),
   encode: identity
 }).annotations({
   identifier: "Lowercase"
@@ -2162,7 +2196,7 @@ export class Uppercase extends /*#__PURE__*/transform(String$.annotations({
   description: "a string that will be converted to uppercase"
 }), Uppercased, {
   strict: true,
-  decode: s => s.toUpperCase(),
+  decode: i => i.toUpperCase(),
   encode: identity
 }).annotations({
   identifier: "Uppercase"
@@ -2177,7 +2211,7 @@ export class Capitalize extends /*#__PURE__*/transform(String$.annotations({
   description: "a string that will be converted to a capitalized format"
 }), Capitalized, {
   strict: true,
-  decode: s => string_.capitalize(s),
+  decode: i => string_.capitalize(i),
   encode: identity
 }).annotations({
   identifier: "Capitalize"
@@ -2192,7 +2226,7 @@ export class Uncapitalize extends /*#__PURE__*/transform(String$.annotations({
   description: "a string that will be converted to an uncapitalized format"
 }), Uncapitalized, {
   strict: true,
-  decode: s => string_.uncapitalize(s),
+  decode: i => string_.uncapitalize(i),
   encode: identity
 }).annotations({
   identifier: "Uncapitalize"
@@ -2233,7 +2267,7 @@ export class Trim extends /*#__PURE__*/transform(String$.annotations({
   description: "a string that will be trimmed"
 }), Trimmed, {
   strict: true,
-  decode: s => s.trim(),
+  decode: i => i.trim(),
   encode: identity
 }).annotations({
   identifier: "Trim"
@@ -2248,21 +2282,21 @@ export const split = separator => transform(String$.annotations({
   description: "a string that will be split"
 }), Array$(String$), {
   strict: true,
-  decode: string_.split(separator),
-  encode: array_.join(separator)
+  decode: i => i.split(separator),
+  encode: a => a.join(separator)
 });
 const getErrorMessage = e => e instanceof Error ? e.message : String(e);
 const getParseJsonTransformation = options => transformOrFail(String$.annotations({
-  [AST.DescriptionAnnotationId]: "a string to be decoded into JSON"
+  description: "a string to be decoded into JSON"
 }), Unknown, {
   strict: true,
-  decode: (s, _, ast) => ParseResult.try({
-    try: () => JSON.parse(s, options?.reviver),
-    catch: e => new ParseResult.Type(ast, s, getErrorMessage(e))
+  decode: (i, _, ast) => ParseResult.try({
+    try: () => JSON.parse(i, options?.reviver),
+    catch: e => new ParseResult.Type(ast, i, getErrorMessage(e))
   }),
-  encode: (u, _, ast) => ParseResult.try({
-    try: () => JSON.stringify(u, options?.replacer, options?.space),
-    catch: e => new ParseResult.Type(ast, u, getErrorMessage(e))
+  encode: (a, _, ast) => ParseResult.try({
+    try: () => JSON.stringify(a, options?.replacer, options?.space),
+    catch: e => new ParseResult.Type(ast, a, getErrorMessage(e))
   })
 }).annotations({
   title: "parseJson",
@@ -2356,11 +2390,11 @@ class URL$ extends /*#__PURE__*/transformOrFail(String$.annotations({
   description: "a string to be decoded into a URL"
 }), URLFromSelf, {
   strict: true,
-  decode: (s, _, ast) => ParseResult.try({
-    try: () => new URL(s),
-    catch: e => new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a URL. ${getErrorMessage(e)}`)
+  decode: (i, _, ast) => ParseResult.try({
+    try: () => new URL(i),
+    catch: e => new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a URL. ${getErrorMessage(e)}`)
   }),
-  encode: url => ParseResult.succeed(url.toString())
+  encode: a => ParseResult.succeed(a.toString())
 }).annotations({
   identifier: "URL",
   pretty: () => url => url.toString()
@@ -2589,29 +2623,36 @@ export const nonNegative = annotations => greaterThanOrEqualTo(0, {
  * @category number transformations
  * @since 3.10.0
  */
-export const clamp = (minimum, maximum) => self => transform(self, self.pipe(typeSchema, between(minimum, maximum)), {
-  strict: false,
-  decode: self => number_.clamp(self, {
-    minimum,
-    maximum
-  }),
-  encode: identity
-});
+export const clamp = (minimum, maximum) => self => {
+  return transform(self, typeSchema(self).pipe(between(minimum, maximum)), {
+    strict: false,
+    decode: i => number_.clamp(i, {
+      minimum,
+      maximum
+    }),
+    encode: identity
+  });
+};
 /**
- * Transforms a `string` into a `number` by parsing the string using the `parse` function of the `effect/Number` module.
+ * Transforms a `string` into a `number` by parsing the string using the `parse`
+ * function of the `effect/Number` module.
  *
- * It returns an error if the value can't be converted (for example when non-numeric characters are provided).
+ * It returns an error if the value can't be converted (for example when
+ * non-numeric characters are provided).
  *
- * The following special string values are supported: "NaN", "Infinity", "-Infinity".
+ * The following special string values are supported: "NaN", "Infinity",
+ * "-Infinity".
  *
  * @category number transformations
  * @since 3.10.0
  */
-export const parseNumber = self => transformOrFail(self, Number$, {
-  strict: false,
-  decode: (s, _, ast) => ParseResult.fromOption(number_.parse(s), () => new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a number`)),
-  encode: n => ParseResult.succeed(String(n))
-});
+export function parseNumber(self) {
+  return transformOrFail(self, Number$, {
+    strict: false,
+    decode: (i, _, ast) => ParseResult.fromOption(number_.parse(i), () => new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a number`)),
+    encode: a => ParseResult.succeed(String(a))
+  });
+}
 /**
  * This schema transforms a `string` into a `number` by parsing the string using the `parse` function of the `effect/Number` module.
  *
@@ -2713,10 +2754,10 @@ export class Not extends /*#__PURE__*/transform( /*#__PURE__*/Boolean$.annotatio
   description: "a boolean that will be negated"
 }), Boolean$, {
   strict: true,
-  decode: boolean_.not,
-  encode: boolean_.not
+  decode: i => boolean_.not(i),
+  encode: a => boolean_.not(a)
 }) {}
-const encodeSymbol = (sym, _, ast) => {
+const encodeSymbol = (sym, ast) => {
   const key = Symbol.keyFor(sym);
   return key === undefined ? ParseResult.fail(new ParseResult.Type(ast, sym, `Unable to encode a unique symbol ${String(sym)} into a string`)) : ParseResult.succeed(key);
 };
@@ -2726,8 +2767,8 @@ class Symbol$ extends /*#__PURE__*/transformOrFail(String$.annotations({
   description: "a string to be decoded into a globally shared symbol"
 }), SymbolFromSelf, {
   strict: false,
-  decode: decodeSymbol,
-  encode: encodeSymbol
+  decode: i => decodeSymbol(i),
+  encode: (a, _, ast) => encodeSymbol(a, ast)
 }).annotations({
   identifier: "Symbol"
 }) {}
@@ -2739,20 +2780,6 @@ export {
  * @since 3.10.0
  */
 Symbol$ as Symbol };
-const SymbolStruct = /*#__PURE__*/TaggedStruct("symbol", {
-  key: String$
-}).annotations({
-  description: "an object to be decoded into a globally shared symbol"
-});
-const SymbolFromStruct = /*#__PURE__*/transformOrFail(SymbolStruct, SymbolFromSelf, {
-  strict: true,
-  decode: ({
-    key
-  }) => decodeSymbol(key),
-  encode: (sym, _, ast) => ParseResult.map(encodeSymbol(sym, _, ast), key => SymbolStruct.make({
-    key
-  }))
-});
 /**
  * @category schema id
  * @since 3.10.0
@@ -2884,7 +2911,7 @@ export const nonPositiveBigInt = annotations => lessThanOrEqualToBigInt(0n, {
  */
 export const clampBigInt = (minimum, maximum) => self => transform(self, self.pipe(typeSchema, betweenBigInt(minimum, maximum)), {
   strict: false,
-  decode: self => bigInt_.clamp(self, {
+  decode: i => bigInt_.clamp(i, {
     minimum,
     maximum
   }),
@@ -2895,8 +2922,8 @@ class BigInt$ extends /*#__PURE__*/transformOrFail(String$.annotations({
   description: "a string to be decoded into a bigint"
 }), BigIntFromSelf, {
   strict: true,
-  decode: (s, _, ast) => ParseResult.fromOption(bigInt_.fromString(s), () => new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a bigint`)),
-  encode: n => ParseResult.succeed(String(n))
+  decode: (i, _, ast) => ParseResult.fromOption(bigInt_.fromString(i), () => new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a bigint`)),
+  encode: a => ParseResult.succeed(String(a))
 }).annotations({
   identifier: "BigInt"
 }) {}
@@ -2978,8 +3005,8 @@ export class BigIntFromNumber extends /*#__PURE__*/transformOrFail(Number$.annot
   description: "a number to be decoded into a bigint"
 }), BigIntFromSelf.pipe(betweenBigInt(BigInt(Number.MIN_SAFE_INTEGER), BigInt(Number.MAX_SAFE_INTEGER))), {
   strict: true,
-  decode: (n, _, ast) => ParseResult.fromOption(bigInt_.fromNumber(n), () => new ParseResult.Type(ast, n, `Unable to decode ${n} into a bigint`)),
-  encode: (b, _, ast) => ParseResult.fromOption(bigInt_.toNumber(b), () => new ParseResult.Type(ast, b, `Unable to encode ${b}n into a number`))
+  decode: (i, _, ast) => ParseResult.fromOption(bigInt_.fromNumber(i), () => new ParseResult.Type(ast, i, `Unable to decode ${i} into a bigint`)),
+  encode: (a, _, ast) => ParseResult.fromOption(bigInt_.toNumber(a), () => new ParseResult.Type(ast, a, `Unable to encode ${a}n into a number`))
 }).annotations({
   identifier: "BigIntFromNumber"
 }) {}
@@ -3003,18 +3030,19 @@ export const RedactedFromSelf = value => declare([value], {
   equivalence: redacted_.getEquivalence
 });
 /**
- * A schema that transforms any type `A` into a `Redacted<A>`.
+ * A transformation that transform a `Schema<A, I, R>` into a
+ * `RedactedFromSelf<A>`.
  *
  * @category Redacted transformations
  * @since 3.10.0
  */
-export const Redacted = value => {
-  return transform(value, RedactedFromSelf(typeSchema(value)), {
+export function Redacted(value) {
+  return transform(value, RedactedFromSelf(typeSchema(asSchema(value))), {
     strict: true,
-    decode: value => redacted_.make(value),
-    encode: value => redacted_.value(value)
+    decode: i => redacted_.make(i),
+    encode: a => redacted_.value(a)
   });
-};
+}
 /**
  * @category Duration constructors
  * @since 3.10.0
@@ -3040,9 +3068,9 @@ export class DurationFromNanos extends /*#__PURE__*/transformOrFail(NonNegativeB
   description: "a finite duration"
 })), {
   strict: true,
-  decode: nanos => ParseResult.succeed(duration_.nanos(nanos)),
-  encode: (duration, _, ast) => option_.match(duration_.toNanos(duration), {
-    onNone: () => ParseResult.fail(new ParseResult.Type(ast, duration, `Unable to encode ${duration} into a bigint`)),
+  decode: i => ParseResult.succeed(duration_.nanos(i)),
+  encode: (a, _, ast) => option_.match(duration_.toNanos(a), {
+    onNone: () => ParseResult.fail(new ParseResult.Type(ast, a, `Unable to encode ${a} into a bigint`)),
     onSome: nanos => ParseResult.succeed(nanos)
   })
 }).annotations({
@@ -3068,8 +3096,8 @@ export class DurationFromMillis extends /*#__PURE__*/transform(NonNegative.annot
   description: "a non-negative number to be decoded into a Duration"
 }), DurationFromSelf, {
   strict: true,
-  decode: ms => duration_.millis(ms),
-  encode: duration => duration_.toMillis(duration)
+  decode: i => duration_.millis(i),
+  encode: a => duration_.toMillis(a)
 }).annotations({
   identifier: "DurationFromMillis"
 }) {}
@@ -3109,29 +3137,29 @@ const isDurationValue = u => typeof u === "object";
  */
 export class Duration extends /*#__PURE__*/transform(Union(DurationValue, HRTime), DurationFromSelf, {
   strict: true,
-  decode: input => {
-    if (isDurationValue(input)) {
-      switch (input._tag) {
+  decode: i => {
+    if (isDurationValue(i)) {
+      switch (i._tag) {
         case "Millis":
-          return duration_.millis(input.millis);
+          return duration_.millis(i.millis);
         case "Nanos":
-          return duration_.nanos(input.nanos);
+          return duration_.nanos(i.nanos);
         case "Infinity":
           return duration_.infinity;
       }
     }
-    const [seconds, nanos] = input;
+    const [seconds, nanos] = i;
     return seconds === -1 ? duration_.infinity : duration_.nanos(BigInt(seconds) * BigInt(1e9) + BigInt(nanos));
   },
-  encode: duration => {
-    switch (duration.value._tag) {
+  encode: a => {
+    switch (a.value._tag) {
       case "Millis":
         return DurationValueMillis.make({
-          millis: duration.value.millis
+          millis: a.value.millis
         });
       case "Nanos":
         return DurationValueNanos.make({
-          nanos: duration.value.nanos
+          nanos: a.value.nanos
         });
       case "Infinity":
         return durationValueInfinity;
@@ -3148,7 +3176,7 @@ export class Duration extends /*#__PURE__*/transform(Union(DurationValue, HRTime
  */
 export const clampDuration = (minimum, maximum) => self => transform(self, self.pipe(typeSchema, betweenDuration(minimum, maximum)), {
   strict: false,
-  decode: self => duration_.clamp(self, {
+  decode: i => duration_.clamp(i, {
     minimum,
     maximum
   }),
@@ -3252,29 +3280,30 @@ export const betweenDuration = (minimum, maximum, annotations) => self => self.p
  * @category Uint8Array constructors
  * @since 3.10.0
  */
-export const Uint8ArrayFromSelf = /*#__PURE__*/declare(Predicate.isUint8Array, {
+export class Uint8ArrayFromSelf extends /*#__PURE__*/declare(Predicate.isUint8Array, {
   identifier: "Uint8ArrayFromSelf",
   pretty: () => u8arr => `new Uint8Array(${JSON.stringify(Array.from(u8arr))})`,
   arbitrary: () => fc => fc.uint8Array(),
   equivalence: () => array_.getEquivalence(Equal.equals)
-});
+}) {}
 /**
  * @category number constructors
  * @since 3.11.10
  */
-export const Uint8 = /*#__PURE__*/Number$.pipe( /*#__PURE__*/between(0, 255, {
+export class Uint8 extends /*#__PURE__*/Number$.pipe( /*#__PURE__*/between(0, 255, {
   identifier: "Uint8",
   description: "a 8-bit unsigned integer"
-}));
-const Uint8Array$ = /*#__PURE__*/transform(Array$(Uint8).annotations({
+})) {}
+/** @ignore */
+class Uint8Array$ extends /*#__PURE__*/transform(Array$(Uint8).annotations({
   description: "an array of 8-bit unsigned integers to be decoded into a Uint8Array"
 }), Uint8ArrayFromSelf, {
   strict: true,
-  decode: numbers => Uint8Array.from(numbers),
-  encode: uint8Array => Array.from(uint8Array)
+  decode: i => Uint8Array.from(i),
+  encode: a => Array.from(a)
 }).annotations({
   identifier: "Uint8Array"
-});
+}) {}
 export {
 /**
  * A schema that transforms an array of numbers into a `Uint8Array`.
@@ -3287,8 +3316,8 @@ const makeUint8ArrayTransformation = (id, decode, encode) => transformOrFail(Str
   description: "a string to be decoded into a Uint8Array"
 }), Uint8ArrayFromSelf, {
   strict: true,
-  decode: (s, _, ast) => either_.mapLeft(decode(s), decodeException => new ParseResult.Type(ast, s, decodeException.message)),
-  encode: u => ParseResult.succeed(encode(u))
+  decode: (i, _, ast) => either_.mapLeft(decode(i), decodeException => new ParseResult.Type(ast, i, decodeException.message)),
+  encode: a => ParseResult.succeed(encode(a))
 }).annotations({
   identifier: id
 });
@@ -3317,8 +3346,8 @@ const makeEncodingTransformation = (id, decode, encode) => transformOrFail(Strin
   description: `A string that is interpreted as being ${id}-encoded and will be decoded into a UTF-8 string`
 }), String$, {
   strict: true,
-  decode: (s, _, ast) => either_.mapLeft(decode(s), decodeException => new ParseResult.Type(ast, s, decodeException.message)),
-  encode: u => ParseResult.succeed(encode(u))
+  decode: (i, _, ast) => either_.mapLeft(decode(i), decodeException => new ParseResult.Type(ast, i, decodeException.message)),
+  encode: a => ParseResult.succeed(encode(a))
 }).annotations({
   identifier: `StringFrom${id}`
 });
@@ -3369,8 +3398,8 @@ export const StringFromUriComponent = /*#__PURE__*/transformOrFail(String$.annot
   description: `A string that is interpreted as being UriComponent-encoded and will be decoded into a UTF-8 string`
 }), String$, {
   strict: true,
-  decode: (s, _, ast) => either_.mapLeft(Encoding.decodeUriComponent(s), decodeException => new ParseResult.Type(ast, s, decodeException.message)),
-  encode: (u, _, ast) => either_.mapLeft(Encoding.encodeUriComponent(u), encodeException => new ParseResult.Type(ast, u, encodeException.message))
+  decode: (i, _, ast) => either_.mapLeft(Encoding.decodeUriComponent(i), decodeException => new ParseResult.Type(ast, i, decodeException.message)),
+  encode: (a, _, ast) => either_.mapLeft(Encoding.encodeUriComponent(a), encodeException => new ParseResult.Type(ast, a, encodeException.message))
 }).annotations({
   identifier: `StringFromUriComponent`
 });
@@ -3461,25 +3490,29 @@ export const getNumberIndexedAccess = self => make(AST.getNumberIndexedAccess(se
  * @category ReadonlyArray transformations
  * @since 3.10.0
  */
-export const head = self => transform(self, OptionFromSelf(getNumberIndexedAccess(typeSchema(self))), {
-  strict: true,
-  decode: array_.head,
-  encode: option_.match({
-    onNone: () => [],
-    onSome: array_.of
-  })
-});
+export function head(self) {
+  return transform(self, OptionFromSelf(getNumberIndexedAccess(typeSchema(self))), {
+    strict: false,
+    decode: i => array_.head(i),
+    encode: a => option_.match(a, {
+      onNone: () => [],
+      onSome: array_.of
+    })
+  });
+}
 /**
  * Get the first element of a `NonEmptyReadonlyArray`.
  *
  * @category NonEmptyReadonlyArray transformations
  * @since 3.12.0
  */
-export const headNonEmpty = self => transform(self, getNumberIndexedAccess(typeSchema(self)), {
-  strict: true,
-  decode: array_.headNonEmpty,
-  encode: array_.of
-});
+export function headNonEmpty(self) {
+  return transform(self, getNumberIndexedAccess(typeSchema(self)), {
+    strict: false,
+    decode: i => array_.headNonEmpty(i),
+    encode: a => array_.of(a)
+  });
+}
 /**
  * Retrieves the first element of a `ReadonlyArray`.
  *
@@ -3490,7 +3523,7 @@ export const headNonEmpty = self => transform(self, getNumberIndexedAccess(typeS
  */
 export const headOrElse = /*#__PURE__*/dual(args => isSchema(args[0]), (self, fallback) => transformOrFail(self, getNumberIndexedAccess(typeSchema(self)), {
   strict: true,
-  decode: (as, _, ast) => as.length > 0 ? ParseResult.succeed(as[0]) : fallback ? ParseResult.succeed(fallback()) : ParseResult.fail(new ParseResult.Type(ast, as, "Unable to retrieve the first element of an empty array")),
+  decode: (i, _, ast) => i.length > 0 ? ParseResult.succeed(i[0]) : fallback ? ParseResult.succeed(fallback()) : ParseResult.fail(new ParseResult.Type(ast, i, "Unable to retrieve the first element of an empty array")),
   encode: a => ParseResult.succeed(array_.of(a))
 }));
 /**
@@ -3659,8 +3692,8 @@ export class DateFromString extends /*#__PURE__*/transform(String$.annotations({
   description: "a string to be decoded into a Date"
 }), DateFromSelf, {
   strict: true,
-  decode: s => new Date(s),
-  encode: d => util_.formatDate(d)
+  decode: i => new Date(i),
+  encode: a => util_.formatDate(a)
 }).annotations({
   identifier: "DateFromString"
 }) {}
@@ -3693,8 +3726,8 @@ export class DateFromNumber extends /*#__PURE__*/transform(Number$.annotations({
   description: "a number to be decoded into a Date"
 }), DateFromSelf, {
   strict: true,
-  decode: n => new Date(n),
-  encode: d => d.getTime()
+  decode: i => new Date(i),
+  encode: a => a.getTime()
 }).annotations({
   identifier: "DateFromNumber"
 }) {}
@@ -3713,7 +3746,7 @@ export class DateTimeUtcFromSelf extends /*#__PURE__*/declare(u => dateTime.isDa
   }).map(date => dateTime.unsafeFromDate(date)),
   equivalence: () => dateTime.Equivalence
 }) {}
-const decodeDateTimeUtc = (input, _, ast) => ParseResult.try({
+const decodeDateTimeUtc = (input, ast) => ParseResult.try({
   try: () => dateTime.unsafeMake(input),
   catch: () => new ParseResult.Type(ast, input, `Unable to decode ${util_.formatUnknown(input)} into a DateTime.Utc`)
 });
@@ -3727,8 +3760,8 @@ export class DateTimeUtcFromNumber extends /*#__PURE__*/transformOrFail(Number$.
   description: "a number to be decoded into a DateTime.Utc"
 }), DateTimeUtcFromSelf, {
   strict: true,
-  decode: decodeDateTimeUtc,
-  encode: dt => ParseResult.succeed(dateTime.toEpochMillis(dt))
+  decode: (i, _, ast) => decodeDateTimeUtc(i, ast),
+  encode: a => ParseResult.succeed(dateTime.toEpochMillis(a))
 }).annotations({
   identifier: "DateTimeUtcFromNumber"
 }) {}
@@ -3742,8 +3775,8 @@ export class DateTimeUtcFromDate extends /*#__PURE__*/transformOrFail(DateFromSe
   description: "a Date to be decoded into a DateTime.Utc"
 }), DateTimeUtcFromSelf, {
   strict: true,
-  decode: decodeDateTimeUtc,
-  encode: dt => ParseResult.succeed(dateTime.toDateUtc(dt))
+  decode: (i, _, ast) => decodeDateTimeUtc(i, ast),
+  encode: a => ParseResult.succeed(dateTime.toDateUtc(a))
 }).annotations({
   identifier: "DateTimeUtcFromDate"
 }) {}
@@ -3757,8 +3790,8 @@ export class DateTimeUtc extends /*#__PURE__*/transformOrFail(String$.annotation
   description: "a string to be decoded into a DateTime.Utc"
 }), DateTimeUtcFromSelf, {
   strict: true,
-  decode: decodeDateTimeUtc,
-  encode: dt => ParseResult.succeed(dateTime.formatIso(dt))
+  decode: (i, _, ast) => decodeDateTimeUtc(i, ast),
+  encode: a => ParseResult.succeed(dateTime.formatIso(a))
 }).annotations({
   identifier: "DateTimeUtc"
 }) {}
@@ -3788,8 +3821,8 @@ export class TimeZoneOffset extends /*#__PURE__*/transform(Number$.annotations({
   description: "a number to be decoded into a TimeZone.Offset"
 }), TimeZoneOffsetFromSelf, {
   strict: true,
-  decode: dateTime.zoneMakeOffset,
-  encode: tz => tz.offset
+  decode: i => dateTime.zoneMakeOffset(i),
+  encode: a => a.offset
 }).annotations({
   identifier: "TimeZoneOffset"
 }) {}
@@ -3816,11 +3849,11 @@ export class TimeZoneNamed extends /*#__PURE__*/transformOrFail(String$.annotati
   description: "a string to be decoded into a TimeZone.Named"
 }), TimeZoneNamedFromSelf, {
   strict: true,
-  decode: (s, _, ast) => ParseResult.try({
-    try: () => dateTime.zoneUnsafeMakeNamed(s),
-    catch: () => new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a TimeZone.Named`)
+  decode: (i, _, ast) => ParseResult.try({
+    try: () => dateTime.zoneUnsafeMakeNamed(i),
+    catch: () => new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a TimeZone.Named`)
   }),
-  encode: tz => ParseResult.succeed(tz.id)
+  encode: a => ParseResult.succeed(a.id)
 }).annotations({
   identifier: "TimeZoneNamed"
 }) {}
@@ -3839,11 +3872,11 @@ export class TimeZone extends /*#__PURE__*/transformOrFail(String$.annotations({
   description: "a string to be decoded into a TimeZone"
 }), TimeZoneFromSelf, {
   strict: true,
-  decode: (s, _, ast) => option_.match(dateTime.zoneFromString(s), {
-    onNone: () => ParseResult.fail(new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a TimeZone`)),
+  decode: (i, _, ast) => option_.match(dateTime.zoneFromString(i), {
+    onNone: () => ParseResult.fail(new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a TimeZone`)),
     onSome: ParseResult.succeed
   }),
-  encode: tz => ParseResult.succeed(dateTime.zoneToString(tz))
+  encode: a => ParseResult.succeed(dateTime.zoneToString(a))
 }).annotations({
   identifier: "TimeZone"
 }) {}
@@ -3877,11 +3910,11 @@ export class DateTimeZoned extends /*#__PURE__*/transformOrFail(String$.annotati
   description: "a string to be decoded into a DateTime.Zoned"
 }), DateTimeZonedFromSelf, {
   strict: true,
-  decode: (s, _, ast) => option_.match(dateTime.makeZonedFromString(s), {
-    onNone: () => ParseResult.fail(new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a DateTime.Zoned`)),
+  decode: (i, _, ast) => option_.match(dateTime.makeZonedFromString(i), {
+    onNone: () => ParseResult.fail(new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a DateTime.Zoned`)),
     onSome: ParseResult.succeed
   }),
-  encode: dt => ParseResult.succeed(dateTime.formatIsoZoned(dt))
+  encode: a => ParseResult.succeed(dateTime.formatIsoZoned(a))
 }).annotations({
   identifier: "DateTimeZoned"
 }) {}
@@ -3937,53 +3970,51 @@ const makeSomeEncoded = value => ({
  * @category Option transformations
  * @since 3.10.0
  */
-export const Option = value => {
+export function Option(value) {
   const value_ = asSchema(value);
-  return transform(optionEncoded(value_), OptionFromSelf(typeSchema(value_)), {
+  const out = transform(optionEncoded(value_), OptionFromSelf(typeSchema(value_)), {
     strict: true,
-    decode: optionDecode,
-    encode: option_.match({
+    decode: i => optionDecode(i),
+    encode: a => option_.match(a, {
       onNone: () => makeNoneEncoded,
       onSome: makeSomeEncoded
     })
   });
-};
+  return out;
+}
 /**
  * @category Option transformations
  * @since 3.10.0
  */
-export const OptionFromNullOr = value => {
-  const value_ = asSchema(value);
-  return transform(NullOr(value_), OptionFromSelf(typeSchema(value_)), {
+export function OptionFromNullOr(value) {
+  return transform(NullOr(value), OptionFromSelf(typeSchema(asSchema(value))), {
     strict: true,
-    decode: option_.fromNullable,
-    encode: option_.getOrNull
+    decode: i => option_.fromNullable(i),
+    encode: a => option_.getOrNull(a)
   });
-};
+}
 /**
  * @category Option transformations
  * @since 3.10.0
  */
-export const OptionFromNullishOr = (value, onNoneEncoding) => {
-  const value_ = asSchema(value);
-  return transform(NullishOr(value_), OptionFromSelf(typeSchema(value_)), {
+export function OptionFromNullishOr(value, onNoneEncoding) {
+  return transform(NullishOr(value), OptionFromSelf(typeSchema(asSchema(value))), {
     strict: true,
-    decode: option_.fromNullable,
-    encode: onNoneEncoding === null ? option_.getOrNull : option_.getOrUndefined
+    decode: i => option_.fromNullable(i),
+    encode: onNoneEncoding === null ? a => option_.getOrNull(a) : a => option_.getOrUndefined(a)
   });
-};
+}
 /**
  * @category Option transformations
  * @since 3.10.0
  */
-export const OptionFromUndefinedOr = value => {
-  const value_ = asSchema(value);
-  return transform(UndefinedOr(value_), OptionFromSelf(typeSchema(value_)), {
+export function OptionFromUndefinedOr(value) {
+  return transform(UndefinedOr(value), OptionFromSelf(typeSchema(asSchema(value))), {
     strict: true,
-    decode: option_.fromNullable,
-    encode: option_.getOrUndefined
+    decode: i => option_.fromNullable(i),
+    encode: a => option_.getOrUndefined(a)
   });
-};
+}
 /**
  * Transforms strings into an Option type, effectively filtering out empty or
  * whitespace-only strings by trimming them and checking their length. Returns
@@ -4001,11 +4032,11 @@ export const OptionFromUndefinedOr = value => {
  * @category Option transformations
  * @since 3.10.0
  */
-export const OptionFromNonEmptyTrimmedString = /*#__PURE__*/transform(String$, /*#__PURE__*/OptionFromSelf(NonEmptyTrimmedString), {
+export class OptionFromNonEmptyTrimmedString extends /*#__PURE__*/transform(String$, /*#__PURE__*/OptionFromSelf(NonEmptyTrimmedString), {
   strict: true,
-  decode: s => option_.filter(option_.some(s.trim()), string_.isNonEmpty),
-  encode: /*#__PURE__*/option_.getOrElse(() => "")
-});
+  decode: i => option_.filter(option_.some(i.trim()), string_.isNonEmpty),
+  encode: a => option_.getOrElse(a, () => "")
+}) {}
 const rightEncoded = right => Struct({
   _tag: Literal("Right"),
   right
@@ -4076,17 +4107,18 @@ export const Either = ({
 }) => {
   const right_ = asSchema(right);
   const left_ = asSchema(left);
-  return transform(eitherEncoded(right_, left_), EitherFromSelf({
+  const out = transform(eitherEncoded(right_, left_), EitherFromSelf({
     left: typeSchema(left_),
     right: typeSchema(right_)
   }), {
     strict: true,
-    decode: eitherDecode,
-    encode: either_.match({
+    decode: i => eitherDecode(i),
+    encode: a => either_.match(a, {
       onLeft: makeLeftEncoded,
       onRight: makeRightEncoded
     })
   });
+  return out;
 };
 /**
  * @example
@@ -4110,25 +4142,26 @@ export const EitherFromUnion = ({
   const toleft = typeSchema(left_);
   const fromRight = transform(right_, rightEncoded(toright), {
     strict: true,
-    decode: makeRightEncoded,
-    encode: r => r.right
+    decode: i => makeRightEncoded(i),
+    encode: a => a.right
   });
   const fromLeft = transform(left_, leftEncoded(toleft), {
     strict: true,
-    decode: makeLeftEncoded,
-    encode: l => l.left
+    decode: i => makeLeftEncoded(i),
+    encode: a => a.left
   });
-  return transform(Union(fromRight, fromLeft), EitherFromSelf({
+  const out = transform(Union(fromRight, fromLeft), EitherFromSelf({
     left: toleft,
     right: toright
   }), {
     strict: true,
-    decode: from => from._tag === "Left" ? either_.left(from.left) : either_.right(from.right),
-    encode: either_.match({
+    decode: i => i._tag === "Left" ? either_.left(i.left) : either_.right(i.right),
+    encode: a => either_.match(a, {
       onLeft: makeLeftEncoded,
       onRight: makeRightEncoded
     })
   });
+  return out;
 };
 const mapArbitrary = (key, value, ctx) => {
   return fc => {
@@ -4171,36 +4204,33 @@ export const MapFromSelf = ({
  * @category ReadonlyMap transformations
  * @since 3.10.0
  */
-export const ReadonlyMap = ({
+export function ReadonlyMap({
   key,
   value
-}) => {
-  const key_ = asSchema(key);
-  const value_ = asSchema(value);
-  return transform(Array$(Tuple(key_, value_)), ReadonlyMapFromSelf({
-    key: typeSchema(key_),
-    value: typeSchema(value_)
+}) {
+  return transform(Array$(Tuple(key, value)), ReadonlyMapFromSelf({
+    key: typeSchema(asSchema(key)),
+    value: typeSchema(asSchema(value))
   }), {
     strict: true,
-    decode: as => new Map(as),
-    encode: map => Array.from(map.entries())
+    decode: i => new Map(i),
+    encode: a => Array.from(a.entries())
   });
-};
-const map = ({
+}
+/** @ignore */
+function map({
   key,
   value
-}) => {
-  const key_ = asSchema(key);
-  const value_ = asSchema(value);
-  return transform(Array$(Tuple(key_, value_)), MapFromSelf({
-    key: typeSchema(key_),
-    value: typeSchema(value_)
+}) {
+  return transform(Array$(Tuple(key, value)), MapFromSelf({
+    key: typeSchema(asSchema(key)),
+    value: typeSchema(asSchema(value))
   }), {
     strict: true,
-    decode: as => new Map(as),
-    encode: map => Array.from(map.entries())
+    decode: i => new Map(i),
+    encode: a => Array.from(a.entries())
   });
-};
+}
 export {
 /**
  * @category Map transformations
@@ -4224,8 +4254,8 @@ export const ReadonlyMapFromRecord = ({
   value: typeSchema(value)
 }), {
   strict: true,
-  decode: record => new Map(Object.entries(record)),
-  encode: record_.fromEntries
+  decode: i => new Map(Object.entries(i)),
+  encode: a => Object.fromEntries(a)
 });
 /**
  * @category Map transformations
@@ -4244,8 +4274,8 @@ export const MapFromRecord = ({
   value: typeSchema(value)
 }), {
   strict: true,
-  decode: record => new Map(Object.entries(record)),
-  encode: record_.fromEntries
+  decode: i => new Map(Object.entries(i)),
+  encode: a => Object.fromEntries(a)
 });
 const setArbitrary = (item, ctx) => fc => {
   const items = fc.array(item(fc));
@@ -4280,22 +4310,21 @@ export const SetFromSelf = value => setFromSelf_(value, `Set<${format(value)}>`)
  * @category ReadonlySet transformations
  * @since 3.10.0
  */
-export const ReadonlySet = value => {
-  const value_ = asSchema(value);
-  return transform(Array$(value_), ReadonlySetFromSelf(typeSchema(value_)), {
+export function ReadonlySet(value) {
+  return transform(Array$(value), ReadonlySetFromSelf(typeSchema(asSchema(value))), {
     strict: true,
-    decode: as => new Set(as),
-    encode: set => Array.from(set)
+    decode: i => new Set(i),
+    encode: a => Array.from(a)
   });
-};
-const set = value => {
-  const value_ = asSchema(value);
-  return transform(Array$(value_), SetFromSelf(typeSchema(value_)), {
+}
+/** @ignore */
+function set(value) {
+  return transform(Array$(value), SetFromSelf(typeSchema(asSchema(value))), {
     strict: true,
-    decode: as => new Set(as),
-    encode: set => Array.from(set)
+    decode: i => new Set(i),
+    encode: a => Array.from(a)
   });
-};
+}
 export {
 /**
  * @category Set transformations
@@ -4325,11 +4354,11 @@ export class BigDecimal extends /*#__PURE__*/transformOrFail(String$.annotations
   description: "a string to be decoded into a BigDecimal"
 }), BigDecimalFromSelf, {
   strict: true,
-  decode: (s, _, ast) => bigDecimal_.fromString(s).pipe(option_.match({
-    onNone: () => ParseResult.fail(new ParseResult.Type(ast, s, `Unable to decode ${JSON.stringify(s)} into a BigDecimal`)),
+  decode: (i, _, ast) => bigDecimal_.fromString(i).pipe(option_.match({
+    onNone: () => ParseResult.fail(new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a BigDecimal`)),
     onSome: val => ParseResult.succeed(bigDecimal_.normalize(val))
   })),
-  encode: val => ParseResult.succeed(bigDecimal_.format(bigDecimal_.normalize(val)))
+  encode: a => ParseResult.succeed(bigDecimal_.format(bigDecimal_.normalize(a)))
 }).annotations({
   identifier: "BigDecimal"
 }) {}
@@ -4344,8 +4373,8 @@ export class BigDecimalFromNumber extends /*#__PURE__*/transform(Number$.annotat
   description: "a number to be decoded into a BigDecimal"
 }), BigDecimalFromSelf, {
   strict: true,
-  decode: bigDecimal_.unsafeFromNumber,
-  encode: bigDecimal_.unsafeToNumber
+  decode: i => bigDecimal_.unsafeFromNumber(i),
+  encode: a => bigDecimal_.unsafeToNumber(a)
 }).annotations({
   identifier: "BigDecimalFromNumber"
 }) {}
@@ -4555,7 +4584,7 @@ export const betweenBigDecimal = (minimum, maximum, annotations) => self => {
  */
 export const clampBigDecimal = (minimum, maximum) => self => transform(self, self.pipe(typeSchema, betweenBigDecimal(minimum, maximum)), {
   strict: false,
-  decode: self => bigDecimal_.clamp(self, {
+  decode: i => bigDecimal_.clamp(i, {
     minimum,
     maximum
   }),
@@ -4586,14 +4615,13 @@ export const ChunkFromSelf = value => {
  * @category Chunk transformations
  * @since 3.10.0
  */
-export const Chunk = value => {
-  const value_ = asSchema(value);
-  return transform(Array$(value_), ChunkFromSelf(typeSchema(value_)), {
+export function Chunk(value) {
+  return transform(Array$(value), ChunkFromSelf(typeSchema(asSchema(value))), {
     strict: true,
-    decode: as => as.length === 0 ? chunk_.empty() : chunk_.fromIterable(as),
-    encode: chunk_.toReadonlyArray
+    decode: i => i.length === 0 ? chunk_.empty() : chunk_.fromIterable(i),
+    encode: a => chunk_.toReadonlyArray(a)
   });
-};
+}
 const nonEmptyChunkArbitrary = item => fc => fastCheck_.array(item(fc), {
   minLength: 1
 }).map(as => chunk_.unsafeFromNonEmptyArray(as));
@@ -4618,39 +4646,48 @@ export const NonEmptyChunkFromSelf = value => {
  * @category Chunk transformations
  * @since 3.10.0
  */
-export const NonEmptyChunk = value => {
-  const value_ = asSchema(value);
-  return transform(NonEmptyArray(value_), NonEmptyChunkFromSelf(typeSchema(value_)), {
+export function NonEmptyChunk(value) {
+  return transform(NonEmptyArray(value), NonEmptyChunkFromSelf(typeSchema(asSchema(value))), {
     strict: true,
-    decode: chunk_.unsafeFromNonEmptyArray,
-    encode: chunk_.toReadonlyArray
+    decode: i => chunk_.unsafeFromNonEmptyArray(i),
+    encode: a => chunk_.toReadonlyArray(a)
   });
-};
-const toData = a => Array.isArray(a) ? data_.array(a) : data_.struct(a);
-const dataArbitrary = item => fc => item(fc).map(toData);
+}
+const decodeData = a => Array.isArray(a) ? data_.array(a) : data_.struct(a);
+const dataArbitrary = item => fc => item(fc).map(decodeData);
 const dataPretty = item => d => `Data(${item(d)})`;
-const dataParse = decodeUnknown => (u, options, ast) => Equal.isEqual(u) ? toComposite(decodeUnknown(u, options), toData, ast, u) : ParseResult.fail(new ParseResult.Type(ast, u));
+const dataParse = decodeUnknown => (u, options, ast) => Equal.isEqual(u) ? toComposite(decodeUnknown(u, options), decodeData, ast, u) : ParseResult.fail(new ParseResult.Type(ast, u));
 /**
+ * Type and Encoded must extend `Readonly<Record<string, any>> |
+ * ReadonlyArray<any>` to be compatible with this API.
+ *
  * @category Data transformations
  * @since 3.10.0
  */
-export const DataFromSelf = item => declare([item], {
-  decode: item => dataParse(ParseResult.decodeUnknown(item)),
-  encode: item => dataParse(ParseResult.encodeUnknown(item))
-}, {
-  description: `Data<${format(item)}>`,
-  pretty: dataPretty,
-  arbitrary: dataArbitrary
-});
+export const DataFromSelf = value => {
+  return declare([value], {
+    decode: item => dataParse(ParseResult.decodeUnknown(item)),
+    encode: item => dataParse(ParseResult.encodeUnknown(item))
+  }, {
+    description: `Data<${format(value)}>`,
+    pretty: dataPretty,
+    arbitrary: dataArbitrary
+  });
+};
 /**
+ * Type and Encoded must extend `Readonly<Record<string, any>> |
+ * ReadonlyArray<any>` to be compatible with this API.
+ *
  * @category Data transformations
  * @since 3.10.0
  */
-export const Data = item => transform(item, DataFromSelf(typeSchema(item)), {
-  strict: false,
-  decode: toData,
-  encode: a => Array.isArray(a) ? Array.from(a) : Object.assign({}, a)
-});
+export const Data = value => {
+  return transform(value, DataFromSelf(typeSchema(value)), {
+    strict: false,
+    decode: i => decodeData(i),
+    encode: a => Array.isArray(a) ? Array.from(a) : Object.assign({}, a)
+  });
+};
 const isField = u => isSchema(u) || isPropertySignature(u);
 const isFields = fields => util_.ownKeys(fields).every(key => isField(fields[key]));
 const getFields = hasFields => "fields" in hasFields ? hasFields.fields : getFields(hasFields[RefineSchemaId]);
@@ -4857,7 +4894,7 @@ const makeClass = ({
       });
       out = transform(encodedSide, declaration, {
         strict: true,
-        decode: input => new this(input, true),
+        decode: i => new this(i, true),
         encode: identity
       }).annotations({
         [AST.SurrogateAnnotationId]: transformationSurrogate.ast,
@@ -5036,8 +5073,8 @@ const fiberIdEncode = input => {
  */
 export class FiberId extends /*#__PURE__*/transform(FiberIdEncoded, FiberIdFromSelf, {
   strict: true,
-  decode: fiberIdDecode,
-  encode: fiberIdEncode
+  decode: i => fiberIdDecode(i),
+  encode: a => fiberIdEncode(a)
 }).annotations({
   identifier: "FiberId"
 }) {}
@@ -5056,19 +5093,19 @@ const CauseInterruptEncoded = /*#__PURE__*/Struct({
   _tag: /*#__PURE__*/Literal("Interrupt"),
   fiberId: FiberIdEncoded
 });
-const causeParallelEncoded = causeEncoded => Struct({
-  _tag: Literal("Parallel"),
-  left: causeEncoded,
-  right: causeEncoded
-});
-const causeSequentialEncoded = causeEncoded => Struct({
-  _tag: Literal("Sequential"),
-  left: causeEncoded,
-  right: causeEncoded
-});
 const causeEncoded = (error, defect) => {
-  const recur = suspend(() => out);
-  const out = Union(CauseEmptyEncoded, causeFailEncoded(error), causeDieEncoded(defect), CauseInterruptEncoded, causeSequentialEncoded(recur), causeParallelEncoded(recur)).annotations({
+  const error_ = asSchema(error);
+  const defect_ = asSchema(defect);
+  const suspended = suspend(() => out);
+  const out = Union(CauseEmptyEncoded, causeFailEncoded(error_), causeDieEncoded(defect_), CauseInterruptEncoded, Struct({
+    _tag: Literal("Sequential"),
+    left: suspended,
+    right: suspended
+  }), Struct({
+    _tag: Literal("Parallel"),
+    left: suspended,
+    right: suspended
+  })).annotations({
     title: `CauseEncoded<${format(error)}>`
   });
   return out;
@@ -5199,14 +5236,15 @@ export const Cause = ({
 }) => {
   const error_ = asSchema(error);
   const defect_ = asSchema(defect);
-  return transform(causeEncoded(error_, defect_), CauseFromSelf({
+  const out = transform(causeEncoded(error_, defect_), CauseFromSelf({
     error: typeSchema(error_),
-    defect: Unknown
+    defect: typeSchema(defect_)
   }), {
     strict: false,
-    decode: causeDecode,
-    encode: causeEncode
+    decode: i => causeDecode(i),
+    encode: a => causeEncode(a)
   });
+  return out;
 };
 /**
  * Defines a schema for handling JavaScript errors (`Error` instances) and other types of defects.
@@ -5221,34 +5259,34 @@ export const Cause = ({
  * @category defect
  * @since 3.10.0
  */
-export const Defect = /*#__PURE__*/transform(Unknown, Unknown, {
+export class Defect extends /*#__PURE__*/transform(Unknown, Unknown, {
   strict: true,
-  decode: u => {
-    if (Predicate.isObject(u) && "message" in u && typeof u.message === "string") {
-      const err = new Error(u.message, {
-        cause: u
+  decode: i => {
+    if (Predicate.isObject(i) && "message" in i && typeof i.message === "string") {
+      const err = new Error(i.message, {
+        cause: i
       });
-      if ("name" in u && typeof u.name === "string") {
-        err.name = u.name;
+      if ("name" in i && typeof i.name === "string") {
+        err.name = i.name;
       }
-      err.stack = "stack" in u && typeof u.stack === "string" ? u.stack : "";
+      err.stack = "stack" in i && typeof i.stack === "string" ? i.stack : "";
       return err;
     }
-    return String(u);
+    return String(i);
   },
-  encode: defect => {
-    if (defect instanceof Error) {
+  encode: a => {
+    if (a instanceof Error) {
       return {
-        name: defect.name,
-        message: defect.message
+        name: a.name,
+        message: a.message
         // no stack because of security reasons
       };
     }
-    return internalCause_.prettyErrorMessage(defect);
+    return internalCause_.prettyErrorMessage(a);
   }
 }).annotations({
   identifier: "Defect"
-});
+}) {}
 const exitFailureEncoded = (error, defect) => Struct({
   _tag: Literal("Failure"),
   cause: causeEncoded(error, defect)
@@ -5257,9 +5295,11 @@ const exitSuccessEncoded = value => Struct({
   _tag: Literal("Success"),
   value
 });
-const exitEncoded = (value, error, defect) => Union(exitFailureEncoded(error, defect), exitSuccessEncoded(value)).annotations({
-  title: `ExitEncoded<${format(value)}, ${format(error)}, ${format(defect)}>`
-});
+const exitEncoded = (value, error, defect) => {
+  return Union(exitFailureEncoded(error, defect), exitSuccessEncoded(value)).annotations({
+    title: `ExitEncoded<${format(value)}, ${format(error)}, ${format(defect)}>`
+  });
+};
 const exitDecode = input => {
   switch (input._tag) {
     case "Failure":
@@ -5314,21 +5354,22 @@ export const Exit = ({
   const success_ = asSchema(success);
   const failure_ = asSchema(failure);
   const defect_ = asSchema(defect);
-  return transform(exitEncoded(success_, failure_, defect_), ExitFromSelf({
+  const out = transform(exitEncoded(success_, failure_, defect_), ExitFromSelf({
     failure: typeSchema(failure_),
     success: typeSchema(success_),
-    defect: Unknown
+    defect: typeSchema(defect_)
   }), {
     strict: false,
-    decode: exitDecode,
-    encode: exit => exit._tag === "Failure" ? {
+    decode: i => exitDecode(i),
+    encode: a => a._tag === "Failure" ? {
       _tag: "Failure",
-      cause: exit.cause
+      cause: a.cause
     } : {
       _tag: "Success",
-      value: exit.value
+      value: a.value
     }
   });
+  return out;
 };
 const hashSetArbitrary = (item, ctx) => fc => {
   const items = fc.array(item(fc));
@@ -5359,14 +5400,13 @@ export const HashSetFromSelf = value => {
  * @category HashSet transformations
  * @since 3.10.0
  */
-export const HashSet = value => {
-  const value_ = asSchema(value);
-  return transform(Array$(value_), HashSetFromSelf(typeSchema(value_)), {
+export function HashSet(value) {
+  return transform(Array$(value), HashSetFromSelf(typeSchema(asSchema(value))), {
     strict: true,
-    decode: as => hashSet_.fromIterable(as),
-    encode: set => Array.from(set)
+    decode: i => hashSet_.fromIterable(i),
+    encode: a => Array.from(a)
   });
-};
+}
 const hashMapArbitrary = (key, value, ctx) => fc => {
   const items = fc.array(fc.tuple(key(fc), value(fc)));
   return (ctx.depthIdentifier !== undefined ? fc.oneof(ctx, fc.constant([]), items) : items).map(hashMap_.fromIterable);
@@ -5403,15 +5443,13 @@ export const HashMap = ({
   key,
   value
 }) => {
-  const key_ = asSchema(key);
-  const value_ = asSchema(value);
-  return transform(Array$(Tuple(key_, value_)), HashMapFromSelf({
-    key: typeSchema(key_),
-    value: typeSchema(value_)
+  return transform(Array$(Tuple(key, value)), HashMapFromSelf({
+    key: typeSchema(asSchema(key)),
+    value: typeSchema(asSchema(value))
   }), {
     strict: true,
-    decode: as => hashMap_.fromIterable(as),
-    encode: map => Array.from(map)
+    decode: i => hashMap_.fromIterable(i),
+    encode: a => Array.from(a)
   });
 };
 const listArbitrary = (item, ctx) => fc => {
@@ -5443,14 +5481,13 @@ export const ListFromSelf = value => {
  * @category List transformations
  * @since 3.10.0
  */
-export const List = value => {
-  const value_ = asSchema(value);
-  return transform(Array$(value_), ListFromSelf(typeSchema(value_)), {
+export function List(value) {
+  return transform(Array$(value), ListFromSelf(typeSchema(asSchema(value))), {
     strict: true,
-    decode: as => list_.fromIterable(as),
-    encode: set => Array.from(set)
+    decode: i => list_.fromIterable(i),
+    encode: a => Array.from(a)
   });
-};
+}
 const sortedSetArbitrary = (item, ord, ctx) => fc => {
   const items = fc.array(item(fc));
   return (ctx.depthIdentifier !== undefined ? fc.oneof(ctx, fc.constant([]), items) : items).map(as => sortedSet_.fromIterable(as, ord));
@@ -5476,15 +5513,14 @@ export const SortedSetFromSelf = (value, ordA, ordI) => {
  * @category SortedSet transformations
  * @since 3.10.0
  */
-export const SortedSet = (value, ordA) => {
-  const value_ = asSchema(value);
-  const to = typeSchema(value_);
-  return transform(Array$(value_), SortedSetFromSelf(to, ordA, ordA), {
+export function SortedSet(value, ordA) {
+  const to = typeSchema(asSchema(value));
+  return transform(Array$(value), SortedSetFromSelf(to, ordA, ordA), {
     strict: true,
-    decode: as => sortedSet_.fromIterable(as, ordA),
-    encode: set => Array.from(sortedSet_.values(set))
+    decode: i => sortedSet_.fromIterable(i, ordA),
+    encode: a => Array.from(sortedSet_.values(a))
   });
-};
+}
 /**
  * Converts an arbitrary value to a `boolean` by testing whether it is truthy.
  * Uses `!!val` to coerce the value to a `boolean`.
@@ -5495,7 +5531,7 @@ export const SortedSet = (value, ordA) => {
  */
 export class BooleanFromUnknown extends /*#__PURE__*/transform(Unknown, Boolean$, {
   strict: true,
-  decode: Predicate.isTruthy,
+  decode: i => Predicate.isTruthy(i),
   encode: identity
 }).annotations({
   identifier: "BooleanFromUnknown"
@@ -5511,8 +5547,8 @@ export class BooleanFromString extends /*#__PURE__*/transform(Literal("true", "f
   description: "a string to be decoded into a boolean"
 }), Boolean$, {
   strict: true,
-  decode: value => value === "true",
-  encode: value => value ? "true" : "false"
+  decode: i => i === "true",
+  encode: a => a ? "true" : "false"
 }).annotations({
   identifier: "BooleanFromString"
 }) {}
@@ -5858,6 +5894,18 @@ const go = (ast, path) => {
       }
   }
 };
+const SymbolStruct = /*#__PURE__*/TaggedStruct("symbol", {
+  key: String$
+}).annotations({
+  description: "an object to be decoded into a globally shared symbol"
+});
+const SymbolFromStruct = /*#__PURE__*/transformOrFail(SymbolStruct, SymbolFromSelf, {
+  strict: true,
+  decode: i => decodeSymbol(i.key),
+  encode: (a, _, ast) => ParseResult.map(encodeSymbol(a, ast), key => SymbolStruct.make({
+    key
+  }))
+});
 /** @ignore */
 class PropertyKey$ extends /*#__PURE__*/Union(String$, Number$, SymbolFromStruct).annotations({
   identifier: "PropertyKey"