effect 4.0.0-rc.111 → 4.0.0-rc.113

package/dist/SchemaAST.js

@@ -16,7 +16,7 @@ import * as Effect from "./Effect.js";
 import * as Exit from "./Exit.js";
 import { format, formatPropertyKey } from "./Formatter.js";
 import { identity, memoize, memoizeIdempotent } from "./Function.js";
-import { effectIsExit, iterateEager } from "./internal/effect.js";
+import { effectIsExit, iterateConcurrent, iterateEager, resolveConcurrency } 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";
@@ -311,56 +311,28 @@ export const isUnion = /*#__PURE__*/makeGuard("Union");
  */
 export const isSuspend = /*#__PURE__*/makeGuard("Suspend");
 /**
- * Represents a single step in an {@link Encoding} chain.
+ * Constructs a {@link Link}.
  *
- * **Details**
- *
- * A link pairs a target {@link AST} with a `Transformation` or `Middleware`
- * that converts values between the current node and the target.
- *
- * - `to` — the AST node on the other side of this transformation step.
- * - `transformation` — the bidirectional conversion logic (decode/encode).
- *
- * Links are composed into a non-empty array ({@link Encoding}) attached to
- * AST nodes that have a different encoded representation.
- *
- * @see {@link Encoding}
- * @see {@link decodeTo}
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class Link {
+export const Link = class {
   to;
   transformation;
   constructor(to, transformation) {
     this.to = to;
     this.transformation = transformation;
   }
-}
+};
 /** @internal */
 export const defaultParseOptions = {};
 /**
- * Represents per-property metadata attached to AST nodes via {@link Base.context}.
- *
- * **Details**
+ * Constructs a {@link Context}.
  *
- * Tracks whether a property key is optional, mutable, has a constructor
- * default, or carries key-level annotations. Typically set by helpers like
- * {@link optionalKey} and `Schema.mutableKey`.
- *
- * - `isOptional` — the property key may be absent from the input.
- * - `isMutable` — the property is `readonly` when `false`.
- * - `constructorDefault` — a {@link Link} applied during construction to
- *   supply missing values.
- * - `annotations` — key-level annotations (e.g. description of the key
- *   itself).
- *
- * @see {@link optionalKey}
- * @see {@link isOptional}
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class Context {
+export const Context = class {
   isOptional;
   isMutable;
   /** Used for constructor default values (e.g. `withConstructorDefault` API) */
@@ -373,29 +345,9 @@ export class Context {
     this.constructorDefault = constructorDefault;
     this.annotations = annotations;
   }
-}
+};
 const TypeId = "~effect/Schema";
