effect 4.0.0-beta.104 → 4.0.0-beta.105

package/src/SchemaAST.ts

@@ -450,6 +450,8 @@ export type Encoding = readonly [Link, ...Array<Link>]
  *   transformations.
  * - `concurrency` — maximum number of async parse effects to run concurrently;
  *   defaults to `1`, or use `"unbounded"`.
+ * - `reportInput` — includes rejected input values in value-bearing schema
+ *   issues.
  *
  * @category options
  * @since 3.10.0
@@ -516,6 +518,35 @@ export interface ParseOptions {
    * @default 1
    */
   readonly concurrency?: number | "unbounded" | undefined
+
+  /**
+   * Whether schema issues should retain and report rejected input values.
+   *
+   * **Details**
+   *
+   * When enabled, value-bearing issues created by the parser expose an `input`
+   * field. Built-in formatters may include reported input in default messages.
+   * The input is retained by reference rather than copied.
+   *
+   * **Gotchas**
+   *
+   * Enabling this option can retain or disclose secrets, personally
+   * identifiable information, and large object graphs. The `input` field is
+   * enumerable and may be included by object enumeration, spread, or
+   * serialization. Disabling it on a nested schema does not redact that value
+   * from an ancestor issue whose input reporting remains enabled. Issues
+   * returned directly by user-defined declarations, checks, transformations,
+   * and middleware are not modified; their authors decide whether to retain an
+   * input. To respect this option, pass the callback's input and parse options
+   * directly to a value-bearing issue constructor. Custom messages and
+   * annotations remain the caller's responsibility regardless of this option.
+   * Formatting an issue with `SchemaIssue.makeFormatterDefault()`, reading
+   * `SchemaError.message`, or formatting a Standard Schema failure can disclose
+   * retained input.
+   *
+   * @default false
+   */
+  readonly reportInput?: boolean | undefined
 }
 
 /** @internal */
@@ -1151,7 +1182,7 @@ export class TemplateLiteral extends Base {
       }
       return Effect.mapBothEager(result, {
         onSuccess: () => input,
-        onFailure: (issue) => new SchemaIssue.Composite(this, [issue])
+        onFailure: (issue) => new SchemaIssue.Composite(this, [issue], input, options)
       })
     }
   }
@@ -1174,9 +1205,11 @@ export class TemplateLiteral extends Base {
           const segments = segmentTemplateLiteralParts(this, s, options)
           if (segments) return Effect.succeed(segments)
           return Effect.fail(
-            new SchemaIssue.InvalidValue({
-              message: "Expected a string matching template literal parts"
-            })
+            new SchemaIssue.InvalidValue(
+              { expected: "a string matching template literal parts" },
+              s,
+              options
+            )
           )
         }),
         SchemaGetter.transform((parts) => parts.join(""))
