effect 4.0.0-beta.103 → 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 */
@@ -532,7 +563,7 @@ export const defaultParseOptions: ParseOptions = {}
  *
  * - `isOptional` — the property key may be absent from the input.
  * - `isMutable` — the property is `readonly` when `false`.
- * - `defaultValue` — an {@link Encoding} applied during construction to
+ * - `constructorDefault` — a {@link Link} applied during construction to
  *   supply missing values.
  * - `annotations` — key-level annotations (e.g. description of the key
  *   itself).
@@ -546,19 +577,19 @@ export class Context {
   readonly isOptional: boolean
   readonly isMutable: boolean
   /** Used for constructor default values (e.g. `withConstructorDefault` API) */
-  readonly defaultValue: Encoding | undefined
+  readonly constructorDefault: Link | undefined
   readonly annotations: Schema.Annotations.Key<unknown> | undefined
 
   constructor(
     isOptional: boolean,
     isMutable: boolean,
     /** Used for constructor default values (e.g. `withConstructorDefault` API) */
-    defaultValue: Encoding | undefined = undefined,
+    constructorDefault: Link | undefined = undefined,
     annotations: Schema.Annotations.Key<unknown> | undefined = undefined
   ) {
     this.isOptional = isOptional
     this.isMutable = isMutable
-    this.defaultValue = defaultValue
+    this.constructorDefault = constructorDefault
     this.annotations = annotations
   }
 }
@@ -1141,8 +1172,8 @@ export class TemplateLiteral extends Base {
     this.suffixLengths = suffixLengths
   }
   /** @internal */
-  getParser(recur: (ast: AST) => SchemaParser.Parser): SchemaParser.Parser {
-    const parser = recur(this.asTemplateLiteralParser())
+  getParser(compile: SchemaParser.Compiler): SchemaParser.Parser {
+    const parser = compile(this.asTemplateLiteralParser())
     return (input, options) => {
       if (input === InternalParser.missing) return InternalParser.missingExit
       const result = parser(input, options)
@@ -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(""))
@@ -1684,7 +1717,10 @@ export class Arrays extends Base {
     }
   }
   /** @internal */
-  getParser(recur: (ast: AST) => SchemaParser.Parser): SchemaParser.Parser {
+  getParser(
+    compile: SchemaParser.Compiler,
+    compileConstructorDefault: SchemaParser.Compiler = compile
+  ): SchemaParser.Parser {
     // oxlint-disable-next-line @typescript-eslint/no-this-alias
     const ast = this
     type ElementParser = { readonly ast: AST; readonly parser: SchemaParser.Parser }
@@ -1712,11 +1748,11 @@ 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: recur(ast) }))
-        rest = ast.rest.map((ast) => ({ ast, parser: recur(ast) }))
+        elements = ast.elements.map((ast) => ({ ast, parser: compileConstructorDefault(ast) }))
+        rest = ast.rest.map((ast) => ({ ast, parser: compileConstructorDefault(ast) }))
       }
 
       const len = input.length
@@ -1742,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
@@ -1826,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)
         )
       }
     }
@@ -1859,7 +1896,9 @@ const wrapPropertyKeyIssue = (
         (issue) =>
           new SchemaIssue.Composite(
             ast,
-            [new SchemaIssue.Pointer([key], issue)]
+            [new SchemaIssue.Pointer([key], issue)],
+            s.input,
+            s.options
           )
       )
     )
@@ -1870,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)
     )
   }
 }
@@ -2076,7 +2115,10 @@ export class Objects extends Base {
     }
   }
   /** @internal */
-  getParser(recur: (ast: AST) => SchemaParser.Parser): SchemaParser.Parser {
+  getParser(
+    compile: SchemaParser.Compiler,
+    compileConstructorDefault: SchemaParser.Compiler = compile
+  ): SchemaParser.Parser {
     // oxlint-disable-next-line @typescript-eslint/no-this-alias
     const ast = this
     const expectedKeys: Array<PropertyKey> = []
@@ -2171,19 +2213,19 @@ 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) => ({
-          parser: recur(ps.type),
+          parser: compileConstructorDefault(ps.type),
           name: ps.name,
           type: ps.type
         }))
         indexes = indexCount
           ? ast.indexSignatures.map((is) => ({
             is,
-            parserKey: recur(parameterFromPropertyKey(is.parameter)),
-            parserValue: recur(is.type)
+            parserKey: compile(parameterFromPropertyKey(is.parameter)),
+            parserValue: compileConstructorDefault(is.type)
           }))
           : undefined
       }
