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

package/src/SchemaAST.ts

@@ -13,16 +13,15 @@
 
 import * as Arr from "./Array.ts"
 import * as Cause from "./Cause.ts"
-import type * as Combiner from "./Combiner.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
 import { format, formatPropertyKey } from "./Formatter.ts"
-import { memoize } from "./Function.ts"
+import { identity, memoize, memoizeIdempotent } from "./Function.ts"
 import { effectIsExit, iterateEager } from "./internal/effect.ts"
-import * as internalRecord from "./internal/record.ts"
+import * as InternalRecord from "./internal/record.ts"
 import * as InternalAnnotations from "./internal/schema/annotations.ts"
 import * as InternalSchemaCause from "./internal/schema/cause.ts"
-import * as Option from "./Option.ts"
+import * as InternalParser from "./internal/schema/parser.ts"
 import * as Pipeable from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
 import * as Result from "./Result.ts"
@@ -451,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
@@ -517,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 */
@@ -533,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).
@@ -547,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
   }
 }
@@ -672,10 +702,10 @@ export class Declaration extends Base {
   }
   /** @internal */
   getParser(): SchemaParser.Parser {
-    const run = this.run(this.typeParameters)
-    return (oinput, options) => {
-      if (Option.isNone(oinput)) return Effect.succeedNone
-      return Effect.mapEager(run(oinput.value, this, options), Option.some)
+    let run: ReturnType<typeof this.run>
+    return (input, options) => {
+      if (input === InternalParser.missing) return InternalParser.missingExit
+      return (run ??= this.run(this.typeParameters))(input, this, options)
     }
   }
   private _rebuild(recur: (ast: AST) => AST, checks: Checks | undefined, encodingChecks: Checks | undefined) {
@@ -816,7 +846,8 @@ export class Void extends Base {
   readonly _tag = "Void"
   /** @internal */
   getParser() {
-    return fromAnyToConst(undefined)
+    const succeed = InternalParser.succeed(undefined)
+    return (input: unknown) => input === InternalParser.missing ? InternalParser.missingExit : succeed
   }
   /** @internal */
   toCodecJson(): AST {
@@ -1080,9 +1111,9 @@ function isTemplateLiteralPart(ast: AST): ast is TemplateLiteralPart {
       return true
     case "Literal":
     case "TemplateLiteral":
-      return ast.checks === undefined
+      return !ast.checks
     case "Union":
-      return ast.checks === undefined && ast.types.every(isTemplateLiteralPart)
+      return !ast.checks && ast.types.every(isTemplateLiteralPart)
     default:
       return false
   }
@@ -1106,6 +1137,10 @@ export class TemplateLiteral extends Base {
   readonly parts: ReadonlyArray<AST>
   /** @internal */
   readonly encodedParts: ReadonlyArray<TemplateLiteralPart>
+  /** @internal */
+  readonly literals: ReadonlyArray<string | undefined>
+  /** @internal */
+  readonly suffixLengths: ReadonlyArray<number>
 
   constructor(
     parts: ReadonlyArray<AST>,
@@ -1116,25 +1151,40 @@ export class TemplateLiteral extends Base {
   ) {
     super(annotations, checks, encoding, context)
     const encodedParts: Array<TemplateLiteralPart> = []
+    const literals: Array<string | undefined> = []
     for (const part of parts) {
       const encoded = toEncoded(part)
       if (isTemplateLiteralPart(encoded)) {
         encodedParts.push(encoded)
+        literals.push(encoded._tag === "Literal" ? globalThis.String(encoded.literal) : undefined)
       } else {
         throw new Error(`Invalid TemplateLiteral part ${encoded._tag}`)
       }
     }
+    const suffixLengths = new Array<number>(encodedParts.length + 1)
+    suffixLengths[encodedParts.length] = 0
+    for (let i = encodedParts.length - 1; i >= 0; i--) {
+      suffixLengths[i] = suffixLengths[i + 1] + (literals[i]?.length ?? 0)
+    }
     this.parts = parts
     this.encodedParts = encodedParts
+    this.literals = literals
+    this.suffixLengths = suffixLengths
   }
   /** @internal */
-  getParser(recur: (ast: AST) => SchemaParser.Parser): SchemaParser.Parser {
-    const parser = recur(this.asTemplateLiteralParser())
-    return (oinput: Option.Option<unknown>, options: ParseOptions) =>
-      Effect.mapBothEager(parser(oinput, options), {
-        onSuccess: () => oinput,
-        onFailure: (issue) => new SchemaIssue.Composite(this, oinput, [issue])
+  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)
+      if ((result as Exit.Exit<unknown, unknown>)._tag === "Success") {
+        return InternalParser.sameExit
+      }
+      return Effect.mapBothEager(result, {
+        onSuccess: () => input,
+        onFailure: (issue) => new SchemaIssue.Composite(this, [issue], input, options)
       })
+    }
   }
   /** @internal */
   getExpected(): string {
@@ -1142,7 +1192,7 @@ export class TemplateLiteral extends Base {
   }
   /** @internal */
   matchPart(s: string, options: ParseOptions): string | undefined {
-    return segmentTemplateLiteralParts(this.encodedParts, s, options) === undefined ? undefined : s
+    return segmentTemplateLiteralParts(this, s, options) === undefined ? undefined : s
   }
   /** @internal */
   asTemplateLiteralParser(): Arrays {
@@ -1152,12 +1202,14 @@ export class TemplateLiteral extends Base {
       tuple,
       new SchemaTransformation.Transformation(
         SchemaGetter.transformOrFail((s: string, options) => {
-          const segments = segmentTemplateLiteralParts(this.encodedParts, s, options)
-          if (segments !== undefined) return Effect.succeed(segments)
+          const segments = segmentTemplateLiteralParts(this, s, options)
+          if (segments) return Effect.succeed(segments)
           return Effect.fail(
-            new SchemaIssue.InvalidValue(Option.some(s), {
-              message: `Expected a string matching template literal parts, got ${format(s)}`
-            })
+            new SchemaIssue.InvalidValue(
+              { expected: "a string matching template literal parts" },
+              s,
+              options
+            )
           )
         }),
         SchemaGetter.transform((parts) => parts.join(""))
@@ -1228,11 +1280,11 @@ export type LiteralValue = string | number | boolean | bigint
  *
  * **Example** (Creating a literal AST)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { SchemaAST } from "effect"
  *
  * const ast = new SchemaAST.Literal("active")
- * console.log(ast.literal) // "active"
+ * ast.literal // => "active"
  * ```
  *
  * @see {@link LiteralValue}
@@ -1309,7 +1361,8 @@ export class String extends Base {
   }
   /** @internal */
   matchPart(s: string, options: ParseOptions): string | undefined {
-    return applyTemplateLiteralPartChecks(this, s, options)
+    const checks = this.checks
+    return checks && !options.disableChecks && collectIssues(checks, s, undefined, this, options) ? undefined : s
   }
   /** @internal */
   getExpected(): string {
@@ -1366,20 +1419,24 @@ export class Number extends Base {
     return this._match(isStringFiniteRegExp, s, options)
   }
   private _match(regexp: RegExp, s: string, options: ParseOptions): number | undefined {
-    return regexp.test(s)
-      ? applyTemplateLiteralPartChecks(this, globalThis.Number(s), options)
-      : undefined
+    if (!regexp.test(s)) return undefined
+    const value = globalThis.Number(s)
+    if (options.disableChecks || !this.checks) return value
+    return collectIssues(this.checks, value, undefined, this, options) ? undefined : value
   }
   /** @internal */
   toCodecJson(): AST {
-    if (this.checks && (hasCheck(this.checks, "isFinite") || hasCheck(this.checks, "isInt"))) {
+    if (
+      this.checks &&
+      (hasCheck(this.checks, "effect/schema/isFinite") || hasCheck(this.checks, "effect/schema/isInt"))
+    ) {
       return this
     }
-    return replaceEncoding(this, [numberToJson])
+    return replaceEncoding(this, [numberToJson(this.checks)])
   }
   /** @internal */
   toCodecStringTree(): AST {
-    if (this.checks && (hasCheck(this.checks, "isFinite") || hasCheck(this.checks, "isInt"))) {
+    if (this.toCodecJson() === this) {
       return replaceEncoding(this, [finiteToString])
     }
     return replaceEncoding(this, [numberToString])
@@ -1390,16 +1447,25 @@ export class Number extends Base {
   }
 }
 
-// oxlint-disable-next-line only-used-in-recursion - @gcanti what's this? :-)
-function hasCheck(checks: ReadonlyArray<Check<unknown>>, tag: string): boolean {
-  return checks.some((c) => {
-    switch (c._tag) {
-      case "Filter":
-        return c.annotations?.meta?._tag === tag
-      case "FilterGroup":
-        return hasCheck(c.checks, tag)
-    }
-  })
+function hasCheck(checks: ReadonlyArray<Check<unknown>>, id: string): boolean {
+  return checks.some((check) =>
+    check.annotations?.representation?.id === id ||
+    (check._tag === "FilterGroup" && hasCheck(check.checks, id))
+  )
+}
+
+function numberToJson(checks: Checks | undefined): Link {
+  const encodedFinite = !checks
+    ? finite
+    : appendChecks(finite, checks)
+
+  return new Link(
+    new Union([encodedFinite, nonFiniteLiterals], "anyOf"),
+    new SchemaTransformation.Transformation(
+      SchemaGetter.Number(),
+      SchemaGetter.transform((n) => globalThis.Number.isFinite(n) ? n : globalThis.String(n))
+    )
+  )
 }
 
 /**
@@ -1481,7 +1547,8 @@ export class Symbol extends Base {
   }
   /** @internal */
   matchKey(s: symbol, options: ParseOptions): symbol | undefined {
-    return applyTemplateLiteralPartChecks(this, s, options)
+    if (options.disableChecks || !this.checks) return s
+    return collectIssues(this.checks, s, undefined, this, options) ? undefined : s
   }
   /** @internal */
   toCodecStringTree(): AST {
@@ -1534,9 +1601,10 @@ export class BigInt extends Base {
   }
   /** @internal */
   matchPart(s: string, options: ParseOptions): bigint | undefined {
-    return isStringBigIntRegExp.test(s)
-      ? applyTemplateLiteralPartChecks(this, globalThis.BigInt(s), options)
-      : undefined
+    if (!isStringBigIntRegExp.test(s)) return undefined
+    const value = globalThis.BigInt(s)
+    if (options.disableChecks || !this.checks) return value
+    return collectIssues(this.checks, value, undefined, this, options) ? undefined : value
   }
   /** @internal */
   toCodecStringTree(): AST {
@@ -1590,15 +1658,14 @@ export const bigInt = new BigInt()
  *
  * **Example** (Inspecting a tuple AST)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaAST } from "effect"
  *
  * const schema = Schema.Tuple([Schema.String, Schema.Number])
  * const ast = schema.ast
  *
  * if (SchemaAST.isArrays(ast)) {
- *   console.log(ast.elements.length) // 2
- *   console.log(ast.rest.length)     // 0
+ *   [ast.elements.length, ast.rest.length] // => [2, 0]
  * }
  * ```
  *
@@ -1630,58 +1697,71 @@ export class Arrays extends Base {
     this.rest = rest
     this.encodingChecks = encodingChecks
 
-    // A required element cannot follow an optional element. ts(1257)
-    const i = elements.findIndex(isOptional)
-    if (i !== -1 && (elements.slice(i + 1).some((e) => !isOptional(e)) || rest.length > 1)) {
+    let hasOptional = false
+    for (let i = 0; i < elements.length; i++) {
+      if (isOptional(elements[i])) {
+        hasOptional = true
+      } else if (hasOptional) {
+        throw new Error("A required element cannot follow an optional element. ts(1257)")
+      }
+    }
+    if (hasOptional && rest.length > 1) {
       throw new Error("A required element cannot follow an optional element. ts(1257)")
     }
 
     // An optional element cannot follow a rest element.ts(1266)
-    if (rest.length > 1 && rest.slice(1).some(isOptional)) {
-      throw new Error("An optional element cannot follow a rest element. ts(1266)")
+    for (let i = 1; i < rest.length; i++) {
+      if (isOptional(rest[i])) {
+        throw new Error("An optional element cannot follow a rest element. ts(1266)")
+      }
     }
   }
   /** @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 elements = ast.elements.map((ast) => ({ ast, parser: recur(ast) }))
-    const rest = ast.rest.map((ast) => ({ ast, parser: recur(ast) }))
-    const elementLen = elements.length
-
-    const [head, ...tail] = rest
-    const tailLen = tail.length
+    type ElementParser = { readonly ast: AST; readonly parser: SchemaParser.Parser }
+    let elements: Array<ElementParser> | undefined
+    let rest: Array<ElementParser> | undefined
+    const elementLen = ast.elements.length
+    const tailLen = Math.max(0, ast.rest.length - 1)
 
     function getParser(
       tailThreshold: number,
       index: number
     ): { readonly ast: AST; readonly parser: SchemaParser.Parser } {
       if (index < elementLen) {
-        return elements[index]
+        return elements![index]
       } else if (index >= tailThreshold) {
-        return tail[index - tailThreshold]
+        return rest![index - tailThreshold + 1]
       }
-      return head
+      return rest![0]
     }
 
-    return Effect.fnUntracedEager(function*(oinput, options) {
-      if (oinput._tag === "None") {
-        return oinput
+    return Effect.fnUntracedEager(function*(input, options) {
+      if (input === InternalParser.missing) {
+        return InternalParser.missing
       }
-      const input = oinput.value
 
       // If the input is not an array, return early with an error
       if (!Array.isArray(input)) {
-        return yield* Effect.fail(new SchemaIssue.InvalidType(ast, oinput))
+        return yield* Effect.fail(new SchemaIssue.InvalidType(ast, input, options))
+      }
+      if (!elements) {
+        elements = ast.elements.map((ast) => ({ ast, parser: compileConstructorDefault(ast) }))
+        rest = ast.rest.map((ast) => ({ ast, parser: compileConstructorDefault(ast) }))
       }
 
       const len = input.length
       const state = {
         ast,
         getParser,
-        oinput,
+        input,
         len,
-        tailThreshold: resolveTailThreshold(len, elementLen, tailLen),
+        tailThreshold: Math.max(elementLen, len - tailLen),
         output: new globalThis.Array(len),
         issues: undefined as Arr.NonEmptyArray<SchemaIssue.Issue> | undefined,
         options
@@ -1698,19 +1778,24 @@ 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, input[i]))
+          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, oinput, [issue]))
+            return yield* Effect.fail(
+              new SchemaIssue.Composite(ast, [issue], input, options)
+            )
           }
         }
       }
       if (state.issues) {
-        return yield* Effect.fail(new SchemaIssue.Composite(ast, oinput, state.issues))
+        return yield* Effect.fail(
+          new SchemaIssue.Composite(ast, state.issues, input, options)
+        )
       }
-      return Option.some(state.output)
+      return state.output
     })
   }
   private _rebuild(recur: (ast: AST) => AST, checks: Checks | undefined, encodingChecks: Checks | undefined) {
@@ -1745,7 +1830,7 @@ export class Arrays extends Base {
 }
 const parseArray = iterateEager<{
   readonly ast: AST
-  readonly oinput: Option.Option<unknown>
+  readonly input: unknown
   readonly len: number
   readonly getParser: (
     tailThreshold: number,
@@ -1757,14 +1842,18 @@ const parseArray = iterateEager<{
   issues: Array<SchemaIssue.Issue> | undefined
 }, unknown>()({
   onItem(s, item, i) {
-    const value = i < s.len ? Option.some(item) : Option.none()
+    const value = i < s.len ? item : InternalParser.missing
     return s.getParser(s.tailThreshold, i).parser(value, s.options)
   },
-  step(s, _, exit, i) {
+  step(s, item, exit, i) {
     if (exit._tag === "Failure") {
       return wrapPropertyKeyIssue(s, s.ast, i, exit)
-    } else if (exit.value._tag === "Some") {
-      s.output[i] = exit.value.value
+    }
+    const value = exit === InternalParser.sameExit
+      ? item
+      : (exit as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
+    if (value !== InternalParser.missing) {
+      s.output[i] = value
     } else {
       const p = s.getParser(s.tailThreshold, i)
       if (isOptional(p.ast)) return
@@ -1773,20 +1862,14 @@ const parseArray = iterateEager<{
         if (s.issues) s.issues.push(issue)
         else s.issues = [issue]
       } else {
-        return Exit.fail(new SchemaIssue.Composite(s.ast, s.oinput, [issue]))
+        return Exit.fail(
+          new SchemaIssue.Composite(s.ast, [issue], s.input, s.options)
+        )
       }
     }
   }
 })
 
-function resolveTailThreshold(
-  inputLen: number,
-  elementLen: number,
-  tailLen: number
-) {
-  return Math.max(elementLen, inputLen - tailLen)
-}
-
 const resolveConcurrency = (value: number | "unbounded" | undefined) => {
   value = value === "unbounded" ? Infinity : value ?? 1
   return value > 1 ? { concurrency: value } : undefined
@@ -1794,7 +1877,7 @@ const resolveConcurrency = (value: number | "unbounded" | undefined) => {
 
 const wrapPropertyKeyIssue = (
   s: {
-    readonly oinput: Option.Option<unknown>
+    readonly input: unknown
     readonly options: ParseOptions
     issues: Array<SchemaIssue.Issue> | undefined
   },
@@ -1810,7 +1893,13 @@ const wrapPropertyKeyIssue = (
     return Exit.failCause(
       Cause.map(
         exit.cause,
-        (issue) => new SchemaIssue.Composite(ast, s.oinput, [new SchemaIssue.Pointer([key], issue)])
+        (issue) =>
+          new SchemaIssue.Composite(
+            ast,
+            [new SchemaIssue.Pointer([key], issue)],
+            s.input,
+            s.options
+          )
       )
     )
   }
@@ -1819,7 +1908,9 @@ const wrapPropertyKeyIssue = (
     if (s.issues) s.issues.push(pointer)
     else s.issues = [pointer]
   } else {
-    return Exit.fail(new SchemaIssue.Composite(ast, s.oinput, [pointer]))
+    return Exit.fail(
+      new SchemaIssue.Composite(ast, [pointer], s.input, s.options)
+    )
   }
 }
 
@@ -1887,37 +1978,6 @@ export class PropertySignature {
   }
 }
 
-/**
- * Represents a bidirectional merge strategy for index signature key-value pairs.
- *
- * **Details**
- *
- * Used by {@link IndexSignature} when the same key appears multiple times
- * (e.g. from `Schema.extend` or overlapping records). Provides separate
- * `decode` and `encode` combiners that determine how duplicate entries are
- * merged.
- *
- * @see {@link IndexSignature}
- * @category models
- * @since 4.0.0
- */
-export class KeyValueCombiner {
-  readonly decode: Combiner.Combiner<readonly [key: PropertyKey, value: any]> | undefined
-  readonly encode: Combiner.Combiner<readonly [key: PropertyKey, value: any]> | undefined
-
-  constructor(
-    decode: Combiner.Combiner<readonly [key: PropertyKey, value: any]> | undefined,
-    encode: Combiner.Combiner<readonly [key: PropertyKey, value: any]> | undefined
-  ) {
-    this.decode = decode
-    this.encode = encode
-  }
-  /** @internal */
-  flip(): KeyValueCombiner {
-    return new KeyValueCombiner(this.encode, this.decode)
-  }
-}
-
 type IndexSignatureParameter =
   | String
   | Number
@@ -1956,7 +2016,6 @@ function isIndexSignatureParameter(ast: AST): ast is IndexSignatureParameter {
  * - `parameter` — the key type AST (e.g. {@link String} for `string` keys,
  *   {@link TemplateLiteral} for patterned keys).
  * - `type` — the value type SchemaAST.
- * - `merge` — optional {@link KeyValueCombiner} for handling duplicate keys.
  *
  * **Gotchas**
  *
@@ -1971,19 +2030,16 @@ function isIndexSignatureParameter(ast: AST): ast is IndexSignatureParameter {
 export class IndexSignature {
   readonly parameter: IndexSignatureParameter
   readonly type: AST
-  readonly merge: KeyValueCombiner | undefined
 
   constructor(
     parameter: AST,
-    type: AST,
-    merge: KeyValueCombiner | undefined
+    type: AST
   ) {
     if (!isIndexSignatureParameter(parameter)) {
       throw new Error(`Invalid index signature parameter ${parameter._tag}`)
     }
     this.parameter = parameter
     this.type = type
-    this.merge = merge
     if (isOptional(type) && !containsUndefined(type)) {
       throw new Error("Cannot use `Schema.optionalKey` with index signatures, use `Schema.optional` instead.")
     }
@@ -2014,17 +2070,14 @@ export class IndexSignature {
  *
  * **Example** (Inspecting a struct AST)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaAST } from "effect"
  *
  * const schema = Schema.Struct({ name: Schema.String })
  * const ast = schema.ast
  *
  * if (SchemaAST.isObjects(ast)) {
- *   for (const ps of ast.propertySignatures) {
- *     console.log(ps.name, ps.type._tag)
- *   }
- *   // "name" "String"
+ *   ast.propertySignatures.map((ps) => [ps.name, ps.type._tag]) // => [["name", "String"]]
  * }
  * ```
  *
@@ -2062,101 +2115,126 @@ 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> = []
-    const expectedKeysSet = new Set<PropertyKey>()
-    const properties: Array<{
-      readonly ps: PropertySignature | IndexSignature
-      readonly parser: SchemaParser.Parser
-      readonly name: PropertyKey
-      readonly type: AST
-    }> = []
     for (const ps of ast.propertySignatures) {
       expectedKeys.push(ps.name)
-      expectedKeysSet.add(ps.name)
-      properties.push({
-        ps,
-        parser: recur(ps.type),
-        name: ps.name,
-        type: ps.type
-      })
     }
+    const hasProperties = expectedKeys.length
     const indexCount = ast.indexSignatures.length
+    let expectedKeysSet = hasProperties && indexCount ? new Set(expectedKeys) : undefined
     // ---------------------------------------------
     // handle empty struct
     // ---------------------------------------------
-    if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
+    if (!hasProperties && !indexCount) {
       return fromRefinement(ast, Predicate.isNotNullish)
     }
 
-    const parseIndexes = indexCount > 0 ?
-      iterateEager<{
-        readonly oinput: Option.Option<unknown>
-        readonly input: Record<PropertyKey, unknown>
-        readonly options: ParseOptions
-        readonly out: Record<PropertyKey, unknown>
-        issues: Array<SchemaIssue.Issue> | undefined
-      }, [key: PropertyKey, is: IndexSignature]>()({
-        onItem: Effect.fnUntracedEager(function*(
-          s,
-          [key, is]
-        ) {
-          const parserKey = recur(parameterFromPropertyKey(is.parameter))
-          const effKey = parserKey(Option.some(key), s.options)
-          const exitKey = (effectIsExit(effKey) ? effKey : yield* Effect.exit(effKey)) as Exit.Exit<
-            Option.Option<PropertyKey>,
-            SchemaIssue.Issue
-          >
-          if (exitKey._tag === "Failure") {
-            const eff = wrapPropertyKeyIssue(s, ast, key, exitKey)
-            if (eff) yield* eff
-            return
-          }
-
-          const value: Option.Option<unknown> = Option.some(s.input[key])
-          const parserValue = recur(is.type)
-          const effValue = parserValue(value, s.options)
-          const exitValue = effectIsExit(effValue) ? effValue : yield* Effect.exit(effValue)
-          if (exitValue._tag === "Failure") {
-            const eff = wrapPropertyKeyIssue(s, ast, key, exitValue)
-            if (eff) yield* eff
-            return
-          } else if (exitKey.value._tag === "Some" && exitValue.value._tag === "Some") {
-            const k2 = exitKey.value.value
-            if (expectedKeysSet.has(key) || expectedKeysSet.has(k2)) {
-              return
-            }
-            const v2 = exitValue.value.value
-            if (is.merge && is.merge.decode && Object.hasOwn(s.out, k2)) {
-              const [k, v] = is.merge.decode.combine([k2, s.out[k2]], [k2, v2])
-              internalRecord.set(s.out, k, v)
-            } else {
-              internalRecord.set(s.out, k2, v2)
-            }
-          }
-        }),
+    let properties: Array<ParsedProperty> | undefined
+    let indexes:
+      | Array<{
+        readonly is: IndexSignature
+        readonly parserKey: SchemaParser.Parser
+        readonly parserValue: SchemaParser.Parser
+      }>
+      | undefined
+    type Index = NonNullable<typeof indexes>[number]
+    const finishIndex = (
+      s: ObjectParserState,
+      key: PropertyKey,
+      k2: PropertyKey | typeof InternalParser.missing,
+      inputValue: unknown,
+      exitValue: Exit.Exit<unknown, SchemaIssue.Issue>
+    ): Effect.Effect<void, SchemaIssue.Issue, any> => {
+      if (exitValue._tag === "Failure") {
+        return wrapPropertyKeyIssue(s, ast, key, exitValue) ?? Exit.void
+      }
+      const value = exitValue === InternalParser.sameExit
+        ? inputValue
+        : (exitValue as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
+      if (k2 !== InternalParser.missing && value !== InternalParser.missing) {
+        if (hasProperties && (expectedKeysSet!.has(key) || expectedKeysSet!.has(k2))) return Exit.void
+        InternalRecord.assignProperty(s.out, k2, value)
+      }
+      return Exit.void
+    }
+    const parseIndex = (
+      s: ObjectParserState,
+      key: PropertyKey,
+      index: Index,
+      exitKey?: Exit.Exit<unknown, SchemaIssue.Issue>
+    ): Effect.Effect<void, SchemaIssue.Issue, any> => {
+      if (!exitKey) {
+        const eff = index.parserKey(key, s.options)
+        if (!effectIsExit(eff)) {
+          return Effect.flatMap(Effect.exit(eff), (exit) => parseIndex(s, key, index, exit))
+        }
+        exitKey = eff
+      }
+      if (exitKey._tag === "Failure") {
+        return wrapPropertyKeyIssue(s, ast, key, exitKey) ?? Exit.void
+      }
+      const k2 = exitKey === InternalParser.sameExit
+        ? key
+        : (exitKey as InternalParser.Success<PropertyKey, SchemaIssue.Issue>)[InternalParser.args]
+      const inputValue = s.input[key]
+      const result = index.parserValue(inputValue, s.options)
+      return effectIsExit(result)
+        ? finishIndex(s, key, k2, inputValue, result)
+        : Effect.flatMap(Effect.exit(result), (exit) => finishIndex(s, key, k2, inputValue, exit))
+    }
+    const parseStringIndex = (
+      s: ObjectParserState,
+      key: PropertyKey,
+      index: Index
+    ): Effect.Effect<void, SchemaIssue.Issue, any> => {
+      const inputValue = s.input[key]
+      const result = index.parserValue(inputValue, s.options)
+      return effectIsExit(result)
+        ? finishIndex(s, key, key, inputValue, result)
+        : Effect.flatMap(Effect.exit(result), (exit) => finishIndex(s, key, key, inputValue, exit))
+    }
+    const parseIndexes = indexCount ?
+      iterateEager<ObjectParserState, [key: PropertyKey, index: Index]>()({
+        onItem: (s, [key, index]) => parseIndex(s, key, index),
         step: (_s, _, exit: Exit.Exit<void, SchemaIssue.Issue>) => exit._tag === "Failure" ? exit : undefined
       }) :
       undefined
 
-    return Effect.fnUntracedEager(function*(oinput, options) {
-      if (oinput._tag === "None") {
-        return oinput
+    return Effect.fnUntracedEager(function*(input, options) {
+      if (input === InternalParser.missing) {
+        return InternalParser.missing
       }
-      const input = oinput.value as Record<PropertyKey, unknown>
 
       // 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, oinput))
+        return yield* Effect.fail(new SchemaIssue.InvalidType(ast, input, options))
+      }
+      if (!properties) {
+        properties = ast.propertySignatures.map((ps) => ({
+          parser: compileConstructorDefault(ps.type),
+          name: ps.name,
+          type: ps.type
+        }))
+        indexes = indexCount
+          ? ast.indexSignatures.map((is) => ({
+            is,
+            parserKey: compile(parameterFromPropertyKey(is.parameter)),
+            parserValue: compileConstructorDefault(is.type)
+          }))
+          : undefined
       }
 
+      const record = input as Record<PropertyKey, unknown>
       const out: Record<PropertyKey, unknown> = {}
       const state = {
         ast,
-        oinput,
-        input,
+        input: record,
         out,
         issues: undefined as Arr.NonEmptyArray<SchemaIssue.Issue> | undefined,
         options
@@ -2169,14 +2247,16 @@ export class Objects extends Base {
       // handle excess properties
       // ---------------------------------------------
       let inputKeys: Array<PropertyKey> | undefined
-      if (ast.indexSignatures.length === 0 && (onExcessPropertyError || onExcessPropertyPreserve)) {
-        inputKeys = Reflect.ownKeys(input)
+      if (!indexCount && (onExcessPropertyError || onExcessPropertyPreserve)) {
+        expectedKeysSet ??= new Set(expectedKeys)
+        inputKeys = Reflect.ownKeys(record)
         for (let i = 0; i < inputKeys.length; i++) {
           const key = inputKeys[i]
           if (!expectedKeysSet.has(key)) {
             // key is unexpected
             if (onExcessPropertyError) {
-              const issue = new SchemaIssue.Pointer([key], new SchemaIssue.UnexpectedKey(ast, input[key]))
+              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)
@@ -2185,11 +2265,13 @@ export class Objects extends Base {
                 }
                 continue
               } else {
-                return yield* Effect.fail(new SchemaIssue.Composite(ast, oinput, [issue]))
+                return yield* Effect.fail(
+                  new SchemaIssue.Composite(ast, [issue], input, options)
+                )
               }
             } else {
               // preserve key
-              internalRecord.set(out, key, input[key])
+              InternalRecord.assignProperty(out, key, record[key])
             }
           }
         }
@@ -2200,20 +2282,34 @@ export class Objects extends Base {
       // ---------------------------------------------
       // handle property signatures
       // ---------------------------------------------
-      const eff = parseProperties(state, properties, concurrency)
-      if (eff) yield* eff
+      if (hasProperties) {
+        const eff = parseProperties(state, properties!, concurrency)
+        if (eff) yield* eff
+      }
 
       // ---------------------------------------------
       // handle index signatures
       // ---------------------------------------------
-      if (parseIndexes) {
-        const keyPairs = Arr.empty<[PropertyKey, IndexSignature]>()
+      if (indexCount && !concurrency) {
+        for (let i = 0; i < indexCount; i++) {
+          const index = indexes![i]
+          const parse = index.is.parameter === string ? parseStringIndex : parseIndex
+          const keys = index.is.parameter === string
+            ? Object.keys(record)
+            : getIndexSignatureKeys(record, index.is.parameter, options)
+          for (let j = 0; j < keys.length; j++) {
+            const eff = parse(state, keys[j], index)
+            if (!effectIsExit(eff)) yield* eff
+            else if (eff._tag === "Failure") return yield* eff as Exit.Exit<never, SchemaIssue.Issue>
+          }
+        }
+      } else if (parseIndexes) {
+        const keyPairs = Arr.empty<[PropertyKey, Index]>()
         for (let i = 0; i < indexCount; i++) {
-          const is = ast.indexSignatures[i]
-          const keys = getIndexSignatureKeys(input, is.parameter, options)
+          const index = indexes![i]
+          const keys = getIndexSignatureKeys(record, index.is.parameter, options)
           for (let j = 0; j < keys.length; j++) {
-            const key = keys[j]
-            keyPairs.push([key, is])
+            keyPairs.push([keys[j], index])
           }
         }
         const eff = parseIndexes(state, keyPairs, concurrency)
@@ -2221,26 +2317,27 @@ export class Objects extends Base {
       }
 
       if (state.issues) {
-        return yield* Effect.fail(new SchemaIssue.Composite(ast, oinput, state.issues))
+        return yield* Effect.fail(
+          new SchemaIssue.Composite(ast, state.issues, input, options)
+        )
       }
       if (options.propertyOrder === "original") {
         // preserve input keys order
-        const keys = (inputKeys ?? Reflect.ownKeys(input)).concat(expectedKeys)
+        const keys = (inputKeys ?? Reflect.ownKeys(record)).concat(expectedKeys)
         const preserved: Record<PropertyKey, unknown> = {}
         for (const key of keys) {
           if (Object.hasOwn(out, key)) {
-            internalRecord.set(preserved, key, out[key])
+            InternalRecord.assignProperty(preserved, key, out[key])
           }
         }
-        return Option.some(preserved)
+        return preserved
       }
-      return Option.some(out)
+      return out
     })
   }
   private _rebuild(
     recur: (ast: AST) => AST,
     recurParameter: (ast: AST) => AST,
-    flipMerge: boolean,
     checks: Checks | undefined,
     encodingChecks: Checks | undefined
   ): Objects {
@@ -2252,10 +2349,9 @@ export class Objects extends Base {
     const indexes = mapOrSame(this.indexSignatures, (is) => {
       const p = recurParameter(is.parameter)
       const t = recur(is.type)
-      const merge = flipMerge ? is.merge?.flip() : is.merge
-      return p === is.parameter && t === is.type && merge === is.merge
+      return p === is.parameter && t === is.type
         ? is
-        : new IndexSignature(p, t, merge)
+        : new IndexSignature(p, t)
     })
 
     return props === this.propertySignatures && indexes === this.indexSignatures && checks === this.checks &&
@@ -2273,11 +2369,11 @@ export class Objects extends Base {
   }
   /** @internal */
   flip(recur: (ast: AST) => AST): AST {
-    return this._rebuild(recur, recur, true, this.encodingChecks, this.checks)
+    return this._rebuild(recur, recur, this.encodingChecks, this.checks)
   }
   /** @internal */
   recur(recur: (ast: AST) => AST, recurParameter: (ast: AST) => AST = recur): AST {
-    return this._rebuild(recur, recurParameter, false, this.checks, this.encodingChecks)
+    return this._rebuild(recur, recurParameter, this.checks, this.encodingChecks)
   }
   /** @internal */
   getExpected(): string {
@@ -2286,42 +2382,41 @@ export class Objects extends Base {
   }
 }
 
+type ObjectParserState = {
+  readonly ast: Objects
+  readonly input: Record<PropertyKey, unknown>
+  readonly options: ParseOptions
+  readonly out: Record<PropertyKey, unknown>
+  issues: Array<SchemaIssue.Issue> | undefined
+}
+
 type ParsedProperty = {
-  readonly ps: PropertySignature | IndexSignature
   readonly parser: SchemaParser.Parser
   readonly name: PropertyKey
   readonly type: AST
 }
 
-const parseProperties = iterateEager<{
-  readonly ast: AST
-  readonly oinput: Option.Option<unknown>
-  readonly input: Record<PropertyKey, unknown>
-  readonly options: ParseOptions
-  readonly out: Record<PropertyKey, unknown>
-  issues: Array<SchemaIssue.Issue> | undefined
-}, ParsedProperty>()({
-  onItem(
-    s: {
-      readonly oinput: Option.Option<unknown>
-      readonly input: Record<PropertyKey, unknown>
-      readonly options: ParseOptions
-      readonly out: Record<PropertyKey, unknown>
-      issues: Array<SchemaIssue.Issue> | undefined
-    },
-    p
-  ) {
-    const value: Option.Option<unknown> = Object.hasOwn(s.input, p.name)
-      ? Option.some(s.input[p.name])
-      : Option.none()
+const parseProperties = iterateEager<ObjectParserState, ParsedProperty>()({
+  onItem(s, p) {
+    if (!Object.hasOwn(s.input, p.name)) {
+      return p.parser(InternalParser.missing, s.options)
+    }
+    const value = s.input[p.name]
+    InternalRecord.assignProperty(s.out, p.name, value)
     return p.parser(value, s.options)
   },
   step(s, p, exit) {
     if (exit._tag === "Failure") {
       return wrapPropertyKeyIssue(s, s.ast, p.name, exit)
-    } else if (exit.value._tag === "Some") {
-      internalRecord.set(s.out, p.name, exit.value.value)
-    } else if (!isOptional(p.type)) {
+    }
+    if (exit === InternalParser.sameExit) return
+    const value = (exit as InternalParser.Success<unknown, SchemaIssue.Issue>)[InternalParser.args]
+    if (value !== InternalParser.missing) {
+      InternalRecord.assignProperty(s.out, p.name, value)
+      return
+    }
+    delete s.out[p.name]
+    if (!isOptional(p.type)) {
       const issue = new SchemaIssue.Pointer([p.name], new SchemaIssue.MissingKey(p.type.context?.annotations))
       if (s.options.errors === "all") {
         if (s.issues) s.issues.push(issue)
@@ -2329,7 +2424,7 @@ const parseProperties = iterateEager<{
         return
       } else {
         return Exit.fail(
-          new SchemaIssue.Composite(s.ast, s.oinput, [issue])
+          new SchemaIssue.Composite(s.ast, [issue], s.input, s.options)
         )
       }
     }
@@ -2422,6 +2517,21 @@ export type Sentinel = {
   readonly literal: LiteralValue | symbol
 }
 
+const toCandidate = memoizeIdempotent((ast: AST): AST => {
+  while (true) {
+    if (isSuspend(ast)) return unknown
+    const encoding = ast.encoding
+    if (!encoding) {
+      // Index signature parameters do not participate in union selection.
+      return (ast as any).recur?.(toCandidate, identity) ?? ast
+    }
+    if (
+      encoding.some((link) => link.transformation._tag === "Middleware" && link.transformation.decode !== identity)
+    ) return unknown
+    ast = encoding[encoding.length - 1].to
+  }
+})
+
 function getCandidateTypes(ast: AST): ReadonlyArray<Type> {
   switch (ast._tag) {
     case "Null":
@@ -2447,7 +2557,7 @@ function getCandidateTypes(ast: AST): ReadonlyArray<Type> {
     case "Objects":
       return ast.propertySignatures.length || ast.indexSignatures.length
         ? ["object"]
-        : ["object", "array"]
+        : ["string", "number", "boolean", "symbol", "bigint", "object", "array", "function"]
     case "Enum":
       return Array.from(new Set(ast.enums.map(([, v]) => typeof v)))
     case "Literal":
@@ -2471,12 +2581,12 @@ function getCandidateTypes(ast: AST): ReadonlyArray<Type> {
 }
 
 /** @internal */
-export function collectSentinels(ast: AST): Array<Sentinel> {
+export function collectSentinels(ast: AST): ReadonlyArray<Sentinel> {
   switch (ast._tag) {
     default:
       return []
     case "Declaration": {
-      const s = ast.annotations?.["~sentinels"]
+      const s = ast.annotations?.[InternalAnnotations.SENTINELS_ANNOTATION_KEY]
       return Array.isArray(s) ? s : []
     }
     case "Objects":
@@ -2493,63 +2603,182 @@ export function collectSentinels(ast: AST): Array<Sentinel> {
         return []
       })
     case "Arrays":
-      return ast.elements.flatMap((e, i) => {
-        return isLiteral(e) && !isOptional(e)
-          ? [{ key: i, literal: e.literal }]
-          : []
+      return ast.elements.flatMap((e, i): Array<Sentinel> => {
+        if (!isOptional(e)) {
+          if (isLiteral(e)) {
+            return [{ key: i, literal: e.literal }]
+          }
+          if (isUniqueSymbol(e)) {
+            return [{ key: i, literal: e.symbol }]
+          }
+        }
+        return []
       })
+    case "Union": {
+      if (ast.types.length === 0) return []
+      const members = ast.types.map((type) => collectSentinels(toCandidate(type)))
+      return members[0].filter((s) =>
+        members.every((sentinels) => sentinels.some((o) => o.key === s.key && o.literal === s.literal))
+      )
+    }
     case "Suspend":
       return collectSentinels(ast.thunk())
   }
 }
 
-type CandidateIndex = {
-  byType?: { [K in Type]?: Array<number> }
-  bySentinel?: Map<PropertyKey, Map<LiteralValue | symbol, Array<number>>>
-  otherwise?: { [K in Type]?: Array<number> }
-}
+type CandidateIndex = (input: any, isConstructor: boolean) => ReadonlyArray<AST>
+type SentinelEntry = readonly [
+  byValue: Map<LiteralValue | symbol, Set<number>>,
+  all: Set<number>
+]
+type SentinelIndex = Map<PropertyKey, SentinelEntry>
 
 const candidateIndexCache = new WeakMap<ReadonlyArray<AST>, CandidateIndex>()
+const emptyCandidates: ReadonlyArray<never> = Object.freeze([])
 
 function getIndex(types: ReadonlyArray<AST>): CandidateIndex {
-  let idx = candidateIndexCache.get(types)
-  if (idx) return idx
-
-  idx = {}
+  let index = candidateIndexCache.get(types)
+  if (index) return index
+
+  let bySentinel: SentinelIndex | undefined
+  let sentinelCandidateCount = 0
+  let otherwise: { [K in Type]?: Array<number> } | undefined
+  let literalCandidates: Map<LiteralValue | symbol, Array<AST>> | undefined
+  let onlyLiterals = true
   for (let i = 0; i < types.length; i++) {
     const a = types[i]
-    const encoded = toEncoded(a)
+    const encoded = toCandidate(a)
     if (isNever(encoded)) continue
 
-    const candidateTypes = getCandidateTypes(encoded)
-    const sentinels = collectSentinels(encoded)
+    if (onlyLiterals) {
+      if (isLiteral(encoded) || isUniqueSymbol(encoded)) {
+        literalCandidates ??= new Map()
+        const literal = isLiteral(encoded) ? encoded.literal : encoded.symbol
+        let arr = literalCandidates.get(literal)
+        if (!arr) literalCandidates.set(literal, arr = [])
+        arr.push(a)
+      } else {
+        onlyLiterals = false
+      }
+    }
 
-    // by-type (always filled – cheap primary filter)
-    idx.byType ??= {}
-    for (const t of candidateTypes) (idx.byType[t] ??= []).push(i)
+    const sentinels = collectSentinels(encoded)
 
-    if (sentinels.length > 0) { // discriminated variants
-      idx.bySentinel ??= new Map()
+    if (sentinels.length) { // discriminated variants
+      bySentinel ??= new Map()
+      sentinelCandidateCount++
       for (const { key, literal } of sentinels) {
-        let m = idx.bySentinel.get(key)
-        if (!m) idx.bySentinel.set(key, m = new Map())
-        let arr = m.get(literal)
-        if (!arr) m.set(literal, arr = [])
-        arr.push(i)
+        let entry = bySentinel.get(key)
+        if (!entry) bySentinel.set(key, entry = [new Map(), new Set()])
+        entry[1].add(i)
+        let indexes = entry[0].get(literal)
+        if (!indexes) entry[0].set(literal, indexes = new Set())
+        indexes.add(i)
       }
     } else { // non-discriminated
-      idx.otherwise ??= {}
-      for (const t of candidateTypes) (idx.otherwise[t] ??= []).push(i)
+      otherwise ??= {}
+      const candidateTypes = getCandidateTypes(encoded)
+      for (const t of candidateTypes) (otherwise[t] ??= []).push(i)
     }
   }
 
-  candidateIndexCache.set(types, idx)
-  return idx
+  if (onlyLiterals && literalCandidates) {
+    literalCandidates.forEach(Object.freeze)
+    index = (input) => literalCandidates.get(input) ?? emptyCandidates
+  } else if (bySentinel?.size === 1 && !otherwise) {
+    const [key, [byValue]] = bySentinel.entries().next().value!
+    const candidates = byValue as unknown as Map<LiteralValue | symbol, ReadonlyArray<AST>>
+    for (const [literal, indexes] of byValue) {
+      candidates.set(literal, Object.freeze(Array.from(indexes, (index) => types[index])))
+    }
+    index = (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
+    }
+  } else if (bySentinel) {
+    // A key owned by every discriminated candidate is safe to use as the initial selector: no candidate can
+    // be excluded merely because it uses a different sentinel key. Prefer the key with the most distinct values
+    // to minimize the matching bucket.
+    let commonSentinel: [PropertyKey, SentinelEntry] | undefined
+    for (const entry of bySentinel) {
+      if (
+        (!commonSentinel || entry[1][0].size > commonSentinel[1][0].size) &&
+        entry[1][1].size === sentinelCandidateCount
+      ) {
+        commonSentinel = entry
+      }
+    }
+
+    index = (input, isConstructor) => {
+      const runtimeType: Type = input === null ? "null" : Array.isArray(input) ? "array" : typeof input
+      const base = otherwise?.[runtimeType] ?? emptyCandidates
+      if (!Predicate.isObjectKeyword(input)) return base.map((i) => types[i])
+
+      // Non-discriminated candidates are runtime-type fallbacks and are never removed by sentinel checks.
+      const selected = new Set(base)
+      let directKey: PropertyKey | undefined
+      // An observed common key can seed the selection directly; an unknown value rules out every
+      // discriminated candidate.
+      if (commonSentinel) {
+        const [key, [byValue]] = commonSentinel
+        const hasKey = Object.hasOwn(input, key)
+        const value = hasKey ? (input as any)[key] : undefined
+        if (hasKey && (!isConstructor || value !== undefined)) {
+          const match = byValue.get(value)
+          if (!match) return base.map((i) => types[i])
+          for (const i of match) selected.add(i)
+          directKey = key
+        }
+      }
+
+      // Without an observed common key, collect positive matches from every sentinel. Constructor mode treats
+      // absent and undefined keys as unconstrained and therefore selects every candidate that owns the key.
+      if (directKey === undefined) {
+        for (const [key, [byValue, all]] of bySentinel) {
+          const hasKey = Object.hasOwn(input, key)
+          const value = hasKey ? (input as any)[key] : undefined
+          if (hasKey && (!isConstructor || value !== undefined)) {
+            const match = byValue.get(value)
+            if (match) {
+              for (const i of match) selected.add(i)
+            }
+          } else if (isConstructor) {
+            for (const i of all) selected.add(i)
+          }
+        }
+      }
+      // Missing keys are neutral. An observed key rejects only selected candidates that own it and do not match.
+      for (const [key, [byValue, all]] of bySentinel) {
+        if (key === directKey) continue
+        const hasKey = Object.hasOwn(input, key)
+        const value = hasKey ? (input as any)[key] : undefined
+        if (hasKey && (!isConstructor || value !== undefined)) {
+          const match = byValue.get(value)
+          for (const i of selected) {
+            if (all.has(i) && !match?.has(i)) selected.delete(i)
+          }
+        }
+      }
+      return Array.from(selected).sort((a, b) => a - b).map((i) => types[i])
+    }
+  } else {
+    index = (input) => {
+      const runtimeType: Type = input === null ? "null" : Array.isArray(input) ? "array" : typeof input
+      return (otherwise?.[runtimeType] ?? emptyCandidates).map((i) => types[i]).filter(filterLiterals(input))
+    }
+  }
+
+  candidateIndexCache.set(types, index)
+  return index
 }
 
 function filterLiterals(input: any) {
   return (ast: AST) => {
-    const encoded = toEncoded(ast)
+    const encoded = toCandidate(ast)
     return encoded._tag === "Literal" ?
       encoded.literal === input
       : encoded._tag === "UniqueSymbol" ?
@@ -2564,30 +2793,12 @@ function filterLiterals(input: any) {
  *
  * @internal
  */
-export function getCandidates(input: any, types: ReadonlyArray<AST>): ReadonlyArray<AST> {
-  const idx = getIndex(types)
-  const runtimeType: Type = input === null ? "null" : Array.isArray(input) ? "array" : typeof input
-
-  // 1. Try sentinel-based dispatch (most selective)
-  if (idx.bySentinel) {
-    const base = idx.otherwise?.[runtimeType] ?? []
-    if (runtimeType === "object" || runtimeType === "array") {
-      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])
-          if (match) {
-            for (const candidate of match) selected.add(candidate)
-          }
-        }
-      }
-      return Array.from(selected).sort((a, b) => a - b).map((i) => types[i]).filter(filterLiterals(input))
-    }
-    return base.map((i) => types[i])
-  }
-
-  // 2. Fallback: runtime-type dispatch only
-  return (idx.byType?.[runtimeType] ?? []).map((i) => types[i]).filter(filterLiterals(input))
+export function getCandidates(
+  input: any,
+  types: ReadonlyArray<AST>,
+  isConstructor = false
+): ReadonlyArray<AST> {
+  return getIndex(types)(input, isConstructor)
 }
 
 /**
@@ -2605,15 +2816,14 @@ export function getCandidates(input: any, types: ReadonlyArray<AST>): ReadonlyAr
  *
  * **Example** (Inspecting a union AST)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaAST } from "effect"
  *
  * const schema = Schema.Union([Schema.String, Schema.Number])
  * const ast = schema.ast
  *
  * if (SchemaAST.isUnion(ast)) {
- *   console.log(ast.types.length) // 2
- *   console.log(ast.mode)         // "anyOf"
+ *   [ast.types.length, ast.mode] // => [2, "anyOf"]
  * }
  * ```
  *
@@ -2642,38 +2852,46 @@ 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
 
-    return (oinput, options) => {
-      if (oinput._tag === "None") {
-        return Effect.succeed(oinput)
+    return (input, options) => {
+      if (input === InternalParser.missing) {
+        return InternalParser.missingExit
+      }
+      const candidates = getCandidates(input, ast.types, compileConstructorDefault !== undefined)
+
+      if (candidates.length === 1) {
+        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, input, options)
+          : Effect.catchCause(result, (cause) => failSingleUnionCandidate(ast, cause, input, options))
       }
-      const input = oinput.value
-      const candidates = getCandidates(input, ast.types)
 
       const state = {
         ast,
-        recur,
-        oinput,
+        compile,
         input,
         out: undefined,
-        successes: [],
+        successes: ast.mode === "oneOf" ? [] : undefined,
         issues: undefined as Arr.NonEmptyArray<SchemaIssue.Issue> | undefined,
         options
       }
       const concurrency = resolveConcurrency(options?.concurrency)
       const eff = parseUnion(state, candidates, concurrency ? { ...concurrency, orderedStep: true } : undefined)
       if (!eff) {
-        return state.out
-          ? Effect.succeed(state.out)
-          : Effect.fail(new SchemaIssue.AnyOf(ast, input, state.issues ?? []))
+        if (state.out) return state.out
+        return Effect.fail(new SchemaIssue.AnyOf(ast, state.issues ?? [], input, options))
       }
-      return Effect.flatMap(eff, (_) => {
-        return state.out
-          ? Effect.succeed(state.out)
-          : Effect.fail(new SchemaIssue.AnyOf(ast, input, state.issues ?? []))
+      return Effect.flatMapEager(eff, (_) => {
+        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))
       })
     }
   }
@@ -2738,19 +2956,29 @@ export class Union<A extends AST = AST> extends Base {
   }
 }
 
+function failSingleUnionCandidate(
+  ast: Union,
+  cause: Cause.Cause<SchemaIssue.Issue>,
+  input: unknown,
+  options: ParseOptions
+) {
+  const issue = InternalSchemaCause.getSchemaIssue(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 oinput: Option.Option<unknown>
   readonly input: unknown
   readonly options: ParseOptions
-  out: Option.Option<unknown> | undefined
-  successes: Array<AST>
+  out: Exit.Success<unknown, SchemaIssue.Issue> | undefined
+  readonly successes: Array<AST> | undefined
   issues: Array<SchemaIssue.Issue> | undefined
 }, AST>()({
   onItem(s, ast) {
-    const parser = s.recur(ast)
-    return parser(s.oinput, s.options)
+    const parser = s.compile(ast)
+    return parser(s.input, s.options)
   },
   step(s, candidate, exit) {
     if (exit._tag === "Failure") {
@@ -2761,13 +2989,14 @@ const parseUnion = iterateEager<{
       if (s.issues) s.issues.push(issue)
       else s.issues = [issue]
     } else {
-      if (s.out && s.ast.mode === "oneOf") {
+      if (s.out && s.successes) {
         s.successes.push(candidate)
-        return Exit.fail(new SchemaIssue.OneOf(s.ast, s.input, s.successes))
+        return Exit.fail(new SchemaIssue.OneOf(s.ast, s.successes, s.input, s.options))
       }
-      s.out = exit.value
-      s.successes.push(candidate)
-      if (s.ast.mode === "anyOf") {
+      s.out = exit
+      if (s.successes) {
+        s.successes.push(candidate)
+      } else {
         return Exit.void
       }
     }
@@ -2780,14 +3009,6 @@ const nonFiniteLiterals = new Union([
   new Literal("NaN")
 ], "anyOf")
 
-const numberToJson = new Link(
-  new Union([number, nonFiniteLiterals], "anyOf"),
-  new SchemaTransformation.Transformation(
-    SchemaGetter.Number(),
-    SchemaGetter.transform((n) => globalThis.Number.isFinite(n) ? n : globalThis.String(n))
-  )
-)
-
 function formatIsMutable(isMutable: boolean | undefined): string {
   return isMutable ? "" : "readonly "
 }
@@ -2821,7 +3042,7 @@ export function memoizeThunk<A>(f: () => A): () => A {
  *
  * **Example** (Defining recursive schema ASTs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaAST } from "effect"
  *
  * interface Category {
@@ -2834,7 +3055,7 @@ export function memoizeThunk<A>(f: () => A): () => A {
  *   children: Schema.Array(Schema.suspend((): Schema.Codec<Category> => Category))
  * })
  *
- * // The recursive branch is a Suspend node
+ * SchemaAST.isObjects(Category.ast) // => true
  * ```
  *
  * @see {@link isSuspend}
@@ -2852,15 +3073,16 @@ export class Suspend extends Base {
     encoding?: Encoding,
     context?: Context
   ) {
-    if (checks !== undefined) {
+    if (checks) {
       throw new Error("Cannot add checks to Suspend")
     }
     super(annotations, undefined, encoding, context)
     this.thunk = memoizeThunk(thunk)
   }
   /** @internal */
-  getParser(recur: (ast: AST) => SchemaParser.Parser): SchemaParser.Parser {
-    return recur(this.thunk())
+  getParser(compile: SchemaParser.Compiler): SchemaParser.Parser {
+    let parser: SchemaParser.Parser
+    return (input, options) => (parser ??= compile(this.thunk()))(input, options)
   }
   /** @internal */
   recur(recur: (ast: AST) => AST) {
@@ -2889,8 +3111,8 @@ export class Suspend extends Base {
  *
  * - `run` — the validation function. Returns `undefined` on success, or an
  *   `Issue` on failure.
- * - `annotations` — optional filter-level metadata (expected message, meta
- *   tags, arbitrary constraint hints).
+ * - `annotations` — optional filter-level annotations (expected message,
+ *   representation, arbitrary constraint hints).
  * - `aborted` — when `true`, parsing stops immediately after this filter
  *   fails (no further checks run).
  *
@@ -2995,7 +3217,7 @@ export function makeFilter<T>(
   aborted: boolean = false
 ): Filter<T> {
   return new Filter(
-    (input, ast, options) => SchemaIssue.make(input, ast, filter(input, ast, options)),
+    (input, ast, options) => SchemaIssue.normalizeFilterOutput(ast, filter(input, ast, options), input, options),
     annotations,
     aborted
   )
@@ -3007,12 +3229,38 @@ export function makeFilterByGuard<T extends E, E>(
   annotations?: Schema.Annotations.Filter
 ): Filter<any> {
   return new Filter(
-    (input: E) => is(input) ? undefined : new SchemaIssue.InvalidValue(Option.some(input)),
+    (input: E, _ast, options) => is(input) ? undefined : new SchemaIssue.InvalidValue(undefined, input, options),
     annotations,
     true // after a guard, we always want to abort
   )
 }
 
+/** @internal */
+export function isFinite(annotations?: Schema.Annotations.Filter) {
+  return makeFilter(
+    (n: number) => globalThis.Number.isFinite(n),
+    {
+      expected: "a finite number",
+      representation: {
+        id: "effect/schema/isFinite",
+        payload: null
+      },
+      toJsonSchema: () => ({ type: "number" }),
+      toCode: () => ({ runtime: "Schema.isFinite()" }),
+      arbitrary: {
+        constraint: {
+          noInfinity: true,
+          noNaN: true
+        }
+      },
+      ...annotations
+    }
+  )
+}
+
+/** @internal */
+export const finite = appendChecks(number, [isFinite()])
+
 /**
  * Creates a {@link Filter} that validates strings by running `RegExp.test`.
  *
@@ -3024,21 +3272,25 @@ export function makeFilterByGuard<T extends E, E>(
  * **Details**
  *
  * The filter can be used with `Schema.filter` or attached directly to a
- * `String` AST node through checks. The regular expression source is stored in
- * annotations for serialization and arbitrary generation.
+ * `String` AST node through checks. The regular expression is cloned and its
+ * `lastIndex` is reset before each test, so global and sticky expressions are
+ * deterministic and the provided regular expression is not mutated. The
+ * regular expression source is stored in annotations for serialization and
+ * arbitrary generation.
  *
  * **Gotchas**
  *
- * Use a non-global, non-sticky regular expression, or reset `lastIndex`
- * yourself, because `RegExp.test` is stateful for expressions with the `g` or
- * `y` flag.
+ * When deriving an arbitrary, only `regExp.source` is used. Regular expression
+ * flags are ignored because fast-check does not support them.
  *
  * **Example** (Validating an email pattern)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { SchemaAST } from "effect"
  *
  * const emailFilter = SchemaAST.isPattern(/^[^@]+@[^@]+$/)
+ * emailFilter.run("alice@example.com", SchemaAST.string, {}) // => undefined
+ * emailFilter.run("invalid", SchemaAST.string, {})?._tag // => "InvalidValue"
  * ```
  *
  * @see {@link Filter}
@@ -3047,14 +3299,19 @@ export function makeFilterByGuard<T extends E, E>(
  */
 export function isPattern(regExp: globalThis.RegExp, annotations?: Schema.Annotations.Filter) {
   const source = regExp.source
+  const pattern = new globalThis.RegExp(source, regExp.flags)
   return makeFilter(
-    (s: string) => regExp.test(s),
+    (s: string) => {
+      pattern.lastIndex = 0
+      return pattern.test(s)
+    },
     {
       expected: `a string matching the RegExp ${source}`,
-      meta: {
-        _tag: "isPattern",
-        regExp
+      representation: {
+        id: "effect/schema/isPattern",
+        payload: { source, flags: regExp.flags }
       },
+      toJsonSchema: () => ({ pattern: source }),
       arbitrary: {
         constraint: {
           patterns: [regExp.source]
@@ -3076,6 +3333,13 @@ function modifyOwnPropertyDescriptors<A extends AST>(
   return Object.create(Object.getPrototypeOf(ast), d)
 }
 
+const contextOwners = new WeakMap<AST, AST>()
+
+/** @internal */
+export function getContextOwner(ast: AST): AST {
+  return contextOwners.get(ast) ?? ast
+}
+
 /** @internal */
 export function replaceEncoding<A extends AST>(ast: A, encoding: Encoding | undefined): A {
   if (ast.encoding === encoding) {
@@ -3091,9 +3355,15 @@ export function replaceContext<A extends AST>(ast: A, context: Context | undefin
   if (ast.context === context) {
     return ast
   }
-  return modifyOwnPropertyDescriptors(ast, (d) => {
+  const owner = getContextOwner(ast)
+  if (owner.context === context) {
+    return owner as A
+  }
+  const out = modifyOwnPropertyDescriptors(ast, (d) => {
     d.context.value = context
   })
+  contextOwners.set(out, owner)
+  return out
 }
 
 /** @internal */
@@ -3114,7 +3384,7 @@ export function annotate<A extends AST>(ast: A, annotations: Schema.Annotations.
 
 /** @internal */
 export function replaceChecks<A extends AST>(ast: A, checks: Checks | undefined): A {
-  if (ast._tag === "Suspend" && checks !== undefined) {
+  if (ast._tag === "Suspend" && checks) {
     throw new Error("Cannot add checks to Suspend")
   }
   if (ast.checks === checks) {
@@ -3130,14 +3400,17 @@ export function appendChecks<A extends AST>(ast: A, checks: Checks | undefined):
   return replaceChecks(ast, combineChecks(ast.checks, checks))
 }
 
+/** @internal */
+export function mapLink(link: Link, f: (ast: AST) => AST): Link {
+  const to = f(link.to)
+  return to === link.to ? link : new Link(to, link.transformation)
+}
+
 function updateLastLink(encoding: Encoding, f: (ast: AST) => AST): Encoding {
   const links = encoding
   const last = links[links.length - 1]
-  const to = f(last.to)
-  if (to !== last.to) {
-    return Arr.append(encoding.slice(0, encoding.length - 1), new Link(to, last.transformation))
-  }
-  return encoding
+  const out = mapLink(last, f)
+  return out === last ? encoding : Arr.append(encoding.slice(0, encoding.length - 1), out)
 }
 
 /** @internal */
@@ -3145,6 +3418,11 @@ export function applyToLastLink(f: (ast: AST) => AST) {
   return <A extends AST>(ast: A): A => ast.encoding ? replaceEncoding(ast, updateLastLink(ast.encoding, f)) : ast
 }
 
+/** @internal */
+export function replaceContextLastLink<A extends AST>(ast: A, context: Context): A {
+  return applyToLastLink((ast) => replaceContext(ast, context))(ast)
+}
+
 /** @internal */
 export function applyToSelfOrLastLinkEncoding(f: (ast: AST) => AST) {
   function out(ast: AST): AST {
@@ -3153,6 +3431,21 @@ export function applyToSelfOrLastLinkEncoding(f: (ast: AST) => AST) {
   return memoize(out)
 }
 
+/** @internal */
+export function applyToSelfOrLastLinkEncodingIdempotent(
+  f: (ast: AST) => AST,
+  options?: { readonly stopAt?: (link: Link) => boolean }
+) {
+  function out(ast: AST): AST {
+    if (ast.encoding) {
+      const last = ast.encoding[ast.encoding.length - 1]
+      return options?.stopAt?.(last) ? ast : replaceEncoding(ast, updateLastLink(ast.encoding, out))
+    }
+    return f(ast)
+  }
+  return memoizeIdempotent(out)
+}
+
 /** @internal */
 export function middlewareDecoding(
   ast: AST,
@@ -3213,7 +3506,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)
@@ -3221,42 +3514,33 @@ export function annotateKey<A extends AST>(ast: A, annotations: Schema.Annotatio
 }
 
 /** @internal */
-export const optionalKeyLastLink = applyToLastLink(optionalKey)
-
-/**
- * Marks an AST node's property key as optional by setting
- * {@link Context.isOptional} to `true`.
- *
- * **Details**
- *
- * Also propagates the optional flag through the last link of the encoding
- * chain if present.
- *
- * @see {@link isOptional}
- * @see {@link Context}
- * @category transforming
- * @since 4.0.0
- */
-export function optionalKey<A extends AST>(ast: A): A {
+export const optionalKey: <A extends AST>(ast: A) => A = memoizeIdempotent(<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))
-}
+})
 
-const mutableKeyLastLink = applyToLastLink(mutableKey)
+const optionalKeyLastLink = applyToLastLink(optionalKey)
+
+/** @internal */
+export const optional = memoize(<A extends AST>(ast: A): Union<A | Undefined> =>
+  optionalKey(new Union([ast, undefined_], "anyOf"))
+)
 
 /** @internal */
-export function mutableKey<A extends AST>(ast: A): A {
+export const mutableKey = memoizeIdempotent(<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))
-}
+})
+
+const mutableKeyLastLink = applyToLastLink(mutableKey)
 
 /** @internal */
 export function withConstructorDefault<A extends AST>(
@@ -3267,10 +3551,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)
 }
 
@@ -3332,11 +3616,11 @@ function parseParameter(ast: AST): {
 }
 
 /** @internal */
-export function record(key: AST, value: AST, keyValueCombiner: KeyValueCombiner | undefined): Objects {
+export function record(key: AST, value: AST): Objects {
   const { literals, parameters: indexSignatures } = parseParameter(key)
   return new Objects(
     literals.map((literal) => new PropertySignature(literal, value)),
-    indexSignatures.map((parameter) => new IndexSignature(parameter, value, keyValueCombiner))
+    indexSignatures.map((parameter) => new IndexSignature(parameter, value))
   )
 }
 
@@ -3366,6 +3650,20 @@ export function isMutable(ast: AST): boolean {
   return ast.context?.isMutable ?? false
 }
 
+function isStructuralCheck(check: Check<any>): boolean {
+  return check.annotations?.[InternalAnnotations.STRUCTURAL_ANNOTATION_KEY] === true ||
+    check._tag === "FilterGroup" && check.checks.every(isStructuralCheck)
+}
+
+function extractStructuralChecks(checks: Checks): Checks | undefined {
+  function extract(check: Check<any>): Array<Check<any>> {
+    if (isStructuralCheck(check)) return [check]
+    return check._tag === "FilterGroup" ? check.checks.flatMap(extract) : []
+  }
+  const out = checks.flatMap(extract)
+  return Arr.isArrayNonEmpty(out) ? out : undefined
+}
+
 /**
  * Strips all encoding transformations from an AST, returning the decoded
  * (type-level) representation.
@@ -3378,12 +3676,12 @@ export function isMutable(ast: AST): boolean {
  *
  * **Example** (Getting the type AST)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaAST } from "effect"
  *
  * const schema = Schema.NumberFromString
  * const typeAst = SchemaAST.toType(schema.ast)
- * console.log(typeAst._tag) // "Number"
+ * typeAst._tag // => "Number"
  * ```
  *
  * @see {@link toEncoded}
@@ -3391,19 +3689,22 @@ export function isMutable(ast: AST): boolean {
  * @category transforming
  * @since 4.0.0
  */
-export const toType = memoize(<A extends AST>(ast: A): A => {
+export const toType = memoizeIdempotent(<A extends AST>(ast: A): A => {
   if (ast.encoding) {
     return toType(replaceEncoding(ast, undefined))
   }
   const out: any = ast
   const type = out.recur?.(toType) ?? out
-  const encodingChecks = type.encodingChecks
+  const encodingChecks: Checks | undefined = type.encodingChecks
   if (encodingChecks) {
+    const checks = type === ast
+      ? encodingChecks
+      : isArrays(type) || isObjects(type) || isDeclaration(type) && type.typeParameters.length > 0
+      ? extractStructuralChecks(encodingChecks)
+      : undefined
     return modifyOwnPropertyDescriptors(type, (d) => {
       d.encodingChecks.value = undefined
-      if (type === ast) {
-        d.checks.value = combineChecks(type.checks, encodingChecks)
-      }
+      d.checks.value = combineChecks(type.checks, checks)
     })
   }
   return type
@@ -3422,12 +3723,12 @@ export const toType = memoize(<A extends AST>(ast: A): A => {
  *
  * **Example** (Getting the encoded AST)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaAST } from "effect"
  *
  * const schema = Schema.NumberFromString
  * const encodedAst = SchemaAST.toEncoded(schema.ast)
- * console.log(encodedAst._tag) // "String"
+ * encodedAst._tag // => "String"
  * ```
  *
  * @see {@link toType}
@@ -3435,7 +3736,7 @@ export const toType = memoize(<A extends AST>(ast: A): A => {
  * @category transforming
  * @since 4.0.0
  */
-export const toEncoded = memoize((ast: AST): AST => {
+export const toEncoded = memoizeIdempotent((ast: AST): AST => {
   return toType(flip(ast))
 })
 
@@ -3498,54 +3799,44 @@ function fromConst<const T>(
   ast: AST,
   value: T
 ): SchemaParser.Parser {
-  const succeed = Effect.succeedSome(value)
-  return (oinput) => {
-    if (oinput._tag === "None") {
-      return Effect.succeedNone
-    }
-    return oinput.value === value
-      ? succeed
-      : Effect.fail(new SchemaIssue.InvalidType(ast, oinput))
+  const succeed = InternalParser.succeed(value)
+  return (input, options) => {
+    if (input === InternalParser.missing) return InternalParser.missingExit
+    if (input === value) return succeed
+    return Effect.fail(new SchemaIssue.InvalidType(ast, input, options))
   }
 }
 
-function fromAnyToConst<const T>(value: T): SchemaParser.Parser {
-  const succeed = Effect.succeedSome(value)
-  return (oinput) => oinput._tag === "None" ? Effect.succeedNone : succeed
-}
-
 function fromRefinement<T>(
   ast: AST,
   refinement: (input: unknown) => input is T
 ): SchemaParser.Parser {
-  return (oinput) => {
-    if (oinput._tag === "None") {
-      return Effect.succeedNone
-    }
-    return refinement(oinput.value)
-      ? Effect.succeed(oinput)
-      : Effect.fail(new SchemaIssue.InvalidType(ast, oinput))
+  return (input, options) => {
+    if (input === InternalParser.missing) return InternalParser.missingExit
+    if (refinement(input)) return InternalParser.sameExit
+    return Effect.fail(new SchemaIssue.InvalidType(ast, input, options))
   }
 }
 
-function applyTemplateLiteralPartChecks<A>(ast: AST, value: A, options: ParseOptions): A | undefined {
-  if (options?.disableChecks || ast.checks === undefined) return value
-  const issues: Array<SchemaIssue.Issue> = []
-  collectIssues(ast.checks, value, issues, ast, options)
-  return issues.length === 0 ? value : undefined
-}
-
 function segmentTemplateLiteralParts(
-  parts: ReadonlyArray<TemplateLiteralPart>,
+  ast: TemplateLiteral,
   input: string,
   options: ParseOptions
 ): Array<string> | undefined {
+  const parts = ast.encodedParts
+  const literals = ast.literals
+  const inputLength = input.length
+  for (let i = 0; i < literals.length; i++) {
+    const literal = literals[i]
+    if (literal && !input.includes(literal)) return undefined
+  }
+  if (ast.suffixLengths[0] > inputLength) return undefined
+
   const out = new Array<string>(parts.length)
-  const failures = new Set<string>()
+  let failures: Set<number> | undefined
   function go(i: number, pos: number): boolean {
-    if (i === parts.length) return pos === input.length
-    const key = `${i}/${pos}`
-    if (failures.has(key)) return false
+    if (i === parts.length) return pos === inputLength
+    if (failures?.has(i * (inputLength + 1) + pos)) return false
     const part = parts[i]
     if (i === parts.length - 1) {
       const s = input.slice(pos)
@@ -3554,21 +3845,28 @@ function segmentTemplateLiteralParts(
         return true
       }
     } else if (part._tag === "Literal") {
-      const s = globalThis.String(part.literal)
+      const s = literals[i]!
       if (input.startsWith(s, pos) && go(i + 1, pos + s.length)) {
         out[i] = s
         return true
       }
     } else {
-      for (let end = input.length; end >= pos; end--) {
+      const maximumEnd = inputLength - ast.suffixLengths[i + 1]
+      // Splits preceding a literal only need to consider occurrences of that literal.
+      const anchor = literals[i + 1]
+      let end = anchor === undefined ? maximumEnd : input.lastIndexOf(anchor, maximumEnd)
+      while (end >= pos) {
         const s = input.slice(pos, end)
         if (part.matchPart(s, options) !== undefined && go(i + 1, end)) {
           out[i] = s
           return true
         }
+        if (end === 0) break
+        end = anchor === undefined ? end - 1 : input.lastIndexOf(anchor, end - 1)
       }
     }
-    failures.add(key)
+    failures ??= new Set()
+    failures.add(i * (inputLength + 1) + pos)
     return false
   }
   return go(0, 0) ? out : undefined
@@ -3582,7 +3880,7 @@ export const enumsToLiterals = memoize((ast: Enum): Union<Literal> => {
   )
 })
 
-const parameterFromPropertyKey = applyToSelfOrLastLinkEncoding((ast) => {
+const parameterFromPropertyKey = applyToSelfOrLastLinkEncodingIdempotent((ast) => {
   switch (ast._tag) {
     default:
       return ast
@@ -3594,7 +3892,7 @@ const parameterFromPropertyKey = applyToSelfOrLastLinkEncoding((ast) => {
 })
 
 /** @internal */
-export const parameterFromString = applyToSelfOrLastLinkEncoding((ast) => {
+export const parameterFromString = applyToSelfOrLastLinkEncodingIdempotent((ast) => {
   switch (ast._tag) {
     default:
       return ast
@@ -3606,7 +3904,7 @@ export const parameterFromString = applyToSelfOrLastLinkEncoding((ast) => {
   }
 })
 
-const partFromString = applyToSelfOrLastLinkEncoding((ast) => {
+const partFromString = applyToSelfOrLastLinkEncodingIdempotent((ast) => {
   switch (ast._tag) {
     default:
       return ast
@@ -3627,7 +3925,7 @@ export const STRING_PATTERN = "[\\s\\S]*?"
 
 const isStringFiniteRegExp = new globalThis.RegExp(`^${FINITE_PATTERN}$`)
 
-const isStringNumberRegExp = new globalThis.RegExp(`(?:${FINITE_PATTERN}|Infinity|-Infinity|NaN)`)
+const isStringNumberRegExp = new globalThis.RegExp(`^(?:${FINITE_PATTERN}|Infinity|-Infinity|NaN)$`)
 
 /** @internal */
 export function isStringFinite(annotations?: Schema.Annotations.Filter) {
@@ -3635,10 +3933,11 @@ export function isStringFinite(annotations?: Schema.Annotations.Filter) {
     isStringFiniteRegExp,
     {
       expected: "a string representing a finite number",
-      meta: {
-        _tag: "isStringFinite",
-        regExp: isStringFiniteRegExp
+      representation: {
+        id: "effect/schema/isStringFinite",
+        payload: null
       },
+      toJsonSchema: () => ({ pattern: isStringFiniteRegExp.source }),
       ...annotations
     }
   )
@@ -3669,10 +3968,11 @@ export function isStringBigInt(annotations?: Schema.Annotations.Filter) {
     isStringBigIntRegExp,
     {
       expected: "a string representing a bigint",
-      meta: {
-        _tag: "isStringBigInt",
-        regExp: isStringBigIntRegExp
+      representation: {
+        id: "effect/schema/isStringBigInt",
+        payload: null
       },
+      toJsonSchema: () => ({ pattern: isStringBigIntRegExp.source }),
       ...annotations
     }
   )
@@ -3702,13 +4002,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(Option.some(sym), { message: "cannot serialize to string, Symbol is not registered" })
+        new SchemaIssue.Forbidden(
+          { message: "cannot serialize to string, Symbol is not registered" },
+          sym,
+          options
+        )
       )
     })
   )
@@ -3720,10 +4024,11 @@ export function isStringSymbol(annotations?: Schema.Annotations.Filter) {
     isStringSymbolRegExp,
     {
       expected: "a string representing a symbol",
-      meta: {
-        _tag: "isStringSymbol",
-        regExp: isStringSymbolRegExp
+      representation: {
+        id: "effect/schema/isStringSymbol",
+        payload: null
       },
+      toJsonSchema: () => ({ pattern: isStringSymbolRegExp.source }),
       ...annotations
     }
   )
@@ -3733,24 +4038,33 @@ export function isStringSymbol(annotations?: Schema.Annotations.Filter) {
 export function collectIssues<T>(
   checks: ReadonlyArray<Check<T>>,
   value: T,
-  issues: Array<SchemaIssue.Issue>,
+  issues: Arr.NonEmptyArray<SchemaIssue.Issue> | undefined,
   ast: AST,
   options: ParseOptions
-) {
+): Arr.NonEmptyArray<SchemaIssue.Issue> | undefined {
   for (let i = 0; i < checks.length; i++) {
     const check = checks[i]
     if (check._tag === "FilterGroup") {
-      collectIssues(check.checks, value, issues, ast, options)
+      issues = collectIssues(check.checks, value, issues, ast, options)
+      if (
+        issues &&
+        (options.errors !== "all" || (issues[issues.length - 1] as SchemaIssue.Filter).filter.aborted)
+      ) {
+        return issues
+      }
     } else {
       const issue = check.run(value, ast, options)
       if (issue) {
-        issues.push(new SchemaIssue.Filter(value, check, issue))
-        if (check.aborted || options?.errors !== "all") {
-          return
+        const filter = new SchemaIssue.Filter(check, issue, value, options)
+        if (issues) issues.push(filter)
+        else issues = [filter]
+        if (options.errors !== "all" || check.aborted) {
+          return issues
         }
       }
     }
   }
+  return issues
 }
 
 /** @internal */
@@ -3758,20 +4072,26 @@ export function runChecks<T>(
   checks: readonly [Check<T>, ...Array<Check<T>>],
   s: T
 ): Result.Result<T, SchemaIssue.Issue> {
-  const issues: Array<SchemaIssue.Issue> = []
-  collectIssues(checks, s, issues, unknown, { errors: "all" })
-  if (Arr.isArrayNonEmpty(issues)) {
-    const issue = new SchemaIssue.Composite(unknown, Option.some(s), issues)
+  const issues = collectIssues(checks, s, undefined, unknown, { errors: "all" })
+  if (issues) {
+    const issue = new SchemaIssue.Composite(unknown, issues)
     return Result.fail(issue)
   }
   return Result.succeed(s)
 }
 
 /** @internal */
-export const ClassTypeId = "~effect/Schema/Class"
+export interface ConstructorDescriptor {
+  readonly isConstructed: Predicate.Predicate<unknown>
+  readonly link: Link
+}
 
 /** @internal */
-export const STRUCTURAL_ANNOTATION_KEY = "~structural"
+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.
@@ -3784,12 +4104,12 @@ export const STRUCTURAL_ANNOTATION_KEY = "~structural"
  *
  * **Example** (Reading annotations)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaAST } from "effect"
  *
  * const schema = Schema.String.annotate({ title: "Name" })
  * const annotations = SchemaAST.resolve(schema.ast)
- * console.log(annotations?.title) // "Name"
+ * annotations?.title // => "Name"
  * ```
  *
  * @see {@link resolveAt}
@@ -3854,6 +4174,82 @@ export const resolveTitle: (ast: AST) => string | undefined = InternalAnnotation
  */
 export const resolveDescription: (ast: AST) => string | undefined = InternalAnnotations.resolveDescription
 
+type TreeFrame = {
+  readonly value: object
+  // Object keys or an array length snapshot.
+  readonly keys: ReadonlyArray<string> | number
+  index: number
+}
+
+function isJsonLeaf(u: unknown): boolean {
+  return u === null || typeof u === "string" || typeof u === "boolean" ||
+    typeof u === "number" && globalThis.Number.isFinite(u)
+}
+
+function isStringTreeLeaf(u: unknown): boolean {
+  return u === undefined || typeof u === "string"
+}
+
+function isTree(u: unknown, isLeaf: (u: unknown) => boolean): boolean {
+  const cache = new WeakMap<object, boolean>()
+  const stack: Array<TreeFrame> = []
+  outer: while (true) {
+    if (typeof u !== "object" || u === null) {
+      if (!isLeaf(u)) {
+        return false
+      }
+    } else {
+      const value = u
+      const cached = cache.get(value)
+      // `false` marks a node on the current path, while `true` marks a fully
+      // validated node that can be safely reused by a DAG.
+      if (cached === false) {
+        return false
+      }
+      if (cached === undefined) {
+        const isArray = Array.isArray(value)
+        if (!isArray) {
+          const prototype = Object.getPrototypeOf(value)
+          // A plain object from another realm has a different Object.prototype,
+          // but that prototype still has a null prototype.
+          if (
+            prototype !== null &&
+            prototype !== Object.prototype &&
+            Object.getPrototypeOf(prototype) !== null
+          ) {
+            return false
+          }
+        }
+        cache.set(value, false)
+        stack.push({
+          value,
+          keys: isArray ? value.length : Object.keys(value),
+          index: 0
+        })
+      }
+    }
+
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1]
+      const keys = frame.keys
+      if (typeof keys === "number") {
+        if (frame.index < keys) {
+          // A sparse slot is read as `undefined`; the leaf predicate determines
+          // whether that is valid for the current tree.
+          u = (frame.value as ReadonlyArray<unknown>)[frame.index++]
+          continue outer
+        }
+      } else if (frame.index < keys.length) {
+        u = (frame.value as Record<string, unknown>)[keys[frame.index++]]
+        continue outer
+      }
+      cache.set(frame.value, true)
+      stack.pop()
+    }
+    return true
+  }
+}
+
 /**
  * Returns true if the value is a JSON value.
  *
@@ -3862,97 +4258,48 @@ export const resolveDescription: (ast: AST) => string | undefined = InternalAnno
  * @internal
  */
 export function isJson(u: unknown): u is Schema.Json {
-  // `onPath` is the current recursion stack: nodes between the root and the
-  // one being visited. A hit here means we looped back to an ancestor — a
-  // real cycle, not a DAG — so the value is not JSON.
-  const onPath = new Set<unknown>()
-  // `validated` memoizes subtrees we've already fully checked. Without it, a
-  // diamond-shaped DAG (same node reached through multiple parents) would be
-  // re-traversed once per parent, which is exponential in the nesting depth.
-  const validated = new Set<unknown>()
-  return recur(u)
-
-  function recur(u: unknown): boolean {
-    if (u === null || typeof u === "string" || typeof u === "boolean") {
-      return true
-    }
-    if (typeof u === "number") {
-      return globalThis.Number.isFinite(u)
-    }
-    if (typeof u !== "object" || u === undefined) {
-      return false
-    }
-    if (onPath.has(u)) {
-      return false
-    }
-    if (validated.has(u)) {
-      return true
-    }
-    const isArray = Array.isArray(u)
-    if (!isArray) {
-      const prototype = Object.getPrototypeOf(u)
-      if (prototype !== null && Object.getPrototypeOf(prototype) !== null) {
-        return false
-      }
-    }
-    onPath.add(u)
-    const ok = isArray
-      ? u.every(recur)
-      : Object.keys(u).every((key) => recur((u as Record<string, unknown>)[key]))
-    // Pop on exit so siblings reaching the same node via a different path
-    // don't see it as an ancestor (that would reject valid DAGs).
-    onPath.delete(u)
-    if (ok) {
-      validated.add(u)
-    }
-    return ok
-  }
+  return isTree(u, isJsonLeaf)
 }
 
 /** @internal */
 export const Json = new Declaration(
   [],
-  () => (input, ast) =>
+  () => (input, ast, options) =>
     isJson(input) ?
-      Effect.succeed(input) :
-      Effect.fail(new SchemaIssue.InvalidType(ast, Option.some(input))),
+      InternalParser.sameExit :
+      Effect.fail(new SchemaIssue.InvalidType(ast, input, options)),
   {
-    typeConstructor: {
-      _tag: "effect/Json"
-    },
-    generation: {
-      runtime: `Schema.Json`,
-      Type: `Schema.Json`
+    representation: {
+      id: "effect/schema/Json",
+      payload: null
     },
     expected: "JSON value",
-    toCodecJson: () => new Link(unknown, SchemaTransformation.passthrough()),
+    toCodecJson: () => undefined,
+    toCodecStringTree: () => unknownToStringTree,
     toArbitrary: () => (fc: typeof FastCheck) => fc.jsonValue()
   }
 )
 
 /** @internal */
 export const MutableJson = annotate(Json, {
-  typeConstructor: {
-    _tag: "effect/MutableJson"
-  },
-  generation: {
-    runtime: `Schema.MutableJson`,
-    Type: `Schema.MutableJson`
+  representation: {
+    id: "effect/schema/MutableJson",
+    payload: null
   }
 })
 
 /** @internal */
-export const unknownToNull = new Link(
-  null_,
-  new SchemaTransformation.Transformation(
-    SchemaGetter.passthrough(),
-    SchemaGetter.transform(() => null)
-  )
+export const unknownToJson = new Link(
+  Json,
+  SchemaTransformation.passthrough()
 )
 
 /** @internal */
-export const unknownToJson = new Link(
-  Json,
+export const objectKeywordToJson = new Link(
+  new Union([
+    new Arrays(false, [], [Json]),
+    new Objects([], [new IndexSignature(string, Json)])
+  ], "anyOf"),
   SchemaTransformation.passthrough()
 )
 
@@ -3964,34 +4311,16 @@ export const unknownToJson = new Link(
  * @internal
  */
 export function isStringTree(u: unknown): u is Schema.StringTree {
-  const seen = new Set<unknown>()
-  return recur(u)
-
-  function recur(u: unknown): boolean {
-    if (u === undefined || typeof u === "string") {
-      return true
-    }
-    if (typeof u !== "object" || u === null) {
-      return false
-    }
-    if (seen.has(u)) {
-      return false
-    }
-    seen.add(u)
-    if (Array.isArray(u)) {
-      return u.every(recur)
-    }
-    return Object.keys(u).every((key) => recur((u as Record<string, unknown>)[key]))
-  }
+  return isTree(u, isStringTreeLeaf)
 }
 
 const StringTree = new Declaration(
   [],
-  () => (input, ast) =>
+  () => (input, ast, options) =>
     isStringTree(input) ?
-      Effect.succeed(input) :
-      Effect.fail(new SchemaIssue.InvalidType(ast, Option.some(input))),
-  { expected: "StringTree" }
+      InternalParser.sameExit :
+      Effect.fail(new SchemaIssue.InvalidType(ast, input, options)),
+  { expected: "StringTree", toCodecStringTree: () => undefined }
 )
 
 /** @internal */