@@ -1715,7 +1748,7 @@ export class Arrays extends Base {
 
       // If the input is not an array, return early with an error
       if (!Array.isArray(input)) {
-        return yield* Effect.fail(new SchemaIssue.InvalidType(ast))
+        return yield* Effect.fail(new SchemaIssue.InvalidType(ast, input, options))
       }
       if (!elements) {
         elements = ast.elements.map((ast) => ({ ast, parser: compileConstructorDefault(ast) }))
@@ -1745,20 +1778,21 @@ export class Arrays extends Base {
       // ---------------------------------------------
       if (ast.rest.length === 0 && len > elementLen) {
         for (let i = elementLen; i <= len - 1; i++) {
-          const issue = new SchemaIssue.Pointer([i], new SchemaIssue.UnexpectedKey(ast))
+          const unexpected = new SchemaIssue.UnexpectedKey(ast, input[i], options)
+          const issue = new SchemaIssue.Pointer([i], unexpected)
           if (options.errors === "all") {
             if (state.issues) state.issues.push(issue)
             else state.issues = [issue]
           } else {
             return yield* Effect.fail(
-              new SchemaIssue.Composite(ast, [issue])
+              new SchemaIssue.Composite(ast, [issue], input, options)
             )
           }
         }
       }
       if (state.issues) {
         return yield* Effect.fail(
-          new SchemaIssue.Composite(ast, state.issues)
+          new SchemaIssue.Composite(ast, state.issues, input, options)
         )
       }
       return state.output
@@ -1829,7 +1863,7 @@ const parseArray = iterateEager<{
         else s.issues = [issue]
       } else {
         return Exit.fail(
-          new SchemaIssue.Composite(s.ast, [issue])
+          new SchemaIssue.Composite(s.ast, [issue], s.input, s.options)
         )
       }
     }
@@ -1862,7 +1896,9 @@ const wrapPropertyKeyIssue = (
         (issue) =>
           new SchemaIssue.Composite(
             ast,
-            [new SchemaIssue.Pointer([key], issue)]
+            [new SchemaIssue.Pointer([key], issue)],
+            s.input,
+            s.options
           )
       )
     )
@@ -1873,7 +1909,7 @@ const wrapPropertyKeyIssue = (
     else s.issues = [pointer]
   } else {
     return Exit.fail(
-      new SchemaIssue.Composite(ast, [pointer])
+      new SchemaIssue.Composite(ast, [pointer], s.input, s.options)
     )
   }
 }
