effect 4.0.0-beta.102 → 4.0.0-beta.103

package/src/SchemaIssue.ts

@@ -5,18 +5,15 @@
  * An `Issue` records what failed and, for nested data, where the failure
  * happened. The Schema system uses these values for missing keys, unexpected
  * keys, invalid types, invalid values, failed filters, failed transformations,
- * and alternatives that did not match. This module also formats issues and
- * supports redaction for sensitive values.
+ * and alternatives that did not match. This module also formats issues.
  *
  * @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 { formatPath, type Formatter as FormatterI } from "./Formatter.ts"
 import * as InternalAnnotations from "./internal/schema/annotations.ts"
-import * as Option from "./Option.ts"
 import { hasProperty } from "./Predicate.ts"
-import * as Redacted from "./Redacted.ts"
 import type * as Schema from "./Schema.ts"
 import type * as SchemaAST from "./SchemaAST.ts"
 
@@ -37,14 +34,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}
@@ -98,11 +93,13 @@ export type Leaf =
  * {@link Filter}, {@link Encoding}, {@link Pointer}, {@link Composite},
  * {@link AnyOf}. All `Issue` instances have a `toString()` that delegates to
  * the default formatter, so `String(issue)` produces a human-readable message.
+ * Built-in issues have no `actual` field, and built-in messages do not include
+ * the rejected value. This is not a general sanitization boundary: paths,
+ * ASTs, union successes, and custom annotations or messages are preserved as
+ * supplied and remain the caller's responsibility.
  *
  * @see {@link Leaf} — the terminal subset
  * @see {@link isIssue} — type guard
- * @see {@link getActual} — extract the actual value from any issue
- *
  * @category models
  * @since 4.0.0
  */
