effect 4.0.0-beta.101 → 4.0.0-beta.103

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 } from "./Function.js";
 import { effectIsExit, iterateEager } from "./internal/effect.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";
@@ -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])
-    });
+    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])
+      });
+    };
   }
   /** @internal */
   getExpected() {
@@ -850,16 +871,16 @@ 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({
+        message: "Expected a string matching template literal parts"
       }));
     }), 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) {
     // 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));
+      }
+      if (!elements) {
+        elements = ast.elements.map(ast => ({
+          ast,
+          parser: recur(ast)
+        }));
+        rest = ast.rest.map(ast => ({
+          ast,
+          parser: recur(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,18 @@ 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 issue = new SchemaIssue.Pointer([i], new SchemaIssue.UnexpectedKey(ast));
           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]));
           }
         }
       }
       if (state.issues) {
-        return yield* Effect.fail(new SchemaIssue.Composite(ast, oinput, state.issues));
+        return yield* Effect.fail(new SchemaIssue.Composite(ast, state.issues));
       }
-      return Option.some(state.output);
+      return state.output;
     });
   }
   _rebuild(recur, checks, encodingChecks) {
@@ -1365,14 +1399,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 +1416,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]));
       }
     }
   }
 });
-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 +1433,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)])));
   }
   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]));
   }
 };
 /**
@@ -1459,32 +1492,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 +1521,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 +1535,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 +1570,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"]]
  * }
  * ```
  *
@@ -1608,73 +1609,81 @@ export class Objects extends Base {
     // 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));
       }
+      if (!properties) {
+        properties = ast.propertySignatures.map(ps => ({
+          parser: recur(ps.type),
+          name: ps.name,
+          type: ps.type
+        }));
+        indexes = indexCount ? ast.indexSignatures.map(is => ({
+          is,
+          parserKey: recur(parameterFromPropertyKey(is.parameter)),
+          parserValue: recur(is.type)
+        })) : undefined;
+      }
+      const record = input;
       const out = {};
       const state = {
         ast,
-        oinput,
-        input,
+        input: record,
         out,
         issues: undefined,
         options
@@ -1686,14 +1695,15 @@ 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 issue = new SchemaIssue.Pointer([key], new SchemaIssue.UnexpectedKey(ast));
               if (errorsAllOption) {
                 if (state.issues) {
                   state.issues.push(issue);
@@ -1702,11 +1712,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]));
               }
             } else {
               // preserve key
-              InternalRecord.set(out, key, input[key]);
+              InternalRecord.assignProperty(out, key, record[key]);
             }
           }
         }
@@ -1715,42 +1725,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));
       }
       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 +1779,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 +1799,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]));
       }
     }
   }
@@ -1843,6 +1873,18 @@ export function tupleWithRest(ast, rest) {
   }
   return new Arrays(ast.isMutable, ast.elements, rest, undefined, ast.checks);
 }
+const toCandidate = /*#__PURE__*/memoize(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 +1908,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 +1926,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,30 +1950,50 @@ 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 "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 literalCandidates;
   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 (literalCandidates !== null) {
+      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 {
+        literalCandidates = null;
+      }
+    }
     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();
       for (const {
@@ -1942,20 +2004,33 @@ function getIndex(types) {
         if (!m) idx.bySentinel.set(key, m = new Map());
         let arr = m.get(literal);
         if (!arr) m.set(literal, arr = []);
-        arr.push(i);
+        if (arr[arr.length - 1] !== i) arr.push(i);
       }
     } else {
       // non-discriminated
       idx.otherwise ??= {};
+      const candidateTypes = getCandidateTypes(encoded);
       for (const t of candidateTypes) (idx.otherwise[t] ??= []).push(i);
     }
   }
+  if (literalCandidates) {
+    literalCandidates.forEach(Object.freeze);
+    idx = input => literalCandidates.get(input) ?? emptyCandidates;
+  } else if (idx.bySentinel?.size === 1 && !idx.otherwise) {
+    for (const [key, byValue] of idx.bySentinel) {
+      const candidates = byValue;
+      for (const [literal, indexes] of byValue) {
+        candidates.set(literal, Object.freeze(indexes.map(index => types[index])));
+      }
+      idx = input => Predicate.isObjectKeyword(input) && Object.hasOwn(input, key) ? candidates.get(input[key]) ?? emptyCandidates : emptyCandidates;
+    }
+  }
   candidateIndexCache.set(types, idx);
   return idx;
 }
 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;
   };
 }
