effect 4.0.0-beta.102 → 4.0.0-beta.104

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";
@@ -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])
+      });
+    };
   }
   /** @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,7 +1049,10 @@ 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() {
@@ -1052,7 +1077,7 @@ 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 === undefined ? finite : appendChecks(finite, 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))));
 }
 /**
@@ -1131,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() {
@@ -1182,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() {
@@ -1234,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]
  * }
  * ```
  *
@@ -1263,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));
+      }
+      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
@@ -1327,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) {
@@ -1361,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;
@@ -1376,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 ? {
@@ -1396,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]));
   }
 };
 /**
@@ -1455,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":
@@ -1510,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**
  *
@@ -1525,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.");
     }
@@ -1562,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"]]
  * }
  * ```
  *
@@ -1600,77 +1605,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.assignProperty(s.out, k, v);
-          } else {
-            InternalRecord.assignProperty(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: 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
@@ -1682,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);
@@ -1698,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.assignProperty(out, key, input[key]);
+              InternalRecord.assignProperty(out, key, record[key]);
             }
           }
         }
@@ -1711,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.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);
@@ -1754,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() {
@@ -1775,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.assignProperty(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]));
       }
     }
   }
@@ -1839,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":
@@ -1904,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 {
@@ -1938,20 +2004,40 @@ 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, 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;
+      };
+    }
+  }
   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;
   };
 }
@@ -1961,28 +2047,34 @@ function filterLiterals(input) {
  *
  * @internal
  */
-export function getCandidates(input, types) {
+export function getCandidates(input, types, isConstructor = false) {
   const idx = getIndex(types);
+  if (typeof idx === "function") return idx(input, isConstructor);
   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)) {
-          const match = m.get(input[k]);
+        const value = Object.hasOwn(input, k) ? input[k] : undefined;
+        if (value !== undefined) {
+          const match = m.get(value);
           if (match) {
             for (const candidate of match) selected.add(candidate);
           }
+        } else if (isConstructor) {
+          for (const indexes of m.values()) {
+            for (const candidate of indexes) selected.add(candidate);
+          }
         }
       }
-      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.
@@ -1999,15 +2091,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"]
  * }
  * ```
  *
@@ -2027,22 +2118,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) : Effect.catchCause(result, cause => failSingleUnionCandidate(ast, cause));
       }
-      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
       };
@@ -2052,10 +2146,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 ?? []));
       });
     };
   }
@@ -2109,10 +2203,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);
+    const parser = s.compile(ast);
+    return parser(s.input, s.options);
   },
   step(s, candidate, exit) {
     if (exit._tag === "Failure") {
@@ -2122,13 +2220,14 @@ 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;
       }
     }
@@ -2165,7 +2264,7 @@ export function memoizeThunk(f) {
  *
  * **Example** (Defining recursive schema ASTs)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Schema, SchemaAST } from "effect"
  *
  * interface Category {
@@ -2178,7 +2277,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}
@@ -2189,15 +2288,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) {
@@ -2298,11 +2398,11 @@ 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 */
@@ -2341,21 +2441,25 @@ export const finite = /*#__PURE__*/appendChecks(number, [/*#__PURE__*/isFinite()
  * **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}
@@ -2364,7 +2468,11 @@ export const finite = /*#__PURE__*/appendChecks(number, [/*#__PURE__*/isFinite()
  */
 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}`,
     representation: {
       id: "effect/schema/isPattern",
@@ -2426,7 +2534,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) {
@@ -2501,7 +2609,7 @@ 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);
@@ -2523,20 +2631,20 @@ const optionalKeyLastLink = /*#__PURE__*/applyToLastLink(optionalKey);
  * @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);
+  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);
 /** @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);
+  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));
 }
 /** @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);
 }
 /**
@@ -2591,12 +2699,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
@@ -2644,12 +2752,12 @@ function extractStructuralChecks(checks) {
  *
  * **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}
@@ -2686,12 +2794,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}
@@ -2753,46 +2861,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) {
-  const literals = parts.map(part => part._tag === "Literal" ? globalThis.String(part.literal) : undefined);
-  if (literals.some(literal => literal !== undefined && !input.includes(literal))) return undefined;
-  const minimumLengths = new Array(parts.length + 1);
-  minimumLengths[parts.length] = 0;
-  for (let i = parts.length - 1; i >= 0; i--) {
-    minimumLengths[i] = minimumLengths[i + 1] + (literals[i]?.length ?? 0);
-  }
-  if (minimumLengths[0] > input.length) return undefined;
+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 = parts.map(() => new Set());
+  let failures;
   function go(i, pos) {
-    if (i === parts.length) return pos === input.length;
-    if (failures[i].has(pos)) 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);
@@ -2807,7 +2901,7 @@ function segmentTemplateLiteralParts(parts, input, options) {
         return true;
       }
     } else {
-      const maximumEnd = input.length - minimumLengths[i + 1];
+      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);
@@ -2821,7 +2915,8 @@ function segmentTemplateLiteralParts(parts, input, options) {
         end = anchor === undefined ? end - 1 : input.lastIndexOf(anchor, end - 1);
       }
     }
-    failures[i].add(pos);
+    failures ??= new Set();
+    failures.add(i * (inputLength + 1) + pos);
     return false;
   }
   return go(0, 0) ? out : undefined;
@@ -2926,7 +3021,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"
   }));
 })));
@@ -2949,32 +3044,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);
+        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";
+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.
  *
@@ -2986,12 +3089,12 @@ export const ClassTypeId = "~effect/Schema/Class";
  *
  * **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}
@@ -3122,7 +3225,7 @@ export function isJson(u) {
   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))), {
+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
@@ -3142,7 +3245,7 @@ export const MutableJson = /*#__PURE__*/annotate(Json, {
 /** @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, undefined)])], "anyOf"), /*#__PURE__*/SchemaTransformation.passthrough());
+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.
  *
@@ -3153,7 +3256,7 @@ export const objectKeywordToJson = /*#__PURE__*/new Link(/*#__PURE__*/new Union(
 export function isStringTree(u) {
   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))), {
+const StringTree = /*#__PURE__*/new Declaration([], () => (input, ast) => isStringTree(input) ? InternalParser.sameExit : Effect.fail(new SchemaIssue.InvalidType(ast)), {
   expected: "StringTree",
   toCodecStringTree: () => undefined
 });