effect 4.0.0-beta.5 → 4.0.0-beta.51

package/dist/SchemaAST.js

@@ -75,9 +75,10 @@
 import * as Arr from "./Array.js";
 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 { effectIsExit } from "./internal/effect.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 Option from "./Option.js";
@@ -388,7 +389,7 @@ export class Declaration extends Base {
   }
   /** @internal */
   getExpected() {
-    const expected = this.annotations?.identifier ?? this.annotations?.expected;
+    const expected = this.annotations?.expected;
     if (typeof expected === "string") return expected;
     return "<Declaration>";
   }
@@ -441,7 +442,7 @@ export class Undefined extends Base {
     return fromConst(this, undefined);
   }
   /** @internal */
-  encodeToNull() {
+  toCodecJson() {
     return replaceEncoding(this, [undefinedToNull]);
   }
   /** @internal */
@@ -477,7 +478,7 @@ export class Void extends Base {
     return fromConst(this, undefined);
   }
   /** @internal */
-  encodeToNull() {
+  toCodecJson() {
     return replaceEncoding(this, [undefinedToNull]);
   }
   /** @internal */
@@ -1041,6 +1042,16 @@ export class Arrays extends Base {
       parser: recur(ast)
     }));
     const elementLen = elements.length;
+    const [head, ...tail] = rest;
+    const tailLen = tail.length;
+    function getParser(tailThreshold, index) {
+      if (index < elementLen) {
+        return elements[index];
+      } else if (index >= tailThreshold) {
+        return tail[index - tailThreshold];
+      }
+      return head;
+    }
     return Effect.fnUntracedEager(function* (oinput, options) {
       if (oinput._tag === "None") {
         return oinput;
@@ -1050,123 +1061,40 @@ export class Arrays extends Base {
       if (!Array.isArray(input)) {
         return yield* Effect.fail(new Issue.InvalidType(ast, oinput));
       }
-      const output = [];
-      let issues;
-      const errorsAllOption = options.errors === "all";
-      let i = 0;
-      // ---------------------------------------------
-      // handle elements
-      // ---------------------------------------------
-      for (; i < elementLen; i++) {
-        const e = elements[i];
-        const value = i < input.length ? Option.some(input[i]) : Option.none();
-        const eff = e.parser(value, options);
-        const exit = effectIsExit(eff) ? eff : yield* Effect.exit(eff);
-        if (exit._tag === "Failure") {
-          const issueElement = Cause.findError(exit.cause);
-          if (Result.isFailure(issueElement)) {
-            return yield* exit;
-          }
-          const issue = new Issue.Pointer([i], issueElement.success);
-          if (errorsAllOption) {
-            if (issues) issues.push(issue);else issues = [issue];
-          } else {
-            return yield* Effect.fail(new Issue.Composite(ast, oinput, [issue]));
-          }
-        } else if (exit.value._tag === "Some") {
-          output[i] = exit.value.value;
-        } else if (!isOptional(e.ast)) {
-          const issue = new Issue.Pointer([i], new Issue.MissingKey(e.ast.context?.annotations));
-          if (errorsAllOption) {
-            if (issues) issues.push(issue);else issues = [issue];
-          } else {
-            return yield* Effect.fail(new Issue.Composite(ast, oinput, [issue]));
-          }
-        }
-      }
+      const len = input.length;
+      const state = {
+        ast,
+        getParser,
+        oinput,
+        len,
+        tailThreshold: resolveTailThreshold(len, elementLen, tailLen),
+        output: new globalThis.Array(len),
+        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)
+      });
+      if (eff) yield* eff;
       // ---------------------------------------------
-      // handle rest element
+      // handle excess indexes
       // ---------------------------------------------
-      const len = input.length;
-      if (ast.rest.length > 0) {
-        const [head, ...tail] = rest;
-        const keyAnnotations = head.ast.context?.annotations;
-        for (; i < len - tail.length; i++) {
-          const eff = head.parser(Option.some(input[i]), options);
-          const exit = effectIsExit(eff) ? eff : yield* Effect.exit(eff);
-          if (exit._tag === "Failure") {
-            const issueRest = Cause.findError(exit.cause);
-            if (Result.isFailure(issueRest)) {
-              return yield* exit;
-            }
-            const issue = new Issue.Pointer([i], issueRest.success);
-            if (errorsAllOption) {
-              if (issues) issues.push(issue);else issues = [issue];
-            } else {
-              return yield* Effect.fail(new Issue.Composite(ast, oinput, [issue]));
-            }
-          } else if (exit.value._tag === "Some") {
-            output[i] = exit.value.value;
-          } else {
-            const issue = new Issue.Pointer([i], new Issue.MissingKey(keyAnnotations));
-            if (errorsAllOption) {
-              if (issues) issues.push(issue);else issues = [issue];
-            } else {
-              return yield* Effect.fail(new Issue.Composite(ast, oinput, [issue]));
-            }
-          }
-        }
-        // ---------------------------------------------
-        // handle post rest elements
-        // ---------------------------------------------
-        for (let j = 0; j < tail.length; j++) {
-          if (len < i + 1) {
-            continue;
-          } else {
-            const tailj = tail[j];
-            const keyAnnotations = tailj.ast.context?.annotations;
-            const eff = tailj.parser(Option.some(input[i]), options);
-            const exit = effectIsExit(eff) ? eff : yield* Effect.exit(eff);
-            if (exit._tag === "Failure") {
-              const issueRest = Cause.findError(exit.cause);
-              if (Result.isFailure(issueRest)) {
-                return yield* exit;
-              }
-              const issue = new Issue.Pointer([i], issueRest.success);
-              if (errorsAllOption) {
-                if (issues) issues.push(issue);else issues = [issue];
-              } else {
-                return yield* Effect.fail(new Issue.Composite(ast, oinput, [issue]));
-              }
-            } else if (exit.value._tag === "Some") {
-              output[i] = exit.value.value;
-            } else {
-              const issue = new Issue.Pointer([i], new Issue.MissingKey(keyAnnotations));
-              if (errorsAllOption) {
-                if (issues) issues.push(issue);else issues = [issue];
-              } else {
-                return yield* Effect.fail(new Issue.Composite(ast, oinput, [issue]));
-              }
-            }
-          }
-        }
-      } else {
-        // ---------------------------------------------
-        // handle excess indexes
-        // ---------------------------------------------
+      if (ast.rest.length === 0 && len > elementLen) {
         for (let i = elementLen; i <= len - 1; i++) {
           const issue = new Issue.Pointer([i], new Issue.UnexpectedKey(ast, input[i]));
-          if (errorsAllOption) {
-            if (issues) issues.push(issue);else issues = [issue];
+          if (options.errors === "all") {
+            if (state.issues) state.issues.push(issue);else state.issues = [issue];
           } else {
             return yield* Effect.fail(new Issue.Composite(ast, oinput, [issue]));
           }
         }
       }
-      if (issues) {
-        return yield* Effect.fail(new Issue.Composite(ast, oinput, issues));
+      if (state.issues) {
+        return yield* Effect.fail(new Issue.Composite(ast, oinput, state.issues));
       }
-      return Option.some(output);
+      return Option.some(state.output);
     });
   }
   /** @internal */
@@ -1180,6 +1108,49 @@ export class Arrays extends Base {
     return "array";
   }
 }
+const parseArray = /*#__PURE__*/iterateEager()({
+  onItem(s, item, i) {
+    const value = i < s.len ? Option.some(item) : Option.none();
+    return s.getParser(s.tailThreshold, i).parser(value, s.options);
+  },
+  step(s, _, 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;
+    } else {
+      const p = s.getParser(s.tailThreshold, i);
+      if (isOptional(p.ast)) return;
+      const issue = new Issue.Pointer([i], new Issue.MissingKey(p.ast.context?.annotations));
+      if (s.options.errors === "all") {
+        if (s.issues) s.issues.push(issue);else s.issues = [issue];
+      } else {
+        return Exit.fail(new Issue.Composite(s.ast, s.oinput, [issue]));
+      }
+    }
+  }
+});
+function resolveTailThreshold(inputLen, elementLen, tailLen) {
+  return Math.max(elementLen, inputLen - tailLen);
+}
+const resolveConcurrency = value => {
+  value = value === "unbounded" ? Infinity : value ?? 1;
+  return value > 1 ? {
+    concurrency: value
+  } : undefined;
+};
+const wrapPropertyKeyIssue = (s, ast, key, exit) => {
+  const issueResult = Cause.findError(exit.cause);
+  if (Result.isFailure(issueResult)) {
+    return exit;
+  }
+  const issue = new Issue.Pointer([key], issueResult.success);
+  if (s.options.errors === "all") {
+    if (s.issues) s.issues.push(issue);else s.issues = [issue];
+  } else {
+    return Exit.fail(new Issue.Composite(ast, s.oinput, [issue]));
+  }
+};
 /**
  * floating point or integer, with optional exponent
  * @internal
@@ -1342,7 +1313,6 @@ export class Objects extends Base {
     const expectedKeys = [];
     const expectedKeysSet = new Set();
     const properties = [];
-    const propertyCount = ast.propertySignatures.length;
     for (const ps of ast.propertySignatures) {
       expectedKeys.push(ps.name);
       expectedKeysSet.add(ps.name);
@@ -1360,6 +1330,37 @@ export class Objects extends Base {
     if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
       return fromRefinement(ast, Predicate.isNotNullish);
     }
+    const parseIndexes = indexCount > 0 ? iterateEager()({
+      onItem: Effect.fnUntracedEager(function* (s, [key, is]) {
+        const parserKey = recur(indexSignatureParameterFromString(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;
+          const v2 = exitValue.value.value;
+          if (is.merge && is.merge.decode && Object.hasOwn(s.out, k2)) {
+            const [k, v] = is.merge.decode.combine([k2, s.out[k2]], [k2, v2]);
+            internalRecord.set(s.out, k, v);
+          } else {
+            internalRecord.set(s.out, k2, v2);
+          }
+        }
+      }),
+      step: (_s, _, exit) => exit._tag === "Failure" ? exit : undefined
+    }) : undefined;
     return Effect.fnUntracedEager(function* (oinput, options) {
       if (oinput._tag === "None") {
         return oinput;
@@ -1370,7 +1371,14 @@ export class Objects extends Base {
         return yield* Effect.fail(new Issue.InvalidType(ast, oinput));
       }
       const out = {};
-      let issues;
+      const state = {
+        ast,
+        oinput,
+        input,
+        out,
+        issues: undefined,
+        options
+      };
       const errorsAllOption = options.errors === "all";
       const onExcessPropertyError = options.onExcessProperty === "error";
       const onExcessPropertyPreserve = options.onExcessProperty === "preserve";
@@ -1387,10 +1395,10 @@ export class Objects extends Base {
             if (onExcessPropertyError) {
               const issue = new Issue.Pointer([key], new Issue.UnexpectedKey(ast, input[key]));
               if (errorsAllOption) {
-                if (issues) {
-                  issues.push(issue);
+                if (state.issues) {
+                  state.issues.push(issue);
                 } else {
-                  issues = [issue];
+                  state.issues = [issue];
                 }
                 continue;
               } else {
@@ -1403,93 +1411,30 @@ export class Objects extends Base {
           }
         }
       }
+      const concurrency = resolveConcurrency(options?.concurrency);
       // ---------------------------------------------
       // handle property signatures
       // ---------------------------------------------
-      for (let i = 0; i < propertyCount; i++) {
-        const p = properties[i];
-        const value = Object.hasOwn(input, p.name) ? Option.some(input[p.name]) : Option.none();
-        const eff = p.parser(value, options);
-        const exit = effectIsExit(eff) ? eff : yield* Effect.exit(eff);
-        if (exit._tag === "Failure") {
-          const issueProp = Cause.findError(exit.cause);
-          if (Result.isFailure(issueProp)) {
-            return yield* exit;
-          }
-          const issue = new Issue.Pointer([p.name], issueProp.success);
-          if (errorsAllOption) {
-            if (issues) issues.push(issue);else issues = [issue];
-            continue;
-          } else {
-            return yield* Effect.fail(new Issue.Composite(ast, oinput, [issue]));
-          }
-        } else if (exit.value._tag === "Some") {
-          internalRecord.set(out, p.name, exit.value.value);
-        } else if (!isOptional(p.type)) {
-          const issue = new Issue.Pointer([p.name], new Issue.MissingKey(p.type.context?.annotations));
-          if (errorsAllOption) {
-            if (issues) issues.push(issue);else issues = [issue];
-            continue;
-          } else {
-            return yield* Effect.fail(new Issue.Composite(ast, oinput, [issue]));
-          }
-        }
-      }
+      const eff = parseProperties(state, properties, concurrency);
+      if (eff) yield* eff;
       // ---------------------------------------------
       // handle index signatures
       // ---------------------------------------------
-      if (indexCount > 0) {
+      if (parseIndexes) {
+        const keyPairs = Arr.empty();
         for (let i = 0; i < indexCount; i++) {
           const is = ast.indexSignatures[i];
           const keys = getIndexSignatureKeys(input, is.parameter);
           for (let j = 0; j < keys.length; j++) {
             const key = keys[j];
-            const parserKey = recur(indexSignatureParameterFromString(is.parameter));
-            const effKey = parserKey(Option.some(key), options);
-            const exitKey = effectIsExit(effKey) ? effKey : yield* Effect.exit(effKey);
-            if (exitKey._tag === "Failure") {
-              const issueKey = Cause.findError(exitKey.cause);
-              if (Result.isFailure(issueKey)) {
-                return yield* exitKey;
-              }
-              const issue = new Issue.Pointer([key], issueKey.success);
-              if (errorsAllOption) {
-                if (issues) issues.push(issue);else issues = [issue];
-                continue;
-              }
-              return yield* Effect.fail(new Issue.Composite(ast, oinput, [issue]));
-            }
-            const value = Option.some(input[key]);
-            const parserValue = recur(is.type);
-            const effValue = parserValue(value, options);
-            const exitValue = effectIsExit(effValue) ? effValue : yield* Effect.exit(effValue);
-            if (exitValue._tag === "Failure") {
-              const issueValue = Cause.findError(exitValue.cause);
-              if (Result.isFailure(issueValue)) {
-                return yield* exitValue;
-              }
-              const issue = new Issue.Pointer([key], issueValue.success);
-              if (errorsAllOption) {
-                if (issues) issues.push(issue);else issues = [issue];
-                continue;
-              } else {
-                return yield* Effect.fail(new Issue.Composite(ast, oinput, [issue]));
-              }
-            } else if (exitKey.value._tag === "Some" && exitValue.value._tag === "Some") {
-              const k2 = exitKey.value.value;
-              const v2 = exitValue.value.value;
-              if (is.merge && is.merge.decode && Object.hasOwn(out, k2)) {
-                const [k, v] = is.merge.decode.combine([k2, out[k2]], [k2, v2]);
-                internalRecord.set(out, k, v);
-              } else {
-                internalRecord.set(out, k2, v2);
-              }
-            }
+            keyPairs.push([key, is]);
           }
         }
+        const eff = parseIndexes(state, keyPairs, concurrency);
+        if (eff) yield* eff;
       }
-      if (issues) {
-        return yield* Effect.fail(new Issue.Composite(ast, oinput, issues));
+      if (state.issues) {
+        return yield* Effect.fail(new Issue.Composite(ast, oinput, state.issues));
       }
       if (options.propertyOrder === "original") {
         // preserve input keys order
@@ -1532,6 +1477,27 @@ export class Objects extends Base {
     return "object";
   }
 }
+const parseProperties = /*#__PURE__*/iterateEager()({
+  onItem(s, p) {
+    const value = Object.hasOwn(s.input, p.name) ? Option.some(s.input[p.name]) : Option.none();
+    return p.parser(value, s.options);
+  },
+  step(s, p, exit) {
+    if (exit._tag === "Failure") {
+      return wrapPropertyKeyIssue(s, s.ast, p.name, exit);
+    } else if (exit.value._tag === "Some") {
+      internalRecord.set(s.out, p.name, exit.value.value);
+    } else if (!isOptional(p.type)) {
+      const issue = new Issue.Pointer([p.name], new Issue.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 Issue.Composite(s.ast, s.oinput, [issue]));
+      }
+    }
+  }
+});
 function mergeChecks(checks, b) {
   if (!checks) {
     return b.checks;
@@ -1619,27 +1585,39 @@ function getCandidateTypes(ast) {
 /** @internal */
 export function collectSentinels(ast) {
   switch (ast._tag) {
+    default:
+      return [];
     case "Declaration":
       {
         const s = ast.annotations?.["~sentinels"];
-        return Array.isArray(s) && s.length ? s : undefined;
+        return Array.isArray(s) ? s : [];
       }
     case "Objects":
-      {
-        const v = ast.propertySignatures.flatMap(ps => isLiteral(ps.type) && !isOptional(ps.type) ? [{
-          key: ps.name,
-          literal: ps.type.literal
-        }] : []);
-        return v.length ? v : undefined;
-      }
+      return ast.propertySignatures.flatMap(ps => {
+        const type = ps.type;
+        if (!isOptional(type)) {
+          if (isLiteral(type)) {
+            return [{
+              key: ps.name,
+              literal: type.literal
+            }];
+          }
+          if (isUniqueSymbol(type)) {
+            return [{
+              key: ps.name,
+              literal: type.symbol
+            }];
+          }
+        }
+        return [];
+      });
     case "Arrays":
-      {
-        const v = ast.elements.flatMap((e, i) => isLiteral(e) && !isOptional(e) ? [{
+      return ast.elements.flatMap((e, i) => {
+        return isLiteral(e) && !isOptional(e) ? [{
           key: i,
           literal: e.literal
-        }] : []);
-        return v.length ? v : undefined;
-      }
+        }] : [];
+      });
     case "Suspend":
       return collectSentinels(ast.thunk());
   }
@@ -1657,7 +1635,7 @@ function getIndex(types) {
     // by-type (always filled – cheap primary filter)
     idx.byType ??= {};
     for (const t of types) (idx.byType[t] ??= []).push(a);
-    if (sentinels?.length) {
+    if (sentinels.length > 0) {
       // discriminated variants
       idx.bySentinel ??= new Map();
       for (const {
@@ -1753,48 +1731,31 @@ export class Union extends Base {
   getParser(recur) {
     // oxlint-disable-next-line @typescript-eslint/no-this-alias
     const ast = this;
-    return Effect.fnUntracedEager(function* (oinput, options) {
+    return (oinput, options) => {
       if (oinput._tag === "None") {
-        return oinput;
+        return Effect.succeed(oinput);
       }
       const input = oinput.value;
-      const oneOf = ast.mode === "oneOf";
       const candidates = getCandidates(input, ast.types);
-      let issues;
-      const tracking = {
+      const state = {
+        ast,
+        recur,
+        oinput,
+        input,
         out: undefined,
-        successes: []
+        successes: [],
+        issues: undefined,
+        options
       };
-      for (let i = 0; i < candidates.length; i++) {
-        const candidate = candidates[i];
-        const parser = recur(candidate);
-        const eff = parser(oinput, options);
-        const exit = effectIsExit(eff) ? eff : yield* Effect.exit(eff);
-        if (exit._tag === "Failure") {
-          const issueResult = Cause.findError(exit.cause);
-          if (Result.isFailure(issueResult)) {
-            return yield* exit;
-          }
-          if (issues) issues.push(issueResult.success);else issues = [issueResult.success];
-          continue;
-        } else {
-          if (tracking.out && oneOf) {
-            tracking.successes.push(candidate);
-            return yield* Effect.fail(new Issue.OneOf(ast, input, tracking.successes));
-          }
-          tracking.out = exit.value;
-          tracking.successes.push(candidate);
-          if (!oneOf) {
-            break;
-          }
-        }
-      }
-      if (tracking.out) {
-        return tracking.out;
-      } else {
-        return yield* Effect.fail(new Issue.AnyOf(ast, input, issues ?? []));
+      const concurrency = resolveConcurrency(options?.concurrency);
+      const eff = parseUnion(state, candidates, concurrency);
+      if (!eff) {
+        return state.out ? Effect.succeed(state.out) : Effect.fail(new Issue.AnyOf(ast, input, state.issues ?? []));
       }
-    });
+      return Effect.flatMap(eff, _ => {
+        return state.out ? Effect.succeed(state.out) : Effect.fail(new Issue.AnyOf(ast, input, state.issues ?? []));
+      });
+    };
   }
   /** @internal */
   recur(recur) {
@@ -1831,6 +1792,31 @@ export class Union extends Base {
     return Array.from(new Set(types)).join(" | ");
   }
 }
+const parseUnion = /*#__PURE__*/iterateEager()({
+  onItem(s, ast) {
+    const parser = s.recur(ast);
+    return parser(s.oinput, s.options);
+  },
+  step(s, candidate, exit) {
+    if (exit._tag === "Failure") {
+      const issueResult = Cause.findError(exit.cause);
+      if (Result.isFailure(issueResult)) {
+        return exit;
+      }
+      if (s.issues) s.issues.push(issueResult.success);else s.issues = [issueResult.success];
+    } else {
+      if (s.out && s.ast.mode === "oneOf") {
+        s.successes.push(candidate);
+        return Exit.fail(new Issue.OneOf(s.ast, s.input, s.successes));
+      }
+      s.out = exit.value;
+      s.successes.push(candidate);
+      if (s.ast.mode === "anyOf") {
+        return Exit.void;
+      }
+    }
+  }
+});
 const nonFiniteLiterals = /*#__PURE__*/new Union([/*#__PURE__*/new Literal("Infinity"), /*#__PURE__*/new Literal("-Infinity"), /*#__PURE__*/new Literal("NaN")], "anyOf");
 const numberToJson = /*#__PURE__*/new Link(/*#__PURE__*/new Union([number, nonFiniteLiterals], "anyOf"), /*#__PURE__*/new Transformation.Transformation(/*#__PURE__*/Getter.Number(), /*#__PURE__*/Getter.transform(n => globalThis.Number.isFinite(n) ? n : globalThis.String(n))));
 function formatIsMutable(isMutable) {
@@ -1869,9 +1855,9 @@ export function memoizeThunk(f) {
  *   readonly children: ReadonlyArray<Category>
  * }
  *
- * const Category: Schema.Schema<Category> = Schema.Struct({
+ * const Category = Schema.Struct({
  *   name: Schema.String,
- *   children: Schema.Array(Schema.suspend(() => Category))
+ *   children: Schema.Array(Schema.suspend((): Schema.Codec<Category> => Category))
  * })
  *
  * // The recursive branch is a Suspend node
@@ -1990,7 +1976,7 @@ export class FilterGroup extends Pipeable.Class {
 }
 /** @internal */
 export function makeFilter(filter, annotations, aborted = false) {
-  return new Filter((input, ast, options) => Issue.make(input, filter(input, ast, options)), annotations, aborted);
+  return new Filter((input, ast, options) => Issue.make(input, ast, filter(input, ast, options)), annotations, aborted);
 }
 /** @internal */
 export function makeFilterByGuard(is, annotations) {
@@ -2057,6 +2043,10 @@ export function replaceContext(ast, context) {
   });
 }
 /** @internal */
+export function getLastEncoding(ast) {
+  return ast.encoding ? getLastEncoding(ast.encoding[ast.encoding.length - 1].to) : ast;
+}
+/** @internal */
 export function annotate(ast, annotations) {
   if (ast.checks) {
     const last = ast.checks[ast.checks.length - 1];
@@ -2161,20 +2151,8 @@ export function mutableKey(ast) {
   return mutableKeyLastLink(replaceContext(ast, context));
 }
 /** @internal */
-export function withConstructorDefault(ast,
-/**
- * The `input` parameters is `None` if the value is not present and
- * `Some(undefined)` if the value is present but undefined
- */
-defaultValue) {
-  const transformation = new Transformation.Transformation(new Getter.Getter(o => {
-    if (Option.isNone(Option.filter(o, Predicate.isNotUndefined))) {
-      const oe = defaultValue(o);
-      return Effect.isEffect(oe) ? oe : Effect.succeed(oe);
-    } else {
-      return Effect.succeed(o);
-    }
-  }), Getter.passthrough());
+export function withConstructorDefault(ast, defaultValue) {
+  const transformation = new Transformation.Transformation(Getter.withDefault(defaultValue), Getter.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);
   return replaceContext(ast, context);
@@ -2500,8 +2478,10 @@ export function isStringBigInt(annotations) {
   });
 }
 /** @internal */
-export const bigIntString = /*#__PURE__*/appendChecks(string, [/*#__PURE__*/isStringBigInt()]);
-const bigIntToString = /*#__PURE__*/new Link(bigIntString, /*#__PURE__*/new Transformation.Transformation(/*#__PURE__*/Getter.transform(globalThis.BigInt), /*#__PURE__*/Getter.String()));
+export const bigIntString = /*#__PURE__*/appendChecks(string, [/*#__PURE__*/isStringBigInt({
+  expected: "a string representing a bigint"
+})]);
+const bigIntToString = /*#__PURE__*/new Link(bigIntString, Transformation.bigintFromString);
 const REGEXP_PATTERN = "Symbol\\((.*)\\)";
 const isStringSymbolRegExp = /*#__PURE__*/new globalThis.RegExp(`^${REGEXP_PATTERN}$`);
 /** @internal */
@@ -2630,4 +2610,107 @@ export const resolveTitle = InternalAnnotations.resolveTitle;
  * @since 4.0.0
  */
 export const resolveDescription = InternalAnnotations.resolveDescription;
+/**
+ * Returns true if the value is a JSON value.
+ *
+ * When a cyclic reference is detected, returns false.
+ *
+ * @internal
+ */
+export function isJson(u) {
+  // `onPath` is the current recursion stack: nodes between the root and the
+  // one being visited. A hit here means we looped back to an ancestor — a
+  // real cycle, not a DAG — so the value is not JSON.
+  const onPath = new Set();
+  // `validated` memoizes subtrees we've already fully checked. Without it, a
+  // diamond-shaped DAG (same node reached through multiple parents) would be
+  // re-traversed once per parent, which is exponential in the nesting depth.
+  const validated = new Set();
+  return recur(u);
+  function recur(u) {
+    if (u === null || typeof u === "string" || typeof u === "boolean") {
+      return true;
+    }
+    if (typeof u === "number") {
+      return globalThis.Number.isFinite(u);
+    }
+    if (typeof u !== "object" || u === undefined) {
+      return false;
+    }
+    if (onPath.has(u)) {
+      return false;
+    }
+    if (validated.has(u)) {
+      return true;
+    }
+    onPath.add(u);
+    const ok = Array.isArray(u) ? u.every(recur) : Object.keys(u).every(key => recur(u[key]));
+    // Pop on exit so siblings reaching the same node via a different path
+    // don't see it as an ancestor (that would reject valid DAGs).
+    onPath.delete(u);
+    if (ok) {
+      validated.add(u);
+    }
+    return ok;
+  }
+}
+/** @internal */
+export const Json = /*#__PURE__*/new Declaration([], () => (input, ast) => isJson(input) ? Effect.succeed(input) : Effect.fail(new Issue.InvalidType(ast, Option.some(input))), {
+  typeConstructor: {
+    _tag: "effect/Json"
+  },
+  generation: {
+    runtime: `Schema.Json`,
+    Type: `Schema.Json`
+  },
+  expected: "JSON value",
+  toCodecJson: () => new Link(unknown, Transformation.passthrough())
+});
+/** @internal */
+export const MutableJson = /*#__PURE__*/annotate(Json, {
+  typeConstructor: {
+    _tag: "effect/MutableJson"
+  },
+  generation: {
+    runtime: `Schema.MutableJson`,
+    Type: `Schema.MutableJson`
+  }
+});
+/** @internal */
+export const unknownToNull = /*#__PURE__*/new Link(null_, /*#__PURE__*/new Transformation.Transformation(/*#__PURE__*/Getter.passthrough(), /*#__PURE__*/Getter.transform(() => null)));
+/** @internal */
+export const unknownToJson = /*#__PURE__*/new Link(Json, /*#__PURE__*/Transformation.passthrough());
+/**
+ * Returns true if the value is a StringTree value.
+ *
+ * When a cyclic reference is detected, returns false.
+ *
+ * @internal
+ */
+export function isStringTree(u) {
+  const seen = new Set();
+  return recur(u);
+  function recur(u) {
+    if (u === undefined || typeof u === "string") {
+      return true;
+    }
+    if (typeof u !== "object" || u === null) {
+      return false;
+    }
+    if (seen.has(u)) {
+      return false;
+    }
+    seen.add(u);
+    if (Array.isArray(u)) {
+      return u.every(recur);
+    }
+    return Object.keys(u).every(key => recur(u[key]));
+  }
+}
+const StringTree = /*#__PURE__*/new Declaration([], () => (input, ast) => isStringTree(input) ? Effect.succeed(input) : Effect.fail(new Issue.InvalidType(ast, Option.some(input))), {
+  expected: "StringTree",
+  toCodecStringTree: () => new Link(unknown, Transformation.passthrough())
+});
+/** @internal */
+export const unknownToStringTree = /*#__PURE__*/new Link(StringTree, /*#__PURE__*/Transformation.passthrough());
 //# sourceMappingURL=SchemaAST.js.map