effect 4.0.0-beta.101 → 4.0.0-beta.102

package/dist/Schema.js

@@ -30,10 +30,11 @@ import * as HashSet_ from "./HashSet.js";
 import * as core from "./internal/core.js";
 import * as InternalRecord from "./internal/record.js";
 import * as InternalAnnotations from "./internal/schema/annotations.js";
-import * as InternalArbitrary from "./internal/schema/arbitrary.js";
-import * as InternalEquivalence from "./internal/schema/equivalence.js";
-import * as InternalStandard from "./internal/schema/representation.js";
 import * as InternalSchema from "./internal/schema/schema.js";
+import * as InternalArbitrary from "./internal/schema/toArbitrary.js";
+import * as InternalEquivalence from "./internal/schema/toEquivalence.js";
+import * as InternalToJsonSchemaDocument from "./internal/schema/toJsonSchemaDocument.js";
+import * as InternalToRepresentation from "./internal/schema/toRepresentation.js";
 import * as JsonPatch from "./JsonPatch.js";
 import * as JsonSchema from "./JsonSchema.js";
 import { remainder } from "./Number.js";
@@ -44,6 +45,7 @@ import * as Pipeable from "./Pipeable.js";
 import * as Predicate from "./Predicate.js";
 import * as Record_ from "./Record.js";
 import * as Redacted_ from "./Redacted.js";
+import * as RegExp_ from "./RegExp.js";
 import * as Result_ from "./Result.js";
 import * as Scheduler from "./Scheduler.js";
 import * as SchemaAST from "./SchemaAST.js";
@@ -195,7 +197,7 @@ export function revealBottom(bottom) {
  * ```ts
  * import { Schema } from "effect"
  *
- * const Age = Schema.Number.pipe(
+ * const Age = Schema.Natural.pipe(
  *   Schema.annotate({
  *     title: "Age",
  *     description: "A non-negative integer representing age in years"
@@ -407,7 +409,7 @@ function makeStandardResult(exit) {
  * // Create a standard schema from a regular schema
  * const PersonSchema = Schema.Struct({
  *   name: Schema.NonEmptyString,
- *   age: Schema.Number.check(Schema.isBetween({ minimum: 0, maximum: 150 }))
+ *   age: Schema.Finite.check(Schema.isBetween({ minimum: 0, maximum: 150 }))
  * })
  *
  * const standardSchema = Schema.toStandardSchemaV1(PersonSchema, {
@@ -1395,32 +1397,6 @@ export const encodeSync = encodeUnknownSync;
  * @since 3.10.0
  */
 export const make = InternalSchema.make;
-/**
- * Transforms a schema into a class that can be extended with `extends`. The
- * resulting class inherits the full schema API (e.g. `annotate`) and can define
- * static methods that reference `this`.
- *
- * **Example** (Wrapping a primitive schema)
- *
- * ```ts
- * import { Schema } from "effect"
- *
- * class MyString extends Schema.asClass(Schema.String) {
- *   static readonly decodeUnknownSync = Schema.decodeUnknownSync(this)
- * }
- *
- * console.log(MyString.decodeUnknownSync("a"))
- * // "a"
- * ```
- *
- * @category constructors
- * @since 4.0.0
- */
-export function asClass(schema) {
-  // oxlint-disable-next-line @typescript-eslint/no-extraneous-class
-  class Class {}
-  return Object.setPrototypeOf(Class, schema);
-}
 /**
  * Checks whether a value is a `Schema`.
  *
@@ -1946,8 +1922,8 @@ const canonicalPropertyKey = key => typeof key === "symbol" ? key : globalThis.S
 export function encodeKeys(mapping) {
   return function (self) {
     const fields = {};
-    const appliedMapping = {};
-    const reverseMapping = {};
+    const appliedMapping = Object.create(null);
+    const reverseMapping = Object.create(null);
     const seenEncodedKeys = new Set();
     for (const k of Reflect.ownKeys(self.fields)) {
       const encoded = toEncoded(self.fields[k]);
@@ -1958,7 +1934,7 @@ export function encodeKeys(mapping) {
         throw new globalThis.Error(`Duplicate encoded keys: ${formatPropertyKey(encodedKey)}`);
       }
       seenEncodedKeys.add(canonical);
-      fields[encodedKey] = encoded;
+      InternalRecord.assignProperty(fields, encodedKey, encoded);
       if (hasMapping) {
         appliedMapping[k] = encodedKey;
         reverseMapping[encodedKey] = k;
@@ -2019,7 +1995,7 @@ derive) {
           const f = derive[k];
           const o = f(input);
           if (Option_.isSome(o)) {
-            out[k] = o.value;
+            InternalRecord.assignProperty(out, k, o.value);
           }
         }
         return out;
@@ -2416,7 +2392,7 @@ export function suspend(f) {
  * ```ts
  * import { Schema } from "effect"
  *
- * const AgeSchema = Schema.Number.pipe(
+ * const AgeSchema = Schema.Finite.pipe(
  *   Schema.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(120))
  * )
  * ```
@@ -3082,8 +3058,8 @@ export function toTaggedUnion(tag) {
           }
           discriminantKeys.add(key);
           discriminants.push(literal);
-          InternalRecord.set(cases, literal, schema);
-          InternalRecord.set(guards, literal, is(toType(schema)));
+          InternalRecord.assignProperty(cases, literal, schema);
+          InternalRecord.assignProperty(guards, literal, is(toType(schema)));
           return;
         }
       }
@@ -3093,12 +3069,16 @@ export function toTaggedUnion(tag) {
       if (arguments.length === 1) {
         const cases = arguments[0];
         return function (value) {
-          return cases[value[tag]](value);
+          const key = value[tag];
+          const handler = Object.hasOwn(cases, key) ? cases[key] : undefined;
+          return handler(value);
         };
       }
       const value = arguments[0];
       const cases = arguments[1];
-      return cases[value[tag]](value);
+      const key = value[tag];
+      const handler = Object.hasOwn(cases, key) ? cases[key] : undefined;
+      return handler(value);
     }
   };
 }
@@ -3132,7 +3112,9 @@ export function TaggedUnion(casesByTag) {
   const cases = {};
   const members = [];
   for (const key of Object.keys(casesByTag)) {
-    members.push(cases[key] = TaggedStruct(key, casesByTag[key]));
+    const member = TaggedStruct(key, casesByTag[key]);
+    InternalRecord.assignProperty(cases, key, member);
+    members.push(member);
   }
   const union = Union(members);
   const {
@@ -3173,9 +3155,7 @@ export function TaggedUnion(casesByTag) {
  */
 export function Opaque() {
   return schema => {
-    // oxlint-disable-next-line @typescript-eslint/no-extraneous-class
-    class Opaque {}
-    return Object.setPrototypeOf(Opaque, schema);
+    return schema;
   };
 }
 /**
@@ -3283,6 +3263,11 @@ export const makeFilter = SchemaAST.makeFilter;
 export function makeFilterGroup(checks, annotations = undefined) {
   return new SchemaAST.FilterGroup(checks, annotations);
 }
+function makeFixedDeclarationReviver(id, schema) {
+  return InternalSchema.makeDeclarationReviver(id, Null, ({
+    annotations
+  }) => annotations === undefined ? schema : schema.annotate(annotations));
+}
 const TRIMMED_PATTERN = "^\\S[\\s\\S]*\\S$|^\\S$|^$";
 /**
  * Validates that a string has no leading or trailing whitespace.
@@ -3303,12 +3288,19 @@ const TRIMMED_PATTERN = "^\\S[\\s\\S]*\\S$|^\\S$|^$";
  * @since 4.0.0
  */
 export function isTrimmed(annotations) {
+  const regExp = new globalThis.RegExp(TRIMMED_PATTERN);
   return makeFilter(s => s.trim() === s, {
     expected: "a string with no leading or trailing whitespace",
-    meta: {
-      _tag: "isTrimmed",
-      regExp: new globalThis.RegExp(TRIMMED_PATTERN)
+    representation: {
+      id: "effect/schema/isTrimmed",
+      payload: null
     },
+    toJsonSchema: () => ({
+      pattern: regExp.source
+    }),
+    toCode: () => ({
+      runtime: "Schema.isTrimmed()"
+    }),
     arbitrary: {
       constraint: {
         patterns: [TRIMMED_PATTERN]
@@ -3317,6 +3309,21 @@ export function isTrimmed(annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isTrimmed` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isTrimmed}.
+ *
+ * @see {@link isTrimmed} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isTrimmedReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isTrimmed", Null, ({
+  annotations
+}) => isTrimmed(annotations));
 /**
  * Validates that a string matches the specified regular expression pattern.
  *
@@ -3334,7 +3341,44 @@ export function isTrimmed(annotations) {
  * @category String checks
  * @since 4.0.0
  */
-export const isPattern = SchemaAST.isPattern;
+export function isPattern(regExp, annotations) {
+  const source = regExp.source;
+  const flags = regExp.flags;
+  const runtimeRegExp = flags === "" ? `new RegExp(${format(source)})` : `new RegExp(${format(source)}, ${format(flags)})`;
+  return SchemaAST.isPattern(regExp, {
+    toCode: () => ({
+      runtime: `Schema.isPattern(${runtimeRegExp})`
+    }),
+    ...annotations
+  });
+}
+const IsPatternPayload = /*#__PURE__*/Struct({
+  source: String,
+  flags: String
+}).check(/*#__PURE__*/makeFilter(payload => {
+  const result = Result_.try(() => new globalThis.RegExp(payload.source, payload.flags));
+  return Result_.isSuccess(result) && result.success.source === payload.source && result.success.flags === payload.flags;
+}));
+/**
+ * Reviver for persisted `isPattern` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isPattern}.
+ *
+ * @see {@link isPattern} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isPatternReviver = {
+  id: "effect/schema/isPattern",
+  payloadSchema: IsPatternPayload,
+  revive: ({
+    annotations,
+    payload
+  }) => isPattern(new globalThis.RegExp(payload.source, payload.flags), annotations)
+};
 /**
  * Validates that a string represents a finite number.
  *
@@ -3353,7 +3397,29 @@ export const isPattern = SchemaAST.isPattern;
  * @category String checks
  * @since 4.0.0
  */
-export const isStringFinite = SchemaAST.isStringFinite;
+export function isStringFinite(annotations) {
+  return SchemaAST.isStringFinite({
+    toCode: () => ({
+      runtime: "Schema.isStringFinite()"
+    }),
+    ...annotations
+  });
+}
+/**
+ * Reviver for persisted `isStringFinite` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isStringFinite}.
+ *
+ * @see {@link isStringFinite} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isStringFiniteReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isStringFinite", Null, ({
+  annotations
+}) => isStringFinite(annotations));
 /**
  * Validates that a string is a signed base-10 integer literal for Effect's
  * BigInt string encoding.
@@ -3371,7 +3437,29 @@ export const isStringFinite = SchemaAST.isStringFinite;
  * @category String checks
  * @since 4.0.0
  */
-export const isStringBigInt = SchemaAST.isStringBigInt;
+export function isStringBigInt(annotations) {
+  return SchemaAST.isStringBigInt({
+    toCode: () => ({
+      runtime: "Schema.isStringBigInt()"
+    }),
+    ...annotations
+  });
+}
+/**
+ * Reviver for persisted `isStringBigInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isStringBigInt}.
+ *
+ * @see {@link isStringBigInt} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isStringBigIntReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isStringBigInt", Null, ({
+  annotations
+}) => isStringBigInt(annotations));
 /**
  * Validates that a string has the `Symbol(description)` format used by Effect's
  * symbol string encoding.
@@ -3384,7 +3472,29 @@ export const isStringBigInt = SchemaAST.isStringBigInt;
  * @category String checks
  * @since 4.0.0
  */