@@ -2213,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)
@@ -2223,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 {
@@ -2275,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") {
@@ -2381,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)
         )
       }
     }
@@ -2577,7 +2620,7 @@ export function collectSentinels(ast: AST): Array<Sentinel> {
 }
 
 type CandidateIndex =
-  | ((input: any) => ReadonlyArray<AST>)
+  | ((input: any, isConstructor: boolean) => ReadonlyArray<AST>)
   | {
     bySentinel?: Map<PropertyKey, Map<LiteralValue | symbol, Array<number>>>
     otherwise?: { [K in Type]?: Array<number> }
@@ -2636,10 +2679,14 @@ function getIndex(types: ReadonlyArray<AST>): CandidateIndex {
       for (const [literal, indexes] of byValue) {
         candidates.set(literal, Object.freeze(indexes.map((index) => types[index])))
       }
-      idx = (input) =>
-        Predicate.isObjectKeyword(input) && Object.hasOwn(input, key)
-          ? candidates.get((input as any)[key]) ?? emptyCandidates
-          : emptyCandidates
+      idx = (input, isConstructor) => {
+        if (Predicate.isObjectKeyword(input)) {
+          const value = Object.hasOwn(input, key) ? (input as any)[key] : undefined
+          if (value !== undefined) return candidates.get(value) ?? emptyCandidates
+          if (isConstructor) return types
+        }
+        return emptyCandidates
+      }
     }
   }
 
