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

package/dist/SchemaAST.js

@@ -15,12 +15,12 @@ import * as Cause from "./Cause.js";
 import * as Effect from "./Effect.js";
 import * as Exit from "./Exit.js";
 import { format, formatPropertyKey } from "./Formatter.js";
-import { memoize } from "./Function.js";
+import { identity, memoize, memoizeIdempotent } from "./Function.js";
 import { effectIsExit, iterateEager } from "./internal/effect.js";
-import * as internalRecord from "./internal/record.js";
+import * as InternalRecord from "./internal/record.js";
 import * as InternalAnnotations from "./internal/schema/annotations.js";
 import * as InternalSchemaCause from "./internal/schema/cause.js";
-import * as Option from "./Option.js";
+import * as InternalParser from "./internal/schema/parser.js";
 import * as Pipeable from "./Pipeable.js";
 import * as Predicate from "./Predicate.js";
 import * as Result from "./Result.js";
@@ -350,7 +350,7 @@ export const defaultParseOptions = {};
  *
  * - `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).
@@ -364,13 +364,13 @@ export class Context {
   isOptional;
   isMutable;
   /** Used for constructor default values (e.g. `withConstructorDefault` API) */
-  defaultValue;
+  constructorDefault;
   annotations;
   constructor(isOptional, isMutable, /** Used for constructor default values (e.g. `withConstructorDefault` API) */
-  defaultValue = undefined, annotations = undefined) {
+  constructorDefault = undefined, annotations = undefined) {
     this.isOptional = isOptional;
     this.isMutable = isMutable;
-    this.defaultValue = defaultValue;
+    this.constructorDefault = constructorDefault;
     this.annotations = annotations;
   }
 }
@@ -443,10 +443,10 @@ export class Declaration extends Base {
   }
   /** @internal */
   getParser() {
-    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;
+    return (input, options) => {
+      if (input === InternalParser.missing) return InternalParser.missingExit;
+      return (run ??= this.run(this.typeParameters))(input, this, options);
     };
   }
   _rebuild(recur, checks, encodingChecks) {
@@ -571,7 +571,8 @@ export class Void extends Base {
   _tag = "Void";
   /** @internal */
   getParser() {
-    return fromAnyToConst(undefined);
+    const succeed = InternalParser.succeed(undefined);
+    return input => input === InternalParser.missing ? InternalParser.missingExit : succeed;
   }
   /** @internal */
   toCodecJson() {
@@ -797,9 +798,9 @@ function isTemplateLiteralPart(ast) {
       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;
   }
@@ -822,27 +823,47 @@ export class TemplateLiteral extends Base {
   parts;
   /** @internal */
   encodedParts;
+  /** @internal */
+  literals;
+  /** @internal */
+  suffixLengths;
   constructor(parts, annotations, checks, encoding, context) {
     super(annotations, checks, encoding, context);
     const encodedParts = [];
+    const literals = [];
     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(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) {
-    const parser = recur(this.asTemplateLiteralParser());
-    return (oinput, options) => Effect.mapBothEager(parser(oinput, options), {
-      onSuccess: () => oinput,
-      onFailure: issue => new SchemaIssue.Composite(this, oinput, [issue])
-    });
+  getParser(compile) {
+    const parser = compile(this.asTemplateLiteralParser());
+    return (input, options) => {
+      if (input === InternalParser.missing) return InternalParser.missingExit;
+      const result = parser(input, options);
+      if (result._tag === "Success") {
+        return InternalParser.sameExit;
+      }
+      return Effect.mapBothEager(result, {
+        onSuccess: () => input,
+        onFailure: issue => new SchemaIssue.Composite(this, [issue], input, options)
+      });
+    };
   }
   /** @internal */
   getExpected() {
@@ -850,17 +871,17 @@ export class TemplateLiteral extends Base {
   }
   /** @internal */
   matchPart(s, options) {
-    return segmentTemplateLiteralParts(this.encodedParts, s, options) === undefined ? undefined : s;
+    return segmentTemplateLiteralParts(this, s, options) === undefined ? undefined : s;
   }
   /** @internal */
   asTemplateLiteralParser() {
     const tuple = new Arrays(false, this.parts.map(partFromString), []);
     return decodeTo(string, tuple, new SchemaTransformation.Transformation(SchemaGetter.transformOrFail((s, options) => {
-      const segments = segmentTemplateLiteralParts(this.encodedParts, s, options);
-      if (segments !== undefined) return Effect.succeed(segments);
-      return Effect.fail(new SchemaIssue.InvalidValue(Option.some(s), {
-        message: `Expected a string matching template literal parts, got ${format(s)}`
-      }));
+      const segments = segmentTemplateLiteralParts(this, s, options);
+      if (segments) return Effect.succeed(segments);
+      return Effect.fail(new SchemaIssue.InvalidValue({
+        expected: "a string matching template literal parts"
+      }, s, options));
     }), SchemaGetter.transform(parts => parts.join(""))));
   }
 }
@@ -908,11 +929,11 @@ export class UniqueSymbol extends Base {
  *
  * **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}
@@ -972,7 +993,8 @@ export class String extends Base {
   }
   /** @internal */
   matchPart(s, options) {
-    return applyTemplateLiteralPartChecks(this, s, options);
+    const checks = this.checks;
+    return checks && !options.disableChecks && collectIssues(checks, s, undefined, this, options) ? undefined : s;
   }
   /** @internal */
   getExpected() {
@@ -1027,18 +1049,21 @@ export class Number extends Base {
     return this._match(isStringFiniteRegExp, s, options);
   }
   _match(regexp, s, options) {
-    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() {
-    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() {
-    if (this.checks && (hasCheck(this.checks, "isFinite") || hasCheck(this.checks, "isInt"))) {
+    if (this.toCodecJson() === this) {
       return replaceEncoding(this, [finiteToString]);
     }
     return replaceEncoding(this, [numberToString]);
@@ -1048,16 +1073,12 @@ export class Number extends Base {
     return "number";
   }
 }
-// oxlint-disable-next-line only-used-in-recursion - @gcanti what's this? :-)
-function hasCheck(checks, tag) {
-  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, id) {
+  return checks.some(check => check.annotations?.representation?.id === id || check._tag === "FilterGroup" && hasCheck(check.checks, id));
+}
+function numberToJson(checks) {
+  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))));
 }
 /**
  * Provides the singleton {@link Number} AST instance.
@@ -1135,7 +1156,8 @@ export class Symbol extends Base {
   }
   /** @internal */
   matchKey(s, options) {
-    return applyTemplateLiteralPartChecks(this, s, options);
+    if (options.disableChecks || !this.checks) return s;
+    return collectIssues(this.checks, s, undefined, this, options) ? undefined : s;
   }
   /** @internal */
   toCodecStringTree() {
@@ -1186,7 +1208,10 @@ export class BigInt extends Base {
   }
   /** @internal */
   matchPart(s, options) {
-    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() {
@@ -1238,15 +1263,14 @@ export const bigInt = /*#__PURE__*/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]
  * }
  * ```
  *
