effect 4.0.0-beta.6 → 4.0.0-beta.62

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}
@@ -482,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)
@@ -504,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))
@@ -670,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>
  * ```
  *
@@ -690,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)
+  })
 }
 
 /**
@@ -1456,6 +1453,65 @@ export function decodeHexString<E extends string>(): Getter<string, E> {
   )
 }
 
+/**
+ * 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`.
  *
@@ -1482,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))
+    })
   })
 }
 
@@ -1517,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())))
 }
 
@@ -1594,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())))
 }
 
@@ -1699,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) => {

package/src/SchemaRepresentation.ts

@@ -1646,7 +1646,7 @@ export const fromASTs: (asts: readonly [AST.AST, ...Array<AST.AST>]) => MultiDoc
  *
  * @since 4.0.0
  */
-export const DocumentFromJson: Schema.Codec<Document, unknown> = Schema.toCodecJson($Document)
+export const DocumentFromJson: Schema.Codec<Document, Schema.Json> = Schema.toCodecJson($Document)
 
 /**
  * Schema codec that decodes a {@link MultiDocument} from JSON and encodes it
@@ -1657,7 +1657,7 @@ export const DocumentFromJson: Schema.Codec<Document, unknown> = Schema.toCodecJ
  *
  * @since 4.0.0
  */
-export const MultiDocumentFromJson: Schema.Codec<MultiDocument, unknown> = Schema.toCodecJson($MultiDocument)
+export const MultiDocumentFromJson: Schema.Codec<MultiDocument, Schema.Json> = Schema.toCodecJson($MultiDocument)
 
 /**
  * Wraps a single {@link Document} as a {@link MultiDocument} with one
@@ -1717,44 +1717,66 @@ export const toSchemaDefaultReviver: Reviver<Schema.Top> = (s, recur) => {
   if (Predicate.isObject(typeConstructor) && typeof typeConstructor._tag === "string") {
     const typeParameters = s.typeParameters.map(recur)
     switch (typeConstructor._tag) {
-      case "effect/Option":
-        return Schema.Option(typeParameters[0])
-      case "effect/Result":
-        return Schema.Result(typeParameters[0], typeParameters[1])
-      case "effect/Redacted":
-        return Schema.Redacted(typeParameters[0])
-      case "effect/Cause/Failure":
-        return Schema.CauseReason(typeParameters[0], typeParameters[1])
-      case "effect/Cause":
-        return Schema.Cause(typeParameters[0], typeParameters[1])
+      // built-in types
+      case "Date":
+        return Schema.Date
       case "Error":
         return Schema.Error
-      case "effect/Exit":
-        return Schema.Exit(typeParameters[0], typeParameters[1], typeParameters[2])
+      case "ErrorWithStack":
+        return Schema.ErrorWithStack
+      case "File":
+        return Schema.File
+      case "FormData":
+        return Schema.FormData
       case "ReadonlyMap":
         return Schema.ReadonlyMap(typeParameters[0], typeParameters[1])
-      case "effect/HashMap":
-        return Schema.HashMap(typeParameters[0], typeParameters[1])
       case "ReadonlySet":
         return Schema.ReadonlySet(typeParameters[0])
       case "RegExp":
         return Schema.RegExp
+      case "Uint8Array":
+        return Schema.Uint8Array
       case "URL":
         return Schema.URL
-      case "File":
-        return Schema.File
-      case "Date":
-        return Schema.Date
-      case "effect/Duration":
-        return Schema.Duration
-      case "FormData":
-        return Schema.FormData
       case "URLSearchParams":
         return Schema.URLSearchParams
-      case "Uint8Array":
-        return Schema.Uint8Array
-      case "DateTime.Utc":
+      // effect types
+      case "effect/Option":
+        return Schema.Option(typeParameters[0])
+      case "effect/Result":
+        return Schema.Result(typeParameters[0], typeParameters[1])
+      case "effect/Redacted":
+        return Schema.Redacted(typeParameters[0])
+      case "effect/DateTime.TimeZone":
+        return Schema.TimeZone
+      case "effect/DateTime.TimeZone.Named":
+        return Schema.TimeZoneNamed
+      case "effect/DateTime.TimeZone.Offset":
+        return Schema.TimeZoneOffset
+      case "effect/DateTime.Utc":
         return Schema.DateTimeUtc
+      case "effect/DateTime.Zoned":
+        return Schema.DateTimeZoned
+      case "effect/BigDecimal":
+        return Schema.BigDecimal
+      case "effect/Chunk":
+        return Schema.Chunk(typeParameters[0])
+      case "effect/Cause":
+        return Schema.Cause(typeParameters[0], typeParameters[1])
+      case "effect/Cause/Failure":
+        return Schema.CauseReason(typeParameters[0], typeParameters[1])
+      case "effect/Duration":
+        return Schema.Duration
+      case "effect/Exit":
+        return Schema.Exit(typeParameters[0], typeParameters[1], typeParameters[2])
+      case "effect/Json":
+        return Schema.Json
+      case "effect/MutableJson":
+        return Schema.MutableJson
+      case "effect/HashMap":
+        return Schema.HashMap(typeParameters[0], typeParameters[1])
+      case "effect/HashSet":
+        return Schema.HashSet(typeParameters[0])
     }
   }
 }
@@ -2993,7 +3015,13 @@ export function fromJsonSchemaMultiDocument(document: JsonSchema.MultiDocument<"
     }
 
     if (Array.isArray(js.allOf)) {
-      return js.allOf.reduce((acc, curr) => combine(acc, recur(curr)), out)
+      out = js.allOf.reduce((acc, curr) => combine(acc, recur(curr)), out)
+    }
+    if (Array.isArray(js.anyOf)) {
+      out = combine({ _tag: "Union", types: js.anyOf.map((type) => recur(type)), mode: "anyOf" }, out)
+    }
+    if (Array.isArray(js.oneOf)) {
+      out = combine({ _tag: "Union", types: js.oneOf.map((type) => recur(type)), mode: "oneOf" }, out)
     }
 
     return out
@@ -3032,10 +3060,6 @@ export function fromJsonSchemaMultiDocument(document: JsonSchema.MultiDocument<"
       } else {
         return { _tag: "Union", types, mode: "anyOf" }
       }
-    } else if (Array.isArray(js.anyOf)) {
-      return { _tag: "Union", types: js.anyOf.map((type) => recur(type)), mode: "anyOf" }
-    } else if (Array.isArray(js.oneOf)) {
-      return { _tag: "Union", types: js.oneOf.map((type) => recur(type)), mode: "oneOf" }
     }
 
     const type = isType(js.type) ? js.type : getType(js)
@@ -3268,7 +3292,7 @@ export function fromJsonSchemaMultiDocument(document: JsonSchema.MultiDocument<"
             return {
               _tag: "Union",
               types,
-              mode: "anyOf",
+              mode: a.mode,
               ...makeAnnotations(a.annotations)
             }
           }