effect 4.0.0-beta.5 → 4.0.0-beta.51

package/src/SchemaGetter.ts

@@ -38,6 +38,7 @@
  * - Parse/stringify JSON → {@link parseJson}, {@link stringifyJson}
  * - Encode/decode Base64 → {@link encodeBase64}, {@link decodeBase64}, {@link decodeBase64String}
  * - Encode/decode Hex → {@link encodeHex}, {@link decodeHex}, {@link decodeHexString}
+ * - Encode/decode URI components → {@link encodeUriComponent}, {@link decodeUriComponent}
  * - Parse DateTime → {@link dateTimeUtcFromInput}
  * - Decode/encode FormData → {@link decodeFormData}, {@link encodeFormData}
  * - Decode/encode URLSearchParams → {@link decodeURLSearchParams}, {@link encodeURLSearchParams}
@@ -86,11 +87,9 @@
  */
 import * as DateTime from "./DateTime.ts"
 import * as Effect from "./Effect.ts"
-import * as Base64 from "./encoding/Base64.ts"
-import * as Base64Url from "./encoding/Base64Url.ts"
-import * as Hex from "./encoding/Hex.ts"
+import * as Encoding from "./Encoding.ts"
 import * as Option from "./Option.ts"
-import { Class } from "./Pipeable.ts"
+import * as Pipeable from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
 import * as Result from "./Result.ts"
 import type * as Schema from "./Schema.ts"
@@ -136,7 +135,7 @@ import * as Str from "./String.ts"
  * @category model
  * @since 4.0.0
  */