@@ -1267,55 +1291,65 @@ export class Arrays extends Base {
     this.elements = elements;
     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) {
+  getParser(compile, compileConstructorDefault = compile) {
     // 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;
+    let elements;
+    let rest;
+    const elementLen = ast.elements.length;
+    const tailLen = Math.max(0, ast.rest.length - 1);
     function getParser(tailThreshold, index) {
       if (index < elementLen) {
         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,
         options
@@ -1331,18 +1365,19 @@ 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;
     });
   }
   _rebuild(recur, checks, encodingChecks) {
@@ -1365,14 +1400,16 @@ export class Arrays extends Base {
 }
 const parseArray = /*#__PURE__*/iterateEager()({
   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[InternalParser.args];
+    if (value !== InternalParser.missing) {
+      s.output[i] = value;
     } else {
       const p = s.getParser(s.tailThreshold, i);
       if (isOptional(p.ast)) return;
@@ -1380,14 +1417,11 @@ const parseArray = /*#__PURE__*/iterateEager()({
       if (s.options.errors === "all") {
         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, elementLen, tailLen) {
-  return Math.max(elementLen, inputLen - tailLen);
-}
 const resolveConcurrency = value => {
   value = value === "unbounded" ? Infinity : value ?? 1;
   return value > 1 ? {
@@ -1400,13 +1434,13 @@ const wrapPropertyKeyIssue = (s, ast, key, exit) => {
   }
   const issue = InternalSchemaCause.getSchemaIssue(exit.cause);
   if (issue === undefined) {
-    return Exit.failCause(Cause.map(exit.cause, issue => new SchemaIssue.Composite(ast, s.oinput, [new SchemaIssue.Pointer([key], issue)])));
+    return Exit.failCause(Cause.map(exit.cause, issue => new SchemaIssue.Composite(ast, [new SchemaIssue.Pointer([key], issue)], s.input, s.options)));
   }
   const pointer = new SchemaIssue.Pointer([key], issue);
   if (s.options.errors === "all") {
     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));
   }
 };
 /**
@@ -1459,32 +1493,6 @@ export class PropertySignature {
     this.type = type;
   }
 }
-/**
- * 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 {
-  decode;
-  encode;
-  constructor(decode, encode) {
-    this.decode = decode;
-    this.encode = encode;
-  }
-  /** @internal */
-  flip() {
-    return new KeyValueCombiner(this.encode, this.decode);
-  }
-}
 function isIndexSignatureParameterSide(ast) {
   switch (ast._tag) {
     case "String":
@@ -1514,7 +1522,6 @@ function isIndexSignatureParameter(ast) {
  * - `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**
  *
@@ -1529,14 +1536,12 @@ function isIndexSignatureParameter(ast) {
 export class IndexSignature {
   parameter;
   type;
-  merge;
-  constructor(parameter, type, merge) {
+  constructor(parameter, type) {
     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.");
     }
@@ -1566,17 +1571,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"]]
  * }
  * ```
  *
@@ -1604,77 +1606,85 @@ export class Objects extends Base {
     }
   }
   /** @internal */
-  getParser(recur) {
+  getParser(compile, compileConstructorDefault = compile) {
     // oxlint-disable-next-line @typescript-eslint/no-this-alias
     const ast = this;
     const expectedKeys = [];
-    const expectedKeysSet = new Set();
-    const properties = [];
     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()({
-      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);
-        if (exitKey._tag === "Failure") {
-          const eff = wrapPropertyKeyIssue(s, ast, key, exitKey);
-          if (eff) yield* eff;
-          return;
-        }
-        const value = 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;
+    let indexes;
+    const finishIndex = (s, key, k2, inputValue, exitValue) => {
+      if (exitValue._tag === "Failure") {
+        return wrapPropertyKeyIssue(s, ast, key, exitValue) ?? Exit.void;
+      }
+      const value = exitValue === InternalParser.sameExit ? inputValue : exitValue[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, key, index, exitKey) => {
+      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[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, key, index) => {
+      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()({
+      onItem: (s, [key, index]) => parseIndex(s, key, index),
       step: (_s, _, exit) => 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;
       // 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;
       const out = {};
       const state = {
         ast,
-        oinput,
-        input,
+        input: record,
         out,
         issues: undefined,
         options
@@ -1686,14 +1696,16 @@ export class Objects extends Base {
       // handle excess properties
       // ---------------------------------------------
       let inputKeys;
-      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);
@@ -1702,11 +1714,11 @@ 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]);
             }
           }
         }
@@ -1715,42 +1727,53 @@ 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) {
+      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;
+          }
+        }
+      } else if (parseIndexes) {
         const keyPairs = Arr.empty();
         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);
         if (eff) yield* eff;
       }
       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 = {};
         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;
     });
   }
-  _rebuild(recur, recurParameter, flipMerge, checks, encodingChecks) {
+  _rebuild(recur, recurParameter, checks, encodingChecks) {
     const props = mapOrSame(this.propertySignatures, ps => {
       const t = recur(ps.type);
       return t === ps.type ? ps : new PropertySignature(ps.name, t);
@@ -1758,18 +1781,17 @@ 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 ? is : new IndexSignature(p, t, merge);
+      return p === is.parameter && t === is.type ? is : new IndexSignature(p, t);
     });
     return props === this.propertySignatures && indexes === this.indexSignatures && checks === this.checks && encodingChecks === this.encodingChecks ? this : new Objects(props, indexes, this.annotations, checks, undefined, this.context, encodingChecks);
   }
   /** @internal */
   flip(recur) {
-    return this._rebuild(recur, recur, true, this.encodingChecks, this.checks);
+    return this._rebuild(recur, recur, this.encodingChecks, this.checks);
   }
   /** @internal */
   recur(recur, recurParameter = recur) {
-    return this._rebuild(recur, recurParameter, false, this.checks, this.encodingChecks);
+    return this._rebuild(recur, recurParameter, this.checks, this.encodingChecks);
   }
   /** @internal */
   getExpected() {
@@ -1779,21 +1801,31 @@ export class Objects extends Base {
 }
 const parseProperties = /*#__PURE__*/iterateEager()({
   onItem(s, p) {
-    const value = Object.hasOwn(s.input, p.name) ? Option.some(s.input[p.name]) : Option.none();
+    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[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);else s.issues = [issue];
         return;
       } 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));
       }
     }
   }
@@ -1843,6 +1875,18 @@ export function tupleWithRest(ast, rest) {
   }
   return new Arrays(ast.isMutable, ast.elements, rest, undefined, ast.checks);
 }
+const toCandidate = /*#__PURE__*/memoizeIdempotent(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.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) {
   switch (ast._tag) {
     case "Null":
@@ -1866,7 +1910,7 @@ function getCandidateTypes(ast) {
     case "ObjectKeyword":
       return ["object", "array", "function"];
     case "Objects":
-      return ast.propertySignatures.length || ast.indexSignatures.length ? ["object"] : ["object", "array"];
+      return ast.propertySignatures.length || ast.indexSignatures.length ? ["object"] : ["string", "number", "boolean", "symbol", "bigint", "object", "array", "function"];
     case "Enum":
       return Array.from(new Set(ast.enums.map(([, v]) => typeof v)));
     case "Literal":
@@ -1884,7 +1928,7 @@ export function collectSentinels(ast) {
       return [];
     case "Declaration":
       {
-        const s = ast.annotations?.["~sentinels"];
+        const s = ast.annotations?.[InternalAnnotations.SENTINELS_ANNOTATION_KEY];
         return Array.isArray(s) ? s : [];
       }
     case "Objects":
@@ -1908,54 +1952,169 @@ export function collectSentinels(ast) {
       });
     case "Arrays":
       return ast.elements.flatMap((e, i) => {
-        return isLiteral(e) && !isOptional(e) ? [{
-          key: i,
-          literal: e.literal
-        }] : [];
+        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());
   }
 }
 const candidateIndexCache = /*#__PURE__*/new WeakMap();
+const emptyCandidates = /*#__PURE__*/Object.freeze([]);
 function getIndex(types) {
-  let idx = candidateIndexCache.get(types);
-  if (idx) return idx;
-  idx = {};
+  let index = candidateIndexCache.get(types);
+  if (index) return index;
+  let bySentinel;
+  let sentinelCandidateCount = 0;
+  let otherwise;
+  let literalCandidates;
+  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);
+    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;
+      }
+    }
     const sentinels = collectSentinels(encoded);
-    // by-type (always filled – cheap primary filter)
-    idx.byType ??= {};
-    for (const t of candidateTypes) (idx.byType[t] ??= []).push(i);
-    if (sentinels.length > 0) {
+    if (sentinels.length) {
       // discriminated variants
-      idx.bySentinel ??= new Map();
+      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;
+    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[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;
+    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 = 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;
+      // 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[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[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[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 = 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) {
   return ast => {
-    const encoded = toEncoded(ast);
+    const encoded = toCandidate(ast);
     return encoded._tag === "Literal" ? encoded.literal === input : encoded._tag === "UniqueSymbol" ? encoded.symbol === input : true;
   };
 }
@@ -1965,28 +2124,8 @@ function filterLiterals(input) {
  *
  * @internal
  */
-export function getCandidates(input, types) {
-  const idx = getIndex(types);
-  const runtimeType = 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[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, types, isConstructor = false) {
+  return getIndex(types)(input, isConstructor);
 }
 /**
  * AST node representing a union of schemas.
@@ -2003,15 +2142,14 @@ export function getCandidates(input, types) {
  *
  * **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"]
  * }
  * ```
  *
@@ -2031,22 +2169,25 @@ export class Union extends Base {
     this.encodingChecks = encodingChecks;
   }
   /** @internal */
-  getParser(recur) {
+  getParser(compile, compileConstructorDefault) {
     // 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._tag === "Success") return result;
+        return effectIsExit(result) ? failSingleUnionCandidate(ast, result.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,
         options
       };
@@ -2056,10 +2197,13 @@ export class Union extends Base {
         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));
       });
     };
   }
@@ -2113,10 +2257,15 @@ export class Union extends Base {
     return Array.from(new Set(types)).join(" | ");
   }
 }
+function failSingleUnionCandidate(ast, cause, input, options) {
+  const issue = InternalSchemaCause.getSchemaIssue(cause);
+  if (!issue) return Exit.failCause(cause);
+  return Exit.fail(new SchemaIssue.AnyOf(ast, [issue], input, options));
+}
 const parseUnion = /*#__PURE__*/iterateEager()({
   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") {
@@ -2126,20 +2275,20 @@ const parseUnion = /*#__PURE__*/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;
       }
     }
   }
 });
 const nonFiniteLiterals = /*#__PURE__*/new Union([/*#__PURE__*/new Literal("Infinity"), /*#__PURE__*/new Literal("-Infinity"), /*#__PURE__*/new Literal("NaN")], "anyOf");