@@ -2177,7 +2213,7 @@ export class Objects extends Base {
 
       // If the input is not a record, return early with an error
       if (!(typeof input === "object" && input !== null && !Array.isArray(input))) {
-        return yield* Effect.fail(new SchemaIssue.InvalidType(ast))
+        return yield* Effect.fail(new SchemaIssue.InvalidType(ast, input, options))
       }
       if (!properties) {
         properties = ast.propertySignatures.map((ps) => ({
@@ -2219,7 +2255,8 @@ export class Objects extends Base {
           if (!expectedKeysSet.has(key)) {
             // key is unexpected
             if (onExcessPropertyError) {
-              const issue = new SchemaIssue.Pointer([key], new SchemaIssue.UnexpectedKey(ast))
+              const unexpected = new SchemaIssue.UnexpectedKey(ast, record[key], options)
+              const issue = new SchemaIssue.Pointer([key], unexpected)
               if (errorsAllOption) {
                 if (state.issues) {
                   state.issues.push(issue)
@@ -2229,7 +2266,7 @@ export class Objects extends Base {
                 continue
               } else {
                 return yield* Effect.fail(
-                  new SchemaIssue.Composite(ast, [issue])
+                  new SchemaIssue.Composite(ast, [issue], input, options)
                 )
               }
             } else {
@@ -2281,7 +2318,7 @@ export class Objects extends Base {
 
       if (state.issues) {
         return yield* Effect.fail(
-          new SchemaIssue.Composite(ast, state.issues)
+          new SchemaIssue.Composite(ast, state.issues, input, options)
         )
       }
       if (options.propertyOrder === "original") {
@@ -2387,7 +2424,7 @@ const parseProperties = iterateEager<ObjectParserState, ParsedProperty>()({
         return
       } else {
         return Exit.fail(
-          new SchemaIssue.Composite(s.ast, [issue])
+          new SchemaIssue.Composite(s.ast, [issue], s.input, s.options)
         )
       }
     }
@@ -2779,8 +2816,8 @@ export class Union<A extends AST = AST> extends Base {
         const result = compile(candidates[0])(input, options)
         if ((result as Exit.Exit<unknown, SchemaIssue.Issue>)._tag === "Success") return result
         return effectIsExit(result)
-          ? failSingleUnionCandidate(ast, (result as Exit.Failure<unknown, SchemaIssue.Issue>).cause)
-          : Effect.catchCause(result, (cause) => failSingleUnionCandidate(ast, cause))
+          ? failSingleUnionCandidate(ast, (result as Exit.Failure<unknown, SchemaIssue.Issue>).cause, input, options)
+          : Effect.catchCause(result, (cause) => failSingleUnionCandidate(ast, cause, input, options))
       }
 
       const state = {
@@ -2795,12 +2832,13 @@ export class Union<A extends AST = AST> extends Base {
       const concurrency = resolveConcurrency(options?.concurrency)
       const eff = parseUnion(state, candidates, concurrency ? { ...concurrency, orderedStep: true } : undefined)
       if (!eff) {
-        return state.out ?? Effect.fail(new SchemaIssue.AnyOf(ast, state.issues ?? []))
+        if (state.out) return state.out
+        return Effect.fail(new SchemaIssue.AnyOf(ast, state.issues ?? [], input, options))
       }
       return Effect.flatMapEager(eff, (_) => {
-        return state.out === InternalParser.sameExit
-          ? Effect.succeed(input)
-          : state.out ?? Effect.fail(new SchemaIssue.AnyOf(ast, state.issues ?? []))
+        if (state.out === InternalParser.sameExit) return Effect.succeed(input)
+        if (state.out) return state.out
+        return Effect.fail(new SchemaIssue.AnyOf(ast, state.issues ?? [], input, options))
       })
     }
   }
@@ -2867,12 +2905,13 @@ export class Union<A extends AST = AST> extends Base {
 
 function failSingleUnionCandidate(
   ast: Union,
-  cause: Cause.Cause<SchemaIssue.Issue>
+  cause: Cause.Cause<SchemaIssue.Issue>,
+  input: unknown,
+  options: ParseOptions
 ) {
   const issue = InternalSchemaCause.getSchemaIssue(cause)
-  return issue
-    ? Exit.fail(new SchemaIssue.AnyOf(ast, [issue]))
-    : Exit.failCause(cause)
+  if (!issue) return Exit.failCause(cause)
+  return Exit.fail(new SchemaIssue.AnyOf(ast, [issue], input, options))
 }
 
 const parseUnion = iterateEager<{
@@ -2899,7 +2938,7 @@ const parseUnion = iterateEager<{
     } else {
       if (s.out && s.successes) {
         s.successes.push(candidate)
-        return Exit.fail(new SchemaIssue.OneOf(s.ast, s.successes))
+        return Exit.fail(new SchemaIssue.OneOf(s.ast, s.successes, s.input, s.options))
       }
       s.out = exit
       if (s.successes) {
@@ -3125,7 +3164,7 @@ export function makeFilter<T>(
   aborted: boolean = false
 ): Filter<T> {
   return new Filter(
-    (input, ast, options) => SchemaIssue.normalizeFilterOutput(ast, filter(input, ast, options)),
+    (input, ast, options) => SchemaIssue.normalizeFilterOutput(ast, filter(input, ast, options), input, options),
     annotations,
     aborted
   )
@@ -3137,7 +3176,7 @@ export function makeFilterByGuard<T extends E, E>(
   annotations?: Schema.Annotations.Filter
 ): Filter<any> {
   return new Filter(
-    (input: E) => is(input) ? undefined : new SchemaIssue.InvalidValue(),
+    (input: E, _ast, options) => is(input) ? undefined : new SchemaIssue.InvalidValue(undefined, input, options),
     annotations,
     true // after a guard, we always want to abort
   )
@@ -3688,13 +3727,10 @@ function fromConst<const T>(
   value: T
 ): SchemaParser.Parser {
   const succeed = InternalParser.succeed(value)
-  return (input) => {
+  return (input, options) => {
     if (input === InternalParser.missing) return InternalParser.missingExit
-    return input === value
-      ? succeed
-      : Effect.fail(
-        new SchemaIssue.InvalidType(ast)
-      )
+    if (input === value) return succeed
+    return Effect.fail(new SchemaIssue.InvalidType(ast, input, options))
   }
 }
 
@@ -3702,13 +3738,10 @@ function fromRefinement<T>(
   ast: AST,
   refinement: (input: unknown) => input is T
 ): SchemaParser.Parser {
-  return (input) => {
+  return (input, options) => {
     if (input === InternalParser.missing) return InternalParser.missingExit
-    return refinement(input)
-      ? InternalParser.sameExit
-      : Effect.fail(
-        new SchemaIssue.InvalidType(ast)
-      )
+    if (refinement(input)) return InternalParser.sameExit
+    return Effect.fail(new SchemaIssue.InvalidType(ast, input, options))
   }
 }
 
@@ -3896,13 +3929,17 @@ const symbolToString = new Link(
   symbolString,
   new SchemaTransformation.Transformation(
     SchemaGetter.transform((description) => globalThis.Symbol.for(isStringSymbolRegExp.exec(description)![1])),
-    SchemaGetter.transformOrFail((sym: symbol) => {
+    SchemaGetter.transformOrFail((sym: symbol, options) => {
       const key = globalThis.Symbol.keyFor(sym)
       if (key !== undefined) {
         return Effect.succeed(globalThis.String(sym))
       }
       return Effect.fail(
-        new SchemaIssue.Forbidden({ message: "cannot serialize to string, Symbol is not registered" })
+        new SchemaIssue.Forbidden(
+          { message: "cannot serialize to string, Symbol is not registered" },
+          sym,
+          options
+        )
       )
     })
   )
@@ -3945,7 +3982,7 @@ export function collectIssues<T>(
     } else {
       const issue = check.run(value, ast, options)
       if (issue) {
-        const filter = new SchemaIssue.Filter(check, issue)
+        const filter = new SchemaIssue.Filter(check, issue, value, options)
         if (issues) issues.push(filter)
         else issues = [filter]
         if (options.errors !== "all" || check.aborted) {
@@ -4154,10 +4191,10 @@ export function isJson(u: unknown): u is Schema.Json {
 /** @internal */
 export const Json = new Declaration(
   [],
-  () => (input, ast) =>
+  () => (input, ast, options) =>
     isJson(input) ?
       InternalParser.sameExit :
-      Effect.fail(new SchemaIssue.InvalidType(ast)),
+      Effect.fail(new SchemaIssue.InvalidType(ast, input, options)),
   {
     representation: {
       id: "effect/schema/Json",
@@ -4206,10 +4243,10 @@ export function isStringTree(u: unknown): u is Schema.StringTree {
 
 const StringTree = new Declaration(
   [],
-  () => (input, ast) =>
+  () => (input, ast, options) =>
     isStringTree(input) ?
       InternalParser.sameExit :
-      Effect.fail(new SchemaIssue.InvalidType(ast)),
+      Effect.fail(new SchemaIssue.InvalidType(ast, input, options)),
   { expected: "StringTree", toCodecStringTree: () => undefined }
 )
 

package/src/SchemaError.ts

@@ -3,7 +3,7 @@
  */
 import * as Data from "./Data.ts"
 import * as Predicate from "./Predicate.ts"
-import type { Issue } from "./SchemaIssue.ts"
+import * as SchemaIssue from "./SchemaIssue.ts"
 
 const TypeId = "~effect/SchemaError/SchemaError"
 
@@ -13,12 +13,12 @@ const TypeId = "~effect/SchemaError/SchemaError"
  *
  * **Details**
  *
- * The `issue` field contains a structured {@link Issue} tree describing
+ * The `issue` field contains a structured {@link SchemaIssue.Issue} tree describing
  * every validation failure, including the path to the problematic value and
- * the expected type or constraint. Built-in issues have no `actual` field,
- * and built-in messages do not include the rejected value. Other Issue fields
- * and custom annotations or messages are not sanitized. `message` renders the
- * issue tree as a human-readable string.
+ * the expected type or constraint. The `message` field renders the issue tree
+ * with the default formatter. When input reporting is enabled, the message may
+ * include reported input. Other Issue fields and custom annotations or messages
+ * are not sanitized.
  *
  * Use {@link isSchemaError} to narrow an unknown value to `SchemaError`.
  *
@@ -40,14 +40,14 @@ const TypeId = "~effect/SchemaError/SchemaError"
  * @since 4.0.0
  */
 export class SchemaError extends Data.TaggedError("SchemaError")<{
-  readonly issue: Issue
+  readonly issue: SchemaIssue.Issue
 }> {
   readonly [TypeId]: typeof TypeId = TypeId
-  constructor(issue: Issue) {
+  constructor(issue: SchemaIssue.Issue) {
     super({ issue })
   }
   override get message() {
-    return this.issue.toString()
+    return SchemaIssue.defaultFormatter(this.issue)
   }
   override toString() {
     return `SchemaError(${this.message})`

package/src/SchemaGetter.ts

@@ -133,7 +133,8 @@ export function succeed<const T, E>(t: T): Getter<T, E> {
  * **Details**
  *
  * - Always fails with the `Issue` returned by `f`.
- * - The failure function receives the original `Option<E>` input for error context.
+ * - The failure function receives the original `Option<E>` input and the
+ *   effective `ParseOptions` for error context.
  *
  * **Example** (Defining an always-failing getter)
  *
@@ -153,8 +154,10 @@ export function succeed<const T, E>(t: T): Getter<T, E> {
  * @category constructors
  * @since 4.0.0
  */
-export function fail<T, E>(f: (oe: Option.Option<E>) => SchemaIssue.Issue): Getter<T, E> {
-  return new Getter((oe) => Effect.fail(f(oe)))
+export function fail<T, E>(
+  f: (oe: Option.Option<E>, options: SchemaAST.ParseOptions) => SchemaIssue.Issue
+): Getter<T, E> {
+  return new Getter((oe, options) => Effect.fail(f(oe, options)))
 }
 
 /**
@@ -189,7 +192,12 @@ export function fail<T, E>(f: (oe: Option.Option<E>) => SchemaIssue.Issue): Gett
  * @since 4.0.0
  */
 export function forbidden<T, E>(message: (oe: Option.Option<E>) => string): Getter<T, E> {
-  return fail<T, E>((oe) => new SchemaIssue.Forbidden({ message: message(oe) }))
+  return fail<T, E>((oe, options) => {
+    const annotations = { message: message(oe) }
+    return Option.isSome(oe)
+      ? new SchemaIssue.Forbidden(annotations, oe.value, options)
+      : new SchemaIssue.Forbidden(annotations)
+  })
 }
 
 const passthrough_ = new Getter<any, any>(Effect.succeed)
@@ -465,7 +473,7 @@ export function checkEffect<T, R = never>(
 ): Getter<T, T, R> {
   return onSome((t, options) => {
     return f(t, options).pipe(Effect.flatMapEager((out) => {
-      const issue = SchemaIssue.makeSingle(out)
+      const issue = SchemaIssue.makeSingle(out, t, options)
       return issue ?
         Effect.fail(issue) :
         Effect.succeed(Option.some(t))
@@ -534,10 +542,10 @@ export function transform<T, E>(f: (e: E) => T): Getter<T, E> {
  * import { Effect, Option, SchemaGetter, SchemaIssue } from "effect"
  *
  * const safeParseInt = SchemaGetter.transformOrFail<number, string>(
- *   (s) => {
+ *   (s, options) => {
  *     const n = parseInt(s, 10)
  *     return isNaN(n)
- *       ? Effect.fail(new SchemaIssue.InvalidValue({ message: "not an integer" }))
+ *       ? Effect.fail(new SchemaIssue.InvalidValue({ message: "not an integer" }, s, options))
  *       : Effect.succeed(n)
  *   }
  * )
@@ -996,7 +1004,9 @@ type ParseJsonOptions = {
  * - Skips `None` inputs.
  * - Without `reviver`: returns `Schema.MutableJson` (typed JSON).
  * - With `reviver`: returns `unknown` (reviver may produce arbitrary values).
- * - On parse failure, fails with `SchemaIssue.InvalidValue` containing a static message.
+ * - On parse failure, fails with `SchemaIssue.InvalidValue` whose `expected`
+ *   annotation is `"a valid JSON string"`. Its default message includes the
+ *   reported input when `reportInput` is enabled.
  *
  * **Example** (Parsing JSON)
  *
@@ -1015,10 +1025,15 @@ type ParseJsonOptions = {
 export function parseJson<E extends string>(): Getter<Schema.MutableJson, E>
 export function parseJson<E extends string>(options: ParseJsonOptions): Getter<unknown, E>
 export function parseJson<E extends string>(options?: ParseJsonOptions | undefined): Getter<unknown, E> {
-  return onSome((input) =>
+  return onSome((input, parseOptions) =>
     Effect.try({
       try: () => Option.some(JSON.parse(input, options?.reviver)),
-      catch: () => new SchemaIssue.InvalidValue({ message: "Expected a valid JSON string" })
+      catch: () =>
+        new SchemaIssue.InvalidValue(
+          { expected: "a valid JSON string" },
+          input,
+          parseOptions
+        )
     })
   )
 }
@@ -1070,7 +1085,7 @@ type StringifyJsonOptions = {
  * @since 4.0.0
  */
 export function stringifyJson(options?: StringifyJsonOptions): Getter<string, unknown> {
-  return onSome((input) =>
+  return onSome((input, parseOptions) =>
     Effect.try({
       try: () => {
         const output = JSON.stringify(input, options?.replacer as any, options?.space)
@@ -1079,7 +1094,12 @@ export function stringifyJson(options?: StringifyJsonOptions): Getter<string, un
         }
         return Option.some(output)
       },
-      catch: () => new SchemaIssue.InvalidValue({ message: "Expected a JSON-serializable value" })
+      catch: () =>
+        new SchemaIssue.InvalidValue(
+          { expected: "a JSON-serializable value" },
+          input,
+          parseOptions
+        )
     })
   )
 }
@@ -1307,10 +1327,15 @@ export function encodeHex<E extends Uint8Array | string>(): Getter<string, E> {
  * @since 4.0.0
  */
 export function decodeBase64<E extends string>(): Getter<Uint8Array, E> {
-  return transformOrFail((input) =>
+  return transformOrFail((input, options) =>
     Effect.mapErrorEager(
       Effect.fromResult(Encoding.decodeBase64(input)),
-      () => new SchemaIssue.InvalidValue({ message: "Expected a valid Base64 string" })
+      () =>
+        new SchemaIssue.InvalidValue(
+          { expected: "a valid Base64 string" },
+          input,
+          options
+        )
     )
   )
 }
@@ -1338,9 +1363,16 @@ export function decodeBase64<E extends string>(): Getter<Uint8Array, E> {
  * @since 4.0.0
  */
 export function decodeBase64String<E extends string>(): Getter<string, E> {
-  return transformOrFail((input) =>
+  return transformOrFail((input, options) =>
     Result.match(Encoding.decodeBase64String(input), {
-      onFailure: () => Effect.fail(new SchemaIssue.InvalidValue({ message: "Expected a valid Base64 string" })),
+      onFailure: () =>
+        Effect.fail(
+          new SchemaIssue.InvalidValue(
+            { expected: "a valid Base64 string" },
+            input,
+            options
+          )
+        ),
       onSuccess: Effect.succeed
     })
   )
@@ -1370,9 +1402,16 @@ export function decodeBase64String<E extends string>(): Getter<string, E> {
  * @since 4.0.0
  */
 export function decodeBase64Url<E extends string>(): Getter<Uint8Array, E> {
-  return transformOrFail((input) =>
+  return transformOrFail((input, options) =>
     Result.match(Encoding.decodeBase64Url(input), {
-      onFailure: () => Effect.fail(new SchemaIssue.InvalidValue({ message: "Expected a valid Base64Url string" })),
+      onFailure: () =>
+        Effect.fail(
+          new SchemaIssue.InvalidValue(
+            { expected: "a valid Base64Url string" },
+            input,
+            options
+          )
+        ),
       onSuccess: Effect.succeed
     })
   )
@@ -1401,9 +1440,16 @@ export function decodeBase64Url<E extends string>(): Getter<Uint8Array, E> {
  * @since 4.0.0
  */
 export function decodeBase64UrlString<E extends string>(): Getter<string, E> {
-  return transformOrFail((input) =>
+  return transformOrFail((input, options) =>
     Result.match(Encoding.decodeBase64UrlString(input), {
-      onFailure: () => Effect.fail(new SchemaIssue.InvalidValue({ message: "Expected a valid Base64Url string" })),
+      onFailure: () =>
+        Effect.fail(
+          new SchemaIssue.InvalidValue(
+            { expected: "a valid Base64Url string" },
+            input,
+            options
+          )
+        ),
       onSuccess: Effect.succeed
     })
   )
@@ -1433,11 +1479,15 @@ export function decodeBase64UrlString<E extends string>(): Getter<string, E> {
  * @since 4.0.0
  */
 export function decodeHex<E extends string>(): Getter<Uint8Array, E> {
-  return transformOrFail((input) =>
+  return transformOrFail((input, options) =>
     Result.match(Encoding.decodeHex(input), {
       onFailure: () =>
         Effect.fail(
-          new SchemaIssue.InvalidValue({ message: "Expected a valid hexadecimal string" })
+          new SchemaIssue.InvalidValue(
+            { expected: "a valid hexadecimal string" },
+            input,
+            options
+          )
         ),
       onSuccess: Effect.succeed
     })
@@ -1467,11 +1517,15 @@ export function decodeHex<E extends string>(): Getter<Uint8Array, E> {
  * @since 4.0.0
  */
 export function decodeHexString<E extends string>(): Getter<string, E> {
-  return transformOrFail((input) =>
+  return transformOrFail((input, options) =>
     Result.match(Encoding.decodeHexString(input), {
       onFailure: () =>
         Effect.fail(
-          new SchemaIssue.InvalidValue({ message: "Expected a valid hexadecimal string" })
+          new SchemaIssue.InvalidValue(
+            { expected: "a valid hexadecimal string" },
+            input,
+            options
+          )
         ),
       onSuccess: Effect.succeed
     })
@@ -1527,14 +1581,16 @@ export function encodeUriComponent<E extends string>(): Getter<string, E> {
  * @since 4.0.0
  */
 export function decodeUriComponent<E extends string>(): Getter<string, E> {
-  return transformOrFail((input) => {
+  return transformOrFail((input, options) => {
     try {
       return Effect.succeed(globalThis.decodeURIComponent(input))
     } catch {
       return Effect.fail(
-        new SchemaIssue.InvalidValue({
-          message: "Expected a valid URI component"
-        })
+        new SchemaIssue.InvalidValue(
+          { expected: "a valid URI component" },
+          input,
+          options
+        )
       )
     }
   })
@@ -1573,9 +1629,12 @@ export function decodeUriComponent<E extends string>(): Getter<string, E> {
  * @since 4.0.0
  */
 export function dateTimeUtcFromInput<E extends DateTime.DateTime.Input>(): Getter<DateTime.Utc, E> {
-  return transformOrFail((input) => {
+  return transformOrFail((input, options) => {
     return Option.match(DateTime.make(input), {
-      onNone: () => Effect.fail(new SchemaIssue.InvalidValue({ message: "Invalid DateTime input" })),
+      onNone: () =>
+        Effect.fail(
+          new SchemaIssue.InvalidValue({ message: "Invalid DateTime input" }, input, options)
+        ),
       onSome: (dt) => Effect.succeed(DateTime.toUtc(dt))
     })
   })