@@ -1967,11 +2042,12 @@ function filterLiterals(input) {
  */
 export function getCandidates(input, types) {
   const idx = getIndex(types);
+  if (typeof idx === "function") return idx(input);
   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 base = idx.otherwise?.[runtimeType] ?? emptyCandidates;
+    if (Predicate.isObjectKeyword(input)) {
       const selected = new Set(base);
       for (const [k, m] of idx.bySentinel) {
         if (Object.hasOwn(input, k)) {
@@ -1981,12 +2057,12 @@ export function getCandidates(input, types) {
           }
         }
       }
-      return Array.from(selected).sort((a, b) => a - b).map(i => types[i]).filter(filterLiterals(input));
+      return Array.from(selected).sort((a, b) => a - b).map(i => types[i]);
     }
     return base.map(i => types[i]);
   }
   // 2. Fallback: runtime-type dispatch only
-  return (idx.byType?.[runtimeType] ?? []).map(i => types[i]).filter(filterLiterals(input));
+  return (idx.otherwise?.[runtimeType] ?? emptyCandidates).map(i => types[i]).filter(filterLiterals(input));
 }
 /**
  * AST node representing a union of schemas.
@@ -2003,15 +2079,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"]
  * }
  * ```
  *
@@ -2034,19 +2109,22 @@ export class Union extends Base {
   getParser(recur) {
     // 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 input = oinput.value;
       const candidates = getCandidates(input, ast.types);
+      if (candidates.length === 1) {
+        const result = recur(candidates[0])(input, options);
+        if (result._tag === "Success") return result;
+        return effectIsExit(result) ? failSingleUnionCandidate(ast, result.cause) : Effect.catchCause(result, cause => failSingleUnionCandidate(ast, cause));
+      }
       const state = {
         ast,
         recur,
-        oinput,
         input,
         out: undefined,
-        successes: [],
+        successes: ast.mode === "oneOf" ? [] : undefined,
         issues: undefined,
         options
       };
@@ -2056,10 +2134,10 @@ 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 ?? []));
+        return state.out ?? Effect.fail(new SchemaIssue.AnyOf(ast, state.issues ?? []));
       }
-      return Effect.flatMap(eff, _ => {
-        return state.out ? Effect.succeed(state.out) : Effect.fail(new SchemaIssue.AnyOf(ast, input, state.issues ?? []));
+      return Effect.flatMapEager(eff, _ => {
+        return state.out === InternalParser.sameExit ? Effect.succeed(input) : state.out ?? Effect.fail(new SchemaIssue.AnyOf(ast, state.issues ?? []));
       });
     };
   }
@@ -2113,10 +2191,14 @@ export class Union extends Base {
     return Array.from(new Set(types)).join(" | ");
   }
 }
+function failSingleUnionCandidate(ast, cause) {
+  const issue = InternalSchemaCause.getSchemaIssue(cause);
+  return issue ? Exit.fail(new SchemaIssue.AnyOf(ast, [issue])) : Exit.failCause(cause);
+}
 const parseUnion = /*#__PURE__*/iterateEager()({
   onItem(s, ast) {
     const parser = s.recur(ast);
-    return parser(s.oinput, s.options);
+    return parser(s.input, s.options);
   },
   step(s, candidate, exit) {
     if (exit._tag === "Failure") {
@@ -2126,20 +2208,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.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 +2252,7 @@ export function memoizeThunk(f) {
  *
  * **Example** (Defining recursive schema ASTs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaAST } from "effect"
  *
  * interface Category {
@@ -2183,7 +2265,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,7 +2276,7 @@ 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);
@@ -2202,7 +2284,8 @@ export class Suspend extends Base {
   }
   /** @internal */
   getParser(recur) {
-    return recur(this.thunk());
+    let parser;
+    return (input, options) => (parser ??= recur(this.thunk()))(input, options);
   }
   /** @internal */
   recur(recur) {
@@ -2223,8 +2306,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 +2386,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)), 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 => is(input) ? undefined : new SchemaIssue.InvalidValue(), 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 +2429,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 +2456,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]
@@ -2400,7 +2522,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 +2536,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);
@@ -2475,8 +2603,7 @@ export function annotateKey(ast, annotations) {
   }) : new Context(false, false, undefined, annotations);
   return replaceContext(ast, context);
 }
-/** @internal */
-export const optionalKeyLastLink = /*#__PURE__*/applyToLastLink(optionalKey);
+const optionalKeyLastLink = /*#__PURE__*/applyToLastLink(optionalKey);
 /**
  * Marks an AST node's property key as optional by setting
  * {@link Context.isOptional} to `true`.
@@ -2560,12 +2687,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 +2717,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 +2740,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}
@@ -2623,11 +2761,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 +2782,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}
@@ -2712,39 +2849,32 @@ 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 => {
+    if (input === InternalParser.missing) return InternalParser.missingExit;
+    return input === value ? succeed : Effect.fail(new SchemaIssue.InvalidType(ast));
   };
 }
-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 => {
+    if (input === InternalParser.missing) return InternalParser.missingExit;
+    return refinement(input) ? InternalParser.sameExit : Effect.fail(new SchemaIssue.InvalidType(ast));
   };
 }
-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 +2883,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;
@@ -2818,15 +2955,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 +2982,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
   });
 }
@@ -2866,7 +3009,7 @@ const symbolToString = /*#__PURE__*/new Link(symbolString, /*#__PURE__*/new Sche
   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"
   }));
 })));
@@ -2874,10 +3017,13 @@ const symbolToString = /*#__PURE__*/new Link(symbolString, /*#__PURE__*/new Sche
 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 +3032,36 @@ 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);
+        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";
 /**
  * Returns all annotations from the AST node.
  *
@@ -2925,12 +3073,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 +3138,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 +3206,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) => isJson(input) ? InternalParser.sameExit : Effect.fail(new SchemaIssue.InvalidType(ast)), {
+  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 +3238,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) => isStringTree(input) ? InternalParser.sameExit : Effect.fail(new SchemaIssue.InvalidType(ast)), {
+  expected: "StringTree",
+  toCodecStringTree: () => undefined
 });
 /** @internal */
 export const unknownToStringTree = /*#__PURE__*/new Link(StringTree, /*#__PURE__*/SchemaTransformation.passthrough());