-const numberToJson = /*#__PURE__*/new Link(/*#__PURE__*/new Union([number, nonFiniteLiterals], "anyOf"), /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.Number(), /*#__PURE__*/SchemaGetter.transform(n => globalThis.Number.isFinite(n) ? n : globalThis.String(n))));
 function formatIsMutable(isMutable) {
   return isMutable ? "" : "readonly ";
 }
@@ -2170,7 +2319,7 @@ export function memoizeThunk(f) {
  *
  * **Example** (Defining recursive schema ASTs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaAST } from "effect"
  *
  * interface Category {
@@ -2183,7 +2332,7 @@ export function memoizeThunk(f) {
  *   children: Schema.Array(Schema.suspend((): Schema.Codec<Category> => Category))
  * })
  *
- * // The recursive branch is a Suspend node
+ * SchemaAST.isObjects(Category.ast) // => true
  * ```
  *
  * @see {@link isSuspend}
@@ -2194,15 +2343,16 @@ export class Suspend extends Base {
   _tag = "Suspend";
   thunk;
   constructor(thunk, annotations, checks, encoding, 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) {
-    return recur(this.thunk());
+  getParser(compile) {
+    let parser;
+    return (input, options) => (parser ??= compile(this.thunk()))(input, options);
   }
   /** @internal */
   recur(recur) {
@@ -2223,8 +2373,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).
  *
@@ -2303,13 +2453,38 @@ export class FilterGroup extends Pipeable.Class {
 }
 /** @internal */
 export function makeFilter(filter, annotations, aborted = false) {
-  return new Filter((input, ast, options) => SchemaIssue.make(input, ast, filter(input, ast, options)), annotations, aborted);
+  return new Filter((input, ast, options) => SchemaIssue.normalizeFilterOutput(ast, filter(input, ast, options), input, options), annotations, aborted);
 }
 /** @internal */
 export function makeFilterByGuard(is, annotations) {
-  return new Filter(input => is(input) ? undefined : new SchemaIssue.InvalidValue(Option.some(input)), annotations, true // after a guard, we always want to abort
+  return new Filter((input, _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) {
+  return makeFilter(n => 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 = /*#__PURE__*/appendChecks(number, [/*#__PURE__*/isFinite()]);
 /**
  * Creates a {@link Filter} that validates strings by running `RegExp.test`.
  *
@@ -2321,21 +2496,25 @@ export function makeFilterByGuard(is, annotations) {
  * **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}
@@ -2344,12 +2523,22 @@ export function makeFilterByGuard(is, annotations) {
  */
 export function isPattern(regExp, annotations) {
   const source = regExp.source;
-  return makeFilter(s => regExp.test(s), {
+  const pattern = new globalThis.RegExp(source, regExp.flags);
+  return makeFilter(s => {
+    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]
@@ -2363,6 +2552,11 @@ function modifyOwnPropertyDescriptors(ast, f) {
   f(d);
   return Object.create(Object.getPrototypeOf(ast), d);
 }
+const contextOwners = /*#__PURE__*/new WeakMap();
+/** @internal */
+export function getContextOwner(ast) {
+  return contextOwners.get(ast) ?? ast;
+}
 /** @internal */
 export function replaceEncoding(ast, encoding) {
   if (ast.encoding === encoding) {
@@ -2377,9 +2571,15 @@ export function replaceContext(ast, context) {
   if (ast.context === context) {
     return ast;
   }
-  return modifyOwnPropertyDescriptors(ast, d => {
+  const owner = getContextOwner(ast);
+  if (owner.context === context) {
+    return owner;
+  }
+  const out = modifyOwnPropertyDescriptors(ast, d => {
     d.context.value = context;
   });
+  contextOwners.set(out, owner);
+  return out;
 }
 /** @internal */
 export function getLastEncoding(ast) {
@@ -2400,7 +2600,7 @@ export function annotate(ast, annotations) {
 }
 /** @internal */
 export function replaceChecks(ast, checks) {
-  if (ast._tag === "Suspend" && checks !== undefined) {
+  if (ast._tag === "Suspend" && checks) {
     throw new Error("Cannot add checks to Suspend");
   }
   if (ast.checks === checks) {
@@ -2414,20 +2614,26 @@ export function replaceChecks(ast, checks) {
 export function appendChecks(ast, checks) {
   return replaceChecks(ast, combineChecks(ast.checks, checks));
 }
+/** @internal */
+export function mapLink(link, f) {
+  const to = f(link.to);
+  return to === link.to ? link : new Link(to, link.transformation);
+}
 function updateLastLink(encoding, f) {
   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 */
 export function applyToLastLink(f) {
   return ast => ast.encoding ? replaceEncoding(ast, updateLastLink(ast.encoding, f)) : ast;
 }
 /** @internal */
+export function replaceContextLastLink(ast, context) {
+  return applyToLastLink(ast => replaceContext(ast, context))(ast);
+}
+/** @internal */
 export function applyToSelfOrLastLinkEncoding(f) {
   function out(ast) {
     return ast.encoding ? replaceEncoding(ast, updateLastLink(ast.encoding, out)) : f(ast);
@@ -2435,6 +2641,17 @@ export function applyToSelfOrLastLinkEncoding(f) {
   return memoize(out);
 }
 /** @internal */
+export function applyToSelfOrLastLinkEncodingIdempotent(f, options) {
+  function out(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, middleware) {
   return appendTransformation(ast, middleware, toType(ast));
 }
@@ -2469,43 +2686,31 @@ export function mapOrSame(as, f) {
 }
 /** @internal */
 export function annotateKey(ast, annotations) {
-  const context = ast.context ? new Context(ast.context.isOptional, ast.context.isMutable, ast.context.defaultValue, {
+  const context = ast.context ? new Context(ast.context.isOptional, ast.context.isMutable, ast.context.constructorDefault, {
     ...ast.context.annotations,
     ...annotations
   }) : new Context(false, false, undefined, annotations);
   return replaceContext(ast, context);
 }
 /** @internal */
-export const optionalKeyLastLink = /*#__PURE__*/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(ast) {
-  const context = ast.context ? ast.context.isOptional === false ? new Context(true, ast.context.isMutable, ast.context.defaultValue, ast.context.annotations) : ast.context : new Context(true, false);
+export const optionalKey = /*#__PURE__*/memoizeIdempotent(ast => {
+  const context = ast.context ? ast.context.isOptional === false ? 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 = /*#__PURE__*/applyToLastLink(mutableKey);
+});
+const optionalKeyLastLink = /*#__PURE__*/applyToLastLink(optionalKey);
+/** @internal */
+export const optional = /*#__PURE__*/memoize(ast => optionalKey(new Union([ast, undefined_], "anyOf")));
 /** @internal */
-export function mutableKey(ast) {
-  const context = ast.context ? ast.context.isMutable === false ? new Context(ast.context.isOptional, true, ast.context.defaultValue, ast.context.annotations) : ast.context : new Context(false, true);
+export const mutableKey = /*#__PURE__*/memoizeIdempotent(ast => {
+  const context = ast.context ? ast.context.isMutable === false ? 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 = /*#__PURE__*/applyToLastLink(mutableKey);
 /** @internal */
 export function withConstructorDefault(ast, defaultValue) {
   const transformation = new SchemaTransformation.Transformation(SchemaGetter.withDefault(defaultValue), SchemaGetter.passthrough());
-  const encoding = [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);
+  const constructorDefault = new Link(unknown, transformation);
+  const context = ast.context ? new Context(ast.context.isOptional, ast.context.isMutable, constructorDefault, ast.context.annotations) : new Context(false, false, constructorDefault);
   return replaceContext(ast, context);
 }
 /**
@@ -2560,12 +2765,12 @@ function parseParameter(ast) {
   };
 }
 /** @internal */
-export function record(key, value, keyValueCombiner) {
+export function record(key, value) {
   const {
     literals,
     parameters: indexSignatures
   } = parseParameter(key);
-  return new Objects(literals.map(literal => new PropertySignature(literal, value)), indexSignatures.map(parameter => new IndexSignature(parameter, value, keyValueCombiner)));
+  return new Objects(literals.map(literal => new PropertySignature(literal, value)), indexSignatures.map(parameter => new IndexSignature(parameter, value)));
 }
 // -------------------------------------------------------------------------------------
 // Public APIs
@@ -2590,6 +2795,17 @@ export function isOptional(ast) {
 export function isMutable(ast) {
   return ast.context?.isMutable ?? false;
 }
+function isStructuralCheck(check) {
+  return check.annotations?.[InternalAnnotations.STRUCTURAL_ANNOTATION_KEY] === true || check._tag === "FilterGroup" && check.checks.every(isStructuralCheck);
+}
+function extractStructuralChecks(checks) {
+  function extract(check) {
+    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.
@@ -2602,12 +2818,12 @@ export function isMutable(ast) {
  *
  * **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}
@@ -2615,7 +2831,7 @@ export function isMutable(ast) {
  * @category transforming
  * @since 4.0.0
  */
-export const toType = /*#__PURE__*/memoize(ast => {
+export const toType = /*#__PURE__*/memoizeIdempotent(ast => {
   if (ast.encoding) {
     return toType(replaceEncoding(ast, undefined));
   }
@@ -2623,11 +2839,10 @@ export const toType = /*#__PURE__*/memoize(ast => {
   const type = out.recur?.(toType) ?? out;
   const encodingChecks = 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;
@@ -2645,12 +2860,12 @@ export const toType = /*#__PURE__*/memoize(ast => {
  *
  * **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}
@@ -2658,7 +2873,7 @@ export const toType = /*#__PURE__*/memoize(ast => {
  * @category transforming
  * @since 4.0.0
  */
-export const toEncoded = /*#__PURE__*/memoize(ast => {
+export const toEncoded = /*#__PURE__*/memoizeIdempotent(ast => {
   return toType(flip(ast));
 });
 function flipEncoding(ast, encoding) {
@@ -2712,39 +2927,34 @@ export function containsUndefined(ast) {
   }
 }
 function fromConst(ast, value) {
-  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(value) {
-  const succeed = Effect.succeedSome(value);
-  return oinput => oinput._tag === "None" ? Effect.succeedNone : succeed;
-}
 function fromRefinement(ast, refinement) {
-  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(ast, value, options) {
-  if (options?.disableChecks || ast.checks === undefined) return value;
-  const issues = [];
-  collectIssues(ast.checks, value, issues, ast, options);
-  return issues.length === 0 ? value : undefined;
-}
-function segmentTemplateLiteralParts(parts, input, options) {
+function segmentTemplateLiteralParts(ast, input, options) {
+  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(parts.length);
-  const failures = new Set();
+  let failures;
   function go(i, pos) {
-    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);
@@ -2753,21 +2963,28 @@ function segmentTemplateLiteralParts(parts, input, options) {
         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;
@@ -2778,7 +2995,7 @@ export const enumsToLiterals = /*#__PURE__*/memoize(ast => {
     title: e[0]
   })), "anyOf");
 });
-const parameterFromPropertyKey = /*#__PURE__*/applyToSelfOrLastLinkEncoding(ast => {
+const parameterFromPropertyKey = /*#__PURE__*/applyToSelfOrLastLinkEncodingIdempotent(ast => {
   switch (ast._tag) {
     default:
       return ast;
@@ -2789,7 +3006,7 @@ const parameterFromPropertyKey = /*#__PURE__*/applyToSelfOrLastLinkEncoding(ast
   }
 });
 /** @internal */
-export const parameterFromString = /*#__PURE__*/applyToSelfOrLastLinkEncoding(ast => {
+export const parameterFromString = /*#__PURE__*/applyToSelfOrLastLinkEncodingIdempotent(ast => {
   switch (ast._tag) {
     default:
       return ast;
@@ -2800,7 +3017,7 @@ export const parameterFromString = /*#__PURE__*/applyToSelfOrLastLinkEncoding(as
       return ast.recur(parameterFromString);
   }
 });
-const partFromString = /*#__PURE__*/applyToSelfOrLastLinkEncoding(ast => {
+const partFromString = /*#__PURE__*/applyToSelfOrLastLinkEncodingIdempotent(ast => {
   switch (ast._tag) {
     default:
       return ast;
@@ -2818,15 +3035,18 @@ const partFromString = /*#__PURE__*/applyToSelfOrLastLinkEncoding(ast => {
  */
 export const STRING_PATTERN = "[\\s\\S]*?";
 const isStringFiniteRegExp = /*#__PURE__*/new globalThis.RegExp(`^${FINITE_PATTERN}$`);
-const isStringNumberRegExp = /*#__PURE__*/new globalThis.RegExp(`(?:${FINITE_PATTERN}|Infinity|-Infinity|NaN)`);
+const isStringNumberRegExp = /*#__PURE__*/new globalThis.RegExp(`^(?:${FINITE_PATTERN}|Infinity|-Infinity|NaN)$`);
 /** @internal */
 export function isStringFinite(annotations) {
   return isPattern(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
   });
 }
@@ -2842,10 +3062,13 @@ const isStringBigIntRegExp = /*#__PURE__*/new globalThis.RegExp(`^${BIGINT_PATTE
 export function isStringBigInt(annotations) {
   return isPattern(isStringBigIntRegExp, {
     expected: "a string representing a bigint",
-    meta: {
-      _tag: "isStringBigInt",
-      regExp: isStringBigIntRegExp
+    representation: {
+      id: "effect/schema/isStringBigInt",
+      payload: null
     },
+    toJsonSchema: () => ({
+      pattern: isStringBigIntRegExp.source
+    }),
     ...annotations
   });
 }
@@ -2861,23 +3084,26 @@ export const symbolString = /*#__PURE__*/appendChecks(string, [/*#__PURE__*/isSt
 /**
  * to distinguish between Symbol and String, we need to add a check to the string keyword
  */
-const symbolToString = /*#__PURE__*/new Link(symbolString, /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(description => globalThis.Symbol.for(isStringSymbolRegExp.exec(description)[1])), /*#__PURE__*/SchemaGetter.transformOrFail(sym => {
+const symbolToString = /*#__PURE__*/new Link(symbolString, /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(description => globalThis.Symbol.for(isStringSymbolRegExp.exec(description)[1])), /*#__PURE__*/SchemaGetter.transformOrFail((sym, 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), {
+  return Effect.fail(new SchemaIssue.Forbidden({
     message: "cannot serialize to string, Symbol is not registered"
-  }));
+  }, sym, options));
 })));
 /** @internal */
 export function isStringSymbol(annotations) {
   return isPattern(isStringSymbolRegExp, {
     expected: "a string representing a symbol",
-    meta: {
-      _tag: "isStringSymbol",
-      regExp: isStringSymbolRegExp
+    representation: {
+      id: "effect/schema/isStringSymbol",
+      payload: null
     },
+    toJsonSchema: () => ({
+      pattern: isStringSymbolRegExp.source
+    }),
     ...annotations
   });
 }
@@ -2886,34 +3112,40 @@ export function collectIssues(checks, value, issues, ast, options) {
   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].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 */
 export function runChecks(checks, s) {
-  const issues = [];
-  collectIssues(checks, s, issues, unknown, {
+  const issues = collectIssues(checks, s, undefined, unknown, {
     errors: "all"
   });
-  if (Arr.isArrayNonEmpty(issues)) {
-    const issue = new SchemaIssue.Composite(unknown, Option.some(s), issues);
+  if (issues) {
+    const issue = new SchemaIssue.Composite(unknown, issues);
     return Result.fail(issue);
   }
   return Result.succeed(s);
 }
 /** @internal */
-export const ClassTypeId = "~effect/Schema/Class";
-/** @internal */
-export const STRUCTURAL_ANNOTATION_KEY = "~structural";
+export function getConstructorDescriptor(ast) {
+  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.
  *
@@ -2925,12 +3157,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}
@@ -2990,6 +3222,66 @@ export const resolveTitle = InternalAnnotations.resolveTitle;
  * @since 4.0.0
  */
 export const resolveDescription = InternalAnnotations.resolveDescription;
+function isJsonLeaf(u) {
+  return u === null || typeof u === "string" || typeof u === "boolean" || typeof u === "number" && globalThis.Number.isFinite(u);
+}
+function isStringTreeLeaf(u) {
+  return u === undefined || typeof u === "string";
+}
+function isTree(u, isLeaf) {
+  const cache = new WeakMap();
+  const stack = [];
+  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[frame.index++];
+          continue outer;
+        }
+      } else if (frame.index < keys.length) {
+        u = frame.value[keys[frame.index++]];
+        continue outer;
+      }
+      cache.set(frame.value, true);
+      stack.pop();
+    }
+    return true;
+  }
+}
 /**
  * Returns true if the value is a JSON value.
  *
@@ -2998,76 +3290,30 @@ export const resolveDescription = InternalAnnotations.resolveDescription;
  * @internal
  */
 export function isJson(u) {
-  // `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();
-  // `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();
-  return recur(u);
-  function recur(u) {
-    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[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 = /*#__PURE__*/new Declaration([], () => (input, ast) => isJson(input) ? Effect.succeed(input) : Effect.fail(new SchemaIssue.InvalidType(ast, Option.some(input))), {
-  typeConstructor: {
-    _tag: "effect/Json"
-  },
-  generation: {
-    runtime: `Schema.Json`,
-    Type: `Schema.Json`
+export const Json = /*#__PURE__*/new Declaration([], () => (input, ast, options) => isJson(input) ? InternalParser.sameExit : Effect.fail(new SchemaIssue.InvalidType(ast, input, options)), {
+  representation: {
+    id: "effect/schema/Json",
+    payload: null
   },
   expected: "JSON value",
-  toCodecJson: () => new Link(unknown, SchemaTransformation.passthrough()),
+  toCodecJson: () => undefined,
+  toCodecStringTree: () => unknownToStringTree,
   toArbitrary: () => fc => fc.jsonValue()
 });
 /** @internal */
 export const MutableJson = /*#__PURE__*/annotate(Json, {
-  typeConstructor: {
-    _tag: "effect/MutableJson"
-  },
-  generation: {
-    runtime: `Schema.MutableJson`,
-    Type: `Schema.MutableJson`
+  representation: {
+    id: "effect/schema/MutableJson",
+    payload: null
   }
 });
 /** @internal */
-export const unknownToNull = /*#__PURE__*/new Link(null_, /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.passthrough(), /*#__PURE__*/SchemaGetter.transform(() => null)));
-/** @internal */
 export const unknownToJson = /*#__PURE__*/new Link(Json, /*#__PURE__*/SchemaTransformation.passthrough());
+/** @internal */
+export const objectKeywordToJson = /*#__PURE__*/new Link(/*#__PURE__*/new Union([/*#__PURE__*/new Arrays(false, [], [Json]), /*#__PURE__*/new Objects([], [/*#__PURE__*/new IndexSignature(string, Json)])], "anyOf"), /*#__PURE__*/SchemaTransformation.passthrough());
 /**
  * Returns true if the value is a StringTree value.
  *
@@ -3076,27 +3322,11 @@ export const unknownToJson = /*#__PURE__*/new Link(Json, /*#__PURE__*/SchemaTran
  * @internal
  */
 export function isStringTree(u) {
-  const seen = new Set();
-  return recur(u);
-  function recur(u) {
-    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[key]));
-  }
+  return isTree(u, isStringTreeLeaf);
 }
-const StringTree = /*#__PURE__*/new Declaration([], () => (input, ast) => isStringTree(input) ? Effect.succeed(input) : Effect.fail(new SchemaIssue.InvalidType(ast, Option.some(input))), {
-  expected: "StringTree"
+const StringTree = /*#__PURE__*/new Declaration([], () => (input, ast, options) => isStringTree(input) ? InternalParser.sameExit : Effect.fail(new SchemaIssue.InvalidType(ast, input, options)), {
+  expected: "StringTree",
+  toCodecStringTree: () => undefined
 });
 /** @internal */
 export const unknownToStringTree = /*#__PURE__*/new Link(StringTree, /*#__PURE__*/SchemaTransformation.passthrough());