-export const isStringSymbol = SchemaAST.isStringSymbol;
+export function isStringSymbol(annotations) {
+  return SchemaAST.isStringSymbol({
+    toCode: () => ({
+      runtime: "Schema.isStringSymbol()"
+    }),
+    ...annotations
+  });
+}
+/**
+ * Reviver for persisted `isStringSymbol` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isStringSymbol}.
+ *
+ * @see {@link isStringSymbol} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isStringSymbolReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isStringSymbol", Null, ({
+  annotations
+}) => isStringSymbol(annotations));
 /**
  * Returns a RegExp for validating an RFC 9562 / RFC 4122 UUID.
  *
@@ -3430,14 +3540,40 @@ export function isUUID(version, annotations) {
   const regExp = getUUIDRegExp(version);
   return isPattern(regExp, {
     expected: version ? `a UUID v${version}` : "a UUID",
-    meta: {
-      _tag: "isUUID",
-      regExp,
-      version
+    representation: {
+      id: "effect/schema/isUUID",
+      payload: {
+        version: version ?? null
+      }
     },
+    toJsonSchema: () => ({
+      pattern: regExp.source,
+      format: "uuid"
+    }),
+    toCode: () => ({
+      runtime: version === undefined ? "Schema.isUUID()" : `Schema.isUUID(${version})`
+    }),
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isUUID` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isUUID}.
+ *
+ * @see {@link isUUID} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isUUIDReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isUUID", /*#__PURE__*/Struct({
+  version: /*#__PURE__*/Union([/*#__PURE__*/Literals([1, 2, 3, 4, 5, 6, 7, 8]), Null])
+}), ({
+  annotations,
+  payload
+}) => isUUID(payload.version ?? undefined, annotations));
 const GUID_REGEXP = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
 /**
  * Validates that a string has the GUID / UUID textual shape.
@@ -3466,13 +3602,34 @@ const GUID_REGEXP = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{
 export function isGUID(annotations) {
   return isPattern(GUID_REGEXP, {
     expected: "a GUID",
-    meta: {
-      _tag: "isGUID",
-      regExp: GUID_REGEXP
+    representation: {
+      id: "effect/schema/isGUID",
+      payload: null
     },
+    toJsonSchema: () => ({
+      pattern: GUID_REGEXP.source
+    }),
+    toCode: () => ({
+      runtime: "Schema.isGUID()"
+    }),
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isGUID` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isGUID}.
+ *
+ * @see {@link isGUID} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isGUIDReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isGUID", Null, ({
+  annotations
+}) => isGUID(annotations));
 /**
  * Validates that a string is a valid ULID (Universally Unique Lexicographically
  * Sortable Identifier).
@@ -3495,13 +3652,34 @@ export function isGUID(annotations) {
 export function isULID(annotations) {
   const regExp = /^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/;
   return isPattern(regExp, {
-    meta: {
-      _tag: "isULID",
-      regExp
+    representation: {
+      id: "effect/schema/isULID",
+      payload: null
     },
+    toJsonSchema: () => ({
+      pattern: regExp.source
+    }),
+    toCode: () => ({
+      runtime: "Schema.isULID()"
+    }),
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isULID` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isULID}.
+ *
+ * @see {@link isULID} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isULIDReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isULID", Null, ({
+  annotations
+}) => isULID(annotations));
 /**
  * Validates that a string is valid Base64 encoded data.
  *
@@ -3524,13 +3702,34 @@ export function isBase64(annotations) {
   const regExp = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
   return isPattern(regExp, {
     expected: "a base64 encoded string",
-    meta: {
-      _tag: "isBase64",
-      regExp
+    representation: {
+      id: "effect/schema/isBase64",
+      payload: null
     },
+    toJsonSchema: () => ({
+      pattern: regExp.source
+    }),
+    toCode: () => ({
+      runtime: "Schema.isBase64()"
+    }),
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isBase64` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isBase64}.
+ *
+ * @see {@link isBase64} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isBase64Reviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isBase64", Null, ({
+  annotations
+}) => isBase64(annotations));
 /**
  * Validates that a string is valid Base64URL encoded data (Base64 with URL-safe
  * characters).
@@ -3554,103 +3753,197 @@ export function isBase64Url(annotations) {
   const regExp = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;
   return isPattern(regExp, {
     expected: "a base64url encoded string",
-    meta: {
-      _tag: "isBase64Url",
-      regExp
+    representation: {
+      id: "effect/schema/isBase64Url",
+      payload: null
     },
+    toJsonSchema: () => ({
+      pattern: regExp.source
+    }),
+    toCode: () => ({
+      runtime: "Schema.isBase64Url()"
+    }),
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isBase64Url` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isBase64Url}.
+ *
+ * @see {@link isBase64Url} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isBase64UrlReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isBase64Url", Null, ({
+  annotations
+}) => isBase64Url(annotations));
 /**
  * Validates at runtime that a string starts with the specified literal prefix.
  *
  * **Details**
  *
- * Notes:
- * The JSON Schema and arbitrary metadata are built from `^${startsWith}` without
- * escaping regexp metacharacters. If the prefix contains regexp syntax, generated
- * patterns may not be equivalent to the runtime `startsWith` check.
+ * RegExp metacharacters in the prefix are escaped in JSON Schema and arbitrary
+ * metadata so that the generated patterns retain literal `startsWith` semantics.
  *
  * @category String checks
  * @since 4.0.0
  */
 export function isStartsWith(startsWith, annotations) {
   const formatted = JSON.stringify(startsWith);
+  const regExp = new globalThis.RegExp(`^${RegExp_.escape(startsWith)}`);
   return makeFilter(s => s.startsWith(startsWith), {
     expected: `a string starting with ${formatted}`,
-    meta: {
-      _tag: "isStartsWith",
-      startsWith,
-      regExp: new globalThis.RegExp(`^${startsWith}`)
+    representation: {
+      id: "effect/schema/isStartsWith",
+      payload: {
+        startsWith
+      }
     },
+    toJsonSchema: () => ({
+      pattern: regExp.source
+    }),
+    toCode: () => ({
+      runtime: `Schema.isStartsWith(${format(startsWith)})`
+    }),
     arbitrary: {
       constraint: {
-        patterns: [`^${startsWith}`]
+        patterns: [regExp.source]
       }
     },
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isStartsWith` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isStartsWith}.
+ *
+ * @see {@link isStartsWith} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isStartsWithReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isStartsWith", /*#__PURE__*/Struct({
+  startsWith: String
+}), ({
+  annotations,
+  payload
+}) => isStartsWith(payload.startsWith, annotations));
 /**
  * Validates at runtime that a string ends with the specified literal suffix.
  *
  * **Details**
  *
- * Notes:
- * The JSON Schema and arbitrary metadata are built from `${endsWith}$` without
- * escaping regexp metacharacters. If the suffix contains regexp syntax, generated
- * patterns may not be equivalent to the runtime `endsWith` check.
+ * RegExp metacharacters in the suffix are escaped in JSON Schema and arbitrary
+ * metadata so that the generated patterns retain literal `endsWith` semantics.
  *
  * @category String checks
  * @since 4.0.0
  */
 export function isEndsWith(endsWith, annotations) {
   const formatted = JSON.stringify(endsWith);
+  const regExp = new globalThis.RegExp(`${RegExp_.escape(endsWith)}$`);
   return makeFilter(s => s.endsWith(endsWith), {
     expected: `a string ending with ${formatted}`,
-    meta: {
-      _tag: "isEndsWith",
-      endsWith,
-      regExp: new globalThis.RegExp(`${endsWith}$`)
+    representation: {
+      id: "effect/schema/isEndsWith",
+      payload: {
+        endsWith
+      }
     },
+    toJsonSchema: () => ({
+      pattern: regExp.source
+    }),
+    toCode: () => ({
+      runtime: `Schema.isEndsWith(${format(endsWith)})`
+    }),
     arbitrary: {
       constraint: {
-        patterns: [`${endsWith}$`]
+        patterns: [regExp.source]
       }
     },
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isEndsWith` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isEndsWith}.
+ *
+ * @see {@link isEndsWith} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isEndsWithReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isEndsWith", /*#__PURE__*/Struct({
+  endsWith: String
+}), ({
+  annotations,
+  payload
+}) => isEndsWith(payload.endsWith, annotations));
 /**
  * Validates at runtime that a string contains the specified literal substring.
  *
  * **Details**
  *
- * Notes:
- * The JSON Schema and arbitrary metadata use the substring as a raw regexp
- * pattern. If the substring contains regexp syntax, generated patterns may not be
- * equivalent to the runtime `includes` check.
+ * RegExp metacharacters in the substring are escaped in JSON Schema and
+ * arbitrary metadata so that the generated patterns retain literal `includes`
+ * semantics.
  *
  * @category String checks
  * @since 4.0.0
  */
 export function isIncludes(includes, annotations) {
   const formatted = JSON.stringify(includes);
+  const regExp = new globalThis.RegExp(RegExp_.escape(includes));
   return makeFilter(s => s.includes(includes), {
     expected: `a string including ${formatted}`,
-    meta: {
-      _tag: "isIncludes",
-      includes,
-      regExp: new globalThis.RegExp(includes)
+    representation: {
+      id: "effect/schema/isIncludes",
+      payload: {
+        includes
+      }
     },
+    toJsonSchema: () => ({
+      pattern: regExp.source
+    }),
+    toCode: () => ({
+      runtime: `Schema.isIncludes(${format(includes)})`
+    }),
     arbitrary: {
       constraint: {
-        patterns: [includes]
+        patterns: [regExp.source]
       }
     },
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isIncludes` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isIncludes}.
+ *
+ * @see {@link isIncludes} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isIncludesReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isIncludes", /*#__PURE__*/Struct({
+  includes: String
+}), ({
+  annotations,
+  payload
+}) => isIncludes(payload.includes, annotations));
 const UPPERCASED_PATTERN = "^[^a-z]*$";
 /**
  * Validates that a string is unchanged by JavaScript's `toUpperCase()`.
@@ -3665,12 +3958,19 @@ const UPPERCASED_PATTERN = "^[^a-z]*$";
  * @since 4.0.0
  */
 export function isUppercased(annotations) {
+  const regExp = new globalThis.RegExp(UPPERCASED_PATTERN);
   return makeFilter(s => s.toUpperCase() === s, {
     expected: "a string with all characters in uppercase",
-    meta: {
-      _tag: "isUppercased",
-      regExp: new globalThis.RegExp(UPPERCASED_PATTERN)
+    representation: {
+      id: "effect/schema/isUppercased",
+      payload: null
     },
+    toJsonSchema: () => ({
+      pattern: regExp.source
+    }),
+    toCode: () => ({
+      runtime: "Schema.isUppercased()"
+    }),
     arbitrary: {
       constraint: {
         patterns: [UPPERCASED_PATTERN]
@@ -3679,6 +3979,21 @@ export function isUppercased(annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isUppercased` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isUppercased}.
+ *
+ * @see {@link isUppercased} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isUppercasedReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isUppercased", Null, ({
+  annotations
+}) => isUppercased(annotations));
 const LOWERCASED_PATTERN = "^[^A-Z]*$";
 /**
  * Validates that a string is unchanged by JavaScript's `toLowerCase()`.
@@ -3693,12 +4008,19 @@ const LOWERCASED_PATTERN = "^[^A-Z]*$";
  * @since 4.0.0
  */
 export function isLowercased(annotations) {
+  const regExp = new globalThis.RegExp(LOWERCASED_PATTERN);
   return makeFilter(s => s.toLowerCase() === s, {
     expected: "a string with all characters in lowercase",
-    meta: {
-      _tag: "isLowercased",
-      regExp: new globalThis.RegExp(LOWERCASED_PATTERN)
+    representation: {
+      id: "effect/schema/isLowercased",
+      payload: null
     },
+    toJsonSchema: () => ({
+      pattern: regExp.source
+    }),
+    toCode: () => ({
+      runtime: "Schema.isLowercased()"
+    }),
     arbitrary: {
       constraint: {
         patterns: [LOWERCASED_PATTERN]
@@ -3707,6 +4029,21 @@ export function isLowercased(annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isLowercased` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isLowercased}.
+ *
+ * @see {@link isLowercased} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isLowercasedReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isLowercased", Null, ({
+  annotations
+}) => isLowercased(annotations));
 const CAPITALIZED_PATTERN = "^[^a-z]?.*$";
 /**
  * Validates that the first character of a string is unchanged by
@@ -3721,12 +4058,19 @@ const CAPITALIZED_PATTERN = "^[^a-z]?.*$";
  * @since 4.0.0
  */
 export function isCapitalized(annotations) {
+  const regExp = new globalThis.RegExp(CAPITALIZED_PATTERN);
   return makeFilter(s => s.charAt(0).toUpperCase() === s.charAt(0), {
     expected: "a string with the first character in uppercase",
-    meta: {
-      _tag: "isCapitalized",
-      regExp: new globalThis.RegExp(CAPITALIZED_PATTERN)
+    representation: {
+      id: "effect/schema/isCapitalized",
+      payload: null
     },
+    toJsonSchema: () => ({
+      pattern: regExp.source
+    }),
+    toCode: () => ({
+      runtime: "Schema.isCapitalized()"
+    }),
     arbitrary: {
       constraint: {
         patterns: [CAPITALIZED_PATTERN]
@@ -3735,6 +4079,21 @@ export function isCapitalized(annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isCapitalized` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isCapitalized}.
+ *
+ * @see {@link isCapitalized} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isCapitalizedReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isCapitalized", Null, ({
+  annotations
+}) => isCapitalized(annotations));
 const UNCAPITALIZED_PATTERN = "^[^A-Z]?.*$";
 /**
  * Validates that the first character of a string is unchanged by
@@ -3749,12 +4108,19 @@ const UNCAPITALIZED_PATTERN = "^[^A-Z]?.*$";
  * @since 4.0.0
  */
 export function isUncapitalized(annotations) {
+  const regExp = new globalThis.RegExp(UNCAPITALIZED_PATTERN);
   return makeFilter(s => s.charAt(0).toLowerCase() === s.charAt(0), {
     expected: "a string with the first character in lowercase",
-    meta: {
-      _tag: "isUncapitalized",
-      regExp: new globalThis.RegExp(UNCAPITALIZED_PATTERN)
+    representation: {
+      id: "effect/schema/isUncapitalized",
+      payload: null
     },
+    toJsonSchema: () => ({
+      pattern: regExp.source
+    }),
+    toCode: () => ({
+      runtime: "Schema.isUncapitalized()"
+    }),
     arbitrary: {
       constraint: {
         patterns: [UNCAPITALIZED_PATTERN]
@@ -3763,6 +4129,28 @@ export function isUncapitalized(annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isUncapitalized` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isUncapitalized}.
+ *
+ * @see {@link isUncapitalized} for creating the corresponding check
+ *
+ * @category String checks
+ * @since 4.0.0
+ */
+export const isUncapitalizedReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isUncapitalized", Null, ({
+  annotations
+}) => isUncapitalized(annotations));
+/**
+ * Schema for finite numbers, rejecting `NaN`, `Infinity`, and `-Infinity`.
+ *
+ * @category Number
+ * @since 3.10.0
+ */
+export const Finite = /*#__PURE__*/make(SchemaAST.finite);
 /**
  * Validates that a number is finite (not `Infinity`, `-Infinity`, or `NaN`).
  *
@@ -3781,21 +4169,22 @@ export function isUncapitalized(annotations) {
  * @category Number checks
  * @since 4.0.0
  */
-export function isFinite(annotations) {
-  return makeFilter(n => globalThis.Number.isFinite(n), {
-    expected: "a finite number",
-    meta: {
-      _tag: "isFinite"
-    },
-    arbitrary: {
-      constraint: {
-        noInfinity: true,
-        noNaN: true
-      }
-    },
-    ...annotations
-  });
-}
+export const isFinite = SchemaAST.isFinite;
+/**
+ * Reviver for persisted `isFinite` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isFinite}.
+ *
+ * @see {@link isFinite} for creating the corresponding check
+ *
+ * @category Number checks
+ * @since 4.0.0
+ */
+export const isFiniteReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isFinite", Null, ({
+  annotations
+}) => isFinite(annotations));
 /**
  * Creates a greater-than (`>`) check for any ordered type from an
  * `Order.Order` instance.
@@ -3957,6 +4346,12 @@ export function makeIsMultipleOf(options) {
     });
   };
 }
+function encodeNumberPayload(number) {
+  if (!globalThis.Number.isFinite(number)) {
+    throw new globalThis.RangeError(`Expected a finite number, got ${format(number)}`);
+  }
+  return number;
+}
 /**
  * Validates that a number is greater than the specified value (exclusive).
  *
@@ -3978,12 +4373,38 @@ export function makeIsMultipleOf(options) {
 export const isGreaterThan = /*#__PURE__*/makeIsGreaterThan({
   order: Order.Number,
   annotate: exclusiveMinimum => ({
-    meta: {
-      _tag: "isGreaterThan",
+    representation: {
+      id: "effect/schema/isGreaterThan",
+      payload: {
+        exclusiveMinimum: encodeNumberPayload(exclusiveMinimum)
+      }
+    },
+    toJsonSchema: () => ({
       exclusiveMinimum
-    }
+    }),
+    toCode: () => ({
+      runtime: `Schema.isGreaterThan(${format(exclusiveMinimum)})`
+    })
   })
 });
+/**
+ * Reviver for persisted `isGreaterThan` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isGreaterThan}.
+ *
+ * @see {@link isGreaterThan} for creating the corresponding check
+ *
+ * @category Number checks
+ * @since 4.0.0
+ */
+export const isGreaterThanReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isGreaterThan", /*#__PURE__*/Struct({
+  exclusiveMinimum: Finite
+}), ({
+  annotations,
+  payload
+}) => isGreaterThan(payload.exclusiveMinimum, annotations));
 /**
  * Validates that a number is greater than or equal to the specified value
  * (inclusive).
@@ -4005,12 +4426,38 @@ export const isGreaterThan = /*#__PURE__*/makeIsGreaterThan({
 export const isGreaterThanOrEqualTo = /*#__PURE__*/makeIsGreaterThanOrEqualTo({
   order: Order.Number,
   annotate: minimum => ({
-    meta: {
-      _tag: "isGreaterThanOrEqualTo",
+    representation: {
+      id: "effect/schema/isGreaterThanOrEqualTo",
+      payload: {
+        minimum: encodeNumberPayload(minimum)
+      }
+    },
+    toJsonSchema: () => ({
       minimum
-    }
+    }),
+    toCode: () => ({
+      runtime: `Schema.isGreaterThanOrEqualTo(${format(minimum)})`
+    })
   })
 });
+/**
+ * Reviver for persisted `isGreaterThanOrEqualTo` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isGreaterThanOrEqualTo}.
+ *
+ * @see {@link isGreaterThanOrEqualTo} for creating the corresponding check
+ *
+ * @category Number checks
+ * @since 4.0.0
+ */
+export const isGreaterThanOrEqualToReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isGreaterThanOrEqualTo", /*#__PURE__*/Struct({
+  minimum: Finite
+}), ({
+  annotations,
+  payload
+}) => isGreaterThanOrEqualTo(payload.minimum, annotations));
 /**
  * Validates that a number is less than the specified value (exclusive).
  *
@@ -4032,12 +4479,38 @@ export const isGreaterThanOrEqualTo = /*#__PURE__*/makeIsGreaterThanOrEqualTo({
 export const isLessThan = /*#__PURE__*/makeIsLessThan({
   order: Order.Number,
   annotate: exclusiveMaximum => ({
-    meta: {
-      _tag: "isLessThan",
+    representation: {
+      id: "effect/schema/isLessThan",
+      payload: {
+        exclusiveMaximum: encodeNumberPayload(exclusiveMaximum)
+      }
+    },
+    toJsonSchema: () => ({
       exclusiveMaximum
-    }
+    }),
+    toCode: () => ({
+      runtime: `Schema.isLessThan(${format(exclusiveMaximum)})`
+    })
   })
 });
+/**
+ * Reviver for persisted `isLessThan` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isLessThan}.
+ *
+ * @see {@link isLessThan} for creating the corresponding check
+ *
+ * @category Number checks
+ * @since 4.0.0
+ */
+export const isLessThanReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isLessThan", /*#__PURE__*/Struct({
+  exclusiveMaximum: Finite
+}), ({
+  annotations,
+  payload
+}) => isLessThan(payload.exclusiveMaximum, annotations));
 /**
  * Validates that a number is less than or equal to the specified value
  * (inclusive).
@@ -4059,12 +4532,38 @@ export const isLessThan = /*#__PURE__*/makeIsLessThan({
 export const isLessThanOrEqualTo = /*#__PURE__*/makeIsLessThanOrEqualTo({
   order: Order.Number,
   annotate: maximum => ({
-    meta: {
-      _tag: "isLessThanOrEqualTo",
+    representation: {
+      id: "effect/schema/isLessThanOrEqualTo",
+      payload: {
+        maximum: encodeNumberPayload(maximum)
+      }
+    },
+    toJsonSchema: () => ({
       maximum
-    }
+    }),
+    toCode: () => ({
+      runtime: `Schema.isLessThanOrEqualTo(${format(maximum)})`
+    })
   })
 });
+/**
+ * Reviver for persisted `isLessThanOrEqualTo` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isLessThanOrEqualTo}.
+ *
+ * @see {@link isLessThanOrEqualTo} for creating the corresponding check
+ *
+ * @category Number checks
+ * @since 4.0.0
+ */
+export const isLessThanOrEqualToReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isLessThanOrEqualTo", /*#__PURE__*/Struct({
+  maximum: Finite
+}), ({
+  annotations,
+  payload
+}) => isLessThanOrEqualTo(payload.maximum, annotations));
 /**
  * Validates that a number is within a specified range. The range boundaries can
  * be inclusive or exclusive based on the provided options.
@@ -4089,14 +4588,54 @@ export const isLessThanOrEqualTo = /*#__PURE__*/makeIsLessThanOrEqualTo({
 export const isBetween = /*#__PURE__*/makeIsBetween({
   order: Order.Number,
   annotate: options => {
+    const exclusiveMinimum = options.exclusiveMinimum ? true : undefined;
+    const exclusiveMaximum = options.exclusiveMaximum ? true : undefined;
+    const payload = {
+      minimum: encodeNumberPayload(options.minimum),
+      maximum: encodeNumberPayload(options.maximum),
+      ...(exclusiveMinimum && {
+        exclusiveMinimum
+      }),
+      ...(exclusiveMaximum && {
+        exclusiveMaximum
+      })
+    };
     return {
-      meta: {
-        _tag: "isBetween",
-        ...options
-      }
+      representation: {
+        id: "effect/schema/isBetween",
+        payload
+      },
+      toJsonSchema: () => ({
+        [exclusiveMinimum ? "exclusiveMinimum" : "minimum"]: options.minimum,
+        [exclusiveMaximum ? "exclusiveMaximum" : "maximum"]: options.maximum
+      }),
+      toCode: () => ({
+        runtime: `Schema.isBetween({ minimum: ${format(options.minimum)}, maximum: ${format(options.maximum)}, exclusiveMinimum: ${format(exclusiveMinimum)}, exclusiveMaximum: ${format(exclusiveMaximum)} })`
+      })
     };
   }
 });
+/**
+ * Reviver for persisted `isBetween` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isBetween}.
+ *
+ * @see {@link isBetween} for creating the corresponding check
+ *
+ * @category Number checks
+ * @since 4.0.0
+ */
+export const isBetweenReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isBetween", /*#__PURE__*/Struct({
+  minimum: Finite,
+  maximum: Finite,
+  exclusiveMinimum: /*#__PURE__*/optional(/*#__PURE__*/Literal(true)),
+  exclusiveMaximum: /*#__PURE__*/optional(/*#__PURE__*/Literal(true))
+}), ({
+  annotations,
+  payload
+}) => isBetween(payload, annotations));
 /**
  * Validates that a number is a multiple of the specified divisor.
  *
@@ -4119,12 +4658,38 @@ export const isMultipleOf = /*#__PURE__*/makeIsMultipleOf({
   zero: 0,
   annotate: divisor => ({
     expected: `a value that is a multiple of ${divisor}`,
-    meta: {
-      _tag: "isMultipleOf",
-      divisor
-    }
+    representation: {
+      id: "effect/schema/isMultipleOf",
+      payload: {
+        divisor
+      }
+    },
+    toJsonSchema: () => ({
+      multipleOf: divisor
+    }),
+    toCode: () => ({
+      runtime: `Schema.isMultipleOf(${format(divisor)})`
+    })
   })
 });
+/**
+ * Reviver for persisted `isMultipleOf` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isMultipleOf}.
+ *
+ * @see {@link isMultipleOf} for creating the corresponding check
+ *
+ * @category Number checks
+ * @since 4.0.0
+ */
+export const isMultipleOfReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isMultipleOf", /*#__PURE__*/Struct({
+  divisor: Finite
+}), ({
+  annotations,
+  payload
+}) => isMultipleOf(payload.divisor, annotations));
 /**
  * Validates that a number is a safe integer (within the safe integer range
  * that can be exactly represented in JavaScript).
@@ -4146,9 +4711,16 @@ export const isMultipleOf = /*#__PURE__*/makeIsMultipleOf({
 export function isInt(annotations) {
   return makeFilter(n => globalThis.Number.isSafeInteger(n), {
     expected: "an integer",
-    meta: {
-      _tag: "isInt"
+    representation: {
+      id: "effect/schema/isInt",
+      payload: null
     },
+    toJsonSchema: () => ({
+      type: "integer"
+    }),
+    toCode: () => ({
+      runtime: "Schema.isInt()"
+    }),
     arbitrary: {
       constraint: {
         integer: true
@@ -4157,6 +4729,41 @@ export function isInt(annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isInt}.
+ *
+ * @see {@link isInt} for creating the corresponding check
+ *
+ * @category Integer checks
+ * @since 4.0.0
+ */
+export const isIntReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isInt", Null, ({
+  annotations
+}) => isInt(annotations));
+/**
+ * Schema for integers, rejecting `NaN`, `Infinity`, and `-Infinity`.
+ *
+ * @category Number
+ * @since 3.10.0
+ */
+export const Int = /*#__PURE__*/Number.check(/*#__PURE__*/isInt());
+/**
+ * Schema for non-negative safe integers, including zero.
+ *
+ * **When to use**
+ *
+ * Use when you need a count, index, or size that cannot be negative.
+ *
+ * @see {@link Int} for safe integers that may be negative
+ *
+ * @category Number
+ * @since 4.0.0
+ */
+export const Natural = /*#__PURE__*/Int.check(/*#__PURE__*/isGreaterThanOrEqualTo(0));
 /**
  * Validates that a number is a 32-bit signed integer (range: -2,147,483,648 to
  * 2,147,483,647).
@@ -4213,38 +4820,14 @@ export function isUint32(annotations) {
     ...annotations
   });
 }
-/**
- * Validates that a Date object represents a valid date (not an invalid date
- * like `new Date("invalid")`).
- *
- * **Details**
- *
- * JSON Schema:
- *
- * This check does not have a direct JSON Schema equivalent, as JSON Schema
- * validates date strings, not Date objects.
- *
- * Arbitrary:
- *
- * When generating test data with fast-check, this applies a `valid: true`
- * constraint to ensure generated Date objects are valid.
- *
- * @category Date checks
- * @since 4.0.0
- */
-export function isDateValid(annotations) {
-  return makeFilter(date => !isNaN(date.getTime()), {
-    expected: "a valid date",
-    meta: {
-      _tag: "isDateValid"
-    },
-    arbitrary: {
-      constraint: {
-        valid: true
-      }
-    },
-    ...annotations
-  });
+function encodeDatePayload(date) {
+  if (globalThis.Number.isNaN(date.getTime())) {
+    throw new globalThis.RangeError(`Expected a valid Date, got ${format(date)}`);
+  }
+  return date.toISOString();
+}
+function formatDateRuntime(date) {
+  return `new Date(${format(date.getTime())})`;
 }
 /**
  * Validates that a Date is greater than the specified value (exclusive).
@@ -4262,12 +4845,21 @@ export function isDateValid(annotations) {
  */
 export const isGreaterThanDate = /*#__PURE__*/makeIsGreaterThan({
   order: Order.Date,
-  annotate: exclusiveMinimum => ({
-    meta: {
-      _tag: "isGreaterThanDate",
-      exclusiveMinimum
-    }
-  })
+  annotate: exclusiveMinimum => {
+    const encoded = encodeDatePayload(exclusiveMinimum);
+    return {
+      representation: {
+        id: "effect/schema/isGreaterThanDate",
+        payload: {
+          exclusiveMinimum: encoded
+        }
+      },
+      toJsonSchema: () => ({}),
+      toCode: () => ({
+        runtime: `Schema.isGreaterThanDate(${formatDateRuntime(exclusiveMinimum)})`
+      })
+    };
+  }
 });
 /**
  * Validates that a Date is greater than or equal to the specified date
@@ -4291,12 +4883,21 @@ export const isGreaterThanDate = /*#__PURE__*/makeIsGreaterThan({
  */
 export const isGreaterThanOrEqualToDate = /*#__PURE__*/makeIsGreaterThanOrEqualTo({
   order: Order.Date,
-  annotate: minimum => ({
-    meta: {
-      _tag: "isGreaterThanOrEqualToDate",
-      minimum
-    }
-  })
+  annotate: minimum => {
+    const encoded = encodeDatePayload(minimum);
+    return {
+      representation: {
+        id: "effect/schema/isGreaterThanOrEqualToDate",
+        payload: {
+          minimum: encoded
+        }
+      },
+      toJsonSchema: () => ({}),
+      toCode: () => ({
+        runtime: `Schema.isGreaterThanOrEqualToDate(${formatDateRuntime(minimum)})`
+      })
+    };
+  }
 });
 /**
  * Validates that a Date is less than the specified value (exclusive).
@@ -4314,12 +4915,21 @@ export const isGreaterThanOrEqualToDate = /*#__PURE__*/makeIsGreaterThanOrEqualT
  */
 export const isLessThanDate = /*#__PURE__*/makeIsLessThan({
   order: Order.Date,
-  annotate: exclusiveMaximum => ({
-    meta: {
-      _tag: "isLessThanDate",
-      exclusiveMaximum
-    }
-  })
+  annotate: exclusiveMaximum => {
+    const encoded = encodeDatePayload(exclusiveMaximum);
+    return {
+      representation: {
+        id: "effect/schema/isLessThanDate",
+        payload: {
+          exclusiveMaximum: encoded
+        }
+      },
+      toJsonSchema: () => ({}),
+      toCode: () => ({
+        runtime: `Schema.isLessThanDate(${formatDateRuntime(exclusiveMaximum)})`
+      })
+    };
+  }
 });
 /**
  * Validates that a Date is less than or equal to the specified date
@@ -4343,12 +4953,21 @@ export const isLessThanDate = /*#__PURE__*/makeIsLessThan({
  */
 export const isLessThanOrEqualToDate = /*#__PURE__*/makeIsLessThanOrEqualTo({
   order: Order.Date,
-  annotate: maximum => ({
-    meta: {
-      _tag: "isLessThanOrEqualToDate",
-      maximum
-    }
-  })
+  annotate: maximum => {
+    const encoded = encodeDatePayload(maximum);
+    return {
+      representation: {
+        id: "effect/schema/isLessThanOrEqualToDate",
+        payload: {
+          maximum: encoded
+        }
+      },
+      toJsonSchema: () => ({}),
+      toCode: () => ({
+        runtime: `Schema.isLessThanOrEqualToDate(${formatDateRuntime(maximum)})`
+      })
+    };
+  }
 });
 /**
  * Validates that a Date is within a specified range. The range boundaries can
@@ -4372,12 +4991,30 @@ export const isLessThanOrEqualToDate = /*#__PURE__*/makeIsLessThanOrEqualTo({
  */
 export const isBetweenDate = /*#__PURE__*/makeIsBetween({
   order: Order.Date,
-  annotate: options => ({
-    meta: {
-      _tag: "isBetweenDate",
-      ...options
-    }
-  })
+  annotate: options => {
+    const exclusiveMinimum = options.exclusiveMinimum ? true : undefined;
+    const exclusiveMaximum = options.exclusiveMaximum ? true : undefined;
+    const payload = {
+      minimum: encodeDatePayload(options.minimum),
+      maximum: encodeDatePayload(options.maximum),
+      ...(exclusiveMinimum && {
+        exclusiveMinimum
+      }),
+      ...(exclusiveMaximum && {
+        exclusiveMaximum
+      })
+    };
+    return {
+      representation: {
+        id: "effect/schema/isBetweenDate",
+        payload
+      },
+      toJsonSchema: () => ({}),
+      toCode: () => ({
+        runtime: `Schema.isBetweenDate({ minimum: ${formatDateRuntime(options.minimum)}, maximum: ${formatDateRuntime(options.maximum)}, exclusiveMinimum: ${format(exclusiveMinimum)}, exclusiveMaximum: ${format(exclusiveMaximum)} })`
+      })
+    };
+  }
 });
 /**
  * Validates that a BigInt is greater than the specified value (exclusive).
@@ -4395,12 +5032,21 @@ export const isBetweenDate = /*#__PURE__*/makeIsBetween({
  */
 export const isGreaterThanBigInt = /*#__PURE__*/makeIsGreaterThan({
   order: Order.BigInt,
-  annotate: exclusiveMinimum => ({
-    meta: {
-      _tag: "isGreaterThanBigInt",
-      exclusiveMinimum
-    }
-  })
+  annotate: exclusiveMinimum => {
+    const encoded = exclusiveMinimum.toString(10);
+    return {
+      representation: {
+        id: "effect/schema/isGreaterThanBigInt",
+        payload: {
+          exclusiveMinimum: encoded
+        }
+      },
+      toJsonSchema: () => ({}),
+      toCode: () => ({
+        runtime: `Schema.isGreaterThanBigInt(${format(exclusiveMinimum)})`
+      })
+    };
+  }
 });
 /**
  * Validates that a BigInt is greater than or equal to the specified value
@@ -4419,12 +5065,21 @@ export const isGreaterThanBigInt = /*#__PURE__*/makeIsGreaterThan({
  */
 export const isGreaterThanOrEqualToBigInt = /*#__PURE__*/makeIsGreaterThanOrEqualTo({
   order: Order.BigInt,
-  annotate: minimum => ({
-    meta: {
-      _tag: "isGreaterThanOrEqualToBigInt",
-      minimum
-    }
-  })
+  annotate: minimum => {
+    const encoded = minimum.toString(10);
+    return {
+      representation: {
+        id: "effect/schema/isGreaterThanOrEqualToBigInt",
+        payload: {
+          minimum: encoded
+        }
+      },
+      toJsonSchema: () => ({}),
+      toCode: () => ({
+        runtime: `Schema.isGreaterThanOrEqualToBigInt(${format(minimum)})`
+      })
+    };
+  }
 });
 /**
  * Validates that a BigInt is less than the specified value (exclusive).
@@ -4442,12 +5097,21 @@ export const isGreaterThanOrEqualToBigInt = /*#__PURE__*/makeIsGreaterThanOrEqua
  */
 export const isLessThanBigInt = /*#__PURE__*/makeIsLessThan({
   order: Order.BigInt,
-  annotate: exclusiveMaximum => ({
-    meta: {
-      _tag: "isLessThanBigInt",
-      exclusiveMaximum
-    }
-  })
+  annotate: exclusiveMaximum => {
+    const encoded = exclusiveMaximum.toString(10);
+    return {
+      representation: {
+        id: "effect/schema/isLessThanBigInt",
+        payload: {
+          exclusiveMaximum: encoded
+        }
+      },
+      toJsonSchema: () => ({}),
+      toCode: () => ({
+        runtime: `Schema.isLessThanBigInt(${format(exclusiveMaximum)})`
+      })
+    };
+  }
 });
 /**
  * Validates that a BigInt is less than or equal to the specified value
@@ -4466,12 +5130,21 @@ export const isLessThanBigInt = /*#__PURE__*/makeIsLessThan({
  */
 export const isLessThanOrEqualToBigInt = /*#__PURE__*/makeIsLessThanOrEqualTo({
   order: Order.BigInt,
-  annotate: maximum => ({
-    meta: {
-      _tag: "isLessThanOrEqualToBigInt",
-      maximum
-    }
-  })
+  annotate: maximum => {
+    const encoded = maximum.toString(10);
+    return {
+      representation: {
+        id: "effect/schema/isLessThanOrEqualToBigInt",
+        payload: {
+          maximum: encoded
+        }
+      },
+      toJsonSchema: () => ({}),
+      toCode: () => ({
+        runtime: `Schema.isLessThanOrEqualToBigInt(${format(maximum)})`
+      })
+    };
+  }
 });
 /**
  * Validates that a BigInt is within a specified range. The range boundaries can
@@ -4490,12 +5163,30 @@ export const isLessThanOrEqualToBigInt = /*#__PURE__*/makeIsLessThanOrEqualTo({
  */
 export const isBetweenBigInt = /*#__PURE__*/makeIsBetween({
   order: Order.BigInt,
-  annotate: options => ({
-    meta: {
-      _tag: "isBetweenBigInt",
-      ...options
-    }
-  })
+  annotate: options => {
+    const exclusiveMinimum = options.exclusiveMinimum ? true : undefined;
+    const exclusiveMaximum = options.exclusiveMaximum ? true : undefined;
+    const payload = {
+      minimum: options.minimum.toString(10),
+      maximum: options.maximum.toString(10),
+      ...(exclusiveMinimum && {
+        exclusiveMinimum
+      }),
+      ...(exclusiveMaximum && {
+        exclusiveMaximum
+      })
+    };
+    return {
+      representation: {
+        id: "effect/schema/isBetweenBigInt",
+        payload
+      },
+      toJsonSchema: () => ({}),
+      toCode: () => ({
+        runtime: `Schema.isBetweenBigInt({ minimum: ${format(options.minimum)}, maximum: ${format(options.maximum)}, exclusiveMinimum: ${format(exclusiveMinimum)}, exclusiveMaximum: ${format(exclusiveMaximum)} })`
+      })
+    };
+  }
 });
 /**
  * Validates that a BigDecimal is greater than the specified value (exclusive).
@@ -4587,11 +5278,23 @@ export function isMinLength(minLength, annotations) {
   minLength = Math.max(0, Math.floor(minLength));
   return makeFilter(input => input.length >= minLength, {
     expected: `a value with a length of at least ${minLength}`,
-    meta: {
-      _tag: "isMinLength",
+    representation: {
+      id: "effect/schema/isMinLength",
+      payload: {
+        minLength
+      }
+    },
+    toJsonSchema: ({
+      type
+    }) => type === "array" ? {
+      minItems: minLength
+    } : {
       minLength
     },
-    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
+    toCode: () => ({
+      runtime: `Schema.isMinLength(${minLength})`
+    }),
+    [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,
     arbitrary: {
       constraint: {
         minLength
@@ -4600,6 +5303,24 @@ export function isMinLength(minLength, annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isMinLength` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isMinLength}.
+ *
+ * @see {@link isMinLength} for creating the corresponding check
+ *
+ * @category Length checks
+ * @since 4.0.0
+ */
+export const isMinLengthReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isMinLength", /*#__PURE__*/Struct({
+  minLength: Natural
+}), ({
+  annotations,
+  payload
+}) => isMinLength(payload.minLength, annotations));
 /**
  * Validates that a value has at least one element. Works with strings and arrays.
  * This is equivalent to `isMinLength(1)`.
@@ -4646,11 +5367,23 @@ export function isMaxLength(maxLength, annotations) {
   maxLength = Math.max(0, Math.floor(maxLength));
   return makeFilter(input => input.length <= maxLength, {
     expected: `a value with a length of at most ${maxLength}`,
-    meta: {
-      _tag: "isMaxLength",
+    representation: {
+      id: "effect/schema/isMaxLength",
+      payload: {
+        maxLength
+      }
+    },
+    toJsonSchema: ({
+      type
+    }) => type === "array" ? {
+      maxItems: maxLength
+    } : {
       maxLength
     },
-    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
+    toCode: () => ({
+      runtime: `Schema.isMaxLength(${maxLength})`
+    }),
+    [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,
     arbitrary: {
       constraint: {
         maxLength
@@ -4659,6 +5392,24 @@ export function isMaxLength(maxLength, annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isMaxLength` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isMaxLength}.
+ *
+ * @see {@link isMaxLength} for creating the corresponding check
+ *
+ * @category Length checks
+ * @since 4.0.0
+ */
+export const isMaxLengthReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isMaxLength", /*#__PURE__*/Struct({
+  maxLength: Natural
+}), ({
+  annotations,
+  payload
+}) => isMaxLength(payload.maxLength, annotations));
 /**
  * Validates that a value's length is within the specified range. Works with
  * strings and arrays.
@@ -4684,12 +5435,32 @@ export function isLengthBetween(minimum, maximum, annotations) {
   maximum = Math.max(0, Math.floor(maximum));
   return makeFilter(input => input.length >= minimum && input.length <= maximum, {
     expected: minimum === maximum ? `a value with a length of ${minimum}` : `a value with a length between ${minimum} and ${maximum}`,
-    meta: {
-      _tag: "isLengthBetween",
-      minimum,
-      maximum
+    representation: {
+      id: "effect/schema/isLengthBetween",
+      payload: {
+        minimum,
+        maximum
+      }
+    },
+    toJsonSchema: ({
+      type
+    }) => type === "array" ? {
+      allOf: [{
+        minItems: minimum
+      }, {
+        maxItems: maximum
+      }]
+    } : {
+      allOf: [{
+        minLength: minimum
+      }, {
+        maxLength: maximum
+      }]
     },
-    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
+    toCode: () => ({
+      runtime: `Schema.isLengthBetween(${minimum}, ${maximum})`
+    }),
+    [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,
     arbitrary: {
       constraint: {
         minLength: minimum,
@@ -4699,6 +5470,25 @@ export function isLengthBetween(minimum, maximum, annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isLengthBetween` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isLengthBetween}.
+ *
+ * @see {@link isLengthBetween} for creating the corresponding check
+ *
+ * @category Length checks
+ * @since 4.0.0
+ */
+export const isLengthBetweenReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isLengthBetween", /*#__PURE__*/Struct({
+  minimum: Natural,
+  maximum: Natural
+}), ({
+  annotations,
+  payload
+}) => isLengthBetween(payload.minimum, payload.maximum, annotations));
 /**
  * Validates that a value has at least the specified size. Works with values
  * that have a `size` property, such as `Set` or `Map`.
@@ -4723,11 +5513,17 @@ export function isMinSize(minSize, annotations) {
   minSize = Math.max(0, Math.floor(minSize));
   return makeFilter(input => input.size >= minSize, {
     expected: `a value with a size of at least ${minSize}`,
-    meta: {
-      _tag: "isMinSize",
-      minSize
+    representation: {
+      id: "effect/schema/isMinSize",
+      payload: {
+        minSize
+      }
     },
-    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
+    toJsonSchema: () => ({}),
+    toCode: () => ({
+      runtime: `Schema.isMinSize(${minSize})`
+    }),
+    [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,
     arbitrary: {
       constraint: {
         minLength: minSize
@@ -4736,6 +5532,24 @@ export function isMinSize(minSize, annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isMinSize` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isMinSize}.
+ *
+ * @see {@link isMinSize} for creating the corresponding check
+ *
+ * @category Size checks
+ * @since 4.0.0
+ */
+export const isMinSizeReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isMinSize", /*#__PURE__*/Struct({
+  minSize: Natural
+}), ({
+  annotations,
+  payload
+}) => isMinSize(payload.minSize, annotations));
 /**
  * Validates that a value has at most the specified size. Works with values
  * that have a `size` property, such as `Set` or `Map`.
@@ -4760,11 +5574,17 @@ export function isMaxSize(maxSize, annotations) {
   maxSize = Math.max(0, Math.floor(maxSize));
   return makeFilter(input => input.size <= maxSize, {
     expected: `a value with a size of at most ${maxSize}`,
-    meta: {
-      _tag: "isMaxSize",
-      maxSize
+    representation: {
+      id: "effect/schema/isMaxSize",
+      payload: {
+        maxSize
+      }
     },
-    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
+    toJsonSchema: () => ({}),
+    toCode: () => ({
+      runtime: `Schema.isMaxSize(${maxSize})`
+    }),
+    [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,
     arbitrary: {
       constraint: {
         maxLength: maxSize
@@ -4773,6 +5593,24 @@ export function isMaxSize(maxSize, annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isMaxSize` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isMaxSize}.
+ *
+ * @see {@link isMaxSize} for creating the corresponding check
+ *
+ * @category Size checks
+ * @since 4.0.0
+ */
+export const isMaxSizeReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isMaxSize", /*#__PURE__*/Struct({
+  maxSize: Natural
+}), ({
+  annotations,
+  payload
+}) => isMaxSize(payload.maxSize, annotations));
 /**
  * Validates that a value's size is within the specified range. Works with
  * values that have a `size` property, such as `Set` or `Map`.
@@ -4798,12 +5636,18 @@ export function isSizeBetween(minimum, maximum, annotations) {
   maximum = Math.max(0, Math.floor(maximum));
   return makeFilter(input => input.size >= minimum && input.size <= maximum, {
     expected: minimum === maximum ? `a value with a size of ${minimum}` : `a value with a size between ${minimum} and ${maximum}`,
-    meta: {
-      _tag: "isSizeBetween",
-      minimum,
-      maximum
+    representation: {
+      id: "effect/schema/isSizeBetween",
+      payload: {
+        minimum,
+        maximum
+      }
     },
-    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
+    toJsonSchema: () => ({}),
+    toCode: () => ({
+      runtime: `Schema.isSizeBetween(${minimum}, ${maximum})`
+    }),
+    [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,
     arbitrary: {
       constraint: {
         minLength: minimum,
@@ -4813,6 +5657,25 @@ export function isSizeBetween(minimum, maximum, annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isSizeBetween` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isSizeBetween}.
+ *
+ * @see {@link isSizeBetween} for creating the corresponding check
+ *
+ * @category Size checks
+ * @since 4.0.0
+ */
+export const isSizeBetweenReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isSizeBetween", /*#__PURE__*/Struct({
+  minimum: Natural,
+  maximum: Natural
+}), ({
+  annotations,
+  payload
+}) => isSizeBetween(payload.minimum, payload.maximum, annotations));
 /**
  * Validates that an object contains at least the specified number of
  * properties. This includes both string and symbol keys when counting
@@ -4837,11 +5700,19 @@ export function isMinProperties(minProperties, annotations) {
   minProperties = Math.max(0, Math.floor(minProperties));
   return makeFilter(input => Reflect.ownKeys(input).length >= minProperties, {
     expected: `a value with at least ${minProperties === 1 ? "1 entry" : `${minProperties} entries`}`,
-    meta: {
-      _tag: "isMinProperties",
-      minProperties
+    representation: {
+      id: "effect/schema/isMinProperties",
+      payload: {
+        minProperties
+      }
     },
-    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
+    toJsonSchema: () => ({
+      minProperties
+    }),
+    toCode: () => ({
+      runtime: `Schema.isMinProperties(${minProperties})`
+    }),
+    [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,
     arbitrary: {
       constraint: {
         minLength: minProperties
@@ -4850,6 +5721,24 @@ export function isMinProperties(minProperties, annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isMinProperties` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isMinProperties}.
+ *
+ * @see {@link isMinProperties} for creating the corresponding check
+ *
+ * @category Object checks
+ * @since 4.0.0
+ */
+export const isMinPropertiesReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isMinProperties", /*#__PURE__*/Struct({
+  minProperties: Natural
+}), ({
+  annotations,
+  payload
+}) => isMinProperties(payload.minProperties, annotations));
 /**
  * Validates that an object contains at most the specified number of properties.
  * This includes both string and symbol keys when counting properties.
@@ -4873,11 +5762,19 @@ export function isMaxProperties(maxProperties, annotations) {
   maxProperties = Math.max(0, Math.floor(maxProperties));
   return makeFilter(input => Reflect.ownKeys(input).length <= maxProperties, {
     expected: `a value with at most ${maxProperties === 1 ? "1 entry" : `${maxProperties} entries`}`,
-    meta: {
-      _tag: "isMaxProperties",
-      maxProperties
+    representation: {
+      id: "effect/schema/isMaxProperties",
+      payload: {
+        maxProperties
+      }
     },
-    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
+    toJsonSchema: () => ({
+      maxProperties
+    }),
+    toCode: () => ({
+      runtime: `Schema.isMaxProperties(${maxProperties})`
+    }),
+    [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,
     arbitrary: {
       constraint: {
         maxLength: maxProperties
@@ -4886,6 +5783,24 @@ export function isMaxProperties(maxProperties, annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isMaxProperties` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isMaxProperties}.
+ *
+ * @see {@link isMaxProperties} for creating the corresponding check
+ *
+ * @category Object checks
+ * @since 4.0.0
+ */
+export const isMaxPropertiesReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isMaxProperties", /*#__PURE__*/Struct({
+  maxProperties: Natural
+}), ({
+  annotations,
+  payload
+}) => isMaxProperties(payload.maxProperties, annotations));
 /**
  * Validates that an object contains between `minimum` and `maximum` properties (inclusive).
  * This includes both string and symbol keys when counting properties.
@@ -4911,12 +5826,21 @@ export function isPropertiesLengthBetween(minimum, maximum, annotations) {
   maximum = Math.max(0, Math.floor(maximum));
   return makeFilter(input => Reflect.ownKeys(input).length >= minimum && Reflect.ownKeys(input).length <= maximum, {
     expected: minimum === maximum ? `a value with exactly ${minimum === 1 ? "1 entry" : `${minimum} entries`}` : `a value with between ${minimum} and ${maximum} entries`,
-    meta: {
-      _tag: "isPropertiesLengthBetween",
-      minimum,
-      maximum
+    representation: {
+      id: "effect/schema/isPropertiesLengthBetween",
+      payload: {
+        minimum,
+        maximum
+      }
     },
-    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
+    toJsonSchema: () => ({
+      minProperties: minimum,
+      maxProperties: maximum
+    }),
+    toCode: () => ({
+      runtime: `Schema.isPropertiesLengthBetween(${minimum}, ${maximum})`
+    }),
+    [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,
     arbitrary: {
       constraint: {
         minLength: minimum,
@@ -4926,6 +5850,25 @@ export function isPropertiesLengthBetween(minimum, maximum, annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isPropertiesLengthBetween` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isPropertiesLengthBetween}.
+ *
+ * @see {@link isPropertiesLengthBetween} for creating the corresponding check
+ *
+ * @category Object checks
+ * @since 4.0.0
+ */
+export const isPropertiesLengthBetweenReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isPropertiesLengthBetween", /*#__PURE__*/Struct({
+  minimum: Natural,
+  maximum: Natural
+}), ({
+  annotations,
+  payload
+}) => isPropertiesLengthBetween(payload.minimum, payload.maximum, annotations));
 /**
  * Validates that every own property key of an object satisfies the encoded side
  * of the provided key schema.
@@ -4961,14 +5904,41 @@ export function isPropertyNames(keySchema, annotations) {
     return true;
   }, {
     expected: "an object with property names matching the schema",
-    meta: {
-      _tag: "isPropertyNames",
-      propertyNames: propertyNames.ast
+    representation: {
+      id: "effect/schema/isPropertyNames",
+      payload: null,
+      schemas: [propertyNames.ast]
     },
-    [SchemaAST.STRUCTURAL_ANNOTATION_KEY]: true,
+    toJsonSchema: ({
+      schemas
+    }) => ({
+      propertyNames: schemas[0]
+    }),
+    toCode: ({
+      schemas
+    }) => ({
+      runtime: `Schema.isPropertyNames(${schemas[0].runtime})`
+    }),
+    [InternalAnnotations.STRUCTURAL_ANNOTATION_KEY]: true,
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isPropertyNames` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isPropertyNames}.
+ *
+ * @see {@link isPropertyNames} for creating the corresponding check
+ *
+ * @category Object checks
+ * @since 4.0.0
+ */
+export const isPropertyNamesReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isPropertyNames", Null, ({
+  annotations,
+  schemas
+}) => isPropertyNames(schemas[0], annotations));
 /**
  * Validates that all items in an array are unique according to Effect equality.
  *
@@ -4986,12 +5956,18 @@ export function isPropertyNames(keySchema, annotations) {
  * @since 4.0.0
  */
 export function isUnique(annotations) {
-  const equivalence = Equal.asEquivalence();
-  return makeFilter(input => Arr.dedupeWith(input, equivalence).length === input.length, {
+  return makeFilter(input => Arr.dedupe(input).length === input.length, {
     expected: "an array with unique items",
-    meta: {
-      _tag: "isUnique"
+    representation: {
+      id: "effect/schema/isUnique",
+      payload: null
     },
+    toJsonSchema: () => ({
+      uniqueItems: true
+    }),
+    toCode: () => ({
+      runtime: "Schema.isUnique()"
+    }),
     arbitrary: {
       constraint: {
         unique: true
@@ -5000,6 +5976,21 @@ export function isUnique(annotations) {
     ...annotations
   });
 }
+/**
+ * Reviver for persisted `isUnique` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isUnique}.
+ *
+ * @see {@link isUnique} for creating the corresponding check
+ *
+ * @category Array checks
+ * @since 4.0.0
+ */
+export const isUniqueReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isUnique", Null, ({
+  annotations
+}) => isUnique(annotations));
 /**
  * Schema for non-empty strings. Validates that a string has at least one
  * character.
@@ -5047,14 +6038,17 @@ export function Option(value) {
     }
     return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)));
   }, {
-    typeConstructor: {
-      _tag: "effect/Option"
-    },
-    generation: {
-      runtime: `Schema.Option(?)`,
-      Type: `Option.Option<?>`,
-      importDeclaration: `import * as Option from "effect/Option"`
+    representation: {
+      id: "effect/schema/Option",
+      payload: null
     },
+    toCode: ({
+      typeParameters
+    }) => ({
+      runtime: `Schema.Option(${typeParameters[0].runtime})`,
+      Type: `Option.Option<${typeParameters[0].Type}>`,
+      importDeclarations: [`import * as Option from "effect/Option"`]
+    }),
     expected: "Option",
     toCodec: ([value]) => link()(Union([Struct({
       _tag: Literal("Some"),
@@ -5085,6 +6079,25 @@ export function Option(value) {
     value
   });
 }
+/**
+ * Reviver for persisted `Option` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Option}.
+ *
+ * @see {@link Option} for creating the corresponding schema
+ *
+ * @category Option
+ * @since 4.0.0
+ */
+export const OptionReviver = /*#__PURE__*/InternalSchema.makeDeclarationReviver("effect/schema/Option", Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = Option(typeParameters[0]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
 /**
  * Decodes a nullable, required value `T` to a required `Option<T>` value.
  *
@@ -5206,14 +6219,17 @@ export function Result(success, failure) {
         });
     }
   }, {
-    typeConstructor: {
-      _tag: "effect/Result"
-    },
-    generation: {
-      runtime: `Schema.Result(?, ?)`,
-      Type: `Result.Result<?, ?>`,
-      importDeclaration: `import * as Result from "effect/Result"`
+    representation: {
+      id: "effect/schema/Result",
+      payload: null
     },
+    toCode: ({
+      typeParameters
+    }) => ({
+      runtime: `Schema.Result(${typeParameters[0].runtime}, ${typeParameters[1].runtime})`,
+      Type: `Result.Result<${typeParameters[0].Type}, ${typeParameters[1].Type}>`,
+      importDeclarations: [`import * as Result from "effect/Result"`]
+    }),
     expected: "Result",
     toCodec: ([success, failure]) => link()(Union([Struct({
       _tag: Literal("Success"),
@@ -5247,6 +6263,42 @@ export function Result(success, failure) {
     failure
   });
 }
+/**
+ * Reviver for persisted {@link Result} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Result}.
+ *
+ * @see {@link Result} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ResultReviver = /*#__PURE__*/InternalSchema.makeDeclarationReviver("effect/schema/Result", Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = Result(typeParameters[0], typeParameters[1]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
+const RedactedOptionsPayload = /*#__PURE__*/declare(input => {
+  if (!Predicate.isObject(input)) {
+    return false;
+  }
+  const keys = globalThis.Object.keys(input);
+  return keys.length > 0 && keys.every(key => {
+    switch (key) {
+      case "label":
+        return typeof input[key] === "string";
+      case "disallowJsonEncode":
+        return input[key] === true;
+      default:
+        return false;
+    }
+  });
+});
+const RedactedRepresentationPayload = /*#__PURE__*/Union([Null, RedactedOptionsPayload]);
 /**
  * Schema for values that hide sensitive information from error output and
  * inspection.
@@ -5272,7 +6324,17 @@ export function Result(success, failure) {
  * @since 3.10.0
  */
 export function Redacted(value, options) {
-  const decodeLabel = typeof options?.label === "string" ? SchemaParser.decodeUnknownEffect(Literal(options.label)) : undefined;
+  const label = typeof options?.label === "string" ? options.label : undefined;
+  const disallowJsonEncode = options?.disallowJsonEncode === true;
+  const normalizedOptions = label !== undefined ? disallowJsonEncode ? {
+    label,
+    disallowJsonEncode: true
+  } : {
+    label
+  } : disallowJsonEncode ? {
+    disallowJsonEncode: true
+  } : undefined;
+  const decodeLabel = label !== undefined ? SchemaParser.decodeUnknownEffect(Literal(label)) : undefined;
   const schema = declareConstructor()([value], ([value]) => (input, ast, poptions) => {
     if (Redacted_.isRedacted(input)) {
       const label = decodeLabel !== undefined ? Effect.mapErrorEager(decodeLabel(input.label, poptions), issue => new SchemaIssue.Pointer(["label"], issue)) : Effect.void;
@@ -5287,28 +6349,30 @@ export function Redacted(value, options) {
     }
     return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)));
   }, {
-    typeConstructor: {
-      _tag: "effect/Redacted",
-      options
-    },
-    generation: {
-      runtime: options !== undefined ? `Schema.Redacted(?, ${format(options)})` : `Schema.Redacted(?)`,
-      Type: `Redacted.Redacted<?>`,
-      importDeclaration: `import * as Redacted from "effect/Redacted"`
+    representation: {
+      id: "effect/schema/Redacted",
+      payload: normalizedOptions ?? null
     },
+    toCode: ({
+      typeParameters
+    }) => ({
+      runtime: normalizedOptions !== undefined ? `Schema.Redacted(${typeParameters[0].runtime}, ${format(normalizedOptions)})` : `Schema.Redacted(${typeParameters[0].runtime})`,
+      Type: `Redacted.Redacted<${typeParameters[0].Type}>`,
+      importDeclarations: [`import * as Redacted from "effect/Redacted"`]
+    }),
     expected: "Redacted",
     toCodecJson: ([value]) => link()(redact(value), {
       decode: SchemaGetter.transform(e => Redacted_.make(e, {
-        label: options?.label
+        label
       })),
-      encode: options?.disallowJsonEncode ? SchemaGetter.forbidden(oe => "Cannot serialize Redacted" + (Option_.isSome(oe) && typeof oe.value.label === "string" ? ` with label: "${oe.value.label}"` : "")) : SchemaGetter.transform(Redacted_.value)
+      encode: disallowJsonEncode ? SchemaGetter.forbidden(oe => "Cannot serialize Redacted" + (Option_.isSome(oe) && typeof oe.value.label === "string" ? ` with label: "${oe.value.label}"` : "")) : SchemaGetter.transform(Redacted_.value)
     }),
     toArbitrary: ([value]) => () => ({
       arbitrary: value.arbitrary.map(a => Redacted_.make(a, {
-        label: options?.label
+        label
       })),
       terminal: value.terminal?.map(a => Redacted_.make(a, {
-        label: options?.label
+        label
       }))
     }),
     toFormatter: () => globalThis.String,
@@ -5318,6 +6382,26 @@ export function Redacted(value, options) {
     value
   });
 }
+/**
+ * Reviver for persisted {@link Redacted} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Redacted}.
+ *
+ * @see {@link Redacted} for creating the corresponding schema
+ *
+ * @category Redacted
+ * @since 4.0.0
+ */
+export const RedactedReviver = /*#__PURE__*/InternalSchema.makeDeclarationReviver("effect/schema/Redacted", RedactedRepresentationPayload, ({
+  annotations,
+  payload,
+  typeParameters
+}) => {
+  const schema = Redacted(typeParameters[0], payload ?? undefined);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
 /**
  * Middleware that wraps decoded errors in `Redacted`, preventing sensitive
  * schema details from leaking in error messages.
@@ -5388,14 +6472,17 @@ export function CauseReason(error, defect) {
         return Effect.succeed(input);
     }
   }, {
-    typeConstructor: {
-      _tag: "effect/Cause/Failure"
-    },
-    generation: {
-      runtime: `Schema.CauseReason(?, ?)`,
-      Type: `Cause.Failure<?, ?>`,
-      importDeclaration: `import * as Cause from "effect/Cause"`
+    representation: {
+      id: "effect/schema/CauseReason",
+      payload: null
     },
+    toCode: ({
+      typeParameters
+    }) => ({
+      runtime: `Schema.CauseReason(${typeParameters[0].runtime}, ${typeParameters[1].runtime})`,
+      Type: `Cause.Failure<${typeParameters[0].Type}, ${typeParameters[1].Type}>`,
+      importDeclarations: [`import * as Cause from "effect/Cause"`]
+    }),
     expected: "Cause.Failure",
     toCodec: ([error, defect]) => link()(Union([Struct({
       _tag: Literal("Fail"),
@@ -5428,6 +6515,25 @@ export function CauseReason(error, defect) {
     defect
   });
 }
+/**
+ * Reviver for persisted `CauseReason` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link CauseReason}.
+ *
+ * @see {@link CauseReason} for creating the corresponding schema
+ *
+ * @category CauseReason
+ * @since 4.0.0
+ */
+export const CauseReasonReviver = /*#__PURE__*/InternalSchema.makeDeclarationReviver("effect/schema/CauseReason", Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = CauseReason(typeParameters[0], typeParameters[1]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
 function causeReasonToArbitrary(error, defect) {
   return (fc, ctx) => {
     const terminal = fc.constant(Cause_.makeInterruptReason());
@@ -5496,14 +6602,17 @@ export function Cause(error, defect) {
       });
     };
   }, {
-    typeConstructor: {
-      _tag: "effect/Cause"
-    },
-    generation: {
-      runtime: `Schema.Cause(?, ?)`,
-      Type: `Cause.Cause<?, ?>`,
-      importDeclaration: `import * as Cause from "effect/Cause"`
+    representation: {
+      id: "effect/schema/Cause",
+      payload: null
     },
+    toCode: ({
+      typeParameters
+    }) => ({
+      runtime: `Schema.Cause(${typeParameters[0].runtime}, ${typeParameters[1].runtime})`,
+      Type: `Cause.Cause<${typeParameters[0].Type}, ${typeParameters[1].Type}>`,
+      importDeclarations: [`import * as Cause from "effect/Cause"`]
+    }),
     expected: "Cause",
     toCodec: ([error, defect]) => link()(ArraySchema(CauseReason(error, defect)), SchemaTransformation.transform({
       decode: Cause_.fromReasons,
@@ -5520,6 +6629,25 @@ export function Cause(error, defect) {
     defect
   });
 }
+/**
+ * Reviver for persisted `Cause` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Cause}.
+ *
+ * @see {@link Cause} for creating the corresponding schema
+ *
+ * @category Cause
+ * @since 4.0.0
+ */
+export const CauseReviver = /*#__PURE__*/InternalSchema.makeDeclarationReviver("effect/schema/Cause", Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = Cause(typeParameters[0], typeParameters[1]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
 function causeToArbitrary(error, defect) {
   return (fc, ctx) => {
     const reason = causeReasonToArbitrary(error, defect)(fc, ctx);
@@ -5536,6 +6664,14 @@ function causeToFormatter(error, defect) {
   const causeReason = causeReasonToFormatter(error, defect);
   return t => `Cause([${t.reasons.map(causeReason).join(", ")}])`;
 }
+const ErrorOptionsPayload = /*#__PURE__*/declare(input => {
+  if (!Predicate.isObject(input)) {
+    return false;
+  }
+  const keys = globalThis.Object.keys(input);
+  return keys.length > 0 && keys.every(key => (key === "includeStack" || key === "excludeCause") && input[key] === true);
+});
+const ErrorRepresentationPayload = /*#__PURE__*/Union([Null, ErrorOptionsPayload]);
 const getErrorOptionsKey = options => (options?.includeStack === true ? 1 : 0) | (options?.excludeCause === true ? 2 : 0);
 const getErrorOptions = key => {
   switch (key) {
@@ -5580,16 +6716,14 @@ export function Error(options) {
   }
   const normalizedOptions = getErrorOptions(key);
   const schema = instanceOf(globalThis.Error, {
-    typeConstructor: {
-      _tag: "Error",
-      ...(normalizedOptions === undefined ? {} : {
-        options: normalizedOptions
-      })
+    representation: {
+      id: "effect/schema/Error",
+      payload: normalizedOptions ?? null
     },
-    generation: {
+    toCode: () => ({
       runtime: normalizedOptions !== undefined ? `Schema.Error(${format(normalizedOptions)})` : `Schema.Error()`,
       Type: `globalThis.Error`
-    },
+    }),
     expected: "Error",
     toCodecJson: () => link()(JsonError, SchemaTransformation.errorFromJsonError(normalizedOptions)),
     toArbitrary: () => fc => fc.string().map(message => new globalThis.Error(message))
@@ -5597,6 +6731,25 @@ export function Error(options) {
   errorSchemaCache[key] = schema;
   return schema;
 }
+/**
+ * Reviver for persisted {@link Error} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Error}.
+ *
+ * @see {@link Error} for creating the corresponding schema
+ *
+ * @category Error
+ * @since 4.0.0
+ */
+export const ErrorReviver = /*#__PURE__*/InternalSchema.makeDeclarationReviver("effect/schema/Error", ErrorRepresentationPayload, ({
+  annotations,
+  payload
+}) => {
+  const schema = Error(payload ?? undefined);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
 const defectSchemaCache = [];
 /**
  * Schema for unexpected defect values represented as `unknown` with a JSON
@@ -5682,14 +6835,17 @@ export function Exit(value, error, defect) {
       }
     };
   }, {
-    typeConstructor: {
-      _tag: "effect/Exit"
-    },
-    generation: {
-      runtime: `Schema.Exit(?, ?, ?)`,
-      Type: `Exit.Exit<?, ?, ?>`,
-      importDeclaration: `import * as Exit from "effect/Exit"`
+    representation: {
+      id: "effect/schema/Exit",
+      payload: null
     },
+    toCode: ({
+      typeParameters
+    }) => ({
+      runtime: `Schema.Exit(${typeParameters[0].runtime}, ${typeParameters[1].runtime}, ${typeParameters[2].runtime})`,
+      Type: `Exit.Exit<${typeParameters[0].Type}, ${typeParameters[1].Type}, ${typeParameters[2].Type}>`,
+      importDeclarations: [`import * as Exit from "effect/Exit"`]
+    }),
     expected: "Exit",
     toCodec: ([value, error, defect]) => link()(Union([Struct({
       _tag: Literal("Success"),
@@ -5743,6 +6899,25 @@ export function Exit(value, error, defect) {
     defect
   });
 }
+/**
+ * Reviver for persisted `Exit` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Exit}.
+ *
+ * @see {@link Exit} for creating the corresponding schema
+ *
+ * @category Exit
+ * @since 4.0.0
+ */
+export const ExitReviver = /*#__PURE__*/InternalSchema.makeDeclarationReviver("effect/schema/Exit", Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = Exit(typeParameters[0], typeParameters[1], typeParameters[2]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
 function oneOfArbitraries(fc, a, b) {
   return a === undefined ? b : b === undefined ? a : fc.oneof(a, b);
 }
@@ -5805,13 +6980,16 @@ export function ReadonlyMap(key, value) {
       return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)));
     };
   }, {
-    typeConstructor: {
-      _tag: "ReadonlyMap"
-    },
-    generation: {
-      runtime: `Schema.ReadonlyMap(?, ?)`,
-      Type: `globalThis.ReadonlyMap<?, ?>`
+    representation: {
+      id: "effect/schema/ReadonlyMap",
+      payload: null
     },
+    toCode: ({
+      typeParameters
+    }) => ({
+      runtime: `Schema.ReadonlyMap(${typeParameters[0].runtime}, ${typeParameters[1].runtime})`,
+      Type: `globalThis.ReadonlyMap<${typeParameters[0].Type}, ${typeParameters[1].Type}>`
+    }),
     expected: "ReadonlyMap",
     toCodec: ([key, value]) => link()(ArraySchema(Tuple([key, value])), SchemaTransformation.transform({
       decode: e => new globalThis.Map(e),
@@ -5833,6 +7011,25 @@ export function ReadonlyMap(key, value) {
     value
   });
 }
+/**
+ * Reviver for persisted {@link ReadonlyMap} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link ReadonlyMap}.
+ *
+ * @see {@link ReadonlyMap} for creating the corresponding schema
+ *
+ * @category ReadonlyMap
+ * @since 4.0.0
+ */
+export const ReadonlyMapReviver = /*#__PURE__*/InternalSchema.makeDeclarationReviver("effect/schema/ReadonlyMap", Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = ReadonlyMap(typeParameters[0], typeParameters[1]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
 /**
  * Schema for hash maps whose keys and values conform to the provided schemas.
  *
@@ -5852,14 +7049,17 @@ export function HashMap(key, value) {
       return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)));
     };
   }, {
-    typeConstructor: {
-      _tag: "effect/HashMap"
-    },
-    generation: {
-      runtime: `Schema.HashMap(?, ?)`,
-      Type: `HashMap.HashMap<?, ?>`,
-      importDeclaration: `import * as HashMap from "effect/HashMap"`
+    representation: {
+      id: "effect/schema/HashMap",
+      payload: null
     },
+    toCode: ({
+      typeParameters
+    }) => ({
+      runtime: `Schema.HashMap(${typeParameters[0].runtime}, ${typeParameters[1].runtime})`,
+      Type: `HashMap.HashMap<${typeParameters[0].Type}, ${typeParameters[1].Type}>`,
+      importDeclarations: [`import * as HashMap from "effect/HashMap"`]
+    }),
     expected: "HashMap",
     toCodec: ([key, value]) => link()(ArraySchema(Tuple([key, value])), SchemaTransformation.transform({
       decode: HashMap_.fromIterable,
@@ -5881,6 +7081,25 @@ export function HashMap(key, value) {
     value
   });
 }
+/**
+ * Reviver for persisted `HashMap` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link HashMap}.
+ *
+ * @see {@link HashMap} for creating the corresponding schema
+ *
+ * @category HashMap
+ * @since 4.0.0
+ */
+export const HashMapReviver = /*#__PURE__*/InternalSchema.makeDeclarationReviver("effect/schema/HashMap", Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = HashMap(typeParameters[0], typeParameters[1]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
 /**
  * Schema for readonly sets whose values conform to the provided element schema.
  *
@@ -5900,13 +7119,16 @@ export function ReadonlySet(value) {
       return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)));
     };
   }, {
-    typeConstructor: {
-      _tag: "ReadonlySet"
-    },
-    generation: {
-      runtime: `Schema.ReadonlySet(?)`,
-      Type: `globalThis.ReadonlySet<?>`
+    representation: {
+      id: "effect/schema/ReadonlySet",
+      payload: null
     },
+    toCode: ({
+      typeParameters
+    }) => ({
+      runtime: `Schema.ReadonlySet(${typeParameters[0].runtime})`,
+      Type: `globalThis.ReadonlySet<${typeParameters[0].Type}>`
+    }),
     expected: "ReadonlySet",
     toCodec: ([value]) => link()(ArraySchema(value), SchemaTransformation.transform({
       decode: e => new globalThis.Set(e),
@@ -5927,6 +7149,25 @@ export function ReadonlySet(value) {
     value
   });
 }
+/**
+ * Reviver for persisted {@link ReadonlySet} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link ReadonlySet}.
+ *
+ * @see {@link ReadonlySet} for creating the corresponding schema
+ *
+ * @category ReadonlySet
+ * @since 4.0.0
+ */
+export const ReadonlySetReviver = /*#__PURE__*/InternalSchema.makeDeclarationReviver("effect/schema/ReadonlySet", Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = ReadonlySet(typeParameters[0]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
 /**
  * Schema for hash sets whose values conform to the provided element schema.
  *
@@ -5946,13 +7187,16 @@ export function HashSet(value) {
       return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)));
     };
   }, {
-    typeConstructor: {
-      _tag: "effect/HashSet"
-    },
-    generation: {
-      runtime: `Schema.HashSet(?)`,
-      Type: `HashSet.HashSet<?>`
+    representation: {
+      id: "effect/schema/HashSet",
+      payload: null
     },
+    toCode: ({
+      typeParameters
+    }) => ({
+      runtime: `Schema.HashSet(${typeParameters[0].runtime})`,
+      Type: `HashSet.HashSet<${typeParameters[0].Type}>`
+    }),
     expected: "HashSet",
     toCodec: ([value]) => link()(ArraySchema(value), SchemaTransformation.transform({
       decode: HashSet_.fromIterable,
@@ -5973,6 +7217,25 @@ export function HashSet(value) {
     value
   });
 }
+/**
+ * Reviver for persisted `HashSet` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link HashSet}.
+ *
+ * @see {@link HashSet} for creating the corresponding schema
+ *
+ * @category HashSet
+ * @since 4.0.0
+ */
+export const HashSetReviver = /*#__PURE__*/InternalSchema.makeDeclarationReviver("effect/schema/HashSet", Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = HashSet(typeParameters[0]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
 /**
  * Schema for chunks whose values conform to the provided element schema.
  *
@@ -5992,13 +7255,16 @@ export function Chunk(value) {
       return Effect.fail(new SchemaIssue.InvalidType(ast, Option_.some(input)));
     };
   }, {
-    typeConstructor: {
-      _tag: "effect/Chunk"
-    },
-    generation: {
-      runtime: `Schema.Chunk(?)`,
-      Type: `Chunk.Chunk<?>`
+    representation: {
+      id: "effect/schema/Chunk",
+      payload: null
     },
+    toCode: ({
+      typeParameters
+    }) => ({
+      runtime: `Schema.Chunk(${typeParameters[0].runtime})`,
+      Type: `Chunk.Chunk<${typeParameters[0].Type}>`
+    }),
     expected: "Chunk",
     toCodec: ([value]) => link()(ArraySchema(value), SchemaTransformation.transform({
       decode: Chunk_.fromIterable,
@@ -6019,6 +7285,25 @@ export function Chunk(value) {
     value
   });
 }
+/**
+ * Reviver for persisted {@link Chunk} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Chunk}.
+ *
+ * @see {@link Chunk} for creating the corresponding schema
+ *
+ * @category Chunk
+ * @since 4.0.0
+ */
+export const ChunkReviver = /*#__PURE__*/InternalSchema.makeDeclarationReviver("effect/schema/Chunk", Null, ({
+  annotations,
+  typeParameters
+}) => {
+  const schema = Chunk(typeParameters[0]);
+  return annotations === undefined ? schema : schema.annotate(annotations);
+});
 /**
  * Schema for JavaScript `RegExp` objects.
  *
@@ -6030,13 +7315,14 @@ export function Chunk(value) {
  * @since 4.0.0
  */
 export const RegExp = /*#__PURE__*/instanceOf(globalThis.RegExp, {
-  typeConstructor: {
-    _tag: "RegExp"
+  representation: {
+    id: "effect/schema/RegExp",
+    payload: null
   },
-  generation: {
+  toCode: () => ({
     runtime: `Schema.RegExp`,
     Type: `globalThis.RegExp`
-  },
+  }),
   expected: "RegExp",
   toCodecJson: () => link()(Struct({
     source: String,
@@ -6060,6 +7346,19 @@ export const RegExp = /*#__PURE__*/instanceOf(globalThis.RegExp, {
   }).map(flags => flags.join(""))).map(([source, flags]) => new globalThis.RegExp(source, flags)),
   toEquivalence: () => (a, b) => a.source === b.source && a.flags === b.flags
 });
+/**
+ * Reviver for persisted `RegExp` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link RegExp} schema.
+ *
+ * @see {@link RegExp} for the corresponding schema
+ *
+ * @category RegExp
+ * @since 4.0.0
+ */
+export const RegExpReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/RegExp", RegExp);
 const URLString = /*#__PURE__*/String.annotate({
   expected: "a string that will be decoded as a URL"
 });
@@ -6076,18 +7375,32 @@ const URLString = /*#__PURE__*/String.annotate({
  * @since 4.0.0
  */
 export const URL = /*#__PURE__*/instanceOf(globalThis.URL, {
-  typeConstructor: {
-    _tag: "URL"
+  representation: {
+    id: "effect/schema/URL",
+    payload: null
   },
-  generation: {
+  toCode: () => ({
     runtime: `Schema.URL`,
     Type: `globalThis.URL`
-  },
+  }),
   expected: "URL",
   toCodecJson: () => link()(URLString, SchemaTransformation.urlFromString),
   toArbitrary: () => fc => fc.webUrl().map(s => new globalThis.URL(s)),
   toEquivalence: () => (a, b) => a.toString() === b.toString()
 });
+/**
+ * Reviver for persisted `URL` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link URL} schema.
+ *
+ * @see {@link URL} for the corresponding schema
+ *
+ * @category URL
+ * @since 4.0.0
+ */
+export const URLReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/URL", URL);
 /**
  * Schema that decodes a `string` into a `URL`.
  *
@@ -6103,14 +7416,10 @@ export const URL = /*#__PURE__*/instanceOf(globalThis.URL, {
  * @since 4.0.0
  */
 export const URLFromString = /*#__PURE__*/URLString.pipe(/*#__PURE__*/decodeTo(URL, SchemaTransformation.urlFromString));
-function dateArbitraryConstraints(constraint, ordered, base, toDate) {
+function dateArbitraryConstraints(ordered, base, toDate) {
   const out = {
     ...base
   };
-  delete out.valid;
-  if (base?.valid || constraint?.valid) {
-    out.noInvalidDate = true;
-  }
   if (ordered?.minimum !== undefined) {
     const minimum = toDate === undefined ? ordered.minimum : toDate(ordered.minimum);
     const nextMin = ordered.exclusiveMinimum ? new globalThis.Date(minimum.getTime() + 1) : minimum;
@@ -6128,21 +7437,20 @@ function dateArbitraryConstraints(constraint, ordered, base, toDate) {
   return out;
 }
 const DateString = /*#__PURE__*/String.annotate({
-  expected: "a string in ISO 8601 format that will be decoded as a Date"
+  expected: "a string that will be decoded as a Date"
 });
 /**
- * Schema for JavaScript `Date` objects.
+ * Schema for valid JavaScript `Date` objects.
  *
  * **When to use**
  *
- * Use to validate in-memory values that must already be JavaScript date
+ * Use to validate in-memory values that must already be valid JavaScript date
  * objects.
  *
  * **Details**
  *
- * This schema accepts any `Date` instance, including invalid dates. The default
- * JSON serializer encodes valid dates as ISO 8601 strings; invalid dates encode
- * as `"Invalid Date"`.
+ * This schema accepts `Date` instances whose timestamp is not `NaN`. The
+ * default JSON serializer encodes dates as ISO 8601 strings.
  *
  * **Example** (Defining a Date schema)
  *
@@ -6153,25 +7461,40 @@ const DateString = /*#__PURE__*/String.annotate({
  * // => Date { 2024-01-01T00:00:00.000Z }
  * ```
  *
- * @see {@link DateValid} for accepting only valid Date instances
  * @see {@link DateFromString} for decoding strings into Date instances
  * @see {@link DateFromMillis} for decoding epoch milliseconds into Date instances
  *
  * @category Date
  * @since 4.0.0
  */
-export const Date = /*#__PURE__*/instanceOf(globalThis.Date, {
-  typeConstructor: {
-    _tag: "Date"
+export const Date = /*#__PURE__*/declare(input => input instanceof globalThis.Date && !globalThis.Number.isNaN(input.getTime()), {
+  representation: {
+    id: "effect/schema/Date",
+    payload: null
   },
-  generation: {
+  toCode: () => ({
     runtime: `Schema.Date`,
     Type: `globalThis.Date`
-  },
-  expected: "Date",
+  }),
+  expected: "a valid Date",
   toCodecJson: () => link()(DateString, SchemaTransformation.dateFromString),
-  toArbitrary: () => (fc, ctx) => fc.date(dateArbitraryConstraints(ctx?.constraint, ctx?.constraint?.ordered?.order === Order.Date ? ctx.constraint.ordered : undefined))
+  toArbitrary: () => (fc, ctx) => fc.date(dateArbitraryConstraints(ctx?.constraint?.ordered?.order === Order.Date ? ctx.constraint.ordered : undefined, {
+    noInvalidDate: true
+  }))
 });
+/**
+ * Reviver for persisted `Date` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Date} schema.
+ *
+ * @see {@link Date} for the corresponding schema
+ *
+ * @category Date
+ * @since 4.0.0
+ */
+export const DateReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/Date", Date);
 /**
  * Schema that decodes a string into a JavaScript `Date`.
  *
@@ -6186,17 +7509,13 @@ export const Date = /*#__PURE__*/instanceOf(globalThis.Date, {
  * The string is passed to JavaScript `Date` construction.
  *
  * Encoding:
- * A valid `Date` is encoded as an ISO string; an invalid `Date` is encoded as
- * `"Invalid Date"`.
- *
- * **Gotchas**
+ * A `Date` is encoded as an ISO string.
  *
- * Invalid date strings can decode to invalid `Date` instances.
+ * Invalid date strings fail decoding.
  *
  * @see {@link DateFromMillis} for decoding epoch milliseconds into Date instances
  * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values
  * @see {@link Date} for accepting Date instances directly
- * @see {@link DateValid} for rejecting invalid Date instances
  *
  * @category Date
  * @since 3.10.0
@@ -6213,15 +7532,16 @@ export const DateFromString = /*#__PURE__*/DateString.pipe(/*#__PURE__*/decodeTo
  * **Details**
  *
  * Decoding:
- * A number of milliseconds since the Unix epoch is decoded as a `Date`.
+ * A safe integer number of milliseconds since the Unix epoch is decoded as a
+ * `Date`.
  *
  * Encoding:
  * A `Date` is encoded as its millisecond timestamp.
  *
  * **Gotchas**
  *
- * This schema accepts any number, including `NaN`, `Infinity`, and `-Infinity`.
- * Those values decode to invalid `Date` instances.
+ * JavaScript `Date` supports a narrower range than safe integers, so integers
+ * outside the supported `Date` range fail decoding.
  *
  * @see {@link DateFromString} for decoding string-encoded dates
  * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
@@ -6229,19 +7549,7 @@ export const DateFromString = /*#__PURE__*/DateString.pipe(/*#__PURE__*/decodeTo
  * @category Date
  * @since 4.0.0
  */
-export const DateFromMillis = /*#__PURE__*/Number.pipe(/*#__PURE__*/decodeTo(Date, SchemaTransformation.dateFromMillis));
-/**
- * Schema for **valid** JavaScript `Date` objects.
- *
- * **Details**
- *
- * This schema accepts `Date` instances but rejects invalid dates (such as `new
- * Date("invalid")`).
- *
- * @category Date
- * @since 4.0.0
- */
-export const DateValid = /*#__PURE__*/Date.check(/*#__PURE__*/isDateValid());
+export const DateFromMillis = /*#__PURE__*/Int.pipe(/*#__PURE__*/decodeTo(Date, SchemaTransformation.dateFromMillis));
 /**
  * Schema for `Duration` values.
  *
@@ -6264,14 +7572,15 @@ export const DateValid = /*#__PURE__*/Date.check(/*#__PURE__*/isDateValid());
  * @since 3.10.0
  */
 export const Duration = /*#__PURE__*/declare(Duration_.isDuration, {
-  typeConstructor: {
-    _tag: "effect/Duration"
+  representation: {
+    id: "effect/schema/Duration",
+    payload: null
   },
-  generation: {
+  toCode: () => ({
     runtime: `Schema.Duration`,
     Type: `Duration.Duration`,
-    importDeclaration: `import * as Duration from "effect/Duration"`
-  },
+    importDeclarations: [`import * as Duration from "effect/Duration"`]
+  }),
   expected: "Duration",
   toCodecJson: () => link()(Union([Struct({
     _tag: Literal("Infinity")
@@ -6323,6 +7632,19 @@ export const Duration = /*#__PURE__*/declare(Duration_.isDuration, {
   toFormatter: () => globalThis.String,
   toEquivalence: () => Duration_.Equivalence
 });
+/**
+ * Reviver for persisted {@link Duration} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Duration} schema.
+ *
+ * @see {@link Duration} for the corresponding schema
+ *
+ * @category Duration
+ * @since 4.0.0
+ */
+export const DurationReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/Duration", Duration);
 const DurationString = /*#__PURE__*/String.annotate({
   expected: "a string that will be decoded as a Duration"
 });
@@ -6342,44 +7664,44 @@ const DurationString = /*#__PURE__*/String.annotate({
  * @since 4.0.0
  */
 export const DurationFromString = /*#__PURE__*/DurationString.pipe(/*#__PURE__*/decodeTo(Duration, SchemaTransformation.durationFromString));
-const bigint0 = /*#__PURE__*/globalThis.BigInt(0);
 /**
- * Schema that decodes a non-negative `bigint` into a
- * `Duration`, treating the bigint as nanoseconds.
+ * Schema that decodes a `bigint` into a `Duration`, treating the bigint as
+ * nanoseconds.
  *
  * **Details**
  *
  * Decoding:
- * A non-negative `bigint` representing nanoseconds is decoded as a `Duration`.
+ * A `bigint` representing nanoseconds is decoded as a `Duration`.
  *
  * Encoding:
- * Finite durations are encoded as a non-negative `bigint` number of nanoseconds.
- * Encoding fails when the duration cannot be represented as nanoseconds, such as
- * `Duration.infinity`.
+ * Finite durations are encoded as a `bigint` number of nanoseconds. Encoding
+ * fails when the duration cannot be represented as nanoseconds, such as
+ * `Duration.infinity` or `Duration.negativeInfinity`.
  *
  * @category Duration
  * @since 3.10.0
  */
-export const DurationFromNanos = /*#__PURE__*/BigInt.check(isGreaterThanOrEqualToBigInt(bigint0)).pipe(/*#__PURE__*/decodeTo(Duration, SchemaTransformation.durationFromNanos));
+export const DurationFromNanos = /*#__PURE__*/BigInt.pipe(/*#__PURE__*/decodeTo(Duration, SchemaTransformation.durationFromNanos));
 /**
- * Schema that decodes a non-negative (possibly infinite)
- * integer into a `Duration`, treating the integer value as the duration in
+ * Schema that decodes a number into a `Duration`, treating the number as
  * milliseconds.
  *
  * **Details**
  *
  * Decoding:
- * - A non-negative (possibly infinite) integer representing milliseconds is
- *   decoded as a `Duration`
+ * - A finite or infinite number is decoded as a `Duration`
  *
  * Encoding:
- * - A `Duration` is encoded to a non-negative (possibly infinite) integer
- *   representing milliseconds
+ * - A `Duration` is encoded to a finite or infinite number of milliseconds
+ *
+ * **Gotchas**
+ *
+ * `NaN` is decoded as `Duration.zero`, matching `Duration.millis`.
  *
  * @category Duration
  * @since 3.10.0
  */
-export const DurationFromMillis = /*#__PURE__*/Number.check(isGreaterThanOrEqualTo(0)).pipe(/*#__PURE__*/decodeTo(Duration, SchemaTransformation.durationFromMillis));
+export const DurationFromMillis = /*#__PURE__*/Number.pipe(/*#__PURE__*/decodeTo(Duration, SchemaTransformation.durationFromMillis));
 const BigDecimalString = /*#__PURE__*/String.annotate({
   expected: "a string that will be decoded as a BigDecimal"
 });
@@ -6450,14 +7772,15 @@ function bigDecimalScaleConstraints(ordered) {
  * @since 3.10.0
  */
 export const BigDecimal = /*#__PURE__*/declare(BigDecimal_.isBigDecimal, {
-  typeConstructor: {
-    _tag: "effect/BigDecimal"
+  representation: {
+    id: "effect/schema/BigDecimal",
+    payload: null
   },
-  generation: {
+  toCode: () => ({
     runtime: `Schema.BigDecimal`,
     Type: `BigDecimal.BigDecimal`,
-    importDeclaration: `import * as BigDecimal from "effect/BigDecimal"`
-  },
+    importDeclarations: [`import * as BigDecimal from "effect/BigDecimal"`]
+  }),
   expected: "BigDecimal",
   toCodecJson: () => link()(BigDecimalString, SchemaTransformation.bigDecimalFromString),
   toArbitrary: () => (fc, ctx) => {
@@ -6479,6 +7802,19 @@ export const BigDecimal = /*#__PURE__*/declare(BigDecimal_.isBigDecimal, {
   toFormatter: () => bd => BigDecimal_.format(bd),
   toEquivalence: () => BigDecimal_.Equivalence
 });
+/**
+ * Reviver for persisted {@link BigDecimal} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link BigDecimal} schema.
+ *
+ * @see {@link BigDecimal} for the corresponding schema
+ *
+ * @category BigDecimal
+ * @since 4.0.0
+ */
+export const BigDecimalReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/BigDecimal", BigDecimal);
 /**
  * Schema that parses a string into a `BigDecimal`.
  *
@@ -6507,6 +7843,10 @@ export const BigDecimal = /*#__PURE__*/declare(BigDecimal_.isBigDecimal, {
  * @since 4.0.0
  */
 export const BigDecimalFromString = /*#__PURE__*/BigDecimalString.pipe(/*#__PURE__*/decodeTo(BigDecimal, SchemaTransformation.bigDecimalFromString));
+const JsonString = /*#__PURE__*/String.annotate({
+  expected: "a string that will be decoded as JSON",
+  contentMediaType: "application/json"
+});
 /**
  * Schema that decodes a JSON-encoded string into an `unknown` value.
  *
@@ -6545,12 +7885,6 @@ export const UnknownFromJsonString = /*#__PURE__*/fromJsonString(Unknown);
  * The resulting schema first parses the input string as JSON, and then runs the
  * provided schema on the parsed result.
  *
- * JSON Schema generation:
- *
- * When using `fromJsonString` with `draft-2020-12` or `openApi3.1`, the
- * resulting schema will be a JSON Schema with a `contentSchema` property that
- * contains the JSON Schema for the given schema.
- *
  * **Example** (Decoding JSON strings with a schema)
  *
  * ```ts
@@ -6563,51 +7897,11 @@ export const UnknownFromJsonString = /*#__PURE__*/fromJsonString(Unknown);
  * // => { a: 1 }
  * ```
  *
- * **Example** (Emitting JSON Schema for a JSON string decoder)
- *
- * ```ts
- * import { Schema } from "effect"
- *
- * const original = Schema.Struct({ a: Schema.String })
- * const schema = Schema.fromJsonString(original)
- *
- * const document = Schema.toJsonSchemaDocument(schema)
- *
- * console.log(JSON.stringify(document, null, 2))
- * // {
- * //   "source": "draft-2020-12",
- * //   "schema": {
- * //     "type": "string",
- * //     "contentMediaType": "application/json",
- * //     "contentSchema": {
- * //       "type": "object",
- * //       "properties": {
- * //         "a": {
- * //           "type": "string"
- * //         }
- * //       },
- * //       "required": [
- * //         "a"
- * //       ],
- * //       "additionalProperties": false
- * //     }
- * //   },
- * //   "definitions": {}
- * // }
- * ```
- *
  * @category constructors
  * @since 4.0.0
  */
 export function fromJsonString(schema) {
-  const identifier = SchemaAST.resolveIdentifier(schema.ast);
-  return String.annotate({
-    // Give the transport wrapper its own name so the decoded payload keeps its identifier.
-    identifier: identifier === undefined ? undefined : `${identifier}JsonString`,
-    expected: "a string that will be decoded as JSON",
-    contentMediaType: "application/json",
-    contentSchema: SchemaAST.toEncoded(schema.ast)
-  }).pipe(decodeTo(schema, SchemaTransformation.fromJsonString));
+  return JsonString.pipe(decodeTo(schema, SchemaTransformation.fromJsonString));
 }
 /**
  * Schema for JavaScript `File` objects.
@@ -6621,19 +7915,20 @@ export function fromJsonString(schema) {
  * @since 4.0.0
  */
 export const File = /*#__PURE__*/instanceOf(globalThis.File, {
-  typeConstructor: {
-    _tag: "File"
+  representation: {
+    id: "effect/schema/File",
+    payload: null
   },
-  generation: {
+  toCode: () => ({
     runtime: `Schema.File`,
     Type: `globalThis.File`
-  },
+  }),
   expected: "File",
   toCodecJson: () => link()(Struct({
     data: String.check(isBase64()),
     type: String,
     name: String,
-    lastModified: Number
+    lastModified: Int
   }), SchemaTransformation.transformOrFail({
     decode: e => Result_.match(Encoding.decodeBase64(e.data), {
       onFailure: error => Effect.fail(new SchemaIssue.InvalidValue(Option_.some(e.data), {
@@ -6663,6 +7958,19 @@ export const File = /*#__PURE__*/instanceOf(globalThis.File, {
     })
   }))
 });
+/**
+ * Reviver for persisted `File` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link File} schema.
+ *
+ * @see {@link File} for the corresponding schema
+ *
+ * @category file
+ * @since 4.0.0
+ */
+export const FileReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/File", File);
 /**
  * Schema for JavaScript `FormData` objects.
  *
@@ -6675,13 +7983,14 @@ export const File = /*#__PURE__*/instanceOf(globalThis.File, {
  * @since 4.0.0
  */
 export const FormData = /*#__PURE__*/instanceOf(globalThis.FormData, {
-  typeConstructor: {
-    _tag: "FormData"
+  representation: {
+    id: "effect/schema/FormData",
+    payload: null
   },
-  generation: {
+  toCode: () => ({
     runtime: `Schema.FormData`,
     Type: `globalThis.FormData`
-  },
+  }),
   expected: "FormData",
   toCodecJson: () => link()(ArraySchema(Tuple([String, Union([Struct({
     _tag: tag("String"),
@@ -6714,6 +8023,19 @@ export const FormData = /*#__PURE__*/instanceOf(globalThis.FormData, {
     }
   }))
 });
+/**
+ * Reviver for persisted `FormData` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link FormData} schema.
+ *
+ * @see {@link FormData} for the corresponding schema
+ *
+ * @category FormData
+ * @since 4.0.0
+ */
+export const FormDataReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/FormData", FormData);
 /**
  * Schema for decoding `FormData` through a bracket-notation tree.
  *
@@ -6813,13 +8135,14 @@ export function fromFormData(schema) {
  * @since 4.0.0
  */
 export const URLSearchParams = /*#__PURE__*/instanceOf(globalThis.URLSearchParams, {
-  typeConstructor: {
-    _tag: "URLSearchParams"
+  representation: {
+    id: "effect/schema/URLSearchParams",
+    payload: null
   },
-  generation: {
+  toCode: () => ({
     runtime: `Schema.URLSearchParams`,
     Type: `globalThis.URLSearchParams`
-  },
+  }),
   expected: "URLSearchParams",
   toCodecJson: () => link()(String.annotate({
     expected: "a query string that will be decoded as URLSearchParams"
@@ -6828,6 +8151,19 @@ export const URLSearchParams = /*#__PURE__*/instanceOf(globalThis.URLSearchParam
     encode: params => params.toString()
   }))
 });
+/**
+ * Reviver for persisted `URLSearchParams` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link URLSearchParams} schema.
+ *
+ * @see {@link URLSearchParams} for the corresponding schema
+ *
+ * @category search params
+ * @since 4.0.0
+ */
+export const URLSearchParamsReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/URLSearchParams", URLSearchParams);
 /**
  * Schema for decoding `URLSearchParams` through a bracket-notation tree.
  *
@@ -6911,20 +8247,6 @@ export const URLSearchParams = /*#__PURE__*/instanceOf(globalThis.URLSearchParam
 export function fromURLSearchParams(schema) {
   return URLSearchParams.pipe(decodeTo(schema, SchemaTransformation.fromURLSearchParams));
 }
-/**
- * Schema for finite numbers, rejecting `NaN`, `Infinity`, and `-Infinity`.
- *
- * @category Number
- * @since 3.10.0
- */
-export const Finite = /*#__PURE__*/Number.check(/*#__PURE__*/isFinite());
-/**
- * Schema for integers, rejecting `NaN`, `Infinity`, and `-Infinity`.
- *
- * @category Number
- * @since 3.10.0
- */
-export const Int = /*#__PURE__*/Number.check(/*#__PURE__*/isInt());
 /**
  * Schema that parses a string into a `number` using JavaScript
  * number coercion.
@@ -7171,17 +8493,31 @@ const Base64String = /*#__PURE__*/String.annotate({
  * @since 4.0.0
  */
 export const Uint8Array = /*#__PURE__*/instanceOf(globalThis.Uint8Array, {
-  typeConstructor: {
-    _tag: "Uint8Array"
+  representation: {
+    id: "effect/schema/Uint8Array",
+    payload: null
   },
-  generation: {
+  toCode: () => ({
     runtime: `Schema.Uint8Array`,
     Type: `globalThis.Uint8Array`
-  },
+  }),
   expected: "Uint8Array",
   toCodecJson: () => link()(Base64String, SchemaTransformation.uint8ArrayFromBase64String),
   toArbitrary: () => fc => fc.uint8Array()
 });
+/**
+ * Reviver for persisted `Uint8Array` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Uint8Array} schema.
+ *
+ * @see {@link Uint8Array} for the corresponding schema
+ *
+ * @category Uint8Array
+ * @since 4.0.0
+ */
+export const Uint8ArrayReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/Uint8Array", Uint8Array);
 /**
  * Schema that decodes a base64 encoded string into a
  * `Uint8Array`.
@@ -7262,22 +8598,36 @@ export const Uint8ArrayFromHex = /*#__PURE__*/String.annotate({
  * @since 3.10.0
  */
 export const DateTimeUtc = /*#__PURE__*/declare(u => DateTime.isDateTime(u) && DateTime.isUtc(u), {
-  typeConstructor: {
-    _tag: "effect/DateTime.Utc"
+  representation: {
+    id: "effect/schema/DateTimeUtc",
+    payload: null
   },
-  generation: {
+  toCode: () => ({
     runtime: `Schema.DateTimeUtc`,
     Type: `DateTime.Utc`,
-    importDeclaration: `import * as DateTime from "effect/DateTime"`
-  },
+    importDeclarations: [`import * as DateTime from "effect/DateTime"`]
+  }),
   expected: "DateTime.Utc",
   toCodecJson: () => link()(String, SchemaTransformation.dateTimeUtcFromString),
-  toArbitrary: () => (fc, ctx) => fc.date(dateArbitraryConstraints(ctx?.constraint, ctx?.constraint?.ordered?.order === DateTime.Order ? ctx.constraint.ordered : undefined, {
-    valid: true
+  toArbitrary: () => (fc, ctx) => fc.date(dateArbitraryConstraints(ctx?.constraint?.ordered?.order === DateTime.Order ? ctx.constraint.ordered : undefined, {
+    noInvalidDate: true
   }, DateTime.toDateUtc)).map(date => DateTime.fromDateUnsafe(date)),
   toFormatter: () => utc => utc.toString(),
   toEquivalence: () => DateTime.Equivalence
 });
+/**
+ * Reviver for persisted {@link DateTimeUtc} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link DateTimeUtc} schema.
+ *
+ * @see {@link DateTimeUtc} for the corresponding schema
+ *
+ * @category DateTime
+ * @since 4.0.0
+ */
+export const DateTimeUtcReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/DateTimeUtc", DateTimeUtc);
 /**
  * Schema that decodes a `Date` into a `DateTime.Utc`.
  *
@@ -7297,12 +8647,12 @@ export const DateTimeUtc = /*#__PURE__*/declare(u => DateTime.isDateTime(u) && D
  * @see {@link DateTimeUtc} for validating values that are already `DateTime.Utc`
  * @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values
  * @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
- * @see {@link DateValid} for validating Date instances without converting them
+ * @see {@link Date} for validating Date instances without converting them
  *
  * @category DateTime
  * @since 3.12.0
  */
-export const DateTimeUtcFromDate = /*#__PURE__*/DateValid.pipe(/*#__PURE__*/decodeTo(DateTimeUtc, {
+export const DateTimeUtcFromDate = /*#__PURE__*/Date.pipe(/*#__PURE__*/decodeTo(DateTimeUtc, {
   decode: /*#__PURE__*/SchemaGetter.dateTimeUtcFromInput(),
   encode: /*#__PURE__*/SchemaGetter.transform(DateTime.toDateUtc)
 }));
@@ -7348,7 +8698,7 @@ export const DateTimeUtcFromString = /*#__PURE__*/String.annotate({
  * @category DateTime
  * @since 4.0.0
  */
-export const DateTimeUtcFromMillis = /*#__PURE__*/Number.pipe(/*#__PURE__*/decodeTo(DateTimeUtc, {
+export const DateTimeUtcFromMillis = /*#__PURE__*/Int.pipe(/*#__PURE__*/decodeTo(DateTimeUtc, {
   decode: /*#__PURE__*/SchemaGetter.dateTimeUtcFromInput(),
   encode: /*#__PURE__*/SchemaGetter.transform(DateTime.toEpochMillis)
 }));
@@ -7365,16 +8715,17 @@ export const DateTimeUtcFromMillis = /*#__PURE__*/Number.pipe(/*#__PURE__*/decod
  * @since 3.10.0
  */
 export const TimeZoneOffset = /*#__PURE__*/declare(DateTime.isTimeZoneOffset, {
-  typeConstructor: {
-    _tag: "effect/DateTime.TimeZone.Offset"
+  representation: {
+    id: "effect/schema/TimeZoneOffset",
+    payload: null
   },
-  generation: {
+  toCode: () => ({
     runtime: `Schema.TimeZoneOffset`,
     Type: `DateTime.TimeZone.Offset`,
-    importDeclaration: `import * as DateTime from "effect/DateTime"`
-  },
+    importDeclarations: [`import * as DateTime from "effect/DateTime"`]
+  }),
   expected: "DateTime.TimeZone.Offset",
-  toCodecJson: () => link()(Number, SchemaTransformation.timeZoneOffsetFromNumber),
+  toCodecJson: () => link()(Int, SchemaTransformation.timeZoneOffsetFromNumber),
   toArbitrary: () => fc => fc.integer({
     min: -12 * 60 * 60 * 1000,
     max: 14 * 60 * 60 * 1000
@@ -7382,6 +8733,19 @@ export const TimeZoneOffset = /*#__PURE__*/declare(DateTime.isTimeZoneOffset, {
   toFormatter: () => tz => DateTime.zoneToString(tz),
   toEquivalence: () => (a, b) => a.offset === b.offset
 });
+/**
+ * Reviver for persisted {@link TimeZoneOffset} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link TimeZoneOffset} schema.
+ *
+ * @see {@link TimeZoneOffset} for the corresponding schema
+ *
+ * @category DateTime
+ * @since 4.0.0
+ */
+export const TimeZoneOffsetReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/TimeZoneOffset", TimeZoneOffset);
 const TimeZoneNamedString = /*#__PURE__*/String.annotate({
   expected: "an IANA time zone identifier"
 });
@@ -7398,20 +8762,34 @@ const TimeZoneNamedString = /*#__PURE__*/String.annotate({
  * @since 3.10.0
  */
 export const TimeZoneNamed = /*#__PURE__*/declare(DateTime.isTimeZoneNamed, {
-  typeConstructor: {
-    _tag: "effect/DateTime.TimeZone.Named"
+  representation: {
+    id: "effect/schema/TimeZoneNamed",
+    payload: null
   },
-  generation: {
+  toCode: () => ({
     runtime: `Schema.TimeZoneNamed`,
     Type: `DateTime.TimeZone.Named`,
-    importDeclaration: `import * as DateTime from "effect/DateTime"`
-  },
+    importDeclarations: [`import * as DateTime from "effect/DateTime"`]
+  }),
   expected: "DateTime.TimeZone.Named",
   toCodecJson: () => link()(TimeZoneNamedString, SchemaTransformation.timeZoneNamedFromString),
   toArbitrary: () => fc => fc.constantFrom(...["UTC", "Europe/London", "America/New_York", "Asia/Tokyo", "Australia/Sydney"].map(DateTime.zoneMakeNamedUnsafe)),
   toFormatter: () => tz => DateTime.zoneToString(tz),
   toEquivalence: () => (a, b) => a.id === b.id
 });
+/**
+ * Reviver for persisted {@link TimeZoneNamed} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link TimeZoneNamed} schema.
+ *
+ * @see {@link TimeZoneNamed} for the corresponding schema
+ *
+ * @category DateTime
+ * @since 4.0.0
+ */
+export const TimeZoneNamedReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/TimeZoneNamed", TimeZoneNamed);
 /**
  * Schema that parses an IANA time zone identifier string into a `DateTime.TimeZone.Named`.
  *
@@ -7444,14 +8822,15 @@ const TimeZoneString = /*#__PURE__*/String.annotate({
  * @since 3.10.0
  */
 export const TimeZone = /*#__PURE__*/declare(DateTime.isTimeZone, {
-  typeConstructor: {
-    _tag: "effect/DateTime.TimeZone"
+  representation: {
+    id: "effect/schema/TimeZone",
+    payload: null
   },
-  generation: {
+  toCode: () => ({
     runtime: `Schema.TimeZone`,
     Type: `DateTime.TimeZone`,
-    importDeclaration: `import * as DateTime from "effect/DateTime"`
-  },
+    importDeclarations: [`import * as DateTime from "effect/DateTime"`]
+  }),
   expected: "DateTime.TimeZone",
   toCodecJson: () => link()(TimeZoneString, SchemaTransformation.timeZoneFromString),
   toArbitrary: () => fc => fc.oneof(fc.integer({
@@ -7461,6 +8840,19 @@ export const TimeZone = /*#__PURE__*/declare(DateTime.isTimeZone, {
   toFormatter: () => tz => DateTime.zoneToString(tz),
   toEquivalence: () => (a, b) => DateTime.zoneToString(a) === DateTime.zoneToString(b)
 });
+/**
+ * Reviver for persisted {@link TimeZone} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link TimeZone} schema.
+ *
+ * @see {@link TimeZone} for the corresponding schema
+ *
+ * @category DateTime
+ * @since 4.0.0
+ */
+export const TimeZoneReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/TimeZone", TimeZone);
 /**
  * Schema that parses a time zone string into a `DateTime.TimeZone`.
  *
@@ -7495,26 +8887,40 @@ const DateTimeZonedString = /*#__PURE__*/String.annotate({
  * @since 3.10.0
  */
 export const DateTimeZoned = /*#__PURE__*/declare(u => DateTime.isDateTime(u) && DateTime.isZoned(u), {
-  typeConstructor: {
-    _tag: "effect/DateTime.Zoned"
+  representation: {
+    id: "effect/schema/DateTimeZoned",
+    payload: null
   },
-  generation: {
+  toCode: () => ({
     runtime: `Schema.DateTimeZoned`,
     Type: `DateTime.Zoned`,
-    importDeclaration: `import * as DateTime from "effect/DateTime"`
-  },
+    importDeclarations: [`import * as DateTime from "effect/DateTime"`]
+  }),
   expected: "DateTime.Zoned",
   toCodecJson: () => link()(DateTimeZonedString, SchemaTransformation.dateTimeZonedFromString),
-  toArbitrary: () => (fc, ctx) => fc.tuple(fc.date(dateArbitraryConstraints(ctx?.constraint, ctx?.constraint?.ordered?.order === DateTime.Order ? ctx.constraint.ordered : undefined, {
+  toArbitrary: () => (fc, ctx) => fc.tuple(fc.date(dateArbitraryConstraints(ctx?.constraint?.ordered?.order === DateTime.Order ? ctx.constraint.ordered : undefined, {
     max: new globalThis.Date(8640000000000000 - 14 * 60 * 60 * 1000),
     min: new globalThis.Date(-8640000000000000 + 14 * 60 * 60 * 1000),
-    valid: true
+    noInvalidDate: true
   }, DateTime.toDateUtc)), fc.constantFrom("UTC", "Europe/London", "America/New_York", "Asia/Tokyo", "Australia/Sydney")).map(([date, zone]) => DateTime.makeZonedUnsafe(date, {
     timeZone: zone
   })),
   toFormatter: () => zoned => DateTime.formatIsoZoned(zoned),
   toEquivalence: () => DateTime.Equivalence
 });
+/**
+ * Reviver for persisted {@link DateTimeZoned} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link DateTimeZoned} schema.
+ *
+ * @see {@link DateTimeZoned} for the corresponding schema
+ *
+ * @category DateTime
+ * @since 4.0.0
+ */
+export const DateTimeZonedReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/DateTimeZoned", DateTimeZoned);
 /**
  * Schema that parses a zoned DateTime string into a `DateTime.Zoned`.
  *
@@ -7629,7 +9035,7 @@ function getClassSchemaFactory(from, identifier, annotations) {
         terminal: from.terminal?.map(args => new self(args))
       }),
       toFormatter: ([from]) => t => `${self.identifier}(${from(t)})`,
-      "~sentinels": SchemaAST.collectSentinels(from.ast),
+      [InternalAnnotations.SENTINELS_ANNOTATION_KEY]: SchemaAST.collectSentinels(from.ast),
       ...annotations
     }));
     return memo = decodeTo(to, transformation)(from);
@@ -7989,14 +9395,15 @@ export function toFormatter(schema, options) {
         }
       case "Union":
         {
-          const getCandidates = t => SchemaAST.getCandidates(t, ast.types);
+          const types = SchemaAST.toType(ast).types;
+          const getCandidates = t => SchemaAST.getCandidates(t, types);
+          const compiled = new Map(types.map((candidate, i) => [candidate, [SchemaParser._is(candidate), recur(ast.types[i])]]));
           return t => {
             const candidates = getCandidates(t);
-            const refinements = candidates.map(SchemaParser._is);
             for (let i = 0; i < candidates.length; i++) {
-              const is = refinements[i];
+              const [is, formatter] = compiled.get(candidates[i]);
               if (is(t)) {
-                return recur(candidates[i])(t);
+                return formatter(t);
               }
             }
             return format(t);
@@ -8056,15 +9463,18 @@ export function toEquivalence(schema) {
 // Representation
 // -----------------------------------------------------------------------------
 /**
- * Derives an intermediate `SchemaRepresentation.Document` from a schema. This
- * document is used internally by {@link toJsonSchemaDocument} and related
- * functions to produce JSON Schema output.
+ * Derives an intermediate `SchemaRepresentation.Document` from the encoded
+ * side of a schema.
+ *
+ * **Details**
+ *
+ * Use {@link toType} before this function to represent the type side instead.
  *
  * @category Representation
  * @since 4.0.0
  */
 export function toRepresentation(schema) {
-  return InternalStandard.fromAST(schema.ast);
+  return InternalToRepresentation.toRepresentation(schema.ast);
 }
 /**
  * Returns a JSON Schema document using draft 2020-12.
@@ -8073,59 +9483,123 @@ export function toRepresentation(schema) {
  *
  * The `options` parameter controls generation details such as additional
  * properties and synthesized check descriptions; it does not change the draft
- * target.
+ * target. Declarations are lowered through their `toCodecJson` or `toCodec`
+ * annotation when available before the representation document is compiled.
  *
  * **Gotchas**
  *
  * JSON Schema generation is best-effort. Some Effect schema semantics cannot
  * be represented exactly in JSON Schema, and importing an emitted JSON Schema
  * may produce an equivalent approximation rather than the original schema
- * shape.
+ * shape. Opaque declarations without a structural codec are represented by an
+ * unconstrained JSON Schema.
  *
  * @category converting
  * @since 4.0.0
  */
 export function toJsonSchemaDocument(schema, options) {
-  const sd = toRepresentation(schema);
-  const jd = InternalStandard.toJsonSchemaDocument(sd, options);
-  return {
-    dialect: "draft-2020-12",
-    schema: jd.schema,
-    definitions: jd.definitions
-  };
+  const document = InternalToRepresentation.toRepresentation(toCodecJsonAST(schema.ast));
+  return InternalToJsonSchemaDocument.toJsonSchemaDocument(document, options);
 }
 /**
  * Derives a canonical JSON codec from a schema. The encoded form is `Json`, and
  * decoding produces the schema's `Type`.
  *
+ * **Gotchas**
+ *
+ * Declarations without a `toCodecJson` or `toCodec` annotation use `Json` as
+ * their encoded schema. This keeps codec construction total, but encoding or
+ * decoding can still fail when declaration values are not JSON values. A
+ * `toCodecJson` callback can return `undefined` when the declaration is already
+ * in canonical JSON form.
+ *
  * @category Canonical Codecs
  * @since 4.0.0
  */
 export function toCodecJson(schema) {
-  return make(toCodecJsonTop(schema.ast), {
+  return make(toCodecJsonAST(schema.ast), {
     schema
   });
 }
-const toCodecJsonTop = /*#__PURE__*/SchemaAST.applyToSelfOrLastLinkEncoding(ast => {
-  const out = toCodecJsonBase(ast, toCodecJsonTop);
-  return out !== ast && SchemaAST.isOptional(ast) ? SchemaAST.optionalKeyLastLink(out) : out;
+const toCodecJsonASTBase = /*#__PURE__*/SchemaAST.applyToSelfOrLastLinkEncoding(ast => {
+  const out = toCodecJsonBase(ast, toCodecJsonAST);
+  const context = ast.context;
+  if (out === ast || context === undefined) return out;
+  return SchemaAST.replaceContextLastLink(out, withoutConstructorDefault(context));
+});
+/** @internal */
+export const toCodecJsonAST = /*#__PURE__*/memoize(ast => {
+  const identifier = InternalAnnotations.resolveIdentifier(ast);
+  const out = toCodecJsonASTBase(ast);
+  if (identifier === undefined || out.encoding === undefined) return out;
+  const encoded = SchemaAST.getLastEncoding(out);
+  if (InternalAnnotations.resolveIdentifier(encoded) !== undefined || InternalAnnotations.resolveIdentifierFallback(encoded) === identifier) {
+    return out;
+  }
+  const annotated = SchemaAST.annotate(encoded, {
+    [InternalAnnotations.IDENTIFIER_FALLBACK_KEY]: identifier
+  });
+  return SchemaAST.applyToSelfOrLastLinkEncoding(() => annotated)(out);
+});
+function withoutConstructorDefault(context) {
+  return context.defaultValue === undefined ? context : new SchemaAST.Context(context.isOptional, context.isMutable, undefined, context.annotations);
+}
+function validateCanonicalObjectPropertyNames(ast) {
+  if (ast.propertySignatures.some(ps => typeof ps.name !== "string")) {
+    throw new globalThis.Error("Objects property names must be strings", {
+      cause: ast
+    });
+  }
+}
+function makeReorder(getPriority) {
+  return types => {
+    // Create a map of original indices for O(1) lookup
+    const indexMap = new Map();
+    for (let i = 0; i < types.length; i++) {
+      indexMap.set(SchemaAST.toEncoded(types[i]), i);
+    }
+    // Create a sorted copy of the types array
+    const sortedTypes = [...types].sort((a, b) => {
+      a = SchemaAST.toEncoded(a);
+      b = SchemaAST.toEncoded(b);
+      const pa = getPriority(a);
+      const pb = getPriority(b);
+      if (pa !== pb) return pa - pb;
+      // If priorities are equal, maintain original order (stable sort)
+      return indexMap.get(a) - indexMap.get(b);
+    });
+    // Check if order changed by comparing arrays
+    const orderChanged = sortedTypes.some((ast, index) => ast !== types[index]);
+    if (!orderChanged) return types;
+    return sortedTypes;
+  };
+}
+const toCodecJsonReorder = /*#__PURE__*/makeReorder(ast => {
+  switch (ast._tag) {
+    case "BigInt":
+    case "Symbol":
+    case "UniqueSymbol":
+      return 0;
+    default:
+      return 1;
+  }
 });
 function toCodecJsonBase(ast, recur) {
   switch (ast._tag) {
     case "Declaration":
       {
         const getLink = ast.annotations?.toCodecJson ?? ast.annotations?.toCodec;
-        if (Predicate.isFunction(getLink)) {
-          const tps = SchemaAST.isDeclaration(ast) ? ast.typeParameters.map(tp => InternalSchema.make(SchemaAST.toEncoded(tp))) : [];
-          const link = getLink(tps);
-          const to = recur(link.to);
-          return SchemaAST.replaceEncoding(ast, to === link.to ? [link] : [new SchemaAST.Link(to, link.transformation)]);
+        if (!Predicate.isFunction(getLink)) {
+          return SchemaAST.replaceEncoding(ast, [SchemaAST.unknownToJson]);
         }
-        return SchemaAST.replaceEncoding(ast, [SchemaAST.unknownToNull]);
+        const typeParameters = ast.typeParameters.map(tp => InternalSchema.make(SchemaAST.toEncoded(tp)));
+        const link = getLink(typeParameters);
+        return link === undefined ? ast : SchemaAST.replaceEncoding(ast, [SchemaAST.mapLink(link, recur)]);
       }
     case "Unknown":
-    case "ObjectKeyword":
       return SchemaAST.replaceEncoding(ast, [SchemaAST.unknownToJson]);
+    case "ObjectKeyword":
+      return SchemaAST.replaceEncoding(ast, [SchemaAST.objectKeywordToJson]);
     case "Undefined":
     case "Void":
     case "Literal":
@@ -8137,16 +9611,12 @@ function toCodecJsonBase(ast, recur) {
       return ast.toCodecStringTree();
     case "Objects":
       {
-        if (ast.propertySignatures.some(ps => typeof ps.name !== "string")) {
-          throw new globalThis.Error("Objects property names must be strings", {
-            cause: ast
-          });
-        }
+        validateCanonicalObjectPropertyNames(ast);
         return ast.recur(recur, SchemaAST.parameterFromString);
       }
     case "Union":
       {
-        const sortedTypes = InternalSchema.jsonReorder(ast.types);
+        const sortedTypes = toCodecJsonReorder(ast.types);
         if (sortedTypes !== ast.types) {
           return new SchemaAST.Union(sortedTypes, ast.mode, ast.annotations, ast.checks, ast.encoding, ast.context, ast.encodingChecks).recur(recur);
         }
@@ -8171,7 +9641,7 @@ export function toCodecIso(schema) {
 }
 const toCodecIsoTop = /*#__PURE__*/memoize(ast => {
   const out = toCodecIsoBase(ast, toCodecIsoTop);
-  return out !== ast && SchemaAST.isOptional(ast) ? SchemaAST.optionalKeyLastLink(out) : out;
+  return out !== ast && ast.context !== undefined ? SchemaAST.replaceContextLastLink(out, withoutConstructorDefault(ast.context)) : out;
 });
 function toCodecIsoBase(ast, recur) {
   switch (ast._tag) {
@@ -8180,8 +9650,7 @@ function toCodecIsoBase(ast, recur) {
         const getLink = ast.annotations?.toCodecIso ?? ast.annotations?.toCodec;
         if (Predicate.isFunction(getLink)) {
           const link = getLink(ast.typeParameters.map(tp => InternalSchema.make(tp)));
-          const to = recur(link.to);
-          return SchemaAST.replaceEncoding(ast, to === link.to ? [link] : [new SchemaAST.Link(to, link.transformation)]);
+          return SchemaAST.replaceEncoding(ast, [SchemaAST.mapLink(link, recur)]);
         }
         return ast;
       }
@@ -8197,10 +9666,11 @@ function toCodecIsoBase(ast, recur) {
  * Converts a schema to the StringTree canonical codec, where every leaf value
  * becomes a string while preserving the original structure.
  *
- * **Details**
+ * **Gotchas**
  *
- * Declarations are converted to `undefined` (unless they have a
- * `toCodecJson` or `toCodec` annotation).
+ * Declarations must provide a structural `toCodecStringTree`, `toCodecJson`, or
+ * `toCodec` encoding. A callback can return `undefined` when the declaration is
+ * already in canonical StringTree form.
  *
  * @category Canonical Codecs
  * @since 4.0.0
@@ -8340,7 +9810,7 @@ const xml = {
     };
   }
 };
-function getStringTreePriority(ast) {
+const toStringTreeReorder = /*#__PURE__*/makeReorder(ast => {
   switch (ast._tag) {
     case "Null":
     case "Boolean":
@@ -8352,20 +9822,23 @@ function getStringTreePriority(ast) {
     default:
       return 1;
   }
-}
-const treeReorder = /*#__PURE__*/InternalSchema.makeReorder(getStringTreePriority);
+});
 function serializerTree(ast, recur, onMissingAnnotation) {
   switch (ast._tag) {
     case "Declaration":
       {
-        const getLink = ast.annotations?.toCodecJson ?? ast.annotations?.toCodec;
-        if (Predicate.isFunction(getLink)) {
-          const tps = SchemaAST.isDeclaration(ast) ? ast.typeParameters.map(tp => make(recur(SchemaAST.toEncoded(tp)))) : [];
-          const link = getLink(tps);
-          const to = recur(link.to);
-          return SchemaAST.replaceEncoding(ast, to === link.to ? [link] : [new SchemaAST.Link(to, link.transformation)]);
+        const typeParameters = ast.typeParameters.map(tp => make(recur(SchemaAST.toEncoded(tp))));
+        const getStringTreeLink = ast.annotations?.toCodecStringTree;
+        if (Predicate.isFunction(getStringTreeLink)) {
+          const link = getStringTreeLink(typeParameters);
+          if (link === undefined) return ast;
+          return SchemaAST.replaceEncoding(ast, [SchemaAST.mapLink(link, recur)]);
         }
-        return onMissingAnnotation(ast);
+        const getJsonLink = ast.annotations?.toCodecJson;
+        const jsonLink = Predicate.isFunction(getJsonLink) ? getJsonLink(typeParameters) : undefined;
+        const getLink = jsonLink === undefined ? ast.annotations?.toCodec : undefined;
+        const link = jsonLink ?? (Predicate.isFunction(getLink) ? getLink(typeParameters) : undefined);
+        return link === undefined ? onMissingAnnotation(ast) : SchemaAST.replaceEncoding(ast, [SchemaAST.mapLink(link, recur)]);
       }
     case "Null":
       return SchemaAST.replaceEncoding(ast, [nullToString]);
@@ -8383,16 +9856,12 @@ function serializerTree(ast, recur, onMissingAnnotation) {
       return ast.toCodecStringTree();
     case "Objects":
       {
-        if (ast.propertySignatures.some(ps => typeof ps.name !== "string")) {
-          throw new globalThis.Error("Objects property names must be strings", {
-            cause: ast
-          });
-        }
+        validateCanonicalObjectPropertyNames(ast);
         return ast.recur(recur, SchemaAST.parameterFromString);
       }
     case "Union":
       {
-        const sortedTypes = treeReorder(ast.types);
+        const sortedTypes = toStringTreeReorder(ast.types);
         if (sortedTypes !== ast.types) {
           return new SchemaAST.Union(sortedTypes, ast.mode, ast.annotations, ast.checks, ast.encoding, ast.context, ast.encodingChecks).recur(recur);
         }
@@ -8413,13 +9882,16 @@ const serializerStringTree = /*#__PURE__*/SchemaAST.applyToSelfOrLastLinkEncodin
   if (isSerializerArrayFromSingle(ast)) {
     return ast;
   }
-  const out = serializerTree(ast, serializerStringTree, ast => SchemaAST.replaceEncoding(ast, [unknownToUndefined]));
-  if (out !== ast && SchemaAST.isOptional(ast)) {
-    return SchemaAST.optionalKeyLastLink(out);
+  const out = serializerTree(ast, serializerStringTree, ast => {
+    throw new globalThis.Error("Missing structural codec for StringTree", {
+      cause: ast
+    });
+  });
+  if (out !== ast && ast.context !== undefined) {
+    return SchemaAST.replaceContextLastLink(out, withoutConstructorDefault(ast.context));
   }
   return out;
 });
-const unknownToUndefined = /*#__PURE__*/new SchemaAST.Link(SchemaAST.undefined, /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.passthrough(), /*#__PURE__*/SchemaGetter.transform(() => undefined)));
 const toArrayFromSingleInputElement = ast => SchemaAST.isOptional(ast) ? SchemaAST.optionalKey(SchemaAST.unknown) : SchemaAST.unknown;
 const arrayFromSingleTransformation = /*#__PURE__*/new SchemaTransformation.Transformation(/*#__PURE__*/SchemaGetter.transform(input => typeof input === "string" ? [input] : input), /*#__PURE__*/SchemaGetter.passthrough());
 const toCodecArrayFromSingleTop = /*#__PURE__*/SchemaAST.applyToSelfOrLastLinkEncoding(ast => {
@@ -8438,6 +9910,192 @@ const toCodecArrayFromSingleTop = /*#__PURE__*/SchemaAST.applyToSelfOrLastLinkEn
 function onSerializerArrayFromSingle(ast) {
   return ast._tag === "Declaration" || ast._tag === "Arrays" || ast._tag === "Objects" || ast._tag === "Union" || ast._tag === "Suspend" ? ast.recur(toCodecArrayFromSingleTop) : ast;
 }
+/**
+ * Reviver for persisted `isGreaterThanDate` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isGreaterThanDate}.
+ *
+ * @see {@link isGreaterThanDate} for creating the corresponding check
+ *
+ * @category Date checks
+ * @since 4.0.0
+ */
+export const isGreaterThanDateReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isGreaterThanDate", /*#__PURE__*/Struct({
+  exclusiveMinimum: Date
+}), ({
+  annotations,
+  payload
+}) => isGreaterThanDate(payload.exclusiveMinimum, annotations));
+/**
+ * Reviver for persisted `isGreaterThanOrEqualToDate` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isGreaterThanOrEqualToDate}.
+ *
+ * @see {@link isGreaterThanOrEqualToDate} for creating the corresponding check
+ *
+ * @category Date checks
+ * @since 4.0.0
+ */
+export const isGreaterThanOrEqualToDateReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isGreaterThanOrEqualToDate", /*#__PURE__*/Struct({
+  minimum: Date
+}), ({
+  annotations,
+  payload
+}) => isGreaterThanOrEqualToDate(payload.minimum, annotations));
+/**
+ * Reviver for persisted `isLessThanDate` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isLessThanDate}.
+ *
+ * @see {@link isLessThanDate} for creating the corresponding check
+ *
+ * @category Date checks
+ * @since 4.0.0
+ */
+export const isLessThanDateReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isLessThanDate", /*#__PURE__*/Struct({
+  exclusiveMaximum: Date
+}), ({
+  annotations,
+  payload
+}) => isLessThanDate(payload.exclusiveMaximum, annotations));
+/**
+ * Reviver for persisted `isLessThanOrEqualToDate` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isLessThanOrEqualToDate}.
+ *
+ * @see {@link isLessThanOrEqualToDate} for creating the corresponding check
+ *
+ * @category Date checks
+ * @since 4.0.0
+ */
+export const isLessThanOrEqualToDateReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isLessThanOrEqualToDate", /*#__PURE__*/Struct({
+  maximum: Date
+}), ({
+  annotations,
+  payload
+}) => isLessThanOrEqualToDate(payload.maximum, annotations));
+/**
+ * Reviver for persisted `isBetweenDate` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isBetweenDate}.
+ *
+ * @see {@link isBetweenDate} for creating the corresponding check
+ *
+ * @category Date checks
+ * @since 4.0.0
+ */
+export const isBetweenDateReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isBetweenDate", /*#__PURE__*/Struct({
+  minimum: Date,
+  maximum: Date,
+  exclusiveMinimum: /*#__PURE__*/optional(/*#__PURE__*/Literal(true)),
+  exclusiveMaximum: /*#__PURE__*/optional(/*#__PURE__*/Literal(true))
+}), ({
+  annotations,
+  payload
+}) => isBetweenDate(payload, annotations));
+/**
+ * Reviver for persisted `isGreaterThanBigInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isGreaterThanBigInt}.
+ *
+ * @see {@link isGreaterThanBigInt} for creating the corresponding check
+ *
+ * @category BigInt checks
+ * @since 4.0.0
+ */
+export const isGreaterThanBigIntReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isGreaterThanBigInt", /*#__PURE__*/Struct({
+  exclusiveMinimum: BigInt
+}), ({
+  annotations,
+  payload
+}) => isGreaterThanBigInt(payload.exclusiveMinimum, annotations));
+/**
+ * Reviver for persisted `isGreaterThanOrEqualToBigInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isGreaterThanOrEqualToBigInt}.
+ *
+ * @see {@link isGreaterThanOrEqualToBigInt} for creating the corresponding check
+ *
+ * @category BigInt checks
+ * @since 4.0.0
+ */
+export const isGreaterThanOrEqualToBigIntReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isGreaterThanOrEqualToBigInt", /*#__PURE__*/Struct({
+  minimum: BigInt
+}), ({
+  annotations,
+  payload
+}) => isGreaterThanOrEqualToBigInt(payload.minimum, annotations));
+/**
+ * Reviver for persisted `isLessThanBigInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isLessThanBigInt}.
+ *
+ * @see {@link isLessThanBigInt} for creating the corresponding check
+ *
+ * @category BigInt checks
+ * @since 4.0.0
+ */
+export const isLessThanBigIntReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isLessThanBigInt", /*#__PURE__*/Struct({
+  exclusiveMaximum: BigInt
+}), ({
+  annotations,
+  payload
+}) => isLessThanBigInt(payload.exclusiveMaximum, annotations));
+/**
+ * Reviver for persisted `isLessThanOrEqualToBigInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isLessThanOrEqualToBigInt}.
+ *
+ * @see {@link isLessThanOrEqualToBigInt} for creating the corresponding check
+ *
+ * @category BigInt checks
+ * @since 4.0.0
+ */
+export const isLessThanOrEqualToBigIntReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isLessThanOrEqualToBigInt", /*#__PURE__*/Struct({
+  maximum: BigInt
+}), ({
+  annotations,
+  payload
+}) => isLessThanOrEqualToBigInt(payload.maximum, annotations));
+/**
+ * Reviver for persisted `isBetweenBigInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link isBetweenBigInt}.
+ *
+ * @see {@link isBetweenBigInt} for creating the corresponding check
+ *
+ * @category BigInt checks
+ * @since 4.0.0
+ */
+export const isBetweenBigIntReviver = /*#__PURE__*/InternalSchema.makeFilterReviver("effect/schema/isBetweenBigInt", /*#__PURE__*/Struct({
+  minimum: BigInt,
+  maximum: BigInt,
+  exclusiveMinimum: /*#__PURE__*/optional(/*#__PURE__*/Literal(true)),
+  exclusiveMaximum: /*#__PURE__*/optional(/*#__PURE__*/Literal(true))
+}), ({
+  annotations,
+  payload
+}) => isBetweenBigInt(payload, annotations));
 // -----------------------------------------------------------------------------
 // Optic APIs
 // -----------------------------------------------------------------------------
@@ -8550,7 +10208,25 @@ export function Tree(node) {
  * @category schemas
  * @since 4.0.0
  */
-export const Json = /*#__PURE__*/make(SchemaAST.Json);
+export const Json = /*#__PURE__*/make(/*#__PURE__*/SchemaAST.annotate(SchemaAST.Json, {
+  toCode: () => ({
+    runtime: "Schema.Json",
+    Type: "Schema.Json"
+  })
+}));
+/**
+ * Reviver for persisted `Json` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Json} schema.
+ *
+ * @see {@link Json} for the corresponding immutable JSON schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const JsonReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/Json", Json);
 const JsonError = /*#__PURE__*/Struct({
   message: String,
   name: /*#__PURE__*/optionalKey(String),
@@ -8564,7 +10240,25 @@ const JsonError = /*#__PURE__*/Struct({
  * @category schemas
  * @since 4.0.0
  */
-export const MutableJson = /*#__PURE__*/make(SchemaAST.MutableJson);
+export const MutableJson = /*#__PURE__*/make(/*#__PURE__*/SchemaAST.annotate(SchemaAST.MutableJson, {
+  toCode: () => ({
+    runtime: "Schema.MutableJson",
+    Type: "Schema.MutableJson"
+  })
+}));
+/**
+ * Reviver for persisted `MutableJson` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link MutableJson} schema.
+ *
+ * @see {@link MutableJson} for the corresponding mutable JSON schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const MutableJsonReviver = /*#__PURE__*/makeFixedDeclarationReviver("effect/schema/MutableJson", MutableJson);
 // -----------------------------------------------------------------------------
 // Annotations
 // -----------------------------------------------------------------------------