-export class Getter<out T, in E, R = never> extends Class {
+export class Getter<out T, in E, R = never> extends Pipeable.Class {
   readonly run: (
     input: Option.Option<E>,
     options: AST.ParseOptions
@@ -484,7 +483,8 @@ export function onSome<T, E, R = never>(
  *   - `undefined` or `true` — value is valid, passes through.
  *   - `false` or a `string` — value is invalid, fails with an `Issue`.
  *   - An `Issue` object — fails with that issue directly.
- *   - `{ path, message }` — fails with a nested path issue.
+ *   - `{ path, issue }` — fails with a nested path issue (`issue` may be a
+ *     message string or a full {@link Issue.Issue}).
  * - Does not transform the value — input and output types are the same.
  *
  * **Example** (Effectful validation)
@@ -506,17 +506,14 @@ export function onSome<T, E, R = never>(
  */
 export function checkEffect<T, R = never>(
   f: (input: T, options: AST.ParseOptions) => Effect.Effect<
-    undefined | boolean | string | Issue.Issue | {
-      readonly path: ReadonlyArray<PropertyKey>
-      readonly message: string
-    },
+    undefined | boolean | Schema.FilterIssue,
     never,
     R
   >
 ): Getter<T, T, R> {
   return onSome((t, options) => {
     return f(t, options).pipe(Effect.flatMapEager((out) => {
-      const issue = Issue.make(t, out)
+      const issue = Issue.makeSingle(t, out)
       return issue ?
         Effect.fail(issue) :
         Effect.succeed(Option.some(t))
@@ -672,16 +669,16 @@ export function omit<T>(): Getter<never, T> {
  * - A field may be `undefined` in the encoded input and should have a fallback.
  *
  * Behavior:
- * - If the input is `Some(undefined)` or `None`, produces `Some(defaultValue())`.
+ * - If the input is `Some(undefined)` or `None`, produces `Some(T)`.
  * - If the input is `Some(value)` where value is not `undefined`, passes it through.
- * - `defaultValue` is called lazily each time a default is needed.
+ * - `defaultValue` is an `Effect` that will be executed each time a default is needed.
  *
  * **Example** (Default value for optional field)
  *
  * ```ts
- * import { SchemaGetter } from "effect"
+ * import { Effect, SchemaGetter } from "effect"
  *
- * const withZero = SchemaGetter.withDefault(() => 0)
+ * const withZero = SchemaGetter.withDefault(Effect.succeed(0))
  * // Getter<number, number | undefined>
  * ```
  *
@@ -692,13 +689,11 @@ export function omit<T>(): Getter<never, T> {
  * @category Constructors
  * @since 4.0.0
  */
-export function withDefault<T>(defaultValue: () => T): Getter<T, T | undefined> {
-  return transformOptional((o) =>
-    o.pipe(
-      Option.filter(Predicate.isNotUndefined),
-      Option.orElseSome(defaultValue)
-    )
-  )
+export function withDefault<T>(defaultValue: Effect.Effect<T>): Getter<T, T | undefined> {
+  return new Getter((o) => {
+    const filtered = Option.filter(o, Predicate.isNotUndefined)
+    return Option.isSome(filtered) ? Effect.succeed(filtered) : Effect.map(defaultValue, Option.some)
+  })
 }
 
 /**
@@ -1218,7 +1213,7 @@ export function split<E extends string>(options?: {
  * @since 4.0.0
  */
 export function encodeBase64<E extends Uint8Array | string>(): Getter<string, E> {
-  return transform(Base64.encode)
+  return transform(Encoding.encodeBase64)
 }
 
 /**
@@ -1244,7 +1239,7 @@ export function encodeBase64<E extends Uint8Array | string>(): Getter<string, E>
  * @since 4.0.0
  */
 export function encodeBase64Url<E extends Uint8Array | string>(): Getter<string, E> {
-  return transform(Base64Url.encode)
+  return transform(Encoding.encodeBase64Url)
 }
 
 /**
@@ -1269,7 +1264,7 @@ export function encodeBase64Url<E extends Uint8Array | string>(): Getter<string,
  * @since 4.0.0
  */
 export function encodeHex<E extends Uint8Array | string>(): Getter<string, E> {
-  return transform(Hex.encode)
+  return transform(Encoding.encodeHex)
 }
 
 /**
@@ -1297,7 +1292,7 @@ export function encodeHex<E extends Uint8Array | string>(): Getter<string, E> {
 export function decodeBase64<E extends string>(): Getter<Uint8Array, E> {
   return transformOrFail((input) =>
     Result.mapError(
-      Base64.decode(input),
+      Encoding.decodeBase64(input),
       (e) => new Issue.InvalidValue(Option.some(input), { message: e.message })
     ).asEffect()
   )
@@ -1327,7 +1322,7 @@ export function decodeBase64<E extends string>(): Getter<Uint8Array, E> {
  */
 export function decodeBase64String<E extends string>(): Getter<string, E> {
   return transformOrFail((input) =>
-    Result.match(Base64.decodeString(input), {
+    Result.match(Encoding.decodeBase64String(input), {
       onFailure: (e) => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: e.message })),
       onSuccess: Effect.succeed
     })
@@ -1358,7 +1353,7 @@ export function decodeBase64String<E extends string>(): Getter<string, E> {
  */
 export function decodeBase64Url<E extends string>(): Getter<Uint8Array, E> {
   return transformOrFail((input) =>
-    Result.match(Base64Url.decode(input), {
+    Result.match(Encoding.decodeBase64Url(input), {
       onFailure: (e) => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: e.message })),
       onSuccess: Effect.succeed
     })
@@ -1389,7 +1384,7 @@ export function decodeBase64Url<E extends string>(): Getter<Uint8Array, E> {
  */
 export function decodeBase64UrlString<E extends string>(): Getter<string, E> {
   return transformOrFail((input) =>
-    Result.match(Base64Url.decodeString(input), {
+    Result.match(Encoding.decodeBase64UrlString(input), {
       onFailure: (e) => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: e.message })),
       onSuccess: Effect.succeed
     })
@@ -1420,7 +1415,7 @@ export function decodeBase64UrlString<E extends string>(): Getter<string, E> {
  */
 export function decodeHex<E extends string>(): Getter<Uint8Array, E> {
   return transformOrFail((input) =>
-    Result.match(Hex.decode(input), {
+    Result.match(Encoding.decodeHex(input), {
       onFailure: (e) => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: e.message })),
       onSuccess: Effect.succeed
     })
@@ -1451,13 +1446,72 @@ export function decodeHex<E extends string>(): Getter<Uint8Array, E> {
  */
 export function decodeHexString<E extends string>(): Getter<string, E> {
   return transformOrFail((input) =>
-    Result.match(Hex.decodeString(input), {
+    Result.match(Encoding.decodeHexString(input), {
       onFailure: (e) => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: e.message })),
       onSuccess: Effect.succeed
     })
   )
 }
 
+/**
+ * Encodes a string using `encodeURIComponent`.
+ *
+ * Behavior:
+ * - Pure, never fails.
+ *
+ * **Example** (Encode a URI component)
+ *
+ * ```ts
+ * import { SchemaGetter } from "effect"
+ *
+ * const encode = SchemaGetter.encodeUriComponent<string>()
+ * ```
+ *
+ * See also:
+ * - {@link decodeUriComponent} - inverse operation
+ *
+ * @category URI
+ * @since 4.0.0
+ */
+export function encodeUriComponent<E extends string>(): Getter<string, E> {
+  return transform(encodeURIComponent)
+}
+
+/**
+ * Decodes a URI component encoded string using `decodeURIComponent`.
+ *
+ * Behavior:
+ * - Fails with `Issue.InvalidValue` if the input contains malformed percent-encoding sequences.
+ *
+ * **Example** (Decode a URI component)
+ *
+ * ```ts
+ * import { SchemaGetter } from "effect"
+ *
+ * const decode = SchemaGetter.decodeUriComponent<string>()
+ * // Getter<string, string>
+ * ```
+ *
+ * See also:
+ * - {@link encodeUriComponent} - inverse operation
+ *
+ * @category URI
+ * @since 4.0.0
+ */
+export function decodeUriComponent<E extends string>(): Getter<string, E> {
+  return transformOrFail((input) => {
+    try {
+      return Effect.succeed(globalThis.decodeURIComponent(input))
+    } catch (e) {
+      return Effect.fail(
+        new Issue.InvalidValue(Option.some(input), {
+          message: e instanceof URIError ? e.message : "Invalid URI component"
+        })
+      )
+    }
+  })
+}
+
 /**
  * Parses a `DateTime.Input` value (string, number, or Date) into a `DateTime.Utc`.
  *
@@ -1484,10 +1538,10 @@ export function decodeHexString<E extends string>(): Getter<string, E> {
  */
 export function dateTimeUtcFromInput<E extends DateTime.DateTime.Input>(): Getter<DateTime.Utc, E> {
   return transformOrFail((input) => {
-    const dt = DateTime.make(input)
-    return dt
-      ? Effect.succeed(DateTime.toUtc(dt))
-      : Effect.fail(new Issue.InvalidValue(Option.some(input), { message: "Invalid DateTime input" }))
+    return Option.match(DateTime.make(input), {
+      onNone: () => Effect.fail(new Issue.InvalidValue(Option.some(input), { message: "Invalid DateTime input" })),
+      onSome: (dt) => Effect.succeed(DateTime.toUtc(dt))
+    })
   })
 }
 
@@ -1519,7 +1573,7 @@ export function dateTimeUtcFromInput<E extends DateTime.DateTime.Input>(): Gette
  * @category FormData
  * @since 4.0.0
  */
-export function decodeFormData(): Getter<Schema.TreeObject<string | Blob>, FormData> {
+export function decodeFormData(): Getter<Schema.TreeRecord<string | Blob>, FormData> {
   return transform((input) => makeTreeRecord(Array.from(input.entries())))
 }
 
@@ -1596,7 +1650,7 @@ export function encodeFormData(): Getter<FormData, unknown> {
  * @category URLSearchParams
  * @since 4.0.0
  */
-export function decodeURLSearchParams(): Getter<Schema.TreeObject<string>, URLSearchParams> {
+export function decodeURLSearchParams(): Getter<Schema.TreeRecord<string>, URLSearchParams> {
   return transform((input) => makeTreeRecord(Array.from(input.entries())))
 }
 
@@ -1701,7 +1755,7 @@ function bracketPathToTokens(bracketPath: string): Array<string | number> {
  */
 export function makeTreeRecord<A>(
   bracketPathEntries: ReadonlyArray<readonly [bracketPath: string, value: A]>
-): Schema.TreeObject<A> {
+): Schema.TreeRecord<A> {
   const out: any = {}
   bracketPathEntries.forEach(([key, value]) => {
     const tokens = bracketPathToTokens(key)

package/src/SchemaIssue.ts

@@ -79,6 +79,7 @@
  * @since 4.0.0
  */
 import type { StandardSchemaV1 } from "@standard-schema/spec"
+import * as Arr from "./Array.ts"
 import { format, formatPath, type Formatter as FormatterI } from "./Formatter.ts"
 import * as InternalAnnotations from "./internal/schema/annotations.ts"
 import * as Option from "./Option.ts"
@@ -867,30 +868,42 @@ export function getActual(issue: Issue): Option.Option<unknown> {
   }
 }
 
-/** @internal */
-export function make(
-  input: unknown,
-  out: undefined | boolean | string | Issue | {
-    readonly path: ReadonlyArray<PropertyKey>
-    readonly message: string
+function makeFilterIssue(input: unknown, entry: Schema.FilterIssue): Issue {
+  if (isIssue(entry)) {
+    return entry
   }
-) {
-  if (isIssue(out)) {
-    return out
+  if (typeof entry === "string") {
+    return new InvalidValue(Option.some(input), { message: entry })
   }
+  const inner = typeof entry.issue === "string"
+    ? new InvalidValue(Option.some(input), { message: entry.issue })
+    : entry.issue
+  return new Pointer(entry.path, inner)
+}
+
+/** @internal */
+export function makeSingle(input: unknown, out: undefined | boolean | Schema.FilterIssue): Issue | undefined {
   if (out === undefined) {
     return undefined
   }
   if (typeof out === "boolean") {
     return out ? undefined : new InvalidValue(Option.some(input))
   }
-  if (typeof out === "string") {
-    return new InvalidValue(Option.some(input), { message: out })
+  return makeFilterIssue(input, out)
+}
+
+/** @internal */
+export function make(input: unknown, ast: AST.AST, out: Schema.FilterOutput): Issue | undefined {
+  if (Array.isArray(out)) {
+    if (Arr.isReadonlyArrayNonEmpty(out)) {
+      if (out.length === 1) {
+        return makeFilterIssue(input, out[0])
+      }
+      return new Composite(ast, Option.some(input), Arr.map(out, (entry) => makeFilterIssue(input, entry)))
+    }
+    return undefined
   }
-  return new Pointer(
-    out.path,
-    new InvalidValue(Option.some(input), { message: out.message })
-  )
+  return makeSingle(input, out as undefined | boolean | Schema.FilterIssue)
 }
 
 /**

package/src/SchemaParser.ts

@@ -49,7 +49,23 @@ export function makeEffect<S extends Schema.Top>(schema: S) {
   const ast = recurDefaults(AST.toType(schema.ast))
   const parser = run<S["Type"], never>(ast)
   return (input: S["~type.make.in"], options?: Schema.MakeOptions): Effect.Effect<S["Type"], Issue.Issue> => {
-    return parser(input, options?.parseOptions)
+    return parser(
+      input,
+      options?.disableChecks
+        ? options?.parseOptions ? { ...options.parseOptions, disableChecks: true } : { disableChecks: true }
+        : options?.parseOptions
+    )
+  }
+}
+
+/**
+ * @category Constructing
+ * @since 4.0.0
+ */
+export function makeOption<S extends Schema.Top>(schema: S) {
+  const parser = makeEffect(schema)
+  return (input: S["~type.make.in"], options?: Schema.MakeOptions): Option.Option<S["Type"]> => {
+    return Exit.getSuccess(Effect.runSyncExit(parser(input, options) as any))
   }
 }
 
@@ -73,10 +89,8 @@ export function makeUnsafe<S extends Schema.Top>(schema: S) {
  * @category Asserting
  * @since 4.0.0
  */
-export function is<S extends Schema.Top & { readonly DecodingServices: never }>(
-  schema: S
-): <I>(input: I) => input is I & S["Type"] {
-  return _is<S["Type"]>(schema.ast)
+export function is<T>(schema: Schema.Schema<T>): <I>(input: I) => input is I & T {
+  return _is<T>(schema.ast)
 }
 
 /** @internal */
@@ -102,11 +116,9 @@ export function _issue<T>(ast: AST.AST) {
  * @category Asserting
  * @since 4.0.0
  */
-export function asserts<S extends Schema.Top & { readonly DecodingServices: never }>(
-  schema: S
-) {
-  const parser = asExit(run<S["Type"], never>(AST.toType(schema.ast)))
-  return <I>(input: I): asserts input is I & S["Type"] => {
+export function asserts<T>(schema: Schema.Schema<T>) {
+  const parser = asExit(run<T, never>(AST.toType(schema.ast)))
+  return <I>(input: I): asserts input is I & T => {
     const exit = parser(input, AST.defaultParseOptions)
     if (Exit.isFailure(exit)) {
       const issue = Cause.findError(exit.cause)
@@ -141,7 +153,7 @@ export const decodeEffect: <S extends Schema.Top>(
  * @category Decoding
  * @since 4.0.0
  */
-export function decodeUnknownPromise<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodeUnknownPromise<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Promise<S["Type"]> {
   return asPromise(decodeUnknownEffect(schema))
@@ -151,7 +163,7 @@ export function decodeUnknownPromise<S extends Schema.Top & { readonly DecodingS
  * @category Decoding
  * @since 4.0.0
  */
-export function decodePromise<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodePromise<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: S["Encoded"], options?: AST.ParseOptions) => Promise<S["Type"]> {
   return asPromise(decodeEffect(schema))
@@ -161,7 +173,7 @@ export function decodePromise<S extends Schema.Top & { readonly DecodingServices
  * @category Decoding
  * @since 4.0.0
  */
-export function decodeUnknownExit<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodeUnknownExit<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Exit.Exit<S["Type"], Issue.Issue> {
   return asExit(decodeUnknownEffect(schema))
@@ -171,7 +183,7 @@ export function decodeUnknownExit<S extends Schema.Top & { readonly DecodingServ
  * @category Decoding
  * @since 4.0.0
  */
-export const decodeExit: <S extends Schema.Top & { readonly DecodingServices: never }>(
+export const decodeExit: <S extends Schema.Decoder<unknown>>(
   schema: S
 ) => (input: S["Encoded"], options?: AST.ParseOptions) => Exit.Exit<S["Type"], Issue.Issue> = decodeUnknownExit
 
@@ -179,7 +191,7 @@ export const decodeExit: <S extends Schema.Top & { readonly DecodingServices: ne
  * @category Decoding
  * @since 4.0.0
  */
-export function decodeUnknownOption<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodeUnknownOption<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Option.Option<S["Type"]> {
   return asOption(decodeUnknownEffect(schema))
@@ -189,7 +201,7 @@ export function decodeUnknownOption<S extends Schema.Top & { readonly DecodingSe
  * @category Decoding
  * @since 4.0.0
  */
-export const decodeOption: <S extends Schema.Top & { readonly DecodingServices: never }>(
+export const decodeOption: <S extends Schema.Decoder<unknown>>(
   schema: S
 ) => (input: S["Encoded"], options?: AST.ParseOptions) => Option.Option<S["Type"]> = decodeUnknownOption
 
@@ -197,7 +209,25 @@ export const decodeOption: <S extends Schema.Top & { readonly DecodingServices:
  * @category Decoding
  * @since 4.0.0
  */
-export function decodeUnknownSync<S extends Schema.Top & { readonly DecodingServices: never }>(
+export function decodeUnknownResult<S extends Schema.Decoder<unknown>>(
+  schema: S
+): (input: unknown, options?: AST.ParseOptions) => Result.Result<S["Type"], Issue.Issue> {
+  return asResult(decodeUnknownEffect(schema))
+}
+
+/**
+ * @category Decoding
+ * @since 4.0.0
+ */
+export const decodeResult: <S extends Schema.Decoder<unknown>>(
+  schema: S
+) => (input: S["Encoded"], options?: AST.ParseOptions) => Result.Result<S["Type"], Issue.Issue> = decodeUnknownResult
+
+/**
+ * @category Decoding
+ * @since 4.0.0
+ */
+export function decodeUnknownSync<S extends Schema.Decoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => S["Type"] {
   return asSync(decodeUnknownEffect(schema))
@@ -207,7 +237,7 @@ export function decodeUnknownSync<S extends Schema.Top & { readonly DecodingServ
  * @category Decoding
  * @since 4.0.0
  */
-export const decodeSync: <S extends Schema.Top & { readonly DecodingServices: never }>(
+export const decodeSync: <S extends Schema.Decoder<unknown>>(
   schema: S
 ) => (input: S["Encoded"], options?: AST.ParseOptions) => S["Type"] = decodeUnknownSync
 
@@ -234,7 +264,7 @@ export const encodeEffect: <S extends Schema.Top>(
  * @category Encoding
  * @since 4.0.0
  */
-export const encodeUnknownPromise = <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodeUnknownPromise = <S extends Schema.Encoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Promise<S["Encoded"]> => asPromise(encodeUnknownEffect(schema))
 
@@ -242,7 +272,7 @@ export const encodeUnknownPromise = <S extends Schema.Top & { readonly EncodingS
  * @category Encoding
  * @since 4.0.0
  */
-export const encodePromise: <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodePromise: <S extends Schema.Encoder<unknown>>(
   schema: S
 ) => (input: S["Type"], options?: AST.ParseOptions) => Promise<S["Encoded"]> = encodeUnknownPromise
 
@@ -250,7 +280,7 @@ export const encodePromise: <S extends Schema.Top & { readonly EncodingServices:
  * @category Encoding
  * @since 4.0.0
  */
-export function encodeUnknownExit<S extends Schema.Top & { readonly EncodingServices: never }>(
+export function encodeUnknownExit<S extends Schema.Encoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Exit.Exit<S["Encoded"], Issue.Issue> {
   return asExit(encodeUnknownEffect(schema))
@@ -260,7 +290,7 @@ export function encodeUnknownExit<S extends Schema.Top & { readonly EncodingServ
  * @category Encoding
  * @since 4.0.0
  */
-export const encodeExit: <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodeExit: <S extends Schema.Encoder<unknown>>(
   schema: S
 ) => (input: S["Type"], options?: AST.ParseOptions) => Exit.Exit<S["Encoded"], Issue.Issue> = encodeUnknownExit
 
@@ -268,7 +298,7 @@ export const encodeExit: <S extends Schema.Top & { readonly EncodingServices: ne
  * @category Encoding
  * @since 4.0.0
  */
-export function encodeUnknownOption<S extends Schema.Top & { readonly EncodingServices: never }>(
+export function encodeUnknownOption<S extends Schema.Encoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => Option.Option<S["Encoded"]> {
   return asOption(encodeUnknownEffect(schema))
@@ -278,7 +308,7 @@ export function encodeUnknownOption<S extends Schema.Top & { readonly EncodingSe
  * @category Encoding
  * @since 4.0.0
  */
-export const encodeOption: <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodeOption: <S extends Schema.Encoder<unknown>>(
   schema: S
 ) => (input: S["Type"], options?: AST.ParseOptions) => Option.Option<S["Encoded"]> = encodeUnknownOption
 
@@ -286,7 +316,25 @@ export const encodeOption: <S extends Schema.Top & { readonly EncodingServices:
  * @category Encoding
  * @since 4.0.0
  */
-export function encodeUnknownSync<S extends Schema.Top & { readonly EncodingServices: never }>(
+export function encodeUnknownResult<S extends Schema.Encoder<unknown>>(
+  schema: S
+): (input: unknown, options?: AST.ParseOptions) => Result.Result<S["Encoded"], Issue.Issue> {
+  return asResult(encodeUnknownEffect(schema))
+}
+
+/**
+ * @category Encoding
+ * @since 4.0.0
+ */
+export const encodeResult: <S extends Schema.Encoder<unknown>>(
+  schema: S
+) => (input: S["Type"], options?: AST.ParseOptions) => Result.Result<S["Encoded"], Issue.Issue> = encodeUnknownResult
+
+/**
+ * @category Encoding
+ * @since 4.0.0
+ */
+export function encodeUnknownSync<S extends Schema.Encoder<unknown>>(
   schema: S
 ): (input: unknown, options?: AST.ParseOptions) => S["Encoded"] {
   return asSync(encodeUnknownEffect(schema))
@@ -296,7 +344,7 @@ export function encodeUnknownSync<S extends Schema.Top & { readonly EncodingServ
  * @category Encoding
  * @since 4.0.0
  */
-export const encodeSync: <S extends Schema.Top & { readonly EncodingServices: never }>(
+export const encodeSync: <S extends Schema.Encoder<unknown>>(
   schema: S
 ) => (input: S["Type"], options?: AST.ParseOptions) => S["Encoded"] = encodeUnknownSync
 
@@ -332,6 +380,23 @@ export function asOption<T, E, R>(
   return (input: E, options?: AST.ParseOptions) => Exit.getSuccess(parserExit(input, options))
 }
 
+function asResult<T, E, R>(
+  parser: (input: E, options?: AST.ParseOptions) => Effect.Effect<T, Issue.Issue, R>
+): (input: E, options?: AST.ParseOptions) => Result.Result<T, Issue.Issue> {
+  const parserExit = asExit(parser)
+  return (input: E, options?: AST.ParseOptions) => {
+    const exit = parserExit(input, options)
+    if (Exit.isSuccess(exit)) {
+      return Result.succeed(exit.value)
+    }
+    const error = Cause.findError(exit.cause)
+    if (Result.isFailure(error)) {
+      throw Cause.squash(error.failure)
+    }
+    return Result.fail(error.success)
+  }
+}
+
 function asSync<T, E, R>(
   parser: (input: E, options?: AST.ParseOptions) => Effect.Effect<T, Issue.Issue, R>
 ): (input: E, options?: AST.ParseOptions) => T {
@@ -352,16 +417,22 @@ export interface Parser {
 const recur = memoize(
   (ast: AST.AST): Parser => {
     let parser: Parser
+    const astOptions = InternalAnnotations.resolve(ast)?.["parseOptions"]
     if (!ast.context && !ast.encoding && !ast.checks) {
       return (ou, options) => {
         parser ??= ast.getParser(recur)
-        return parser(ou, InternalAnnotations.resolve(ast)?.["parseOptions"] ?? options)
+        if (astOptions) {
+          options = { ...options, ...astOptions }
+        }
+        return parser(ou, options)
       }
     }
     const isStructural = AST.isArrays(ast) || AST.isObjects(ast) ||
       (AST.isDeclaration(ast) && ast.typeParameters.length > 0)
     return (ou, options) => {
-      options = InternalAnnotations.resolve(ast)?.["parseOptions"] ?? options
+      if (astOptions) {
+        options = { ...options, ...astOptions }
+      }
       const encoding = ast.encoding
       let srou: Effect.Effect<Option.Option<unknown>, Issue.Issue, unknown> | undefined
       if (encoding) {
@@ -385,7 +456,7 @@ const recur = memoize(
       parser ??= ast.getParser(recur)
       let sroa = srou ? Effect.flatMapEager(srou, (ou) => parser(ou, options)) : parser(ou, options)
 
-      if (ast.checks) {
+      if (ast.checks && !options?.disableChecks) {
         const checks = ast.checks
         if (options?.errors === "all" && isStructural && Option.isSome(ou)) {
           sroa = Effect.catchEager(sroa, (issue) => {