@@ -132,22 +129,26 @@ 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"
  *
  * function describe(issue: SchemaIssue.Issue): string {
  *   if (issue._tag === "Filter") {
- *     return `Filter failed on: ${JSON.stringify(issue.actual)}`
+ *     return `Filter failed: ${String(issue.issue)}`
  *   }
  *   return String(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`
@@ -158,10 +159,6 @@ class Base {
  */
 export class Filter extends Base {
   readonly _tag = "Filter"
-  /**
-   * The input value that caused the issue.
-   */
-  readonly actual: unknown
   /**
    * The filter that failed.
    */
@@ -172,10 +169,6 @@ export class Filter extends Base {
   readonly issue: Issue
 
   constructor(
-    /**
-     * The input value that caused the issue.
-     */
-    actual: unknown,
     /**
      * The filter that failed.
      */
@@ -186,7 +179,6 @@ export class Filter extends Base {
     issue: Issue
   ) {
     super()
-    this.actual = actual
     this.filter = filter
     this.issue = issue
   }
@@ -203,8 +195,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)
@@ -219,10 +209,6 @@ export class Encoding extends Base {
    * The schema that caused the issue.
    */
   readonly ast: SchemaAST.AST
-  /**
-   * The input value that caused the issue.
-   */
-  readonly actual: Option.Option<unknown>
   /**
    * The issue that occurred.
    */
@@ -233,10 +219,6 @@ export class Encoding extends Base {
      * The schema that caused the issue.
      */
     ast: SchemaAST.AST,
-    /**
-     * The input value that caused the issue.
-     */
-    actual: Option.Option<unknown>,
     /**
      * The issue that occurred.
      */
@@ -244,7 +226,6 @@ export class Encoding extends Base {
   ) {
     super()
     this.ast = ast
-    this.actual = actual
     this.issue = issue
   }
 }
@@ -261,11 +242,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
@@ -307,7 +286,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
@@ -345,9 +323,9 @@ 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"`.
  *
  * @see {@link MissingKey} — the opposite case (required key absent)
  * @see {@link Pointer} — wraps this issue with the unexpected key's path
@@ -361,24 +339,14 @@ export class UnexpectedKey extends Base {
    * The schema that caused the issue.
    */
   readonly ast: SchemaAST.AST
-  /**
-   * The input value that caused the issue.
-   */
-  readonly actual: unknown
-
   constructor(
     /**
      * The schema that caused the issue.
      */
-    ast: SchemaAST.AST,
-    /**
-     * The input value that caused the issue.
-     */
-    actual: unknown
+    ast: SchemaAST.AST
   ) {
     super()
     this.ast = ast
-    this.actual = actual
   }
 }
 
@@ -393,8 +361,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)
@@ -409,10 +375,6 @@ export class Composite extends Base {
    * The schema that caused the issue.
    */
   readonly ast: SchemaAST.AST
-  /**
-   * The input value that caused the issue.
-   */
-  readonly actual: Option.Option<unknown>
   /**
    * The issues that occurred.
    */
@@ -423,10 +385,6 @@ export class Composite extends Base {
      * The schema that caused the issue.
      */
     ast: SchemaAST.AST,
-    /**
-     * The input value that caused the issue.
-     */
-    actual: Option.Option<unknown>,
     /**
      * The issues that occurred.
      */
@@ -434,14 +392,13 @@ export class Composite extends Base {
   ) {
     super()
     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**
  *
@@ -451,23 +408,15 @@ 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>"`.
  *
- * **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 issue = new SchemaIssue.InvalidType(Schema.String.ast)
+ * String(issue) // => "Expected string"
  * ```
  *
  * @see {@link InvalidValue} — the input has the right type but fails a value constraint
@@ -481,24 +430,14 @@ export class InvalidType extends Base {
    * The schema that caused the issue.
    */
   readonly ast: SchemaAST.AST
-  /**
-   * The input value that caused the issue.
-   */
-  readonly actual: Option.Option<unknown>
-
   constructor(
     /**
      * The schema that caused the issue.
      */
-    ast: SchemaAST.AST,
-    /**
-     * The input value that caused the issue.
-     */
-    actual: Option.Option<unknown>
+    ast: SchemaAST.AST
   ) {
     super()
     this.ast = ast
-    this.actual = actual
   }
 }
 
@@ -513,23 +452,17 @@ 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
+ * - The default formatter renders this as `"Expected a valid value"` unless a
  *   custom `message` annotation is provided.
  *
  * **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 issue = new SchemaIssue.InvalidValue({ message: "must not be empty" })
+ * String(issue) // => "must not be empty"
  * ```
  *
  * @see {@link InvalidType} — the input has the wrong type entirely
@@ -540,27 +473,15 @@ export class InvalidType extends Base {
  */
 export class InvalidValue extends Base {
   readonly _tag = "InvalidValue"
-  /**
-   * The value that caused the issue.
-   */
-  readonly actual: Option.Option<unknown>
   /**
    * The metadata for the issue.
    */
   readonly annotations: Schema.Annotations.Issue | undefined
 
   constructor(
-    /**
-     * The value that caused the issue.
-     */
-    actual: Option.Option<unknown>,
-    /**
-     * The metadata for the issue.
-     */
     annotations?: Schema.Annotations.Issue | undefined
   ) {
     super()
-    this.actual = actual
     this.annotations = annotations
   }
 }
@@ -576,22 +497,18 @@ 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 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"
+ * String(issue) // => "async operation not allowed in sync context"
  * ```
  *
  * @see {@link InvalidValue} — for value-constraint failures (not operation failures)
@@ -601,27 +518,18 @@ export class InvalidValue extends Base {
  */
 export class Forbidden extends Base {
   readonly _tag = "Forbidden"
-  /**
-   * The input value that caused the issue.
-   */
-  readonly actual: Option.Option<unknown>
   /**
    * The metadata for the issue.
    */
   readonly annotations: Schema.Annotations.Issue | undefined
 
   constructor(
-    /**
-     * The input value that caused the issue.
-     */
-    actual: Option.Option<unknown>,
     /**
      * The metadata for the issue.
      */
     annotations: Schema.Annotations.Issue | undefined
   ) {
     super()
-    this.actual = actual
     this.annotations = annotations
   }
 }
@@ -637,9 +545,12 @@ 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.
  *
  * @see {@link OneOf} — the opposite: *too many* members matched
  * @see {@link Composite} — groups multiple issues under a non-union schema
@@ -653,10 +564,6 @@ export class AnyOf extends Base {
    * The schema that caused the issue.
    */
   readonly ast: SchemaAST.Union
-  /**
-   * The input value that caused the issue.
-   */
-  readonly actual: unknown
   /**
    * The issues that occurred.
    */
@@ -667,10 +574,6 @@ export class AnyOf extends Base {
      * The schema that caused the issue.
      */
     ast: SchemaAST.Union,
-    /**
-     * The input value that caused the issue.
-     */
-    actual: unknown,
     /**
      * The issues that occurred.
      */
@@ -678,7 +581,6 @@ export class AnyOf extends Base {
   ) {
     super()
     this.ast = ast
-    this.actual = actual
     this.issues = issues
   }
 }
@@ -695,10 +597,9 @@ 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"`.
  *
  * @see {@link AnyOf} — the opposite: *no* members matched
  *
@@ -711,10 +612,6 @@ export class OneOf extends Base {
    * The schema that caused the issue.
    */
   readonly ast: SchemaAST.Union
-  /**
-   * The input value that caused the issue.
-   */
-  readonly actual: unknown
   /**
    * The schemas that were successful.
    */
@@ -725,10 +622,6 @@ export class OneOf extends Base {
      * The schema that caused the issue.
      */
     ast: SchemaAST.Union,
-    /**
-     * The input value that caused the issue.
-     */
-    actual: unknown,
     /**
      * The schemas that were successful.
      */
@@ -736,100 +629,48 @@ export class OneOf extends Base {
   ) {
     super()
     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: Issue): Option.Option<unknown> {
-  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: unknown, entry: Schema.FilterIssue): Issue {
+function makeFilterIssue(entry: Schema.FilterIssue): Issue {
   if (isIssue(entry)) {
     return entry
   }
   if (typeof entry === "string") {
-    return new InvalidValue(Option.some(input), { message: entry })
+    return new InvalidValue({ message: entry })
   }
   const inner = typeof entry.issue === "string"
-    ? new InvalidValue(Option.some(input), { message: entry.issue })
+    ? new InvalidValue({ message: entry.issue })
     : entry.issue
   return new Pointer(entry.path, inner)
 }
 
 /** @internal */
-export function makeSingle(input: unknown, out: undefined | boolean | Schema.FilterIssue): Issue | undefined {
+export function makeSingle(out: undefined | boolean | Schema.FilterIssue): Issue | undefined {
   if (out === undefined) {
     return undefined
   }
   if (typeof out === "boolean") {
-    return out ? undefined : new InvalidValue(Option.some(input))
+    return out ? undefined : new InvalidValue()
   }
-  return makeFilterIssue(input, out)
+  return makeFilterIssue(out)
 }
 
 /** @internal */
-export function make(input: unknown, ast: SchemaAST.AST, out: Schema.FilterOutput): Issue | undefined {
+export function normalizeFilterOutput(
+  ast: SchemaAST.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)))
+    if (!Arr.isReadonlyArrayNonEmpty(out)) {
+      return undefined
     }
-    return undefined
+    return out.length === 1
+      ? makeFilterIssue(out[0])
+      : new Composite(ast, Arr.map(out, makeFilterIssue))
   }
-  return makeSingle(input, out as undefined | boolean | Schema.FilterIssue)
+  return makeSingle(out as undefined | boolean | Schema.FilterIssue)
 }
 
 /**
@@ -840,7 +681,7 @@ export function make(input: unknown, ast: SchemaAST.AST, out: Schema.FilterOutpu
  * @see {@link makeFormatterDefault} — creates a `Formatter<string>`
  * @see {@link makeFormatterStandardSchemaV1} — creates a `Formatter<StandardSchemaV1.FailureResult>`
  *
- * @category Formatter
+ * @category formatting
  * @since 4.0.0
  */
 export interface Formatter<out Format> extends FormatterI<Issue, Format> {}
@@ -856,7 +697,7 @@ export interface Formatter<out Format> extends FormatterI<Issue, Format> {}
  * @see {@link defaultLeafHook} — the built-in implementation
  * @see {@link Leaf} — the union of terminal issue types
  *
- * @category Formatter
+ * @category formatting
  * @since 4.0.0
  */
 export type LeafHook = (issue: Leaf) => string
@@ -872,27 +713,28 @@ export type LeafHook = (issue: Leaf) => string
  *
  * - 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>"`
+ *   - `InvalidType` → `"Expected <type>"`
+ *   - `InvalidValue` → `"Expected a valid value"`
  *   - `MissingKey` → `"Missing key"`
- *   - `UnexpectedKey` → `"Unexpected key with value <actual>"`
+ *   - `UnexpectedKey` → `"Expected no excess property"`
  *   - `Forbidden` → `"Forbidden operation"`
- *   - `OneOf` → `"Expected exactly one member to match the input <actual>"`
+ *   - `OneOf` → `"Expected exactly one member to match"`
  *
  * **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: LeafHook = (issue): string => {
@@ -900,17 +742,17 @@ export const defaultLeafHook: LeafHook = (issue): string => {
   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))
     case "InvalidValue":
-      return `Invalid data ${formatOption(issue.actual)}`
+      return "Expected a valid value"
     case "MissingKey":
       return "Missing key"
     case "UnexpectedKey":
-      return `Unexpected key with value ${format(issue.actual)}`
+      return "Expected no excess property"
     case "Forbidden":
       return "Forbidden operation"
     case "OneOf":
-      return `Expected exactly one member to match the input ${format(issue.actual)}`
+      return "Expected exactly one member to match"
   }
 }
 
@@ -926,11 +768,12 @@ export const defaultLeafHook: LeafHook = (issue): string => {
  *
  * - Returns `string` to override the message, or `undefined` to fall back to
  *   the default formatting.
+ * - Built-in issues have no `actual` field.
  *
  * @see {@link defaultCheckHook} — the built-in implementation
  * @see {@link Filter} — the issue type this hook formats
  *
- * @category Formatter
+ * @category formatting
  * @since 4.0.0
  */
 export type CheckHook = (issue: Filter) => string | undefined
@@ -947,12 +790,12 @@ export type CheckHook = (issue: Filter) => string | undefined
  * - 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>"`.
  *
  * @see {@link CheckHook}
  * @see {@link makeFormatterStandardSchemaV1}
  *
- * @category Formatter
+ * @category formatting
  * @since 4.0.0
  */
 export const defaultCheckHook: CheckHook = (issue): string | undefined => {
@@ -978,17 +821,18 @@ export const defaultCheckHook: CheckHook = (issue): string | undefined => {
  *
  * **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?: {
@@ -1006,8 +850,8 @@ type DefaultIssue = {
   readonly path: ReadonlyArray<PropertyKey>
 }
 
-function getExpectedMessage(expected: string, actual: string): string {
-  return `Expected ${expected}, got ${actual}`
+function getExpectedMessage(expected: string): string {
+  return `Expected ${expected}`
 }
 
 function toDefaultIssues(
@@ -1026,7 +870,7 @@ function toDefaultIssues(
         case "InvalidValue":
           return [{
             path,
-            message: getExpectedMessage(formatCheck(issue.filter), format(issue.actual))
+            message: getExpectedMessage(formatCheck(issue.filter))
           }]
         default:
           return toDefaultIssues(issue.issue, path, leafHook, checkHook)
@@ -1039,12 +883,11 @@ function toDefaultIssues(
     case "Composite":
       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 }]
+        return [{
+          path,
+          message: findMessage(issue) ?? getExpectedMessage(InternalAnnotations.getExpected(issue.ast))
+        }]
       }
       return issue.issues.flatMap((issue) => toDefaultIssues(issue, path, leafHook, checkHook))
     }
@@ -1085,16 +928,17 @@ function formatCheck<T>(check: SchemaAST.Check<T>): string {
  *
  * **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(): Formatter<string> {
@@ -1144,33 +988,3 @@ function getMessageAnnotation(
   const message = annotations?.[type]
   if (typeof message === "string") return message
 }
-
-function formatOption(actual: Option.Option<unknown>): string {
-  if (Option.isNone(actual)) return "no value provided"
-  return format(actual.value)
-}
-
-/** @internal */
-export function redact(issue: Issue): 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))
-    case "Pointer":
-      return new Pointer(issue.path, redact(issue.issue))
-
-    case "Encoding":
-    case "InvalidType":
-    case "InvalidValue":
-    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)))
-  }
-}