@@ -2664,9 +2711,13 @@ function filterLiterals(input: any) {
  *
  * @internal
  */
-export function getCandidates(input: any, types: ReadonlyArray<AST>): ReadonlyArray<AST> {
+export function getCandidates(
+  input: any,
+  types: ReadonlyArray<AST>,
+  isConstructor = false
+): ReadonlyArray<AST> {
   const idx = getIndex(types)
-  if (typeof idx === "function") return idx(input)
+  if (typeof idx === "function") return idx(input, isConstructor)
 
   const runtimeType: Type = input === null ? "null" : Array.isArray(input) ? "array" : typeof input
 
@@ -2676,11 +2727,16 @@ export function getCandidates(input: any, types: ReadonlyArray<AST>): ReadonlyAr
     if (Predicate.isObjectKeyword(input)) {
       const selected = new Set(base)
       for (const [k, m] of idx.bySentinel) {
-        if (Object.hasOwn(input, k)) {
-          const match = m.get((input as any)[k])
+        const value = Object.hasOwn(input, k) ? (input as any)[k] : undefined
+        if (value !== undefined) {
+          const match = m.get(value)
           if (match) {
             for (const candidate of match) selected.add(candidate)
           }
+        } else if (isConstructor) {
+          for (const indexes of m.values()) {
+            for (const candidate of indexes) selected.add(candidate)
+          }
         }
       }
       return Array.from(selected).sort((a, b) => a - b).map((i) => types[i])
@@ -2743,7 +2799,10 @@ export class Union<A extends AST = AST> extends Base {
     this.encodingChecks = encodingChecks
   }
   /** @internal */
-  getParser(recur: (ast: AST) => SchemaParser.Parser): SchemaParser.Parser {
+  getParser(
+    compile: SchemaParser.Compiler,
+    compileConstructorDefault?: SchemaParser.Compiler
+  ): SchemaParser.Parser {
     // oxlint-disable-next-line @typescript-eslint/no-this-alias
     const ast = this
 
@@ -2751,19 +2810,19 @@ export class Union<A extends AST = AST> extends Base {
       if (input === InternalParser.missing) {
         return InternalParser.missingExit
       }
-      const candidates = getCandidates(input, ast.types)
+      const candidates = getCandidates(input, ast.types, compileConstructorDefault !== undefined)
 
       if (candidates.length === 1) {
-        const result = recur(candidates[0])(input, options)
+        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 = {
         ast,
-        recur,
+        compile,
         input,
         out: undefined,
         successes: ast.mode === "oneOf" ? [] : undefined,
@@ -2773,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))
       })
     }
   }
@@ -2845,16 +2905,17 @@ 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<{
-  readonly recur: (ast: AST) => SchemaParser.Parser
+  readonly compile: (ast: AST) => SchemaParser.Parser
   readonly ast: Union
   readonly input: unknown
   readonly options: ParseOptions
@@ -2863,7 +2924,7 @@ const parseUnion = iterateEager<{
   issues: Array<SchemaIssue.Issue> | undefined
 }, AST>()({
   onItem(s, ast) {
-    const parser = s.recur(ast)
+    const parser = s.compile(ast)
     return parser(s.input, s.options)
   },
   step(s, candidate, exit) {
@@ -2877,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) {
@@ -2966,9 +3027,9 @@ export class Suspend extends Base {
     this.thunk = memoizeThunk(thunk)
   }
   /** @internal */
-  getParser(recur: (ast: AST) => SchemaParser.Parser): SchemaParser.Parser {
+  getParser(compile: SchemaParser.Compiler): SchemaParser.Parser {
     let parser: SchemaParser.Parser
-    return (input, options) => (parser ??= recur(this.thunk()))(input, options)
+    return (input, options) => (parser ??= compile(this.thunk()))(input, options)
   }
   /** @internal */
   recur(recur: (ast: AST) => AST) {
@@ -3103,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
   )
@@ -3115,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
   )
@@ -3364,7 +3425,7 @@ export function annotateKey<A extends AST>(ast: A, annotations: Schema.Annotatio
     new Context(
       ast.context.isOptional,
       ast.context.isMutable,
-      ast.context.defaultValue,
+      ast.context.constructorDefault,
       { ...ast.context.annotations, ...annotations }
     ) :
     new Context(false, false, undefined, annotations)
@@ -3390,7 +3451,7 @@ const optionalKeyLastLink = applyToLastLink(optionalKey)
 export function optionalKey<A extends AST>(ast: A): A {
   const context = ast.context ?
     ast.context.isOptional === false ?
-      new Context(true, ast.context.isMutable, ast.context.defaultValue, ast.context.annotations) :
+      new Context(true, ast.context.isMutable, ast.context.constructorDefault, ast.context.annotations) :
       ast.context :
     new Context(true, false)
   return optionalKeyLastLink(replaceContext(ast, context))
@@ -3402,7 +3463,7 @@ const mutableKeyLastLink = applyToLastLink(mutableKey)
 export function mutableKey<A extends AST>(ast: A): A {
   const context = ast.context ?
     ast.context.isMutable === false ?
-      new Context(ast.context.isOptional, true, ast.context.defaultValue, ast.context.annotations) :
+      new Context(ast.context.isOptional, true, ast.context.constructorDefault, ast.context.annotations) :
       ast.context :
     new Context(false, true)
   return mutableKeyLastLink(replaceContext(ast, context))
@@ -3417,10 +3478,10 @@ export function withConstructorDefault<A extends AST>(
     SchemaGetter.withDefault(defaultValue),
     SchemaGetter.passthrough()
   )
-  const encoding: Encoding = [new Link(unknown, transformation)]
+  const constructorDefault = new Link(unknown, transformation)
   const context = ast.context ?
-    new Context(ast.context.isOptional, ast.context.isMutable, encoding, ast.context.annotations) :
-    new Context(false, false, encoding)
+    new Context(ast.context.isOptional, ast.context.isMutable, constructorDefault, ast.context.annotations) :
+    new Context(false, false, constructorDefault)
   return replaceContext(ast, context)
 }
 
@@ -3666,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))
   }
 }
 
@@ -3680,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))
   }
 }
 
@@ -3874,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
+        )
       )
     })
   )
@@ -3923,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) {
@@ -3949,7 +4008,17 @@ export function runChecks<T>(
 }
 
 /** @internal */
-export const ClassTypeId = "~effect/Schema/Class"
+export interface ConstructorDescriptor {
+  readonly isConstructed: Predicate.Predicate<unknown>
+  readonly link: Link
+}
+
+/** @internal */
+export function getConstructorDescriptor(ast: AST): ConstructorDescriptor | undefined {
+  if (!isDeclaration(ast)) return undefined
+  const getDescriptor = ast.annotations?.[InternalAnnotations.CONSTRUCTOR_ANNOTATION_KEY]
+  return Predicate.isFunction(getDescriptor) ? getDescriptor(ast.typeParameters) : undefined
+}
 
 /**
  * Returns all annotations from the AST node.
@@ -4122,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",
@@ -4174,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})`