-/**
- * Represents the abstract base class for all {@link AST} node variants.
- *
- * **Details**
- *
- * Every AST node extends `Base` and inherits these fields:
- *
- * - `annotations` — user-supplied metadata (identifier, title, description,
- *   arbitrary keys).
- * - `checks` — optional {@link Checks} for post-type-match validation.
- * - `encoding` — optional {@link Encoding} chain for type ↔ wire
- *   transformations.
- * - `context` — optional {@link Context} for per-property metadata.
- *
- * Subclasses add a `_tag` discriminant and variant-specific data.
- *
- * @see {@link AST}
- * @category models
- * @since 4.0.0
- */
-export class Base {
+class ASTNodeImpl {
   [TypeId] = TypeId;
   annotations;
   checks;
@@ -412,34 +364,27 @@ export class Base {
   }
 }
 /**
- * AST node for user-defined opaque types with custom parsing logic.
- *
- * **When to use**
+ * Constructs a {@link Declaration}.
  *
- * Use when you need a custom schema AST node because none of the built-in
- * nodes fit.
- *
- * **Details**
- *
- * - `typeParameters` — inner schemas this declaration is parameterized over
- *   (e.g. the element type for a custom collection).
- * - `run` — factory that receives `typeParameters` and returns a parser that
- *   validates or transforms raw input.
- *
- * @see {@link isDeclaration}
- * @category models
- * @since 3.10.0
+ * @category constructors
+ * @since 4.0.0
  */
-export class Declaration extends Base {
+export const Declaration = class extends ASTNodeImpl {
   _tag = "Declaration";
   typeParameters;
   run;
   encodingChecks;
-  constructor(typeParameters, run, annotations, checks, encoding, context, encodingChecks) {
+  /**
+   * Parser factory {@link flip} swaps in, so a declaration can behave
+   * differently when encoding. `undefined` reuses `run`.
+   */
+  encodingRun;
+  constructor(typeParameters, run, annotations, checks, encoding, context, encodingChecks, encodingRun) {
     super(annotations, checks, encoding, context);
     this.typeParameters = typeParameters;
     this.run = run;
     this.encodingChecks = encodingChecks;
+    this.encodingRun = encodingRun;
   }
   /** @internal */
   getParser() {
@@ -449,17 +394,17 @@ export class Declaration extends Base {
       return (run ??= this.run(this.typeParameters))(input, this, options);
     };
   }
-  _rebuild(recur, checks, encodingChecks) {
+  _rebuild(recur, checks, encodingChecks, run, encodingRun) {
     const tps = mapOrSame(this.typeParameters, recur);
-    return tps === this.typeParameters && checks === this.checks && encodingChecks === this.encodingChecks ? this : new Declaration(tps, this.run, this.annotations, checks, undefined, this.context, encodingChecks);
+    return tps === this.typeParameters && checks === this.checks && encodingChecks === this.encodingChecks && run === this.run && encodingRun === this.encodingRun ? this : new Declaration(tps, run, this.annotations, checks, undefined, this.context, encodingChecks, encodingRun);
   }
   /** @internal */
   recur(recur) {
-    return this._rebuild(recur, this.checks, this.encodingChecks);
+    return this._rebuild(recur, this.checks, this.encodingChecks, this.run, this.encodingRun);
   }
   /** @internal */
   flip(recur) {
-    return this._rebuild(recur, this.encodingChecks, this.checks);
+    return this._rebuild(recur, this.encodingChecks, this.checks, this.encodingRun ?? this.run, this.run);
   }
   /** @internal */
   getExpected() {
@@ -467,20 +412,14 @@ export class Declaration extends Base {
     if (typeof expected === "string") return expected;
     return "<Declaration>";
   }
-}
+};
 /**
- * AST node matching the `null` literal value.
- *
- * **Details**
+ * Constructs a {@link Null}.
  *
- * Parsing succeeds only when the input is exactly `null`.
- *
- * @see {@link null_ null}
- * @see {@link isNull}
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class Null extends Base {
+export const Null = class extends ASTNodeImpl {
   _tag = "Null";
   /** @internal */
   getParser() {
@@ -490,7 +429,7 @@ export class Null extends Base {
   getExpected() {
     return "null";
   }
-}
+};
 const null_ = /*#__PURE__*/new Null();
 export {
 /**
@@ -506,18 +445,12 @@ export {
  */
 null_ as null };
 /**
- * AST node matching the `undefined` value.
- *
- * **Details**
+ * Constructs a {@link Undefined}.
  *
- * Parsing succeeds only when the input is exactly `undefined`.
- *
- * @see {@link undefined}
- * @see {@link isUndefined}
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class Undefined extends Base {
+export const Undefined = class extends ASTNodeImpl {
   _tag = "Undefined";
   /** @internal */
   getParser() {
@@ -531,7 +464,7 @@ export class Undefined extends Base {
   getExpected() {
     return "undefined";
   }
-}
+};
 const undefinedToNull = /*#__PURE__*/new Link(null_, /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(() => undefined), /*#__PURE__*/SchemaGetter.transform(() => null)));
 const undefined_ = /*#__PURE__*/new Undefined();
 export {
@@ -548,26 +481,12 @@ export {
  */
 undefined_ as undefined };
 /**
- * AST node matching TypeScript `void` return-value semantics.
- *
- * **When to use**
- *
- * Use when you need an AST node for a value whose result is intentionally
- * ignored.
- *
- * **Details**
- *
- * Parsers built from this node accept any present runtime input and map it to
- * `undefined`. Public schemas built from it may still expose `void` as their
- * typed decoded and encoded representation.
+ * Constructs a {@link Void}.
  *
- * @see {@link undefined} for the AST singleton that matches only exact `undefined`
- * @see {@link void_ void}
- * @see {@link isVoid}
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class Void extends Base {
+export const Void = class extends ASTNodeImpl {
   _tag = "Void";
   /** @internal */
   getParser() {
@@ -582,7 +501,7 @@ export class Void extends Base {
   getExpected() {
     return "void";
   }
-}
+};
 const void_ = /*#__PURE__*/new Void();
 export {
 /**
@@ -607,19 +526,12 @@ export {
  */
 void_ as void };
 /**
- * AST node representing the `never` type — no value matches.
- *
- * **Details**
- *
- * Parsing always fails. Useful as a placeholder in unions or as the result
- * of narrowing that eliminates all options.
+ * Constructs a {@link Never}.
  *
- * @see {@link never}
- * @see {@link isNever}
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class Never extends Base {
+export const Never = class extends ASTNodeImpl {
   _tag = "Never";
   /** @internal */
   getParser() {
@@ -629,7 +541,7 @@ export class Never extends Base {
   getExpected() {
     return "never";
   }
-}
+};
 /**
  * Provides the singleton {@link Never} AST instance.
  *
@@ -646,15 +558,12 @@ export class Never extends Base {
  */
 export const never = /*#__PURE__*/new Never();
 /**
- * AST node representing the `any` type — every value matches.
+ * Constructs a {@link Any}.
  *
- * @see {@link any}
- * @see {@link isAny}
- *
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class Any extends Base {
+export const Any = class extends ASTNodeImpl {
   _tag = "Any";
   /** @internal */
   getParser() {
@@ -664,7 +573,7 @@ export class Any extends Base {
   getExpected() {
     return "any";
   }
-}
+};
 /**
  * Provides the singleton {@link Any} AST instance.
  *
@@ -680,19 +589,12 @@ export class Any extends Base {
  */
 export const any = /*#__PURE__*/new Any();
 /**
- * AST node representing the `unknown` type — every value matches.
- *
- * **Details**
+ * Constructs a {@link Unknown}.
  *
- * Unlike {@link Any}, this is type-safe: the parsed result is typed as
- * `unknown` rather than `any`.
- *
- * @see {@link unknown}
- * @see {@link isUnknown}
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class Unknown extends Base {
+export const Unknown = class extends ASTNodeImpl {
   _tag = "Unknown";
   /** @internal */
   getParser() {
@@ -702,7 +604,7 @@ export class Unknown extends Base {
   getExpected() {
     return "unknown";
   }
-}
+};
 /**
  * Provides the singleton {@link Unknown} AST instance.
  *
@@ -718,16 +620,12 @@ export class Unknown extends Base {
  */
 export const unknown = /*#__PURE__*/new Unknown();
 /**
- * AST node matching the TypeScript `object` type — accepts objects, arrays,
- * and functions (anything non-primitive and non-null).
- *
- * @see {@link objectKeyword}
- * @see {@link isObjectKeyword}
+ * Constructs a {@link ObjectKeyword}.
  *
- * @category models
- * @since 3.10.0
+ * @category constructors
+ * @since 4.0.0
  */
-export class ObjectKeyword extends Base {
+export const ObjectKeyword = class extends ASTNodeImpl {
   _tag = "ObjectKeyword";
   /** @internal */
   getParser() {
@@ -737,7 +635,7 @@ export class ObjectKeyword extends Base {
   getExpected() {
     return "object | array | function";
   }
-}
+};
 /**
  * Provides the singleton {@link ObjectKeyword} AST instance.
  *
@@ -754,22 +652,21 @@ export class ObjectKeyword extends Base {
  */
 export const objectKeyword = /*#__PURE__*/new ObjectKeyword();
 /**
- * AST node representing a TypeScript `enum`.
- *
- * **Details**
+ * Constructs a {@link Enum}. Numeric values must be finite.
  *
- * Holds `enums` as an array of `[name, value]` pairs where values are
- * `string | number`. Parsing succeeds when the input matches any enum value.
- *
- * @see {@link isEnum}
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class Enum extends Base {
+export const Enum = class extends ASTNodeImpl {
   _tag = "Enum";
   enums;
   constructor(enums, annotations, checks, encoding, context) {
     super(annotations, checks, encoding, context);
+    for (const [, value] of enums) {
+      if (typeof value === "number" && !globalThis.Number.isFinite(value)) {
+        throw new Error(`A numeric enum value must be finite, got ${format(value)}`);
+      }
+    }
     this.enums = enums;
   }
   /** @internal */
@@ -781,7 +678,7 @@ export class Enum extends Base {
   toCodecStringTree() {
     if (this.enums.some(([_, v]) => typeof v === "number")) {
       const coercions = Object.fromEntries(this.enums.map(([_, v]) => [globalThis.String(v), v]));
-      return replaceEncoding(this, [new Link(new Union(Object.keys(coercions).map(k => new Literal(k)), "anyOf"), new SchemaTransformation.Transformation(SchemaGetter.transform(s => coercions[s]), SchemaGetter.String()))]);
+      return replaceEncoding(this, [new Link(new Union(Object.keys(coercions).map(k => new Literal(k))), new SchemaTransformation.Transformation(SchemaGetter.transform(s => coercions[s]), SchemaGetter.String()))]);
     }
     return this;
   }
@@ -789,36 +686,46 @@ export class Enum extends Base {
   getExpected() {
     return this.enums.map(([_, value]) => JSON.stringify(value)).join(" | ");
   }
-}
-function isTemplateLiteralPart(ast) {
+};
+function isTemplateLiteralPart(ast, path, validated) {
+  if (validated.has(ast)) return true;
+  if (ast.encoding) {
+    throw new Error(`TemplateLiteral parts cannot have an encoding at ${path}`);
+  }
+  let valid;
   switch (ast._tag) {
     case "String":
     case "Number":
     case "BigInt":
-      return true;
+      valid = true;
+      break;
     case "Literal":
+      valid = !ast.checks;
+      break;
     case "TemplateLiteral":
-      return !ast.checks;
+      valid = !ast.checks && ast.parts.every((part, index) => isTemplateLiteralPart(part, `${path}.parts[${index}]`, validated));
+      break;
     case "Union":
-      return !ast.checks && ast.types.every(isTemplateLiteralPart);
+      valid = !ast.checks && ast.types.every((part, index) => isTemplateLiteralPart(part, `${path}.types[${index}]`, validated));
+      break;
     default:
       return false;
   }
+  if (valid) validated.add(ast);
+  return valid;
 }
 /**
- * AST node representing a TypeScript template literal type
- * (e.g. `` `user_${string}` ``).
+ * Constructs a {@link TemplateLiteral}.
  *
- * **Details**
+ * **Gotchas**
  *
- * `parts` is an array of AST nodes; each part contributes to matching
- * strings at runtime.
+ * Throws if a part contains an encoding, including inside unions or nested
+ * template literals. Parts must describe their values without transformations.
  *
- * @see {@link isTemplateLiteral}
- * @category models
- * @since 3.10.0
+ * @category constructors
+ * @since 4.0.0
  */
-export class TemplateLiteral extends Base {
+export const TemplateLiteral = class extends ASTNodeImpl {
   _tag = "TemplateLiteral";
   parts;
   /** @internal */
@@ -831,14 +738,14 @@ export class TemplateLiteral extends Base {
     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 validated = new WeakSet();
+    for (let index = 0; index < parts.length; index++) {
+      const part = parts[index];
+      if (!isTemplateLiteralPart(part, `parts[${index}]`, validated)) {
+        throw new Error(`Invalid TemplateLiteral part ${part._tag}`);
       }
+      encodedParts.push(part);
+      literals.push(part._tag === "Literal" ? globalThis.String(part.literal) : undefined);
     }
     const suffixLengths = new Array(encodedParts.length + 1);
     suffixLengths[encodedParts.length] = 0;
@@ -852,7 +759,8 @@ export class TemplateLiteral extends Base {
   }
   /** @internal */
   getParser(compile) {
-    const parser = compile(this.asTemplateLiteralParser());
+    const tuple = new Arrays(false, this.parts.map(partFromString), []);
+    const parser = compile(decodeTo(string, tuple, templateLiteralTransformation(this)));
     return (input, options) => {
       if (input === InternalParser.missing) return InternalParser.missingExit;
       const result = parser(input, options);
@@ -873,31 +781,39 @@ export class TemplateLiteral extends Base {
   matchPart(s, options) {
     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, s, options);
-      if (segments) return Effect.succeed(segments);
-      return Effect.fail(new SchemaIssue.InvalidValue({
-        expected: "a string matching template literal parts"
-      }, s, options));
-    }), SchemaGetter.transform(parts => parts.join(""))));
-  }
+};
+/** @internal */
+export function templateLiteralParser(parts) {
+  // Encoded members can overlap even when decoding selects exactly one member.
+  // Match their spellings here; the original tuple enforces the union's mode.
+  const normalize = memoize(encoded => {
+    if (encoded._tag !== "Union") return encoded;
+    const types = mapOrSame(encoded.types, normalize);
+    return (encoded.options?.mode ?? "anyOf") === "anyOf" && types === encoded.types ? encoded : new Union(types, encoded.options === undefined ? undefined : {
+      ...encoded.options,
+      mode: "anyOf"
+    }, encoded.annotations, encoded.checks, undefined, encoded.context);
+  });
+  const template = new TemplateLiteral(parts.map(part => normalize(toEncoded(part))));
+  const tuple = new Arrays(false, parts.map(partFromString), []);
+  return decodeTo(template, tuple, templateLiteralTransformation(template));
+}
+function templateLiteralTransformation(template) {
+  return new SchemaTransformation.Transformation(SchemaGetter.transformEffect((s, options) => {
+    const segments = segmentTemplateLiteralParts(template, s, options);
+    if (segments) return Effect.succeed(segments);
+    return Effect.fail(new SchemaIssue.InvalidValue({
+      expected: "a string matching template literal parts"
+    }, s, options));
+  }), SchemaGetter.transform(parts => parts.join("")));
 }
 /**
- * AST node matching a specific `unique symbol` value.
- *
- * **Details**
+ * Constructs a {@link UniqueSymbol}.
  *
- * Parsing succeeds only when the input is reference-equal to the stored
- * `symbol`.
- *
- * @see {@link isUniqueSymbol}
- * @category models
- * @since 3.10.0
+ * @category constructors
+ * @since 4.0.0
  */
-export class UniqueSymbol extends Base {
+export const UniqueSymbol = class extends ASTNodeImpl {
   _tag = "UniqueSymbol";
   symbol;
   constructor(symbol, annotations, checks, encoding, context) {
@@ -910,38 +826,21 @@ export class UniqueSymbol extends Base {
   }
   /** @internal */
   toCodecStringTree() {
-    return replaceEncoding(this, [symbolToString]);
+    const key = globalThis.Symbol.keyFor(this.symbol);
+    return replaceEncoding(this, [new Link(key === undefined ? never : new Literal(globalThis.String(this.symbol)), symbolToString.transformation)]);
   }
   /** @internal */
   getExpected() {
     return globalThis.String(this.symbol);
   }
-}
+};
 /**
- * AST node matching an exact primitive value (string, number, boolean, or
- * bigint).
- *
- * **Details**
- *
- * Parsing succeeds only when the input is strictly equal (`===`) to the
- * stored `literal`. Numeric literals must be finite — `Infinity`, `-Infinity`,
- * and `NaN` are rejected at construction time.
- *
- * **Example** (Creating a literal AST)
- *
- * ```ts import.meta.vitest
- * import { SchemaAST } from "effect"
+ * Constructs a {@link Literal}.
  *
- * const ast = new SchemaAST.Literal("active")
- * ast.literal // => "active"
- * ```
- *
- * @see {@link LiteralValue}
- * @see {@link isLiteral}
- * @category models
- * @since 3.10.0
+ * @category constructors
+ * @since 4.0.0
  */
-export class Literal extends Base {
+export const Literal = class extends ASTNodeImpl {
   _tag = "Literal";
   literal;
   constructor(literal, annotations, checks, encoding, context) {
@@ -971,21 +870,18 @@ export class Literal extends Base {
   getExpected() {
     return typeof this.literal === "string" ? JSON.stringify(this.literal) : globalThis.String(this.literal);
   }
-}
+};
 function literalToString(ast) {
   const literalAsString = globalThis.String(ast.literal);
   return replaceEncoding(ast, [new Link(new Literal(literalAsString), new SchemaTransformation.Transformation(SchemaGetter.transform(() => ast.literal), SchemaGetter.transform(() => literalAsString)))]);
 }
 /**
- * AST node matching any `string` value.
- *
- * @see {@link string}
- * @see {@link isString}
+ * Constructs a {@link String}.
  *
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class String extends Base {
+export const String = class extends ASTNodeImpl {
   _tag = "String";
   /** @internal */
   getParser() {
@@ -1000,7 +896,7 @@ export class String extends Base {
   getExpected() {
     return "string";
   }
-}
+};
 /**
  * Provides the singleton {@link String} AST instance.
  *
@@ -1016,25 +912,12 @@ export class String extends Base {
  */
 export const string = /*#__PURE__*/new String();
 /**
- * AST node matching any `number` value (including `NaN`, `Infinity`,
- * `-Infinity`).
- *
- * **Details**
- *
- * Default JSON serialization:
- *
- * - Finite numbers are serialized as JSON numbers.
- * - `Infinity`, `-Infinity`, and `NaN` are serialized as JSON strings.
- *
- * If the node has an `isFinite` or `isInt` check, the string fallback is
- * skipped since non-finite values cannot occur.
+ * Constructs a {@link Number}.
  *
- * @see {@link number}
- * @see {@link isNumber}
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class Number extends Base {
+export const Number = class extends ASTNodeImpl {
   _tag = "Number";
   /** @internal */
   getParser() {
@@ -1072,7 +955,7 @@ export class Number extends Base {
   getExpected() {
     return "number";
   }
-}
+};
 function hasCheck(checks, id) {
   return checks.some(check => check.annotations?.representation?.id === id || check._tag === "FilterGroup" && hasCheck(check.checks, id));
 }
@@ -1092,15 +975,12 @@ function hasCheck(checks, id) {
  */
 export const number = /*#__PURE__*/new Number();
 /**
- * AST node matching any `boolean` value (`true` or `false`).
+ * Constructs a {@link Boolean}.
  *
- * @see {@link boolean}
- * @see {@link isBoolean}
- *
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class Boolean extends Base {
+export const Boolean = class extends ASTNodeImpl {
   _tag = "Boolean";
   /** @internal */
   getParser() {
@@ -1110,7 +990,7 @@ export class Boolean extends Base {
   getExpected() {
     return "boolean";
   }
-}
+};
 /**
  * Provides the singleton {@link Boolean} AST instance.
  *
@@ -1127,24 +1007,12 @@ export class Boolean extends Base {
  */
 export const boolean = /*#__PURE__*/new Boolean();
 /**
- * AST node matching any `symbol` value.
- *
- * **When to use**
- *
- * Use when you need the AST node class for schemas that match any JavaScript
- * symbol value.
+ * Constructs a {@link Symbol}.
  *
- * **Details**
- *
- * When serialized to a string-based codec, symbols are converted via
- * `Symbol.keyFor` and must be registered with `Symbol.for`.
- *
- * @see {@link symbol}
- * @see {@link isSymbol}
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class Symbol extends Base {
+export const Symbol = class extends ASTNodeImpl {
   _tag = "Symbol";
   /** @internal */
   getParser() {
@@ -1163,7 +1031,7 @@ export class Symbol extends Base {
   getExpected() {
     return "symbol";
   }
-}
+};
 /**
  * Provides the singleton {@link Symbol} AST instance.
  *
@@ -1184,19 +1052,12 @@ export class Symbol extends Base {
  */
 export const symbol = /*#__PURE__*/new Symbol();
 /**
- * AST node matching any `bigint` value.
+ * Constructs a {@link BigInt}.
  *
- * **Details**
- *
- * When serialized to a string-based codec, bigints are converted to/from
- * their decimal string representation.
- *
- * @see {@link bigInt}
- * @see {@link isBigInt}
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class BigInt extends Base {
+export const BigInt = class extends ASTNodeImpl {
   _tag = "BigInt";
   /** @internal */
   getParser() {
@@ -1217,7 +1078,7 @@ export class BigInt extends Base {
   getExpected() {
     return "bigint";
   }
-}
+};
 /**
  * Provides the singleton {@link BigInt} AST instance.
  *
@@ -1234,48 +1095,12 @@ export class BigInt extends Base {
  */
 export const bigInt = /*#__PURE__*/new BigInt();
 /**
- * AST node for array-like types — both tuples and arrays.
- *
- * **When to use**
- *
- * Use when constructing or inspecting AST nodes for tuple or array-like schemas,
- * including rest elements.
- *
- * **Details**
- *
- * - `elements` — positional element types (tuple elements). An element is
- *   optional if its {@link Context.isOptional} is `true`.
- * - `rest` — the rest/variadic element types. When non-empty, the first
- *   entry is the "spread" type (e.g. `...Array<string>`), and subsequent
- *   entries are trailing positional elements after the spread.
- * - `isMutable` — whether the resulting array is `readonly` (`false`) or
- *   mutable (`true`).
- *
- * **Gotchas**
- *
- * Construction enforces TypeScript ordering rules: a required element
- * cannot follow an optional one, and an optional element cannot follow a
- * rest element.
+ * Constructs a {@link Arrays}.
  *
- * **Example** (Inspecting a tuple AST)
- *
- * ```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)) {
- *   [ast.elements.length, ast.rest.length] // => [2, 0]
- * }
- * ```
- *
- * @see {@link isArrays}
- * @see {@link Objects}
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class Arrays extends Base {
+export const Arrays = class extends ASTNodeImpl {
   _tag = "Arrays";
   isMutable;
   elements;
@@ -1350,10 +1175,11 @@ export class Arrays extends Base {
         issues: undefined,
         options
       };
-      const concurrency = resolveConcurrency(options?.concurrency);
-      const eff = parseArray(state, input, {
-        concurrency: concurrency?.concurrency,
-        end: ast.rest.length === 0 ? elementLen : Math.max(len, elementLen + tailLen)
+      const end = ast.rest.length === 0 ? elementLen : Math.max(len, elementLen + tailLen);
+      const concurrency = options.concurrency === undefined ? 1 : resolveConcurrency(options.concurrency);
+      const eff = concurrency === 1 ? parseArray(state, input, 0, end) : parseArrayConcurrent(state, input, {
+        concurrency,
+        end
       });
       if (eff) yield* eff;
       // ---------------------------------------------
@@ -1393,8 +1219,8 @@ export class Arrays extends Base {
   getExpected() {
     return "array";
   }
-}
-const parseArray = /*#__PURE__*/iterateEager()({
+};
+const parseArrayOptions = {
   onItem(s, item, i) {
     const value = i < s.len ? item : InternalParser.missing;
     return s.getParser(s.tailThreshold, i).parser(value, s.options);
@@ -1417,13 +1243,9 @@ const parseArray = /*#__PURE__*/iterateEager()({
       }
     }
   }
-});
-const resolveConcurrency = value => {
-  value = value === "unbounded" ? Infinity : value ?? 1;
-  return value > 1 ? {
-    concurrency: value
-  } : undefined;
 };
+const parseArray = /*#__PURE__*/iterateEager()(parseArrayOptions);
+const parseArrayConcurrent = /*#__PURE__*/iterateConcurrent()(parseArrayOptions);
 const wrapPropertyKeyIssue = (s, ast, key, exit) => {
   if (exit.cause.reasons.length === 0) {
     return exit;
@@ -1469,26 +1291,19 @@ export function getIndexSignatureKeys(input, parameter, options = defaultParseOp
   return go(parameterFromPropertyKey(toEncoded(parameter)));
 }
 /**
- * Represents a named property within an {@link Objects} node.
+ * Constructs a {@link PropertySignature}.
  *
- * **Details**
- *
- * Pairs a `name` (any `PropertyKey`) with a `type` ({@link AST}). The
- * property's optionality and mutability are determined by the `type`'s
- * {@link Context}.
- *
- * @see {@link Objects}
- * @category models
- * @since 3.10.0
+ * @category constructors
+ * @since 4.0.0
  */
-export class PropertySignature {
+export const PropertySignature = class {
   name;
   type;
   constructor(name, type) {
     this.name = name;
     this.type = type;
   }
-}
+};
 function isIndexSignatureParameterSide(ast) {
   switch (ast._tag) {
     case "String":
@@ -1506,30 +1321,12 @@ function isIndexSignatureParameter(ast) {
   return isIndexSignatureParameterSide(ast) && isIndexSignatureParameterSide(toEncoded(ast));
 }
 /**
- * Represents an index signature entry within an {@link Objects} node.
- *
- * **When to use**
- *
- * Use when constructing or inspecting object AST entries for record-like keys
- * and values.
+ * Constructs a {@link IndexSignature}.
  *
- * **Details**
- *
- * - `parameter` — the key type AST (e.g. {@link String} for `string` keys,
- *   {@link TemplateLiteral} for patterned keys).
- * - `type` — the value type SchemaAST.
- *
- * **Gotchas**
- *
- * Using `Schema.optionalKey` on the value type is not allowed for index
- * signatures (throws at construction); use `Schema.optional` instead.
- *
- * @see {@link Objects}
- * @see {@link PropertySignature}
- * @category models
- * @since 3.10.0
+ * @category constructors
+ * @since 4.0.0
  */
-export class IndexSignature {
+export const IndexSignature = class {
   parameter;
   type;
   constructor(parameter, type) {
@@ -1542,50 +1339,14 @@ export class IndexSignature {
       throw new Error("Cannot use `Schema.optionalKey` with index signatures, use `Schema.optional` instead.");
     }
   }
-}
+};
 /**
- * AST node for object-like schemas, including structs and records.
- *
- * **When to use**
- *
- * Use when constructing or inspecting AST nodes for structs or records rather
- * than array-like schemas.
- *
- * **Details**
- *
- * - `propertySignatures` — named properties with their types (struct fields).
- * - `indexSignatures` — index signature entries (record patterns), each with
- *   a `parameter` AST for matching keys and a `type` AST for values.
- *
- * An `Objects` node with no properties and no index signatures performs only a
- * non-nullish check: it accepts any value except `null` and `undefined`,
- * including primitive values.
- *
- * **Gotchas**
- *
- * Duplicate property names throw at construction time.
- *
- * **Example** (Inspecting a struct AST)
+ * Constructs a {@link Objects}.
  *
- * ```ts import.meta.vitest
- * import { Schema, SchemaAST } from "effect"
- *
- * const schema = Schema.Struct({ name: Schema.String })
- * const ast = schema.ast
- *
- * if (SchemaAST.isObjects(ast)) {
- *   ast.propertySignatures.map((ps) => [ps.name, ps.type._tag]) // => [["name", "String"]]
- * }
- * ```
- *
- * @see {@link isObjects}
- * @see {@link PropertySignature}
- * @see {@link IndexSignature}
- * @see {@link Arrays}
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class Objects extends Base {
+export const Objects = class extends ASTNodeImpl {
   _tag = "Objects";
   propertySignatures;
   indexSignatures;
@@ -1607,7 +1368,7 @@ export class Objects extends Base {
     const ast = this;
     const expectedKeys = [];
     for (const ps of ast.propertySignatures) {
-      expectedKeys.push(ps.name);
+      expectedKeys.push(typeof ps.name === "number" ? globalThis.String(ps.name) : ps.name);
     }
     const hasProperties = expectedKeys.length;
     const indexCount = ast.indexSignatures.length;
@@ -1626,7 +1387,7 @@ export class Objects extends Base {
       }
       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;
+        if (hasProperties && (expectedKeysSet.has(key) || expectedKeysSet.has(typeof k2 === "number" ? globalThis.String(k2) : k2))) return Exit.void;
         InternalRecord.assignProperty(s.out, k2, value);
       }
       return Exit.void;
@@ -1652,18 +1413,11 @@ export class Objects extends Base {
       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
+    const parseIndexes = indexCount ? iterateConcurrent()({
+      onItem: (s, [key, index]) => index.is.parameter === string ? parseStringIndex(s, key, index) : parseIndex(s, key, index),
+      step: (_s, _item, exit) => exit._tag === "Failure" ? exit : undefined
     }) : undefined;
-    return Effect.fnUntracedEager(function* (input, options) {
-      if (input === InternalParser.missing) {
-        return InternalParser.missing;
-      }
-      // 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, input, options));
-      }
+    const compileMembers = () => {
       if (!properties) {
         properties = ast.propertySignatures.map(ps => ({
           parser: compileConstructorDefault(ps.type),
@@ -1676,6 +1430,17 @@ export class Objects extends Base {
           parserValue: compileConstructorDefault(is.type)
         })) : undefined;
       }
+      return properties;
+    };
+    const fallback = Effect.fnUntracedEager(function* (input, options) {
+      if (input === InternalParser.missing) {
+        return InternalParser.missing;
+      }
+      // 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, input, options));
+      }
+      compileMembers();
       const record = input;
       const out = {};
       const state = {
@@ -1687,54 +1452,56 @@ export class Objects extends Base {
       };
       const errorsAllOption = options.errors === "all";
       const onExcessPropertyError = options.onExcessProperty === "error";
-      const onExcessPropertyPreserve = options.onExcessProperty === "preserve";
+      const concurrency = options.concurrency === undefined ? 1 : resolveConcurrency(options.concurrency);
       // ---------------------------------------------
       // handle excess properties
       // ---------------------------------------------
-      let inputKeys;
-      if (!indexCount && (onExcessPropertyError || onExcessPropertyPreserve)) {
+      const indexKeys = indexCount && onExcessPropertyError ? ast.indexSignatures.map(index => getIndexSignatureKeys(record, index.parameter, options)) : undefined;
+      if (onExcessPropertyError) {
         expectedKeysSet ??= new Set(expectedKeys);
-        inputKeys = Reflect.ownKeys(record);
+        const coveredKeys = indexKeys ? new Set(expectedKeysSet) : expectedKeysSet;
+        if (indexKeys) {
+          for (const keys of indexKeys) {
+            for (const key of keys) coveredKeys.add(key);
+          }
+        }
+        const inputKeys = Reflect.ownKeys(record);
         for (let i = 0; i < inputKeys.length; i++) {
           const key = inputKeys[i];
-          if (!expectedKeysSet.has(key)) {
+          if (!coveredKeys.has(key)) {
             // key is unexpected
-            if (onExcessPropertyError) {
-              const unexpected = new SchemaIssue.UnexpectedKey(ast, record[key], options);
-              const issue = new SchemaIssue.Pointer([key], unexpected);
-              if (errorsAllOption) {
-                if (state.issues) {
-                  state.issues.push(issue);
-                } else {
-                  state.issues = [issue];
-                }
-                continue;
+            const unexpected = new SchemaIssue.UnexpectedKey(ast, record[key], options);
+            const issue = new SchemaIssue.Pointer([key], unexpected);
+            if (errorsAllOption) {
+              if (state.issues) {
+                state.issues.push(issue);
               } else {
-                return yield* Effect.fail(new SchemaIssue.Composite(ast, [issue], input, options));
+                state.issues = [issue];
               }
+              continue;
             } else {
-              // preserve key
-              InternalRecord.assignProperty(out, key, record[key]);
+              return yield* Effect.fail(new SchemaIssue.Composite(ast, [issue], input, options));
             }
           }
         }
       }
-      const concurrency = resolveConcurrency(options?.concurrency);
       // ---------------------------------------------
       // handle property signatures
       // ---------------------------------------------
       if (hasProperties) {
-        const eff = parseProperties(state, properties, concurrency);
+        const eff = concurrency === 1 ? parseProperties(state, properties) : parsePropertiesConcurrent(state, properties, {
+          concurrency
+        });
         if (eff) yield* eff;
       }
       // ---------------------------------------------
       // handle index signatures
       // ---------------------------------------------
-      if (indexCount && !concurrency) {
+      if (indexCount && concurrency === 1) {
         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);
+          const keys = indexKeys?.[i] ?? (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;
@@ -1744,30 +1511,77 @@ export class Objects extends Base {
         const keyPairs = Arr.empty();
         for (let i = 0; i < indexCount; i++) {
           const index = indexes[i];
-          const keys = getIndexSignatureKeys(record, index.is.parameter, options);
+          const keys = indexKeys?.[i] ?? (index.is.parameter === string ? Object.keys(record) : getIndexSignatureKeys(record, index.is.parameter, options));
           for (let j = 0; j < keys.length; j++) {
             keyPairs.push([keys[j], index]);
           }
         }
-        const eff = parseIndexes(state, keyPairs, concurrency);
+        const eff = parseIndexes(state, keyPairs, {
+          concurrency
+        });
         if (eff) yield* eff;
       }
       if (state.issues) {
         return yield* Effect.fail(new SchemaIssue.Composite(ast, state.issues, input, options));
       }
-      if (options.propertyOrder === "original") {
-        // preserve input keys order
-        const keys = (inputKeys ?? Reflect.ownKeys(record)).concat(expectedKeys);
-        const preserved = {};
-        for (const key of keys) {
-          if (Object.hasOwn(out, key)) {
-            InternalRecord.assignProperty(preserved, key, out[key]);
+      return out;
+    });
+    if (indexCount) return fallback;
+    // Resumes at the property whose parser suspended, without replaying the
+    // properties already parsed.
+    const resume = (state, index, pending) => {
+      const property = properties[index];
+      return Effect.flatMap(Effect.exit(pending), exit => {
+        const terminal = stepProperty(state, property, exit);
+        if (terminal) return terminal;
+        const done = () => InternalParser.succeed(state.out);
+        const eff = parseProperties(state, properties.slice(index + 1));
+        return eff ? Effect.flatMapEager(eff, done) : done();
+      });
+    };
+    // Fast path: a struct without index signatures, under the default parse
+    // options, needs none of the generator the fallback runs per value.
+    return (input, options) => {
+      if (input === InternalParser.missing) return InternalParser.missingExit;
+      if (options.errors === "all" || options.onExcessProperty !== undefined || options.concurrency !== undefined && resolveConcurrency(options.concurrency) !== 1) {
+        return fallback(input, options);
+      }
+      if (!(typeof input === "object" && input !== null && !Array.isArray(input))) {
+        return Effect.fail(new SchemaIssue.InvalidType(ast, input, options));
+      }
+      const props = compileMembers();
+      const record = input;
+      const out = {};
+      const state = {
+        ast,
+        input: record,
+        out,
+        issues: undefined,
+        options
+      };
+      try {
+        for (let index = 0; index < props.length; index++) {
+          const property = props[index];
+          const name = property.name;
+          const hasKey = hasPropertySignature(record, name);
+          const value = hasKey ? record[name] : InternalParser.missing;
+          const exit = property.parser(value, options);
+          if (!effectIsExit(exit)) {
+            return resume(state, index, exit);
+          }
+          if (exit === InternalParser.sameExit) {
+            if (hasKey) InternalRecord.assignProperty(out, name, value);
+            continue;
           }
+          const terminal = stepProperty(state, property, exit);
+          if (terminal) return terminal;
         }
-        return preserved;
+      } catch (error) {
+        // `Effect.fnUntracedEager` turns a synchronous throw into a defect
+        return Effect.die(error);
       }
-      return out;
-    });
+      return InternalParser.succeed(out);
+    };
   }
   _rebuild(recur, recurParameter, checks, encodingChecks) {
     const props = mapOrSame(this.propertySignatures, ps => {
@@ -1794,38 +1608,41 @@ export class Objects extends Base {
     if (this.propertySignatures.length === 0 && this.indexSignatures.length === 0) return "object | array";
     return "object";
   }
+};
+function stepProperty(s, p, exit) {
+  if (exit._tag === "Failure") {
+    return wrapPropertyKeyIssue(s, s.ast, p.name, exit);
+  }
+  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, [issue], s.input, s.options));
+    }
+  }
 }
-const parseProperties = /*#__PURE__*/iterateEager()({
+const parsePropertiesOptions = {
   onItem(s, p) {
-    if (!Object.hasOwn(s.input, p.name)) {
+    if (!hasPropertySignature(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);
-    }
-    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, [issue], s.input, s.options));
-      }
-    }
-  }
-});
+  step: stepProperty
+};
+const parseProperties = /*#__PURE__*/iterateEager()(parsePropertiesOptions);
+const parsePropertiesConcurrent = /*#__PURE__*/iterateConcurrent()(parsePropertiesOptions);
 function combineChecks(a, b) {
   if (!a) return b;
   if (!b) return a;
@@ -1846,8 +1663,8 @@ export function tuple(elements, checks = undefined) {
   return new Arrays(false, elements.map(e => e.ast), [], undefined, checks);
 }
 /** @internal */
-export function union(members, mode, checks) {
-  return new Union(members.map(getAST), mode, undefined, checks);
+export function union(members, options, checks) {
+  return new Union(members.map(getAST), options, undefined, checks);
 }
 /** @internal */
 export function structWithRest(ast, records) {
@@ -1871,6 +1688,13 @@ export function tupleWithRest(ast, rest) {
   }
   return new Arrays(ast.isMutable, ast.elements, rest, undefined, ast.checks);
 }
+/** @internal */
+export function mutable(ast) {
+  if (ast.encoding) {
+    throw new Error("mutable does not support encodings");
+  }
+  return new Arrays(true, ast.elements, ast.rest, ast.annotations, ast.checks, undefined, ast.context, ast.encodingChecks);
+}
 const toCandidate = /*#__PURE__*/memoizeIdempotent(ast => {
   while (true) {
     if (isSuspend(ast)) return unknown;
@@ -1976,6 +1800,7 @@ export function collectSentinels(ast) {
 }
 const candidateIndexCache = /*#__PURE__*/new WeakMap();
 const emptyCandidates = /*#__PURE__*/Object.freeze([]);
+const hasPropertySignature = (input, key) => key === "__proto__" ? Object.hasOwn(input, key) : key in input;
 function getIndex(types) {
   let index = candidateIndexCache.get(types);
   if (index) return index;
@@ -2033,7 +1858,7 @@ function getIndex(types) {
     }
     index = (input, isConstructor) => {
       if (Predicate.isObjectKeyword(input)) {
-        const value = Object.hasOwn(input, key) ? input[key] : undefined;
+        const value = hasPropertySignature(input, key) ? input[key] : undefined;
         if (value !== undefined) return candidates.get(value) ?? emptyCandidates;
         if (isConstructor) return types;
       }
@@ -2060,7 +1885,7 @@ function getIndex(types) {
       // discriminated candidate.
       if (commonSentinel) {
         const [key, [byValue]] = commonSentinel;
-        const hasKey = Object.hasOwn(input, key);
+        const hasKey = hasPropertySignature(input, key);
         const value = hasKey ? input[key] : undefined;
         if (hasKey && (!isConstructor || value !== undefined)) {
           const match = byValue.get(value);
@@ -2073,7 +1898,7 @@ function getIndex(types) {
       // absent and undefined keys as unconstrained and therefore selects every candidate that owns the key.
       if (directKey === undefined) {
         for (const [key, [byValue, all]] of bySentinel) {
-          const hasKey = Object.hasOwn(input, key);
+          const hasKey = hasPropertySignature(input, key);
           const value = hasKey ? input[key] : undefined;
           if (hasKey && (!isConstructor || value !== undefined)) {
             const match = byValue.get(value);
@@ -2088,7 +1913,7 @@ function getIndex(types) {
       // Missing keys are neutral. An observed key rejects only selected candidates that own it and do not match.
       for (const [key, [byValue, all]] of bySentinel) {
         if (key === directKey) continue;
-        const hasKey = Object.hasOwn(input, key);
+        const hasKey = hasPropertySignature(input, key);
         const value = hasKey ? input[key] : undefined;
         if (hasKey && (!isConstructor || value !== undefined)) {
           const match = byValue.get(value);
@@ -2124,44 +1949,20 @@ export function getCandidates(input, types, isConstructor = false) {
   return getIndex(types)(input, isConstructor);
 }
 /**
- * AST node representing a union of schemas.
- *
- * **Details**
- *
- * - `types` — the member AST nodes.
- * - `mode` — `"anyOf"` succeeds on the first match (like TypeScript unions);
- *   `"oneOf"` requires exactly one member to match (fails if multiple do).
- *
- * During parsing, members are tried in order. An internal candidate index
- * narrows which members to try based on the runtime type of the input and
- * discriminant ("sentinel") fields, making large unions efficient.
- *
- * **Example** (Inspecting a union AST)
- *
- * ```ts import.meta.vitest
- * import { Schema, SchemaAST } from "effect"
- *
- * const schema = Schema.Union([Schema.String, Schema.Number])
- * const ast = schema.ast
+ * Constructs a {@link Union}.
  *
- * if (SchemaAST.isUnion(ast)) {
- *   [ast.types.length, ast.mode] // => [2, "anyOf"]
- * }
- * ```
- *
- * @see {@link isUnion}
- * @category models
- * @since 3.10.0
+ * @category constructors
+ * @since 4.0.0
  */
-export class Union extends Base {
+export const Union = class extends ASTNodeImpl {
   _tag = "Union";
   types;
-  mode;
+  options;
   encodingChecks;
-  constructor(types, mode, annotations, checks, encoding, context, encodingChecks) {
+  constructor(types, options, annotations, checks, encoding, context, encodingChecks) {
     super(annotations, checks, encoding, context);
     this.types = types;
-    this.mode = mode;
+    this.options = options;
     this.encodingChecks = encodingChecks;
   }
   /** @internal */
@@ -2173,6 +1974,9 @@ export class Union extends Base {
         return InternalParser.missingExit;
       }
       const candidates = getCandidates(input, ast.types, compileConstructorDefault !== undefined);
+      if (candidates.length === 0) {
+        return Effect.fail(new SchemaIssue.AnyOf(ast, [], input, options));
+      }
       if (candidates.length === 1) {
         const result = compile(candidates[0])(input, options);
         if (result._tag === "Success") return result;
@@ -2183,15 +1987,11 @@ export class Union extends Base {
         compile,
         input,
         out: undefined,
-        successes: ast.mode === "oneOf" ? [] : undefined,
+        successes: ast.options?.mode === "oneOf" ? [] : undefined,
         issues: undefined,
         options
       };
-      const concurrency = resolveConcurrency(options?.concurrency);
-      const eff = parseUnion(state, candidates, concurrency ? {
-        ...concurrency,
-        orderedStep: true
-      } : undefined);
+      const eff = parseUnion(state, candidates);
       if (!eff) {
         if (state.out) return state.out;
         return Effect.fail(new SchemaIssue.AnyOf(ast, state.issues ?? [], input, options));
@@ -2205,7 +2005,7 @@ export class Union extends Base {
   }
   _rebuild(recur, checks, encodingChecks) {
     const types = mapOrSame(this.types, recur);
-    return types === this.types && checks === this.checks && encodingChecks === this.encodingChecks ? this : new Union(types, this.mode, this.annotations, checks, undefined, this.context, encodingChecks);
+    return types === this.types && checks === this.checks && encodingChecks === this.encodingChecks ? this : new Union(types, this.options, this.annotations, checks, undefined, this.context, encodingChecks);
   }
   /** @internal */
   recur(recur) {
@@ -2252,7 +2052,7 @@ export class Union extends Base {
     });
     return Array.from(new Set(types)).join(" | ");
   }
-}
+};
 function failSingleUnionCandidate(ast, cause, input, options) {
   const issue = InternalSchemaCause.getSchemaIssue(cause);
   if (!issue) return Exit.failCause(cause);
@@ -2284,7 +2084,7 @@ const parseUnion = /*#__PURE__*/iterateEager()({
     }
   }
 });
-const nonFiniteLiterals = /*#__PURE__*/new Union([/*#__PURE__*/new Literal("Infinity"), /*#__PURE__*/new Literal("-Infinity"), /*#__PURE__*/new Literal("NaN")], "anyOf");
+const nonFiniteLiterals = /*#__PURE__*/new Union([/*#__PURE__*/new Literal("Infinity"), /*#__PURE__*/new Literal("-Infinity"), /*#__PURE__*/new Literal("NaN")]);
 function formatIsMutable(isMutable) {
   return isMutable ? "" : "readonly ";
 }
@@ -2305,37 +2105,12 @@ export function memoizeThunk(f) {
   };
 }
 /**
- * AST node for lazy/recursive schemas.
- *
- * **Details**
- *
- * Wraps a thunk (`() => AST`) that is memoized on first call. Use this to
- * define recursive or mutually recursive schemas without infinite loops at
- * construction time.
+ * Constructs a {@link Suspend}.
  *
- * **Example** (Defining recursive schema ASTs)
- *
- * ```ts import.meta.vitest
- * import { Schema, SchemaAST } from "effect"
- *
- * interface Category {
- *   readonly name: string
- *   readonly children: ReadonlyArray<Category>
- * }
- *
- * const Category = Schema.Struct({
- *   name: Schema.String,
- *   children: Schema.Array(Schema.suspend((): Schema.Codec<Category> => Category))
- * })
- *
- * SchemaAST.isObjects(Category.ast) // => true
- * ```
- *
- * @see {@link isSuspend}
- * @category models
- * @since 3.10.0
+ * @category constructors
+ * @since 4.0.0
  */
-export class Suspend extends Base {
+export const Suspend = class extends ASTNodeImpl {
   _tag = "Suspend";
   thunk;
   constructor(thunk, annotations, checks, encoding, context) {
@@ -2358,32 +2133,14 @@ export class Suspend extends Base {
   getExpected(getExpected) {
     return getExpected(this.thunk());
   }
-}
-// -----------------------------------------------------------------------------
-// Checks
-// -----------------------------------------------------------------------------
+};
 /**
- * Represents a single validation check attached to an AST node.
- *
- * **Details**
- *
- * - `run` — the validation function. Returns `undefined` on success, or an
- *   `Issue` on failure.
- * - `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).
- *
- * Use `.annotate()` to add metadata and `.abort()` to mark as aborting.
- * Combine with another check via `.and()` to form a {@link FilterGroup}.
+ * Constructs a {@link Filter}.
  *
- * @see {@link FilterGroup}
- * @see {@link Check}
- * @see {@link isPattern}
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class Filter extends Pipeable.Class {
+export const Filter = class extends Pipeable.Class {
   _tag = "Filter";
   run;
   annotations;
@@ -2413,22 +2170,14 @@ export class Filter extends Pipeable.Class {
   and(other, annotations) {
     return new FilterGroup([this, other], annotations);
   }
-}
+};
 /**
- * Represents a composite validation check grouping multiple {@link Check} values.
- *
- * **Details**
+ * Constructs a {@link FilterGroup}.
  *
- * Created by calling `.and()` on a {@link Filter} or another `FilterGroup`.
- * All inner checks are run; failures from aborted filters still stop
- * evaluation.
- *
- * @see {@link Filter}
- * @see {@link Check}
- * @category models
+ * @category constructors
  * @since 4.0.0
  */
-export class FilterGroup extends Pipeable.Class {
+export const FilterGroup = class extends Pipeable.Class {
   _tag = "FilterGroup";
   checks;
   annotations;
@@ -2446,7 +2195,7 @@ export class FilterGroup extends Pipeable.Class {
   and(other, annotations) {
     return new FilterGroup([this, other], annotations);
   }
-}
+};
 /** @internal */
 export function makeFilter(filter, annotations, aborted = false) {
   return new Filter((input, ast, options) => SchemaIssue.normalizeFilterOutput(ast, filter(input, ast, options), input, options), annotations, aborted);
@@ -2470,18 +2219,15 @@ export function isFinite(annotations) {
     toCode: () => ({
       runtime: "Schema.isFinite()"
     }),
-    arbitrary: {
-      constraint: {
-        noInfinity: true,
-        noNaN: true
-      }
+    arbitraryConstraint: {
+      number: "finite"
     },
     ...annotations
   });
 }
 /** @internal */
 export const finite = /*#__PURE__*/appendChecks(number, [/*#__PURE__*/isFinite()]);
-const numberToJson = /*#__PURE__*/new Link(/*#__PURE__*/new Union([finite, nonFiniteLiterals], "anyOf"), /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.Number(), /*#__PURE__*/SchemaGetter.transform(n => globalThis.Number.isFinite(n) ? n : globalThis.String(n))));
+const numberToJson = /*#__PURE__*/new Link(/*#__PURE__*/new Union([finite, nonFiniteLiterals]), /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.Number(), /*#__PURE__*/SchemaGetter.transform(n => globalThis.Number.isFinite(n) ? n : globalThis.String(n))));
 /**
  * Creates a {@link Filter} that validates strings by running `RegExp.test`.
  *
@@ -2501,8 +2247,12 @@ const numberToJson = /*#__PURE__*/new Link(/*#__PURE__*/new Union([finite, nonFi
  *
  * **Gotchas**
  *
- * When deriving an arbitrary, only `regExp.source` is used. Regular expression
- * flags are ignored because fast-check does not support them.
+ * Arbitrary metadata preserves both `regExp.source` and `regExp.flags`.
+ * Implementations that cannot consume all flags may still use the source as a
+ * generation hint because the Schema filter validates every generated value.
+ * JSON Schema has no way to carry JavaScript regular-expression flags. The
+ * generated `pattern` contains the source only, so validation can differ when
+ * the RegExp uses flags or relies on JavaScript's non-Unicode behavior.
  *
  * **Example** (Validating an email pattern)
  *
@@ -2536,10 +2286,11 @@ export function isPattern(regExp, annotations) {
     toJsonSchema: () => ({
       pattern: source
     }),
-    arbitrary: {
-      constraint: {
-        patterns: [regExp.source]
-      }
+    arbitraryConstraint: {
+      patterns: [{
+        source: regExp.source,
+        flags: regExp.flags
+      }]
     },
     ...annotations
   });
@@ -2696,7 +2447,7 @@ export const optionalKey = /*#__PURE__*/memoizeIdempotent(ast => {
 });
 const optionalKeyLastLink = /*#__PURE__*/applyToLastLink(optionalKey);
 /** @internal */
-export const optional = /*#__PURE__*/memoize(ast => optionalKey(new Union([ast, undefined_], "anyOf")));
+export const optional = /*#__PURE__*/memoize(ast => optionalKey(new Union([ast, undefined_])));
 /** @internal */
 export const mutableKey = /*#__PURE__*/memoizeIdempotent(ast => {
   const context = ast.context ? ast.context.isMutable === false ? new Context(ast.context.isOptional, true, ast.context.constructorDefault, ast.context.annotations) : ast.context : new Context(false, true);
@@ -2716,9 +2467,8 @@ export function withConstructorDefault(ast, defaultValue) {
  *
  * **Details**
  *
- * This is the low-level primitive behind `Schema.transform` and
- * `Schema.transformOrFail`. It appends a {@link Link} to the `to` node's
- * encoding chain.
+ * This is the low-level primitive behind `Schema.decodeTo`. It appends a
+ * {@link Link} to the `to` node's encoding chain.
  *
  * - Returns a new AST with the same type as `to`.
  *
@@ -2780,7 +2530,7 @@ export function record(key, value) {
  * Checks `ast.context?.isOptional`. Defaults to `false` when no
  * {@link Context} is set.
  *
- * @see {@link optionalKey}
+ * @see `Schema.optionalKey`
  * @see {@link Context}
  * @category predicates
  * @since 4.0.0
@@ -2924,7 +2674,7 @@ export function containsUndefined(ast) {
   }
 }
 function fromConst(ast, value) {
-  const succeed = InternalParser.succeed(value);
+  const succeed = value === 0 ? InternalParser.sameExit : InternalParser.succeed(value);
   return (input, options) => {
     if (input === InternalParser.missing) return InternalParser.missingExit;
     if (input === value) return succeed;
@@ -2986,12 +2736,6 @@ function segmentTemplateLiteralParts(ast, input, options) {
   }
   return go(0, 0) ? out : undefined;
 }
-/** @internal */
-export const enumsToLiterals = /*#__PURE__*/memoize(ast => {
-  return new Union(ast.enums.map(e => new Literal(e[1], {
-    title: e[0]
-  })), "anyOf");
-});
 const parameterFromPropertyKey = /*#__PURE__*/applyToSelfOrLastLinkEncodingIdempotent(ast => {
   switch (ast._tag) {
     default:
@@ -3049,7 +2793,7 @@ export function isStringFinite(annotations) {
 }
 const finiteString = /*#__PURE__*/appendChecks(string, [/*#__PURE__*/isStringFinite()]);
 const finiteToString = /*#__PURE__*/new Link(finiteString, SchemaTransformation.numberFromString);
-const numberToString = /*#__PURE__*/new Link(/*#__PURE__*/new Union([finiteString, nonFiniteLiterals], "anyOf"), SchemaTransformation.numberFromString);
+const numberToString = /*#__PURE__*/new Link(/*#__PURE__*/new Union([finiteString, nonFiniteLiterals]), SchemaTransformation.numberFromString);
 /**
  * signed integer only (no leading "+" because TypeScript doesn't support it)
  */
@@ -3074,14 +2818,14 @@ export const bigIntString = /*#__PURE__*/appendChecks(string, [/*#__PURE__*/isSt
   expected: "a string representing a bigint"
 })]);
 const bigIntToString = /*#__PURE__*/new Link(bigIntString, SchemaTransformation.bigintFromString);
-const REGEXP_PATTERN = "Symbol\\((.*)\\)";
+const REGEXP_PATTERN = "Symbol\\(([\\s\\S]*)\\)";
 const isStringSymbolRegExp = /*#__PURE__*/new globalThis.RegExp(`^${REGEXP_PATTERN}$`);
 /** @internal */
 export const symbolString = /*#__PURE__*/appendChecks(string, [/*#__PURE__*/isStringSymbol()]);
 /**
  * to distinguish between Symbol and String, we need to add a check to the string keyword
  */
-const symbolToString = /*#__PURE__*/new Link(symbolString, /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(description => globalThis.Symbol.for(isStringSymbolRegExp.exec(description)[1])), /*#__PURE__*/SchemaGetter.transformOrFail((sym, options) => {
+const symbolToString = /*#__PURE__*/new Link(symbolString, /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(description => globalThis.Symbol.for(isStringSymbolRegExp.exec(description)[1])), /*#__PURE__*/SchemaGetter.transformEffect((sym, options) => {
   const key = globalThis.Symbol.keyFor(sym);
   if (key !== undefined) {
     return Effect.succeed(globalThis.String(sym));
@@ -3150,7 +2894,7 @@ export function getConstructorDescriptor(ast) {
  *
  * If the node has {@link Checks}, returns annotations from the last check
  * (which is where user-supplied annotations end up after `.pipe(Schema.annotations(...))`).
- * Otherwise returns `Base.annotations` directly.
+ * Otherwise returns the node's `annotations` directly.
  *
  * **Example** (Reading annotations)
  *
@@ -3297,8 +3041,7 @@ export const Json = /*#__PURE__*/new Declaration([], () => (input, ast, options)
   },
   expected: "JSON value",
   toCodecJson: () => undefined,
-  toCodecStringTree: () => unknownToStringTree,
-  toArbitrary: () => fc => fc.jsonValue()
+  toCodecStringTree: () => unknownToStringTree
 });
 /** @internal */
 export const MutableJson = /*#__PURE__*/annotate(Json, {
@@ -3310,7 +3053,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)])], "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)])]), /*#__PURE__*/SchemaTransformation.passthrough());
 /**
  * Returns true if the value is a StringTree value.
  *