effect 4.0.0-beta.42 → 4.0.0-beta.44

package/dist/Schema.js

@@ -95,7 +95,7 @@ import * as Encoding from "./Encoding.js";
 import * as Equal from "./Equal.js";
 import * as Equivalence from "./Equivalence.js";
 import * as Exit_ from "./Exit.js";
-import { format, formatDate, formatPropertyKey } from "./Formatter.js";
+import { format, formatPropertyKey } from "./Formatter.js";
 import { identity } from "./Function.js";
 import * as HashMap_ from "./HashMap.js";
 import * as HashSet_ from "./HashSet.js";
@@ -105,6 +105,7 @@ import * as InternalArbitrary from "./internal/schema/arbitrary.js";
 import * as InternalEquivalence from "./internal/schema/equivalence.js";
 import * as InternalStandard from "./internal/schema/representation.js";
 import * as InternalSchema from "./internal/schema/schema.js";
+import { SchemaError } from "./internal/schema/schema.js";
 import * as InternalToCodec from "./internal/schema/to-codec.js";
 import * as JsonPatch from "./JsonPatch.js";
 import * as JsonSchema from "./JsonSchema.js";
@@ -329,7 +330,7 @@ export function annotateKey(annotations) {
 export function revealCodec(codec) {
   return codec;
 }
-const SchemaErrorTypeId = "~effect/Schema/SchemaError";
+export {
 /**
  * Error thrown (or returned as the error channel value) when schema decoding
  * or encoding fails.
@@ -358,21 +359,7 @@ const SchemaErrorTypeId = "~effect/Schema/SchemaError";
  *
  * @since 4.0.0
  */
-export class SchemaError {
-  [SchemaErrorTypeId] = SchemaErrorTypeId;
-  _tag = "SchemaError";
-  name = "SchemaError";
-  issue;
-  constructor(issue) {
-    this.issue = issue;
-  }
-  get message() {
-    return this.issue.toString();
-  }
-  toString() {
-    return `SchemaError(${this.message})`;
-  }
-}
+SchemaError };
 /**
  * Returns `true` if `u` is a {@link SchemaError}.
  *
@@ -393,7 +380,7 @@ export class SchemaError {
  * @since 4.0.0
  */
 export function isSchemaError(u) {
-  return Predicate.hasProperty(u, SchemaErrorTypeId);
+  return Predicate.hasProperty(u, InternalSchema.SchemaErrorTypeId);
 }
 function makeStandardResult(exit) {
   return Exit_.isSuccess(exit) ? exit.value : {
@@ -916,6 +903,31 @@ export const encodeSync = Parser.encodeSync;
  * @since 4.0.0
  */
 export const make = InternalSchema.make;
+/**
+ * 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
+ * static methods that reference `this`.
+ *
+ * **Example** (Wrapping a primitive schema)
+ *
+ * ```ts
+ * import { Schema } from "effect"
+ *
+ * class MyString extends Schema.asClass(Schema.String) {
+ *   static readonly decodeUnknownSync = Schema.decodeUnknownSync(this)
+ * }
+ *
+ * console.log(MyString.decodeUnknownSync("a"))
+ * // "a"
+ * ```
+ *
+ * @since 4.0.0
+ */
+export function asClass(schema) {
+  // oxlint-disable-next-line @typescript-eslint/no-extraneous-class
+  class Class {}
+  return Object.setPrototypeOf(Class, schema);
+}
 /**
  * Tests if a value is a `Schema`.
  *
@@ -1975,38 +1987,34 @@ export function encode(transformation) {
 /**
  * Attaches a constructor default value to a schema field.
  *
- * The `defaultValue` function receives `Option.some(undefined)` when the field is
- * explicitly set to `undefined`, or `Option.none()` when the field is absent.
- * Return `Option.some(value)` to supply a default, or `Option.none()` to leave the
- * field required. An `Effect` may be returned for async or service-dependent defaults.
- *
- * Constructor defaults are applied only during `makeUnsafe` / `make`, not during
- * decoding or encoding.
+ * Constructor defaults are applied only during `make*`, not during decoding or
+ * encoding.
  *
  * **Example** (Optional field with a static default)
  *
  * ```ts
- * import { Option, Schema } from "effect"
+ * import { Effect, Schema } from "effect"
  *
  * const MySchema = Schema.Struct({
  *   name: Schema.String.pipe(
  *     Schema.optionalKey,
- *     Schema.withConstructorDefault(() => Option.some("anonymous"))
+ *     Schema.withConstructorDefault(Effect.succeed("anonymous"))
  *   )
  * })
  *
- * const value = MySchema.makeUnsafe({})
+ * const value = MySchema.make({})
  * // value: { name: "anonymous" }
  * ```
  *
  * @since 4.0.0
  */
-export function withConstructorDefault(defaultValue) {
-  return schema => {
-    return make(AST.withConstructorDefault(schema.ast, defaultValue), {
-      schema
-    });
-  };
+export function withConstructorDefault(
+// `S["~type.make.in"]` instead of `S["Type"]` is intentional here because
+// it makes easier to define the default value if there are nested defaults
+defaultValue) {
+  return schema => make(AST.withConstructorDefault(schema.ast, defaultValue), {
+    schema
+  });
 }
 /**
  * **Options**
@@ -2025,10 +2033,10 @@ export function withConstructorDefault(defaultValue) {
  * **Example** (Default for a missing struct key)
  *
  * ```ts
- * import { Schema } from "effect"
+ * import { Effect, Schema } from "effect"
  *
  * const MySchema = Schema.Struct({
- *   name: Schema.String.pipe(Schema.withDecodingDefaultKey(() => "anonymous"))
+ *   name: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed("anonymous")))
  * })
  *
  * const result = Schema.decodeUnknownSync(MySchema)({})
@@ -2067,10 +2075,10 @@ export function withDecodingDefaultKey(defaultValue, options) {
  * **Example** (Default for an optional field value)
  *
  * ```ts
- * import { Schema } from "effect"
+ * import { Effect, Schema } from "effect"
  *
  * const MySchema = Schema.Struct({
- *   name: Schema.String.pipe(Schema.optional, Schema.withDecodingDefault(() => "anonymous"))
+ *   name: Schema.String.pipe(Schema.optional, Schema.withDecodingDefault(Effect.succeed("anonymous")))
  * })
  *
  * const result = Schema.decodeUnknownSync(MySchema)({ name: undefined })
@@ -2091,7 +2099,7 @@ export function withDecodingDefault(defaultValue, options) {
 }
 /**
  * Combines a {@link Literal} schema with {@link withConstructorDefault}, making it ideal
- * for discriminator fields in tagged unions. When constructing via `makeUnsafe`, the
+ * for discriminator fields in tagged unions. When constructing via `make`, the
  * `_tag` field can be omitted and will be filled automatically.
  *
  * **Example** (Discriminated union tag)
@@ -2101,8 +2109,8 @@ export function withDecodingDefault(defaultValue, options) {
  *
  * const A = Schema.Struct({ _tag: Schema.tag("A"), value: Schema.Number })
  *
- * // _tag is optional in makeUnsafe, auto-filled to "A"
- * const a = A.makeUnsafe({ value: 42 })
+ * // _tag is optional in make, auto-filled to "A"
+ * const a = A.make({ value: 42 })
  * // a: { _tag: "A", value: 42 }
  * ```
  *
@@ -2111,7 +2119,7 @@ export function withDecodingDefault(defaultValue, options) {
  * @since 4.0.0
  */
 export function tag(literal) {
-  return Literal(literal).pipe(withConstructorDefault(() => Option_.some(literal)));
+  return Literal(literal).pipe(withConstructorDefault(Effect.succeed(literal)));
 }
 /**
  * Like {@link tag}, but additionally omits the tag field from the encoded output.
@@ -2137,7 +2145,7 @@ export function tag(literal) {
  * @since 4.0.0
  */
 export function tagDefaultOmit(literal) {
-  return tag(literal).pipe(withDecodingDefaultKey(() => literal, {
+  return tag(literal).pipe(withDecodingDefaultKey(Effect.succeed(literal), {
     encodingStrategy: "omit"
   }));
 }
@@ -2146,7 +2154,7 @@ export function tagDefaultOmit(literal) {
  * to identify the specific variant of the object, which is especially useful
  * when working with union types.
  *
- * When using the `makeUnsafe` method, the `_tag` field is optional and will be
+ * When using the `make` method, the `_tag` field is optional and will be
  * added automatically. However, when decoding or encoding, the `_tag` field
  * must be present in the input.
  *
@@ -2300,21 +2308,24 @@ export function TaggedUnion(casesByTag) {
   });
 }
 /**
- * Wraps a schema so that its decoded `Type` becomes a nominally distinct type `Self`.
- * Useful for creating opaque types that are structurally identical to a base schema
+ * Wraps a struct schema so that its decoded `Type` becomes a nominally distinct type `Self`.
+ * Useful for creating opaque types that are structurally identical to a base struct
  * but type-incompatible with it.
  *
- * **Example** (Opaque user ID)
+ * **Example** (Opaque struct)
  *
  * ```ts
  * import { Schema } from "effect"
  *
- * type UserId = string & { readonly _tag: "UserId" }
- * const UserId = Schema.Opaque<UserId>()(Schema.String)
+ * class Person extends Schema.Opaque<Person>()(
+ *   Schema.Struct({
+ *     name: Schema.String
+ *   })
+ * ) {}
  *
- * // Decoded value is UserId, not plain string
- * const id = Schema.decodeUnknownSync(UserId)("abc")
- * // id: UserId
+ * // Decoded value is Person, not { name: string }
+ * const person = Schema.decodeUnknownSync(Person)({ name: "Alice" })
+ * // person: Person
  * ```
  *
  * @since 4.0.0
@@ -2323,8 +2334,7 @@ export function Opaque() {
   return schema => {
     // oxlint-disable-next-line @typescript-eslint/no-extraneous-class
     class Opaque {}
-    Object.setPrototypeOf(Opaque, schema);
-    return Opaque;
+    return Object.setPrototypeOf(Opaque, schema);
   };
 }
 /**
@@ -4059,19 +4069,18 @@ export function isUnique(annotations) {
     ...annotations
   });
 }
-// -----------------------------------------------------------------------------
-// Built-in Schemas
-// -----------------------------------------------------------------------------
 /**
  * A schema for non-empty strings. Validates that a string has at least one
  * character.
  *
+ * @category String
  * @since 4.0.0
  */
 export const NonEmptyString = /*#__PURE__*/String.check(/*#__PURE__*/isNonEmpty());
 /**
  * A schema representing a single character.
  *
+ * @category String
  * @since 4.0.0
  */
 export const Char = /*#__PURE__*/String.check(/*#__PURE__*/isLengthBetween(1, 1));
@@ -4630,7 +4639,7 @@ export const Defect = /*#__PURE__*/Union([/*#__PURE__*/ErrorJsonEncoded.pipe(/*#
  * A schema that represents defects, that also includes stack traces in the
  * encoded form.
  *
- * @category Constructors
+ * @category Defect
  * @since 4.0.0
  */
 export const DefectWithStack = /*#__PURE__*/Union([/*#__PURE__*/ErrorJsonEncoded.pipe(/*#__PURE__*/decodeTo(ErrorWithStack, /*#__PURE__*/Transformation.errorFromErrorJsonEncoded({
@@ -4990,7 +4999,7 @@ export function Chunk(value) {
  *
  * The default JSON serializer encodes a `RegExp` as `{ source, flags }`.
  *
- * @category Schemas
+ * @category RegExp
  * @since 4.0.0
  */
 export const RegExp = /*#__PURE__*/instanceOf(globalThis.RegExp, {
@@ -5024,6 +5033,9 @@ export const RegExp = /*#__PURE__*/instanceOf(globalThis.RegExp, {
   }).map(flags => flags.join(""))).map(([source, flags]) => new globalThis.RegExp(source, flags)),
   toEquivalence: () => (a, b) => a.source === b.source && a.flags === b.flags
 });
+const URLString = /*#__PURE__*/String.annotate({
+  expected: "a string that will be decoded as a URL"
+});
 /**
  * A schema for JavaScript `URL` objects.
  *
@@ -5043,9 +5055,7 @@ export const URL = /*#__PURE__*/instanceOf(globalThis.URL, {
     Type: `globalThis.URL`
   },
   expected: "URL",
-  toCodecJson: () => link()(String.annotate({
-    expected: "a string that will be decoded as a URL"
-  }), Transformation.urlFromString),
+  toCodecJson: () => link()(URLString, Transformation.urlFromString),
   toArbitrary: () => fc => fc.webUrl().map(s => new globalThis.URL(s)),
   toEquivalence: () => (a, b) => a.toString() === b.toString()
 });
@@ -5061,9 +5071,10 @@ export const URL = /*#__PURE__*/instanceOf(globalThis.URL, {
  * @category URL
  * @since 4.0.0
  */
-export const URLFromString = /*#__PURE__*/String.annotate({
-  expected: "a string that will be decoded as a URL"
-}).pipe(/*#__PURE__*/decodeTo(URL, Transformation.urlFromString)); // TODO: remove duplication with URL schema
+export const URLFromString = /*#__PURE__*/URLString.pipe(/*#__PURE__*/decodeTo(URL, Transformation.urlFromString));
+const DateString = /*#__PURE__*/String.annotate({
+  expected: "a string in ISO 8601 format that will be decoded as a Date"
+});
 /**
  * A schema for JavaScript `Date` objects.
  *
@@ -5080,7 +5091,7 @@ export const URLFromString = /*#__PURE__*/String.annotate({
  * // => Date { 2024-01-01T00:00:00.000Z }
  * ```
  *
- * @category Schemas
+ * @category Date
  * @since 4.0.0
  */
 export const Date = /*#__PURE__*/instanceOf(globalThis.Date, {
@@ -5092,20 +5103,29 @@ export const Date = /*#__PURE__*/instanceOf(globalThis.Date, {
     Type: `globalThis.Date`
   },
   expected: "Date",
-  toCodecJson: () => link()(String.annotate({
-    expected: "a string in ISO 8601 format that will be decoded as a Date"
-  }), Transformation.transform({
-    decode: s => new globalThis.Date(s),
-    encode: formatDate
-  })),
+  toCodecJson: () => link()(DateString, Transformation.dateFromString),
   toArbitrary: () => (fc, ctx) => fc.date(ctx?.constraints?.date)
 });
+/**
+ * A transformation schema that parses an ISO 8601 string into a `Date`.
+ *
+ * Decoding:
+ * - A `string` is decoded as a `Date`.
+ *
+ * Encoding:
+ * - A `Date` is encoded as a `string`.
+ *
+ * @category Date
+ * @since 4.0.0
+ */
+export const DateFromString = /*#__PURE__*/DateString.pipe(/*#__PURE__*/decodeTo(Date, Transformation.dateFromString));
 /**
  * A schema for **valid** JavaScript `Date` objects.
  *
  * This schema accepts `Date` instances but rejects invalid dates (such as `new
  * Date("invalid")`).
  *
+ * @category Date
  * @since 4.0.0
  */
 export const DateValid = /*#__PURE__*/Date.check(/*#__PURE__*/isDateValid());
@@ -5220,6 +5240,9 @@ export const DurationFromNanos = /*#__PURE__*/BigInt.check(isGreaterThanOrEqualT
  * @since 4.0.0
  */
 export const DurationFromMillis = /*#__PURE__*/Number.check(isGreaterThanOrEqualTo(0)).pipe(/*#__PURE__*/decodeTo(Duration, Transformation.durationFromMillis));
+const BigDecimalString = /*#__PURE__*/String.annotate({
+  expected: "a string that will be decoded as a BigDecimal"
+});
 /**
  * A schema for `BigDecimal` values.
  *
@@ -5227,6 +5250,7 @@ export const DurationFromMillis = /*#__PURE__*/Number.check(isGreaterThanOrEqual
  *
  * - encodes `BigDecimal` as a `string`
  *
+ * @category BigDecimal
  * @since 4.0.0
  */
 export const BigDecimal = /*#__PURE__*/declare(BigDecimal_.isBigDecimal, {
@@ -5239,9 +5263,7 @@ export const BigDecimal = /*#__PURE__*/declare(BigDecimal_.isBigDecimal, {
     importDeclaration: `import * as BigDecimal from "effect/BigDecimal"`
   },
   expected: "BigDecimal",
-  toCodecJson: () => link()(String.annotate({
-    expected: "a string that will be decoded as a BigDecimal"
-  }), Transformation.bigDecimalFromString),
+  toCodecJson: () => link()(BigDecimalString, Transformation.bigDecimalFromString),
   toArbitrary: () => fc => fc.tuple(fc.bigInt(), fc.integer({
     min: 0,
     max: 20
@@ -5249,6 +5271,19 @@ export const BigDecimal = /*#__PURE__*/declare(BigDecimal_.isBigDecimal, {
   toFormatter: () => bd => BigDecimal_.format(bd),
   toEquivalence: () => BigDecimal_.Equivalence
 });
+/**
+ * A transformation schema that parses a string into a `BigDecimal`.
+ *
+ * Decoding:
+ * - A `string` is decoded as a `BigDecimal`.
+ *
+ * Encoding:
+ * - A `BigDecimal` is encoded as a `string`.
+ *
+ * @category BigDecimal
+ * @since 4.0.0
+ */
+export const BigDecimalFromString = /*#__PURE__*/BigDecimalString.pipe(/*#__PURE__*/decodeTo(BigDecimal, Transformation.bigDecimalFromString));
 /**
  * A transformation schema that decodes a JSON-encoded string into an `unknown` value.
  *
@@ -5269,6 +5304,7 @@ export const BigDecimal = /*#__PURE__*/declare(BigDecimal_.isBigDecimal, {
  * // => { a: 1, b: 2 }
  * ```
  *
+ * @category JSON
  * @since 4.0.0
  */
 export const UnknownFromJsonString = /*#__PURE__*/fromJsonString(Unknown);
@@ -5333,6 +5369,7 @@ export const UnknownFromJsonString = /*#__PURE__*/fromJsonString(Unknown);
  * // }
  * ```
  *
+ * @category JSON
  * @since 4.0.0
  */
 export function fromJsonString(schema) {
@@ -5348,7 +5385,7 @@ export function fromJsonString(schema) {
  * The default JSON serializer encodes a `File` as `{ data, type, name, lastModified }`
  * where `data` is base64-encoded.
  *
- * @category Schemas
+ * @category File
  * @since 4.0.0
  */
 export const File = /*#__PURE__*/instanceOf(globalThis.File, {
@@ -5400,7 +5437,7 @@ export const File = /*#__PURE__*/instanceOf(globalThis.File, {
  * The default JSON serializer encodes a `FormData` as an array of `[key, entry]`
  * pairs where each entry is tagged as `"String"` or `"File"`.
  *
- * @category Schemas
+ * @category FormData
  * @since 4.0.0
  */
 export const FormData = /*#__PURE__*/instanceOf(globalThis.FormData, {
@@ -5534,7 +5571,7 @@ export function fromFormData(schema) {
  *
  * The default JSON serializer encodes a `URLSearchParams` as a query string.
  *
- * @category Schemas
+ * @category URLSearchParams
  * @since 4.0.0
  */
 export const URLSearchParams = /*#__PURE__*/instanceOf(globalThis.URLSearchParams, {
@@ -5633,12 +5670,14 @@ export function fromURLSearchParams(schema) {
 /**
  * A schema for finite numbers, rejecting `NaN`, `Infinity`, and `-Infinity`.
  *
+ * @category Number
  * @since 4.0.0
  */
 export const Finite = /*#__PURE__*/Number.check(/*#__PURE__*/isFinite());
 /**
  * A schema for integers, rejecting `NaN`, `Infinity`, and `-Infinity`.
  *
+ * @category Number
  * @since 4.0.0
  */
 export const Int = /*#__PURE__*/Number.check(/*#__PURE__*/isInt());
@@ -5651,6 +5690,7 @@ export const Int = /*#__PURE__*/Number.check(/*#__PURE__*/isInt());
  * Encoding:
  * - A number is encoded as a `string`.
  *
+ * @category Number
  * @since 4.0.0
  */
 export const NumberFromString = /*#__PURE__*/String.annotate({
@@ -5666,14 +5706,29 @@ export const NumberFromString = /*#__PURE__*/String.annotate({
  * Encoding:
  * - A finite number is encoded as a `string`.
  *
+ * @category Number
  * @since 4.0.0
  */
 export const FiniteFromString = /*#__PURE__*/String.annotate({
   expected: "a string that will be decoded as a finite number"
 }).pipe(/*#__PURE__*/decodeTo(Finite, Transformation.numberFromString));
+/**
+ * A transformation schema that parses a string into a `bigint`.
+ *
+ * Decoding:
+ * - A `string` is decoded as a `bigint`.
+ *
+ * Encoding:
+ * - A `bigint` is encoded as a `string`.
+ *
+ * @category BigInt
+ * @since 4.0.0
+ */
+export const BigIntFromString = /*#__PURE__*/make(AST.bigIntString).pipe(/*#__PURE__*/decodeTo(BigInt, Transformation.bigintFromString));
 /**
  * A schema for strings that contains no leading or trailing whitespaces.
  *
+ * @category String
  * @since 4.0.0
  */
 export const Trimmed = /*#__PURE__*/String.check(/*#__PURE__*/isTrimmed());
@@ -5686,19 +5741,100 @@ export const Trimmed = /*#__PURE__*/String.check(/*#__PURE__*/isTrimmed());
  * Encoding:
  * - The trimmed string is encoded as is.
  *
+ * @category String
  * @since 4.0.0
  */
 export const Trim = /*#__PURE__*/String.annotate({
   expected: "a string that will be decoded as a trimmed string"
 }).pipe(/*#__PURE__*/decodeTo(Trimmed, /*#__PURE__*/Transformation.trim()));
+/**
+ * Decodes a base64 (RFC4648) encoded string into a UTF-8 string.
+ *
+ * Decoding:
+ * - A **valid** base64 encoded string is decoded as a UTF-8 `string`.
+ *
+ * Encoding:
+ * - A `string` is encoded as a base64-encoded string.
+ *
+ * @category String
+ * @since 4.0.0
+ */
+export const StringFromBase64 = /*#__PURE__*/String.annotate({
+  expected: "a base64 encoded string that will be decoded as a UTF-8 string"
+}).pipe(/*#__PURE__*/decodeTo(String, Transformation.stringFromBase64String));
+/**
+ * Decodes a base64 (URL) encoded string into a UTF-8 string.
+ *
+ * Decoding:
+ * - A **valid** base64 (URL) encoded string is decoded as a UTF-8 `string`.
+ *
+ * Encoding:
+ * - A `string` is encoded as a base64 (URL) encoded string.
+ *
+ * @category String
+ * @since 4.0.0
+ */
+export const StringFromBase64Url = /*#__PURE__*/String.annotate({
+  expected: "a base64 (URL) encoded string that will be decoded as a UTF-8 string"
+}).pipe(/*#__PURE__*/decodeTo(String, Transformation.stringFromBase64UrlString));
+/**
+ * Decodes a hex encoded string into a UTF-8 string.
+ *
+ * Decoding:
+ * - A **valid** hex encoded string is decoded as a UTF-8 `string`.
+ *
+ * Encoding:
+ * - A `string` is encoded as a hex string.
+ *
+ * @category String
+ * @since 4.0.0
+ */
+export const StringFromHex = /*#__PURE__*/String.annotate({
+  expected: "a hex encoded string that will be decoded as a UTF-8 string"
+}).pipe(/*#__PURE__*/decodeTo(String, Transformation.stringFromHexString));
+/**
+ * Decodes a URI component encoded string into a UTF-8 string.
+ * Can be used to store data in a URL.
+ *
+ * Decoding:
+ * - A **valid** URI component encoded string is decoded as a UTF-8 `string`.
+ *
+ * Encoding:
+ * - A `string` is encoded as a URI component encoded string.
+ *
+ * **Example**
+ *
+ * ```ts
+ * import { Schema } from "effect"
+ *
+ * const PaginationSchema = Schema.Struct({
+ *   maxItemPerPage: Schema.Number,
+ *   page: Schema.Number
+ * })
+ *
+ * const UrlSchema = Schema.StringFromUriComponent.pipe(
+ *   Schema.decodeTo(Schema.fromJsonString(PaginationSchema))
+ * )
+ *
+ * console.log(Schema.encodeSync(UrlSchema)({ maxItemPerPage: 10, page: 1 }))
+ * // %7B%22maxItemPerPage%22%3A10%2C%22page%22%3A1%7D
+ * ```
+ *
+ * @category String
+ * @since 4.0.0
+ */
+export const StringFromUriComponent = /*#__PURE__*/String.annotate({
+  expected: "a URI component encoded string that will be decoded as a UTF-8 string"
+}).pipe(/*#__PURE__*/decodeTo(String, Transformation.stringFromUriComponent));
 /**
  * A union schema for JavaScript property keys: `number | symbol | string`.
  *
- * @category Schemas
+ * @category PropertyKey
  * @since 4.0.0
  */
 export const PropertyKey = /*#__PURE__*/Union([Finite, Symbol, String]);
 /**
+ * @category StandardSchema
  * @since 4.0.0
  */
 export const StandardSchemaV1FailureResult = /*#__PURE__*/Struct({
@@ -5903,6 +6039,9 @@ export const TimeZoneOffset = /*#__PURE__*/declare(DateTime.isTimeZoneOffset, {
   toFormatter: () => tz => DateTime.zoneToString(tz),
   toEquivalence: () => (a, b) => a.offset === b.offset
 });
+const TimeZoneNamedString = /*#__PURE__*/String.annotate({
+  expected: "an IANA time zone identifier"
+});
 /**
  * A schema for `DateTime.TimeZone.Named` values.
  *
@@ -5923,13 +6062,27 @@ export const TimeZoneNamed = /*#__PURE__*/declare(DateTime.isTimeZoneNamed, {
     importDeclaration: `import * as DateTime from "effect/DateTime"`
   },
   expected: "DateTime.TimeZone.Named",
-  toCodecJson: () => link()(String.annotate({
-    expected: "an IANA time zone identifier"
-  }), Transformation.timeZoneNamedFromString),
+  toCodecJson: () => link()(TimeZoneNamedString, Transformation.timeZoneNamedFromString),
   toArbitrary: () => fc => fc.constantFrom(...["UTC", "Europe/London", "America/New_York", "Asia/Tokyo", "Australia/Sydney"].map(DateTime.zoneMakeNamedUnsafe)),
   toFormatter: () => tz => DateTime.zoneToString(tz),
   toEquivalence: () => (a, b) => a.id === b.id
 });
+/**
+ * A transformation schema that parses an IANA time zone identifier string into a `DateTime.TimeZone.Named`.
+ *
+ * Decoding:
+ * - A `string` is decoded as a `DateTime.TimeZone.Named`.
+ *
+ * Encoding:
+ * - A `DateTime.TimeZone.Named` is encoded as a `string`.
+ *
+ * @category DateTime
+ * @since 4.0.0
+ */
+export const TimeZoneNamedFromString = /*#__PURE__*/TimeZoneNamedString.pipe(/*#__PURE__*/decodeTo(TimeZoneNamed, Transformation.timeZoneNamedFromString));
+const TimeZoneString = /*#__PURE__*/String.annotate({
+  expected: "a time zone string (IANA identifier or offset like +03:00)"
+});
 /**
  * A schema for `DateTime.TimeZone` values.
  *
@@ -5951,9 +6104,7 @@ export const TimeZone = /*#__PURE__*/declare(DateTime.isTimeZone, {
     importDeclaration: `import * as DateTime from "effect/DateTime"`
   },
   expected: "DateTime.TimeZone",
-  toCodecJson: () => link()(String.annotate({
-    expected: "a time zone string (IANA identifier or offset like +03:00)"
-  }), Transformation.timeZoneFromString),
+  toCodecJson: () => link()(TimeZoneString, Transformation.timeZoneFromString),
   toArbitrary: () => fc => fc.oneof(fc.integer({
     min: -12 * 60 * 60 * 1000,
     max: 14 * 60 * 60 * 1000
@@ -5961,6 +6112,22 @@ export const TimeZone = /*#__PURE__*/declare(DateTime.isTimeZone, {
   toFormatter: () => tz => DateTime.zoneToString(tz),
   toEquivalence: () => (a, b) => DateTime.zoneToString(a) === DateTime.zoneToString(b)
 });
+/**
+ * A transformation schema that parses a time zone string into a `DateTime.TimeZone`.
+ *
+ * Decoding:
+ * - A `string` (IANA identifier or offset like `+03:00`) is decoded as a `DateTime.TimeZone`.
+ *
+ * Encoding:
+ * - A `DateTime.TimeZone` is encoded as a `string`.
+ *
+ * @category DateTime
+ * @since 4.0.0
+ */
+export const TimeZoneFromString = /*#__PURE__*/TimeZoneString.pipe(/*#__PURE__*/decodeTo(TimeZone, Transformation.timeZoneFromString));
+const DateTimeZonedString = /*#__PURE__*/String.annotate({
+  expected: "a zoned DateTime string (e.g. 2024-01-01T00:00:00.000+00:00[Europe/London])"
+});
 /**
  * A schema for `DateTime.Zoned` values.
  *
@@ -5982,9 +6149,7 @@ export const DateTimeZoned = /*#__PURE__*/declare(u => DateTime.isDateTime(u) &&
     importDeclaration: `import * as DateTime from "effect/DateTime"`
   },
   expected: "DateTime.Zoned",
-  toCodecJson: () => link()(String.annotate({
-    expected: "a zoned DateTime string (e.g. 2024-01-01T00:00:00.000+00:00[Europe/London])"
-  }), Transformation.dateTimeZonedFromString),
+  toCodecJson: () => link()(DateTimeZonedString, Transformation.dateTimeZonedFromString),
   toArbitrary: () => (fc, ctx) => fc.tuple(fc.date({
     noInvalidDate: true,
     min: new globalThis.Date(-8640000000000000 + 14 * 60 * 60 * 1000),
@@ -5996,14 +6161,27 @@ export const DateTimeZoned = /*#__PURE__*/declare(u => DateTime.isDateTime(u) &&
   toFormatter: () => zoned => DateTime.formatIsoZoned(zoned),
   toEquivalence: () => DateTime.Equivalence
 });
+/**
+ * A transformation schema that parses a zoned DateTime string into a `DateTime.Zoned`.
+ *
+ * Decoding:
+ * - A `string` (e.g. `2024-01-01T00:00:00.000+00:00[Europe/London]`) is decoded as a `DateTime.Zoned`.
+ *
+ * Encoding:
+ * - A `DateTime.Zoned` is encoded as a `string`.
+ *
+ * @category DateTime
+ * @since 4.0.0
+ */
+export const DateTimeZonedFromString = /*#__PURE__*/DateTimeZonedString.pipe(/*#__PURE__*/decodeTo(DateTimeZoned, Transformation.dateTimeZonedFromString));
 const immerable = /*#__PURE__*/globalThis.Symbol.for("immer-draftable");
-function makeClass(Inherited, identifier, struct, annotations) {
+function makeClass(Inherited, identifier, struct, annotations, proto) {
   const getClassSchema = getClassSchemaFactory(struct, identifier, annotations);
   const ClassTypeId = getClassTypeId(identifier); // HMR support
-  return class extends Inherited {
+  const out = class extends Inherited {
     constructor(...[input, options]) {
       const props = input ?? {};
-      const validated = struct.makeUnsafe(props, options);
+      const validated = struct.make(props, options);
       super({
         ...props,
         ...validated
@@ -6012,11 +6190,6 @@ function makeClass(Inherited, identifier, struct, annotations) {
         disableChecks: true
       });
     }
-    toString() {
-      return `${identifier}(${format({
-        ...this
-      })})`;
-    }
     static [TypeId] = TypeId;
     get [ClassTypeId]() {
       return ClassTypeId;
@@ -6033,9 +6206,12 @@ function makeClass(Inherited, identifier, struct, annotations) {
     static rebuild(ast) {
       return getClassSchema(this).rebuild(ast);
     }
-    static makeUnsafe(input, options) {
+    static make(input, options) {
       return new this(input, options);
     }
+    static makeEffect(input, options) {
+      return Effect.mapErrorEager(Parser.makeEffect(getClassSchema(this))(input, options), issue => new SchemaError(issue));
+    }
     static makeOption(input, options) {
       return Parser.makeOption(getClassSchema(this))(input, options);
     }
@@ -6056,13 +6232,17 @@ function makeClass(Inherited, identifier, struct, annotations) {
         };
         return makeClass(this, identifier, makeStruct(AST.struct(fields, struct.ast.checks, {
           identifier
-        }), fields), annotations);
+        }), fields), annotations, proto);
       };
     }
     static mapFields(f, options) {
       return struct.mapFields(f, options);
     }
   };
+  if (proto !== undefined) {
+    Object.assign(out.prototype, proto(identifier));
+  }
+  return out;
 }
 function getClassTransformation(self) {
   return new Transformation.Transformation(Getter.transform(input => new self(input)), Getter.passthrough());
@@ -6140,7 +6320,13 @@ function isStruct(schema) {
  */
 export const Class = identifier => (schema, annotations) => {
   const struct = isStruct(schema) ? schema : Struct(schema);
-  return makeClass(Data.Class, identifier, struct, annotations);
+  return makeClass(Data.Class, identifier, struct, annotations, identifier => ({
+    toString() {
+      return `${identifier}(${format({
+        ...this
+      })})`;
+    }
+  }));
 };
 /**
  * Like {@link Class} but automatically adds a `_tag` literal field set to the
@@ -6202,8 +6388,9 @@ export const TaggedClass = identifier => {
  */
 export const ErrorClass = identifier => (schema, annotations) => {
   const struct = isStruct(schema) ? schema : Struct(schema);
-  const self = makeClass(core.Error, identifier, struct, annotations);
-  self.prototype.name = identifier;
+  const self = makeClass(core.Error, identifier, struct, annotations, identifier => ({
+    name: identifier
+  }));
   return self;
 };
 /**
@@ -6867,12 +7054,26 @@ export const MutableJson = /*#__PURE__*/make(AST.MutableJson);
 // Annotations
 // -----------------------------------------------------------------------------
 /**
- * Return all the typed annotations from the schema.
+ * Resolves the typed annotations from a schema. The term "resolve" (rather
+ * than "get") reflects the lookup strategy: if the schema has checks, the
+ * annotations are taken from the last check; otherwise they are taken from
+ * the base schema instance.
  *
  * @category Schema Resolvers
  * @since 4.0.0
  */
-export function resolveInto(schema) {
+export function resolveAnnotations(schema) {
   return InternalAnnotations.resolve(schema.ast);
 }
+/**
+ * Resolves the context (key-level) annotations from a schema. Context
+ * annotations are those attached via `annotateKey` and live on the AST's
+ * `context` rather than on the schema node itself.
+ *
+ * @category Schema Resolvers
+ * @since 4.0.0
+ */
+export function resolveAnnotationsKey(schema) {
+  return schema.ast.context?.annotations;
+}
 //# sourceMappingURL=Schema.js.map