effect 4.0.0-beta.99 → 4.0.0-rc.108

package/dist/SchemaIssue.js

@@ -1,9 +1,8 @@
 import * as Arr from "./Array.js";
 import { format, formatPath } from "./Formatter.js";
 import * as InternalAnnotations from "./internal/schema/annotations.js";
-import * as Option from "./Option.js";
+import * as InternalParser from "./internal/schema/parser.js";
 import { hasProperty } from "./Predicate.js";
-import * as Redacted from "./Redacted.js";
 const TypeId = "~effect/SchemaIssue/Issue";
 /**
  * Returns `true` if the given value is an {@link Issue}.
@@ -20,14 +19,12 @@ const TypeId = "~effect/SchemaIssue/Issue";
  *
  * **Example** (Type-guarding an unknown error)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { SchemaIssue } from "effect"
  *
  * const issue = new SchemaIssue.MissingKey(undefined)
- * console.log(SchemaIssue.isIssue(issue))
- * // true
- * console.log(SchemaIssue.isIssue("not an issue"))
- * // false
+ * SchemaIssue.isIssue(issue) // => true
+ * SchemaIssue.isIssue("not an issue") // => false
  * ```
  *
  * @see {@link Issue}
@@ -36,12 +33,46 @@ const TypeId = "~effect/SchemaIssue/Issue";
  * @since 4.0.0
  */
 export function isIssue(u) {
-  return hasProperty(u, TypeId);
+  return hasProperty(u, TypeId) && u[TypeId] === TypeId;
+}
+/**
+ * Returns `true` when an issue contains an input reported by the schema parser.
+ *
+ * **When to use**
+ *
+ * Use when reading `Issue.input`, especially when `undefined` is a valid input
+ * value.
+ *
+ * **Details**
+ *
+ * Reported input is stored as an own property. This guard checks for that
+ * property and narrows `input` from optional to required.
+ *
+ * **Example** (Reading a reported input)
+ *
+ * ```ts import.meta.vitest
+ * import { Result, Schema, SchemaIssue } from "effect"
+ *
+ * const result = Schema.decodeUnknownResult(Schema.String)(1, { reportInput: true })
+ * if (Result.isFailure(result) && SchemaIssue.hasInput(result.failure.issue)) {
+ *   result.failure.issue.input // => 1
+ * }
+ * ```
+ *
+ * @see {@link Issue} for the complete issue model
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export function hasInput(issue) {
+  return Object.hasOwn(issue, "input");
 }
 class Base {
   [TypeId] = TypeId;
-  toString() {
-    return defaultFormatter(this);
+  constructor(input, options) {
+    if (options?.reportInput === true && input !== InternalParser.missing) {
+      this.input = input;
+    }
   }
 }
 /**
@@ -54,22 +85,28 @@ class Base {
  *
  * **Details**
  *
- * - `actual` is the raw input value that was tested (plain `unknown`, not
- *   wrapped in `Option`).
  * - `filter` is the AST filter node that produced this issue.
  * - `issue` is the inner issue describing the failure reason.
  *
  * **Example** (Matching a Filter issue)
  *
- * ```ts
- * import { SchemaIssue } from "effect"
+ * ```ts import.meta.vitest
+ * import { SchemaAST, SchemaIssue } from "effect"
+ *
+ * const formatIssue = SchemaIssue.makeFormatterDefault()
  *
  * function describe(issue: SchemaIssue.Issue): string {
  *   if (issue._tag === "Filter") {
- *     return `Filter failed on: ${JSON.stringify(issue.actual)}`
+ *     return `Filter failed: ${formatIssue(issue.issue)}`
  *   }
- *   return String(issue)
+ *   return formatIssue(issue)
  * }
+ *
+ * const issue = new SchemaIssue.Filter(
+ *   SchemaAST.isPattern(/^valid$/),
+ *   new SchemaIssue.InvalidValue()
+ * )
+ * describe(issue) // => `Filter failed: Expected a valid value`
  * ```
  *
  * @see {@link Leaf} — terminal issue types that commonly appear as the inner `issue`
@@ -80,10 +117,6 @@ class Base {
  */
 export class Filter extends Base {
   _tag = "Filter";
-  /**
-   * The input value that caused the issue.
-   */
-  actual;
   /**
    * The filter that failed.
    */
@@ -93,10 +126,6 @@ export class Filter extends Base {
    */
   issue;
   constructor(
-  /**
-   * The input value that caused the issue.
-   */
-  actual,
   /**
    * The filter that failed.
    */
@@ -104,9 +133,17 @@ export class Filter extends Base {
   /**
    * The issue that occurred.
    */
-  issue) {
-    super();
-    this.actual = actual;
+  issue,
+  /**
+   * The present input associated with the issue. It is retained only when
+   * `options.reportInput` is `true`.
+   */
+  input,
+  /**
+   * The effective parse options controlling input retention.
+   */
+  options) {
+    super(input, options);
     this.filter = filter;
     this.issue = issue;
   }
@@ -122,8 +159,6 @@ export class Filter extends Base {
  * **Details**
  *
  * - `ast` is the AST node for the transformation that failed.
- * - `actual` is `Option.some(value)` when the input was present, or
- *   `Option.none()` when it was absent.
  * - `issue` is the inner issue describing the failure.
  *
  * @see {@link Filter} — failure from a refinement check (not a transformation)
@@ -138,10 +173,6 @@ export class Encoding extends Base {
    * The schema that caused the issue.
    */
   ast;
-  /**
-   * The input value that caused the issue.
-   */
-  actual;
   /**
    * The issue that occurred.
    */
@@ -152,16 +183,20 @@ export class Encoding extends Base {
    */
   ast,
   /**
-   * The input value that caused the issue.
+   * The issue that occurred.
    */
-  actual,
+  issue,
   /**
-   * The issue that occurred.
+   * The present input associated with the issue. It is retained only when
+   * `options.reportInput` is `true`.
    */
-  issue) {
-    super();
+  input,
+  /**
+   * The effective parse options controlling input retention.
+   */
+  options) {
+    super(input, options);
     this.ast = ast;
-    this.actual = actual;
     this.issue = issue;
   }
 }
@@ -177,11 +212,9 @@ export class Encoding extends Base {
  * **Details**
  *
  * - `path` is an array of property keys (strings, numbers, or symbols).
- * - Has no `actual` value — {@link getActual} returns `Option.none()`.
  * - Formatters concatenate nested `Pointer` paths into a single path like
  *   `["a"]["b"][0]`.
  *
- * @see {@link getActual} — returns `Option.none()` for `Pointer`
  * @see {@link Composite} — groups multiple issues under one schema node
  *
  * @category models
@@ -220,7 +253,6 @@ export class Pointer extends Base {
  *
  * **Details**
  *
- * - Has no `actual` value — {@link getActual} returns `Option.none()`.
  * - `annotations` may contain a custom `messageMissingKey` for formatting.
  *
  * @see {@link Pointer} — wraps this issue with the missing key's path
@@ -255,9 +287,10 @@ export class MissingKey extends Base {
  *
  * **Details**
  *
- * - `actual` is the raw value at the unexpected key (plain `unknown`).
  * - `ast` is the schema that was being validated against.
  * - `annotations` on `ast` may contain a custom `messageUnexpectedKey`.
+ * - The default formatter renders this as `"Expected no excess property"`, or
+ *   `"Unexpected key with value <input>"` when the issue reports an input.
  *
  * @see {@link MissingKey} — the opposite case (required key absent)
  * @see {@link Pointer} — wraps this issue with the unexpected key's path
@@ -271,22 +304,22 @@ export class UnexpectedKey extends Base {
    * The schema that caused the issue.
    */
   ast;
-  /**
-   * The input value that caused the issue.
-   */
-  actual;
   constructor(
   /**
    * The schema that caused the issue.
    */
   ast,
   /**
-   * The input value that caused the issue.
+   * The present input associated with the issue. It is retained only when
+   * `options.reportInput` is `true`.
    */
-  actual) {
-    super();
+  input,
+  /**
+   * The effective parse options controlling input retention.
+   */
+  options) {
+    super(input, options);
     this.ast = ast;
-    this.actual = actual;
   }
 }
 /**
@@ -300,8 +333,6 @@ export class UnexpectedKey extends Base {
  * **Details**
  *
  * - `issues` is a non-empty readonly array (at least one child).
- * - `actual` is `Option.some(value)` when the input was present, or
- *   `Option.none()` when absent.
  * - Formatters flatten `Composite` by recursing into each child.
  *
  * @see {@link AnyOf} — used for union no-match errors (similar but different semantics)
@@ -316,10 +347,6 @@ export class Composite extends Base {
    * The schema that caused the issue.
    */
   ast;
-  /**
-   * The input value that caused the issue.
-   */
-  actual;
   /**
    * The issues that occurred.
    */
@@ -330,22 +357,26 @@ export class Composite extends Base {
    */
   ast,
   /**
-   * The input value that caused the issue.
+   * The issues that occurred.
    */
-  actual,
+  issues,
   /**
-   * The issues that occurred.
+   * The present input associated with the issue. It is retained only when
+   * `options.reportInput` is `true`.
    */
-  issues) {
-    super();
+  input,
+  /**
+   * The effective parse options controlling input retention.
+   */
+  options) {
+    super(input, options);
     this.ast = ast;
-    this.actual = actual;
     this.issues = issues;
   }
 }
 /**
  * Represents a schema issue produced when the runtime type of the input does not match the type
- * expected by the schema (e.g. got `null` when `string` was expected).
+ * expected by the schema.
  *
  * **When to use**
  *
@@ -355,23 +386,17 @@ export class Composite extends Base {
  * **Details**
  *
  * - `ast` is the schema node that expected a different type.
- * - `actual` is `Option.some(value)` when the input was present, or
- *   `Option.none()` when no value was provided.
- * - The default formatter renders this as `"Expected <type>, got <actual>"`.
+ * - The default formatter renders this as `"Expected <type>"`, adding
+ *   `", got <input>"` when the issue reports an input.
  *
- * **Example** (Formatting output)
+ * **Example** (Formatting a type mismatch)
  *
- * ```ts
- * import { Schema } from "effect"
+ * ```ts import.meta.vitest
+ * import { Schema, SchemaIssue } from "effect"
  *
- * try {
- *   Schema.decodeUnknownSync(Schema.String)(42)
- * } catch (e) {
- *   if (Schema.isSchemaError(e)) {
- *     console.log(String(e.issue))
- *     // "Expected string, got 42"
- *   }
- * }
+ * const formatIssue = SchemaIssue.makeFormatterDefault()
+ * const issue = new SchemaIssue.InvalidType(Schema.String.ast)
+ * formatIssue(issue) // => "Expected string"
  * ```
  *
  * @see {@link InvalidValue} — the input has the right type but fails a value constraint
@@ -385,22 +410,22 @@ export class InvalidType extends Base {
    * The schema that caused the issue.
    */
   ast;
-  /**
-   * The input value that caused the issue.
-   */
-  actual;
   constructor(
   /**
    * The schema that caused the issue.
    */
   ast,
   /**
-   * The input value that caused the issue.
+   * The present input associated with the issue. It is retained only when
+   * `options.reportInput` is `true`.
    */
-  actual) {
-    super();
+  input,
+  /**
+   * The effective parse options controlling input retention.
+   */
+  options) {
+    super(input, options);
     this.ast = ast;
-    this.actual = actual;
   }
 }
 /**
@@ -414,23 +439,22 @@ export class InvalidType extends Base {
  *
  * **Details**
  *
- * - `actual` is `Option.some(value)` when the failing value is known, or
- *   `Option.none()` when absent.
- * - `annotations` optionally carries a `message` string for formatting.
- * - The default formatter renders this as `"Invalid data <actual>"` unless a
- *   custom `message` annotation is provided.
+ * - A `message` annotation is returned unchanged and takes precedence over all
+ *   other default formatting.
+ * - Without `message`, an `expected` annotation is formatted as
+ *   `"Expected <expected>"`, adding `", got <input>"` when input is reported.
+ * - Without either annotation, the default formatter renders
+ *   `"Expected a valid value"`, or `"Invalid data <input>"` when input is
+ *   reported.
  *
  * **Example** (Returning InvalidValue from a custom filter)
  *
- * ```ts
- * import { Option, SchemaIssue } from "effect"
+ * ```ts import.meta.vitest
+ * import { SchemaIssue } from "effect"
  *
- * const issue = new SchemaIssue.InvalidValue(
- *   Option.some(""),
- *   { message: "must not be empty" }
- * )
- * console.log(String(issue))
- * // "must not be empty"
+ * const formatIssue = SchemaIssue.makeFormatterDefault()
+ * const issue = new SchemaIssue.InvalidValue({ message: "must not be empty" })
+ * formatIssue(issue) // => "must not be empty"
  * ```
  *
  * @see {@link InvalidType} — the input has the wrong type entirely
@@ -441,28 +465,32 @@ export class InvalidType extends Base {
  */
 export class InvalidValue extends Base {
   _tag = "InvalidValue";
-  /**
-   * The value that caused the issue.
-   */
-  actual;
   /**
    * The metadata for the issue.
    */
   annotations;
   constructor(
   /**
-   * The value that caused the issue.
+   * The metadata for the issue.
    */
-  actual,
+  annotations,
   /**
-   * The metadata for the issue.
+   * The present input associated with the issue. It is retained only when
+   * `options.reportInput` is `true`.
    */
-  annotations) {
-    super();
-    this.actual = actual;
+  input,
+  /**
+   * The effective parse options controlling input retention.
+   */
+  options) {
+    super(input, options);
     this.annotations = annotations;
   }
 }
+/** @internal */
+export function makeCompositeAtKey(compositeAst, pointerKey, pointerIssue, compositeInput, parseOptions) {
+  return new Composite(compositeAst, [new Pointer([pointerKey], pointerIssue)], compositeInput, parseOptions);
+}
 /**
  * Represents a schema issue produced when a forbidden operation is encountered during parsing,
  * such as an asynchronous Effect running inside `Schema.decodeUnknownSync`.
@@ -474,22 +502,19 @@ export class InvalidValue extends Base {
  *
  * **Details**
  *
- * - `actual` is `Option.some(value)` when the input is known, or
- *   `Option.none()` when absent.
  * - `annotations` optionally carries a `message` string.
  * - The default formatter renders this as `"Forbidden operation"`.
  *
  * **Example** (Creating a Forbidden issue)
  *
- * ```ts
- * import { Option, SchemaIssue } from "effect"
+ * ```ts import.meta.vitest
+ * import { SchemaIssue } from "effect"
  *
+ * const formatIssue = SchemaIssue.makeFormatterDefault()
  * const issue = new SchemaIssue.Forbidden(
- *   Option.none(),
  *   { message: "async operation not allowed in sync context" }
  * )
- * console.log(String(issue))
- * // "async operation not allowed in sync context"
+ * formatIssue(issue) // => "async operation not allowed in sync context"
  * ```
  *
  * @see {@link InvalidValue} — for value-constraint failures (not operation failures)
@@ -499,25 +524,25 @@ export class InvalidValue extends Base {
  */
 export class Forbidden extends Base {
   _tag = "Forbidden";
-  /**
-   * The input value that caused the issue.
-   */
-  actual;
   /**
    * The metadata for the issue.
    */
   annotations;
   constructor(
   /**
-   * The input value that caused the issue.
+   * The metadata for the issue.
    */
-  actual,
+  annotations,
   /**
-   * The metadata for the issue.
+   * The present input associated with the issue. It is retained only when
+   * `options.reportInput` is `true`.
    */
-  annotations) {
-    super();
-    this.actual = actual;
+  input,
+  /**
+   * The effective parse options controlling input retention.
+   */
+  options) {
+    super(input, options);
     this.annotations = annotations;
   }
 }
@@ -532,9 +557,13 @@ export class Forbidden extends Base {
  * **Details**
  *
  * - `ast` is the `Union` AST node.
- * - `actual` is the raw input value (plain `unknown`).
- * - `issues` contains per-member failures. When empty, the formatter falls
- *   back to the union's `expected` annotation.
+ * - `issues` contains the per-member failures.
+ *
+ * **Gotchas**
+ *
+ * `issues` is empty when no union member was applicable. In that case, the
+ * default formatter reports the expected type for the union and appends
+ * `", got <input>"` when input is reported.
  *
  * @see {@link OneOf} — the opposite: *too many* members matched
  * @see {@link Composite} — groups multiple issues under a non-union schema
@@ -548,10 +577,6 @@ export class AnyOf extends Base {
    * The schema that caused the issue.
    */
   ast;
-  /**
-   * The input value that caused the issue.
-   */
-  actual;
   /**
    * The issues that occurred.
    */
@@ -562,16 +587,20 @@ export class AnyOf extends Base {
    */
   ast,
   /**
-   * The input value that caused the issue.
+   * The issues that occurred.
    */
-  actual,
+  issues,
   /**
-   * The issues that occurred.
+   * The present input associated with the issue. It is retained only when
+   * `options.reportInput` is `true`.
    */
-  issues) {
-    super();
+  input,
+  /**
+   * The effective parse options controlling input retention.
+   */
+  options) {
+    super(input, options);
     this.ast = ast;
-    this.actual = actual;
     this.issues = issues;
   }
 }
@@ -587,10 +616,11 @@ export class AnyOf extends Base {
  * **Details**
  *
  * - `ast` is the `Union` AST node.
- * - `actual` is the raw input value (plain `unknown`).
  * - `successes` lists the AST nodes of each member that accepted the input.
  * - The default formatter renders this as
- *   `"Expected exactly one member to match the input <actual>"`.
+ *   `"Expected exactly one member to match"`, or
+ *   `"Expected exactly one member to match the input <input>"` when input is
+ *   reported.
  *
  * @see {@link AnyOf} — the opposite: *no* members matched
  *
@@ -603,10 +633,6 @@ export class OneOf extends Base {
    * The schema that caused the issue.
    */
   ast;
-  /**
-   * The input value that caused the issue.
-   */
-  actual;
   /**
    * The schemas that were successful.
    */
@@ -617,107 +643,56 @@ export class OneOf extends Base {
    */
   ast,
   /**
-   * The input value that caused the issue.
+   * The schemas that were successful.
    */
-  actual,
+  successes,
   /**
-   * The schemas that were successful.
+   * The present input associated with the issue. It is retained only when
+   * `options.reportInput` is `true`.
    */
-  successes) {
-    super();
+  input,
+  /**
+   * The effective parse options controlling input retention.
+   */
+  options) {
+    super(input, options);
     this.ast = ast;
-    this.actual = actual;
     this.successes = successes;
   }
 }
-/**
- * Extracts the actual input value from any {@link Issue} variant.
- *
- * **When to use**
- *
- * Use when you need to retrieve an `Issue`'s offending input value for logging
- * or custom error rendering.
- *
- * **Details**
- *
- * - Returns `Option.none()` for `Pointer` and `MissingKey` (they carry no
- *   value).
- * - Returns the existing `Option` for variants that already store `actual` as
- *   `Option<unknown>` (`InvalidType`, `InvalidValue`, `Forbidden`, `Encoding`,
- *   `Composite`).
- * - Wraps `actual` with `Option.some` for variants that store it as plain
- *   `unknown` (`AnyOf`, `UnexpectedKey`, `OneOf`, `Filter`).
- *
- * **Example** (Extracting the actual value)
- *
- * ```ts
- * import { Option, SchemaIssue } from "effect"
- *
- * const issue = new SchemaIssue.MissingKey(undefined)
- * console.log(SchemaIssue.getActual(issue))
- * // { _tag: "None" }
- * ```
- *
- * @see {@link Issue}
- * @see {@link isIssue}
- *
- * @category getters
- * @since 4.0.0
- */
-export function getActual(issue) {
-  switch (issue._tag) {
-    case "Pointer":
-    case "MissingKey":
-      return Option.none();
-    case "InvalidType":
-    case "InvalidValue":
-    case "Forbidden":
-    case "Encoding":
-    case "Composite":
-      return issue.actual;
-    case "AnyOf":
-    case "UnexpectedKey":
-    case "OneOf":
-    case "Filter":
-      return Option.some(issue.actual);
-  }
-}
-function makeFilterIssue(input, entry) {
+function makeFilterIssue(entry, input, options) {
   if (isIssue(entry)) {
     return entry;
   }
   if (typeof entry === "string") {
-    return new InvalidValue(Option.some(input), {
+    return new InvalidValue({
       message: entry
-    });
+    }, input, options);
   }
-  const inner = typeof entry.issue === "string" ? new InvalidValue(Option.some(input), {
+  const inner = typeof entry.issue === "string" ? new InvalidValue({
     message: entry.issue
-  }) : entry.issue;
+  }, input, options) : entry.issue;
   return new Pointer(entry.path, inner);
 }
 /** @internal */
-export function makeSingle(input, out) {
+export function makeSingle(out, input, options) {
   if (out === undefined) {
     return undefined;
   }
   if (typeof out === "boolean") {
-    return out ? undefined : new InvalidValue(Option.some(input));
+    return out ? undefined : new InvalidValue(undefined, input, options);
   }
-  return makeFilterIssue(input, out);
+  return makeFilterIssue(out, input, options);
 }
 /** @internal */
-export function make(input, ast, out) {
+export function normalizeFilterOutput(ast, out, input, options) {
   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)));
+    if (!Arr.isReadonlyArrayNonEmpty(out)) {
+      return undefined;
     }
-    return undefined;
+    return out.length === 1 ? makeFilterIssue(out[0], input, options) : new Composite(ast, Arr.map(out, entry => makeFilterIssue(entry, input, options)), input, options);
   }
-  return makeSingle(input, out);
+  return makeSingle(out, input, options);
 }
 /**
  * Returns the built-in {@link LeafHook} used by default formatters.
@@ -729,28 +704,34 @@ export function make(input, ast, out) {
  * **Details**
  *
  * - Checks for a `message` annotation first; returns it if present.
- * - Otherwise generates a default message per `_tag`:
- *   - `InvalidType` → `"Expected <type>, got <actual>"`
- *   - `InvalidValue` → `"Invalid data <actual>"`
+ * - For `InvalidValue`, an `expected` annotation uses the standard expected
+ *   value message and includes reported input when available.
+ * - Otherwise generates a default message per `_tag`. When the issue reports
+ *   input, the message includes its formatted value where applicable:
+ *   - `InvalidType` → `"Expected <type>"` or `"Expected <type>, got <input>"`
+ *   - `InvalidValue` → `"Expected a valid value"` or `"Invalid data <input>"`
  *   - `MissingKey` → `"Missing key"`
- *   - `UnexpectedKey` → `"Unexpected key with value <actual>"`
+ *   - `UnexpectedKey` → `"Expected no excess property"` or
+ *     `"Unexpected key with value <input>"`
  *   - `Forbidden` → `"Forbidden operation"`
- *   - `OneOf` → `"Expected exactly one member to match the input <actual>"`
+ *   - `OneOf` → `"Expected exactly one member to match"` or
+ *     `"Expected exactly one member to match the input <input>"`
  *
  * **Example** (Formatting Standard Schema issues with defaultLeafHook)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { SchemaIssue } from "effect"
  *
  * const formatter = SchemaIssue.makeFormatterStandardSchemaV1({
  *   leafHook: SchemaIssue.defaultLeafHook
  * })
+ * formatter(new SchemaIssue.MissingKey(undefined)) // => { issues: [{ path: [], message: "Missing key" }] }
  * ```
  *
  * @see {@link LeafHook}
  * @see {@link makeFormatterStandardSchemaV1}
  *
- * @category Formatter
+ * @category formatting
  * @since 4.0.0
  */
 export const defaultLeafHook = issue => {
@@ -758,17 +739,28 @@ export const defaultLeafHook = issue => {
   if (message !== undefined) return message;
   switch (issue._tag) {
     case "InvalidType":
-      return getExpectedMessage(InternalAnnotations.getExpected(issue.ast), formatOption(issue.actual));
+      return getExpectedMessage(InternalAnnotations.getExpected(issue.ast), issue);
     case "InvalidValue":
-      return `Invalid data ${formatOption(issue.actual)}`;
+      {
+        const expected = findExpected(issue);
+        if (expected !== undefined) return getExpectedMessage(expected, issue);
+        const input = formatInput(issue);
+        return input === undefined ? "Expected a valid value" : `Invalid data ${input}`;
+      }
     case "MissingKey":
       return "Missing key";
     case "UnexpectedKey":
-      return `Unexpected key with value ${format(issue.actual)}`;
+      {
+        const input = formatInput(issue);
+        return input === undefined ? "Expected no excess property" : `Unexpected key with value ${input}`;
+      }
     case "Forbidden":
       return "Forbidden operation";
     case "OneOf":
-      return `Expected exactly one member to match the input ${format(issue.actual)}`;
+      {
+        const input = formatInput(issue);
+        return input === undefined ? "Expected exactly one member to match" : `Expected exactly one member to match the input ${input}`;
+      }
   }
 };
 /**
@@ -783,17 +775,16 @@ export const defaultLeafHook = issue => {
  * - Looks for a `message` annotation on the inner issue first, then on the
  *   filter itself.
  * - Returns `undefined` when no annotation is found, causing the formatter to
- *   fall back to `"Expected <filter>, got <actual>"`.
+ *   fall back to `"Expected <filter>"` or, when the filter reports input,
+ *   `"Expected <filter>, got <input>"`.
  *
  * @see {@link CheckHook}
  * @see {@link makeFormatterStandardSchemaV1}
  *
- * @category Formatter
+ * @category formatting
  * @since 4.0.0
  */
-export const defaultCheckHook = issue => {
-  return findMessage(issue.issue) ?? findMessage(issue);
-};
+export const defaultCheckHook = issue => findMessage(issue.issue) ?? findMessage(issue);
 /**
  * Creates a {@link Formatter} that produces a `StandardSchemaV1.FailureResult`.
  *
@@ -810,20 +801,30 @@ export const defaultCheckHook = issue => {
  * - `Pointer` paths are accumulated to produce full property paths.
  * - Falls back to {@link defaultLeafHook} / {@link defaultCheckHook} when no
  *   hooks are provided.
+ * - Default messages include reported input when the issue that produces the
+ *   message has an `input` field. The returned Standard Schema issues do not
+ *   receive an `input` field.
+ *
+ * **Gotchas**
+ *
+ * Reported input can appear inside the Standard Schema `message` string even
+ * though it is not exposed as a separate property. Custom hooks control their
+ * complete message and are not modified.
  *
  * **Example** (Creating a Standard Schema V1 formatter)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { SchemaIssue } from "effect"
  *
  * const formatter = SchemaIssue.makeFormatterStandardSchemaV1()
+ * formatter(new SchemaIssue.MissingKey(undefined)).issues[0].message // => "Missing key"
  * ```
  *
  * @see {@link makeFormatterDefault} — produces a plain string instead
  * @see {@link LeafHook}
  * @see {@link CheckHook}
  *
- * @category Formatter
+ * @category formatting
  * @since 4.0.0
  */
 export function makeFormatterStandardSchemaV1(options) {
@@ -831,8 +832,16 @@ export function makeFormatterStandardSchemaV1(options) {
     issues: toDefaultIssues(issue, [], options?.leafHook ?? defaultLeafHook, options?.checkHook ?? defaultCheckHook)
   });
 }
-function getExpectedMessage(expected, actual) {
-  return `Expected ${expected}, got ${actual}`;
+function formatInput(issue) {
+  return hasInput(issue) ? format(issue.input) : undefined;
+}
+function findExpected(issue) {
+  const expected = issue.annotations?.expected;
+  return typeof expected === "string" ? expected : undefined;
+}
+function getExpectedMessage(expected, issue) {
+  const input = formatInput(issue);
+  return input === undefined ? `Expected ${expected}` : `Expected ${expected}, got ${input}`;
 }
 function toDefaultIssues(issue, path, leafHook, checkHook) {
   switch (issue._tag) {
@@ -845,15 +854,14 @@ function toDefaultIssues(issue, path, leafHook, checkHook) {
             message
           }];
         }
-        switch (issue.issue._tag) {
-          case "InvalidValue":
-            return [{
-              path,
-              message: getExpectedMessage(formatCheck(issue.filter), format(issue.actual))
-            }];
-          default:
-            return toDefaultIssues(issue.issue, path, leafHook, checkHook);
+        if (issue.issue._tag !== "InvalidValue") {
+          return toDefaultIssues(issue.issue, path, leafHook, checkHook);
         }
+        const expected = findExpected(issue.issue);
+        return [{
+          path,
+          message: expected === undefined ? getExpectedMessage(formatCheck(issue.filter), issue) : getExpectedMessage(expected, issue.issue)
+        }];
       }
     case "Encoding":
       return toDefaultIssues(issue.issue, path, leafHook, checkHook);
@@ -863,16 +871,10 @@ function toDefaultIssues(issue, path, leafHook, checkHook) {
       return issue.issues.flatMap(issue => toDefaultIssues(issue, path, leafHook, checkHook));
     case "AnyOf":
       {
-        const message = findMessage(issue);
         if (issue.issues.length === 0) {
-          if (message !== undefined) return [{
-            path,
-            message
-          }];
-          const expected = getExpectedMessage(InternalAnnotations.getExpected(issue.ast), format(issue.actual));
           return [{
             path,
-            message: expected
+            message: findMessage(issue) ?? getExpectedMessage(InternalAnnotations.getExpected(issue.ast), issue)
           }];
         }
         return issue.issues.flatMap(issue => toDefaultIssues(issue, path, leafHook, checkHook));
@@ -905,88 +907,80 @@ function formatCheck(check) {
  *
  * **Details**
  *
- * This is the default formatter used by `SchemaIssue.toString()`.
- *
  * - Flattens the issue tree into `{ message, path }` entries using
  *   {@link defaultLeafHook} and {@link defaultCheckHook}.
+ * - Includes reported input in default messages when the node producing the
+ *   message has an `input` field.
  * - Each entry is rendered as `"<message>"` or `"<message>\n  at <path>"`.
  * - Multiple entries are joined with newlines.
  *
+ * **Gotchas**
+ *
+ * Formatting an issue can disclose input retained with `reportInput: true`.
+ * Wrapper inputs are not inherited by child messages, and custom messages are
+ * returned unchanged.
+ *
  * **Example** (Formatting an issue as a string)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { SchemaIssue } from "effect"
  *
  * const formatter = SchemaIssue.makeFormatterDefault()
+ * formatter(new SchemaIssue.MissingKey(undefined)) // => "Missing key"
  * ```
  *
  * @see {@link makeFormatterStandardSchemaV1} — produces Standard Schema V1 format instead
  * @see {@link Formatter}
  *
- * @category Formatter
+ * @category formatting
  * @since 4.0.0
  */
 export function makeFormatterDefault() {
-  return issue => toDefaultIssues(issue, [], defaultLeafHook, defaultCheckHook).map(formatDefaultIssue).join("\n");
+  return issue => formatIssue(issue, "");
 }
 /** @internal */
 export const defaultFormatter = /*#__PURE__*/makeFormatterDefault();
-function formatDefaultIssue(issue) {
-  let out = issue.message;
-  if (issue.path && issue.path.length > 0) {
-    const path = formatPath(issue.path);
-    out += `\n  at ${path}`;
-  }
-  return out;
-}
-function findMessage(issue) {
+function formatIssue(issue, path) {
+  let message;
   switch (issue._tag) {
-    case "InvalidType":
-    case "OneOf":
-    case "Composite":
-    case "AnyOf":
-      return getMessageAnnotation(issue.ast.annotations);
-    case "InvalidValue":
-    case "Forbidden":
-      return getMessageAnnotation(issue.annotations);
-    case "MissingKey":
-      return getMessageAnnotation(issue.annotations, "messageMissingKey");
-    case "UnexpectedKey":
-      return getMessageAnnotation(issue.ast.annotations, "messageUnexpectedKey");
     case "Filter":
-      return getMessageAnnotation(issue.filter.annotations);
+      {
+        const annotated = defaultCheckHook(issue);
+        if (annotated !== undefined) {
+          message = annotated;
+        } else {
+          if (issue.issue._tag !== "InvalidValue") {
+            return formatIssue(issue.issue, path);
+          }
+          const expected = findExpected(issue.issue);
+          message = expected === undefined ? getExpectedMessage(formatCheck(issue.filter), issue) : getExpectedMessage(expected, issue.issue);
+        }
+        break;
+      }
     case "Encoding":
-      return findMessage(issue.issue);
-  }
-}
-function getMessageAnnotation(annotations, type = "message") {
-  const message = annotations?.[type];
-  if (typeof message === "string") return message;
-}
-function formatOption(actual) {
-  if (Option.isNone(actual)) return "no value provided";
-  return format(actual.value);
-}
-/** @internal */
-export function redact(issue) {
-  switch (issue._tag) {
-    case "MissingKey":
-      return issue;
-    case "Forbidden":
-      return new Forbidden(Option.map(issue.actual, Redacted.make), issue.annotations);
-    case "Filter":
-      return new Filter(Redacted.make(issue.actual), issue.filter, redact(issue.issue));
+      return formatIssue(issue.issue, path);
     case "Pointer":
-      return new Pointer(issue.path, redact(issue.issue));
-    case "Encoding":
-    case "InvalidType":
-    case "InvalidValue":
+      return formatIssue(issue.issue, path + formatPath(issue.path));
     case "Composite":
-      return new InvalidValue(Option.map(issue.actual, Redacted.make));
     case "AnyOf":
-    case "OneOf":
-    case "UnexpectedKey":
-      return new InvalidValue(Option.some(Redacted.make(issue.actual)));
+      {
+        if (issue._tag === "Composite" || issue.issues.length > 0) {
+          return issue.issues.map(issue => formatIssue(issue, path)).join("\n");
+        }
+        message = findMessage(issue) ?? getExpectedMessage(InternalAnnotations.getExpected(issue.ast), issue);
+        break;
+      }
+    default:
+      message = defaultLeafHook(issue);
+      break;
   }
+  return path ? `${message}\n  at ${path}` : message;
+}
+function findMessage(issue) {
+  if (issue._tag === "Pointer") return;
+  if (issue._tag === "Encoding") return findMessage(issue.issue);
+  const annotations = issue._tag === "Filter" ? issue.filter.annotations : "annotations" in issue ? issue.annotations : issue.ast.annotations;
+  const message = annotations?.[issue._tag === "MissingKey" ? "messageMissingKey" : issue._tag === "UnexpectedKey" ? "messageUnexpectedKey" : "message"];
+  if (typeof message === "string") return message;
 }
 //# sourceMappingURL=SchemaIssue.js.map