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

package/src/SchemaRepresentation.ts

@@ -6,7 +6,6 @@
 import * as InternalRecord from "./internal/record.ts"
 import * as InternalFromJsonSchemaDocument from "./internal/schema/fromJsonSchemaDocument.ts"
 import * as InternalFromRepresentation from "./internal/schema/fromRepresentation.ts"
-import * as InternalSchema from "./internal/schema/schema.ts"
 import * as InternalToCodeDocument from "./internal/schema/toCodeDocument.ts"
 import * as InternalToJsonSchemaDocument from "./internal/schema/toJsonSchemaDocument.ts"
 import * as InternalToRepresentation from "./internal/schema/toRepresentation.ts"
@@ -14,7 +13,7 @@ import type * as JsonSchema from "./JsonSchema.ts"
 import * as Option from "./Option.ts"
 import * as Schema from "./Schema.ts"
 import * as SchemaAST from "./SchemaAST.ts"
-import * as SchemaGetter from "./SchemaGetter.ts"
+import * as InternalGetter from "./SchemaGetter.ts"
 
 /**
  * Open persistence identity carried by declarations and opaque checks.
@@ -60,8 +59,8 @@ export declare namespace ToJsonSchema {
    * **Gotchas**
    *
    * Treat the input schemas as immutable. The returned value must be a valid JSON Schema object graph and must not be
-   * mutated after this function returns. Return a new object graph to produce different output during a later
-   * compilation.
+   * mutated after this function returns. Local `$defs` references must use valid JSON Pointer URI fragments. Return a
+   * new object graph to produce different output during a later compilation.
    *
    * @category models
    * @since 4.0.0
@@ -275,7 +274,12 @@ export interface Literal extends Keyword<"Literal"> {
 }
 
 /**
- * A unique global symbol representation.
+ * A unique symbol representation.
+ *
+ * **Details**
+ *
+ * Globally registered symbols have an exact JSON string representation. Local
+ * symbols have no JSON representation.
  *
  * @category models
  * @since 4.0.0
@@ -297,7 +301,7 @@ export interface ObjectKeyword extends Keyword<"ObjectKeyword"> {}
  *
  * **Details**
  *
- * Enum members are stored as native string or number values. Persistent
+ * Enum members are stored as native string or finite number values. Persistent
  * codecs add an explicit type discriminator when encoding them.
  *
  * @category models
@@ -335,271 +339,1822 @@ export interface Element {
  * @category models
  * @since 4.0.0
  */
-export interface Arrays extends Keyword<"Arrays"> {
-  readonly elements: ReadonlyArray<Element>
-  readonly rest: ReadonlyArray<Representation>
-}
+export interface Arrays extends Keyword<"Arrays"> {
+  readonly elements: ReadonlyArray<Element>
+  readonly rest: ReadonlyArray<Representation>
+}
+
+/**
+ * A property signature.
+ *
+ * **Details**
+ *
+ * The live representation stores the native property key. Persistent codecs
+ * add an explicit type discriminator when encoding it.
+ *
+ * **Gotchas**
+ *
+ * Local symbols can be represented while the schema is live, but persistent
+ * codecs reject them because they cannot be reconstructed by identity.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface PropertySignature {
+  readonly name: PropertyKey
+  readonly type: Representation
+  readonly isOptional: boolean
+  readonly isMutable: boolean
+  readonly annotations?: Schema.Annotations.Annotations | undefined
+}
+
+/**
+ * An index signature.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface IndexSignature {
+  readonly parameter: Representation
+  readonly type: Representation
+}
+
+/**
+ * An object representation.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface Objects extends Keyword<"Objects"> {
+  readonly propertySignatures: ReadonlyArray<PropertySignature>
+  readonly indexSignatures: ReadonlyArray<IndexSignature>
+}
+
+/**
+ * A union representation.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface Union extends Keyword<"Union"> {
+  readonly types: ReadonlyArray<Representation>
+  readonly options?: SchemaAST.UnionOptions | undefined
+}
+
+/**
+ * The structural schema representation.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export type Representation =
+  | Declaration
+  | Reference
+  | Suspend
+  | Null
+  | Undefined
+  | Void
+  | Never
+  | Unknown
+  | Any
+  | String
+  | Number
+  | Boolean
+  | BigInt
+  | Symbol
+  | Literal
+  | UniqueSymbol
+  | ObjectKeyword
+  | Enum
+  | TemplateLiteral
+  | Arrays
+  | Objects
+  | Union
+
+/**
+ * A structural check.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export type Check = Filter | FilterGroup
+
+/**
+ * An opaque leaf check.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface Filter {
+  readonly _tag: "Filter"
+  readonly representation?: CheckRepresentationAnnotation<Representation> | undefined
+  readonly annotations?: Schema.Annotations.Annotations | undefined
+  readonly aborted: boolean
+}
+
+/**
+ * A non-empty group of checks.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface FilterGroup {
+  readonly _tag: "FilterGroup"
+  readonly representation?: CheckRepresentationAnnotation<Representation> | undefined
+  readonly annotations?: Schema.Annotations.Annotations | undefined
+  readonly checks: readonly [Check, ...Array<Check>]
+}
+
+/**
+ * Named representation definitions.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface References {
+  readonly [$ref: string]: Representation
+}
+
+/**
+ * A single representation and its definitions.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface Document {
+  readonly representation: Representation
+  readonly references: References
+}
+
+/**
+ * Multiple representations sharing definitions.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface MultiDocument {
+  readonly representations: readonly [Representation, ...Array<Representation>]
+  readonly references: References
+}
+
+/**
+ * Reviver for a declaration.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface DeclarationReviver<P> {
+  readonly id: string
+  readonly payloadSchema: Schema.Decoder<P>
+  readonly revive: (input: {
+    readonly payload: P
+    readonly typeParameters: ReadonlyArray<Schema.Top>
+    readonly annotations: Schema.Annotations.Annotations | undefined
+  }) => Schema.Top
+}
+
+/**
+ * Reviver for a leaf check.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface FilterReviver<P> {
+  readonly id: string
+  readonly payloadSchema: Schema.Decoder<P>
+  readonly revive: (input: {
+    readonly payload: P
+    readonly schemas: ReadonlyArray<Schema.Top>
+    readonly annotations: Schema.Annotations.Filter | undefined
+  }) => SchemaAST.Filter<any>
+}
+
+/**
+ * Reviver for a check group.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface FilterGroupReviver<P> {
+  readonly id: string
+  readonly payloadSchema: Schema.Decoder<P>
+  readonly revive: (input: {
+    readonly payload: P
+    readonly schemas: ReadonlyArray<Schema.Top>
+    readonly annotations: Schema.Annotations.Filter | undefined
+  }) => SchemaAST.FilterGroup<any>
+}
+
+/**
+ * A check reviver.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export type CheckReviver<P> = FilterReviver<P> | FilterGroupReviver<P>
+
+/**
+ * A typed reviver.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export type Reviver<P> = DeclarationReviver<P> | CheckReviver<P>
+
+/**
+ * A reviver erased only at collection boundaries.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export type AnyReviver = Reviver<any>
+
+/**
+ * Creates a declaration reviver while inferring its payload type from `payloadSchema`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const makeReviverDeclaration: <P>(
+  id: string,
+  payloadSchema: Schema.Decoder<P>,
+  revive: DeclarationReviver<P>["revive"]
+) => DeclarationReviver<P> = (id, payloadSchema, revive) => ({ id, payloadSchema, revive })
+
+/**
+ * Creates a filter reviver while inferring its payload type from `payloadSchema`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const makeReviverFilter: <P>(
+  id: string,
+  payloadSchema: Schema.Decoder<P>,
+  revive: FilterReviver<P>["revive"]
+) => FilterReviver<P> = (id, payloadSchema, revive) => ({ id, payloadSchema, revive })
+
+/**
+ * Creates a filter group reviver while inferring its payload type from `payloadSchema`.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const makeReviverFilterGroup: <P>(
+  id: string,
+  payloadSchema: Schema.Decoder<P>,
+  revive: FilterGroupReviver<P>["revive"]
+) => FilterGroupReviver<P> = (id, payloadSchema, revive) => ({ id, payloadSchema, revive })
+
+function makeFixedDeclarationReviver(id: string, schema: Schema.Top): DeclarationReviver<null> {
+  return makeReviverDeclaration(
+    id,
+    Schema.Null,
+    ({ annotations }) => annotations === undefined ? schema : schema.annotate(annotations)
+  )
+}
+
+const IsPatternPayload = Schema.Struct({
+  source: Schema.String,
+  flags: Schema.String
+}).check(Schema.makeFilter((payload: { readonly source: string; readonly flags: string }) => {
+  try {
+    const regExp = new globalThis.RegExp(payload.source, payload.flags)
+    return regExp.source === payload.source && regExp.flags === payload.flags
+  } catch {
+    return false
+  }
+}))
+
+type ErrorRepresentationOptions = {
+  readonly includeStack?: true | undefined
+  readonly excludeCause?: true | undefined
+}
+type ErrorRepresentationPayload = ErrorRepresentationOptions | null
+const ErrorOptionsPayload = Schema.declare((input): input is ErrorRepresentationOptions => {
+  if (typeof input !== "object" || input === null) return false
+  const object = input as Record<string, unknown>
+  const keys = globalThis.Object.keys(input)
+  return keys.length > 0 &&
+    keys.every((key) => (key === "includeStack" || key === "excludeCause") && object[key] === true)
+})
+const ErrorRepresentationPayload: Schema.Decoder<ErrorRepresentationPayload> = Schema.Union([
+  Schema.Null,
+  ErrorOptionsPayload
+])
+
+type RedactedRepresentationOptions = {
+  readonly label?: string | undefined
+  readonly disallowJsonEncode?: true | undefined
+}
+type RedactedRepresentationPayload = RedactedRepresentationOptions | null
+const RedactedOptionsPayload = Schema.declare((input): input is RedactedRepresentationOptions => {
+  if (typeof input !== "object" || input === null) return false
+  const object = input as Record<string, unknown>
+  const keys = globalThis.Object.keys(input)
+  return keys.length > 0 && keys.every((key) => {
+    switch (key) {
+      case "label":
+        return typeof object[key] === "string"
+      case "disallowJsonEncode":
+        return object[key] === true
+      default:
+        return false
+    }
+  })
+})
+const RedactedRepresentationPayload: Schema.Decoder<RedactedRepresentationPayload> = Schema.Union([
+  Schema.Null,
+  RedactedOptionsPayload
+])
+
+/**
+ * Reviver for persisted `isTrimmed` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isTrimmed}.
+ *
+ * @see {@link Schema.isTrimmed} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isTrimmedReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isTrimmed",
+  Schema.Null,
+  ({ annotations }) => Schema.isTrimmed(annotations)
+)
+
+/**
+ * Reviver for persisted `isPattern` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isPattern}.
+ *
+ * @see {@link Schema.isPattern} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isPatternReviver: FilterReviver<{
+  readonly source: string
+  readonly flags: string
+}> = makeReviverFilter(
+  "effect/schema/isPattern",
+  IsPatternPayload,
+  ({ annotations, payload }) => Schema.isPattern(new globalThis.RegExp(payload.source, payload.flags), annotations)
+)
+
+/**
+ * Reviver for persisted `isStringFinite` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isStringFinite}.
+ *
+ * @see {@link Schema.isStringFinite} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isStringFiniteReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isStringFinite",
+  Schema.Null,
+  ({ annotations }) => Schema.isStringFinite(annotations)
+)
+
+/**
+ * Reviver for persisted `isStringBigInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isStringBigInt}.
+ *
+ * @see {@link Schema.isStringBigInt} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isStringBigIntReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isStringBigInt",
+  Schema.Null,
+  ({ annotations }) => Schema.isStringBigInt(annotations)
+)
+
+/**
+ * Reviver for persisted `isStringSymbol` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isStringSymbol}.
+ *
+ * @see {@link Schema.isStringSymbol} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isStringSymbolReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isStringSymbol",
+  Schema.Null,
+  ({ annotations }) => Schema.isStringSymbol(annotations)
+)
+
+/**
+ * Reviver for persisted `isUUID` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isUUID}.
+ *
+ * @see {@link Schema.isUUID} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isUUIDReviver: FilterReviver<{
+  readonly version: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | null
+}> = makeReviverFilter(
+  "effect/schema/isUUID",
+  Schema.Struct({ version: Schema.Union([Schema.Literals([1, 2, 3, 4, 5, 6, 7, 8]), Schema.Null]) }),
+  ({ annotations, payload }) => Schema.isUUID(payload.version ?? undefined, annotations)
+)
+
+/**
+ * Reviver for persisted `isGUID` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isGUID}.
+ *
+ * @see {@link Schema.isGUID} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isGUIDReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isGUID",
+  Schema.Null,
+  ({ annotations }) => Schema.isGUID(annotations)
+)
+
+/**
+ * Reviver for persisted `isULID` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isULID}.
+ *
+ * @see {@link Schema.isULID} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isULIDReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isULID",
+  Schema.Null,
+  ({ annotations }) => Schema.isULID(annotations)
+)
+
+/**
+ * Reviver for persisted `isBase64` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isBase64}.
+ *
+ * @see {@link Schema.isBase64} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isBase64Reviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isBase64",
+  Schema.Null,
+  ({ annotations }) => Schema.isBase64(annotations)
+)
+
+/**
+ * Reviver for persisted `isBase64Url` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isBase64Url}.
+ *
+ * @see {@link Schema.isBase64Url} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isBase64UrlReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isBase64Url",
+  Schema.Null,
+  ({ annotations }) => Schema.isBase64Url(annotations)
+)
+
+/**
+ * Reviver for persisted `isStartsWith` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isStartsWith}.
+ *
+ * @see {@link Schema.isStartsWith} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isStartsWithReviver: FilterReviver<{
+  readonly startsWith: string
+}> = makeReviverFilter(
+  "effect/schema/isStartsWith",
+  Schema.Struct({ startsWith: Schema.String }),
+  ({ annotations, payload }) => Schema.isStartsWith(payload.startsWith, annotations)
+)
+
+/**
+ * Reviver for persisted `isEndsWith` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isEndsWith}.
+ *
+ * @see {@link Schema.isEndsWith} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isEndsWithReviver: FilterReviver<{
+  readonly endsWith: string
+}> = makeReviverFilter(
+  "effect/schema/isEndsWith",
+  Schema.Struct({ endsWith: Schema.String }),
+  ({ annotations, payload }) => Schema.isEndsWith(payload.endsWith, annotations)
+)
+
+/**
+ * Reviver for persisted `isIncludes` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isIncludes}.
+ *
+ * @see {@link Schema.isIncludes} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isIncludesReviver: FilterReviver<{
+  readonly includes: string
+}> = makeReviverFilter(
+  "effect/schema/isIncludes",
+  Schema.Struct({ includes: Schema.String }),
+  ({ annotations, payload }) => Schema.isIncludes(payload.includes, annotations)
+)
+
+/**
+ * Reviver for persisted `isUppercased` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isUppercased}.
+ *
+ * @see {@link Schema.isUppercased} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isUppercasedReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isUppercased",
+  Schema.Null,
+  ({ annotations }) => Schema.isUppercased(annotations)
+)
+
+/**
+ * Reviver for persisted `isLowercased` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLowercased}.
+ *
+ * @see {@link Schema.isLowercased} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isLowercasedReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isLowercased",
+  Schema.Null,
+  ({ annotations }) => Schema.isLowercased(annotations)
+)
+
+/**
+ * Reviver for persisted `isCapitalized` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isCapitalized}.
+ *
+ * @see {@link Schema.isCapitalized} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isCapitalizedReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isCapitalized",
+  Schema.Null,
+  ({ annotations }) => Schema.isCapitalized(annotations)
+)
+
+/**
+ * Reviver for persisted `isUncapitalized` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isUncapitalized}.
+ *
+ * @see {@link Schema.isUncapitalized} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isUncapitalizedReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isUncapitalized",
+  Schema.Null,
+  ({ annotations }) => Schema.isUncapitalized(annotations)
+)
+
+/**
+ * Reviver for persisted `isFinite` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isFinite}.
+ *
+ * @see {@link Schema.isFinite} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isFiniteReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isFinite",
+  Schema.Null,
+  ({ annotations }) => Schema.isFinite(annotations)
+)
+
+/**
+ * Reviver for persisted `isGreaterThan` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isGreaterThan}.
+ *
+ * @see {@link Schema.isGreaterThan} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isGreaterThanReviver: FilterReviver<{
+  readonly exclusiveMinimum: number
+}> = makeReviverFilter(
+  "effect/schema/isGreaterThan",
+  Schema.Struct({ exclusiveMinimum: Schema.Finite }),
+  ({ annotations, payload }) => Schema.isGreaterThan(payload.exclusiveMinimum, annotations)
+)
+
+/**
+ * Reviver for persisted `isGreaterThanOrEqualTo` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isGreaterThanOrEqualTo}.
+ *
+ * @see {@link Schema.isGreaterThanOrEqualTo} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isGreaterThanOrEqualToReviver: FilterReviver<{
+  readonly minimum: number
+}> = makeReviverFilter(
+  "effect/schema/isGreaterThanOrEqualTo",
+  Schema.Struct({ minimum: Schema.Finite }),
+  ({ annotations, payload }) => Schema.isGreaterThanOrEqualTo(payload.minimum, annotations)
+)
+
+/**
+ * Reviver for persisted `isLessThan` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLessThan}.
+ *
+ * @see {@link Schema.isLessThan} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isLessThanReviver: FilterReviver<{
+  readonly exclusiveMaximum: number
+}> = makeReviverFilter(
+  "effect/schema/isLessThan",
+  Schema.Struct({ exclusiveMaximum: Schema.Finite }),
+  ({ annotations, payload }) => Schema.isLessThan(payload.exclusiveMaximum, annotations)
+)
+
+/**
+ * Reviver for persisted `isLessThanOrEqualTo` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLessThanOrEqualTo}.
+ *
+ * @see {@link Schema.isLessThanOrEqualTo} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isLessThanOrEqualToReviver: FilterReviver<{
+  readonly maximum: number
+}> = makeReviverFilter(
+  "effect/schema/isLessThanOrEqualTo",
+  Schema.Struct({ maximum: Schema.Finite }),
+  ({ annotations, payload }) => Schema.isLessThanOrEqualTo(payload.maximum, annotations)
+)
+
+/**
+ * Reviver for persisted `isBetween` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isBetween}.
+ *
+ * @see {@link Schema.isBetween} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isBetweenReviver: FilterReviver<{
+  readonly minimum: number
+  readonly maximum: number
+  readonly exclusiveMinimum?: true | undefined
+  readonly exclusiveMaximum?: true | undefined
+}> = makeReviverFilter(
+  "effect/schema/isBetween",
+  Schema.Struct({
+    minimum: Schema.Finite,
+    maximum: Schema.Finite,
+    exclusiveMinimum: Schema.optional(Schema.Literal(true)),
+    exclusiveMaximum: Schema.optional(Schema.Literal(true))
+  }),
+  ({ annotations, payload }) => Schema.isBetween(payload, annotations)
+)
+
+/**
+ * Reviver for persisted `isMultipleOf` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isMultipleOf}.
+ *
+ * @see {@link Schema.isMultipleOf} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isMultipleOfReviver: FilterReviver<{
+  readonly divisor: number
+}> = makeReviverFilter(
+  "effect/schema/isMultipleOf",
+  Schema.Struct({ divisor: Schema.Finite }),
+  ({ annotations, payload }) => Schema.isMultipleOf(payload.divisor, annotations)
+)
+
+/**
+ * Reviver for persisted `isInt` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isInt}.
+ *
+ * @see {@link Schema.isInt} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isIntReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isInt",
+  Schema.Null,
+  ({ annotations }) => Schema.isInt(annotations)
+)
+
+/**
+ * Reviver for persisted `isMinLength` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isMinLength}.
+ *
+ * @see {@link Schema.isMinLength} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isMinLengthReviver: FilterReviver<{
+  readonly minLength: number
+}> = makeReviverFilter(
+  "effect/schema/isMinLength",
+  Schema.Struct({ minLength: Schema.Natural }),
+  ({ annotations, payload }) => Schema.isMinLength(payload.minLength, annotations)
+)
+
+/**
+ * Reviver for persisted `isMaxLength` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isMaxLength}.
+ *
+ * @see {@link Schema.isMaxLength} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isMaxLengthReviver: FilterReviver<{
+  readonly maxLength: number
+}> = makeReviverFilter(
+  "effect/schema/isMaxLength",
+  Schema.Struct({ maxLength: Schema.Natural }),
+  ({ annotations, payload }) => Schema.isMaxLength(payload.maxLength, annotations)
+)
+
+/**
+ * Reviver for persisted `isLengthBetween` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLengthBetween}.
+ *
+ * @see {@link Schema.isLengthBetween} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isLengthBetweenReviver: FilterReviver<{
+  readonly minimum: number
+  readonly maximum: number
+}> = makeReviverFilter(
+  "effect/schema/isLengthBetween",
+  Schema.Struct({ minimum: Schema.Natural, maximum: Schema.Natural }),
+  ({ annotations, payload }) => Schema.isLengthBetween(payload.minimum, payload.maximum, annotations)
+)
+
+/**
+ * Reviver for persisted `isMinSize` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isMinSize}.
+ *
+ * @see {@link Schema.isMinSize} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isMinSizeReviver: FilterReviver<{
+  readonly minSize: number
+}> = makeReviverFilter(
+  "effect/schema/isMinSize",
+  Schema.Struct({ minSize: Schema.Natural }),
+  ({ annotations, payload }) => Schema.isMinSize(payload.minSize, annotations)
+)
+
+/**
+ * Reviver for persisted `isMaxSize` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isMaxSize}.
+ *
+ * @see {@link Schema.isMaxSize} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isMaxSizeReviver: FilterReviver<{
+  readonly maxSize: number
+}> = makeReviverFilter(
+  "effect/schema/isMaxSize",
+  Schema.Struct({ maxSize: Schema.Natural }),
+  ({ annotations, payload }) => Schema.isMaxSize(payload.maxSize, annotations)
+)
+
+/**
+ * Reviver for persisted `isSizeBetween` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isSizeBetween}.
+ *
+ * @see {@link Schema.isSizeBetween} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isSizeBetweenReviver: FilterReviver<{
+  readonly minimum: number
+  readonly maximum: number
+}> = makeReviverFilter(
+  "effect/schema/isSizeBetween",
+  Schema.Struct({ minimum: Schema.Natural, maximum: Schema.Natural }),
+  ({ annotations, payload }) => Schema.isSizeBetween(payload.minimum, payload.maximum, annotations)
+)
+
+/**
+ * Reviver for persisted `isMinProperties` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isMinProperties}.
+ *
+ * @see {@link Schema.isMinProperties} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isMinPropertiesReviver: FilterReviver<{
+  readonly minProperties: number
+}> = makeReviverFilter(
+  "effect/schema/isMinProperties",
+  Schema.Struct({ minProperties: Schema.Natural }),
+  ({ annotations, payload }) => Schema.isMinProperties(payload.minProperties, annotations)
+)
+
+/**
+ * Reviver for persisted `isMaxProperties` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isMaxProperties}.
+ *
+ * @see {@link Schema.isMaxProperties} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isMaxPropertiesReviver: FilterReviver<{
+  readonly maxProperties: number
+}> = makeReviverFilter(
+  "effect/schema/isMaxProperties",
+  Schema.Struct({ maxProperties: Schema.Natural }),
+  ({ annotations, payload }) => Schema.isMaxProperties(payload.maxProperties, annotations)
+)
+
+/**
+ * Reviver for persisted `isPropertiesLengthBetween` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isPropertiesLengthBetween}.
+ *
+ * @see {@link Schema.isPropertiesLengthBetween} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isPropertiesLengthBetweenReviver: FilterReviver<{
+  readonly minimum: number
+  readonly maximum: number
+}> = makeReviverFilter(
+  "effect/schema/isPropertiesLengthBetween",
+  Schema.Struct({ minimum: Schema.Natural, maximum: Schema.Natural }),
+  ({ annotations, payload }) => Schema.isPropertiesLengthBetween(payload.minimum, payload.maximum, annotations)
+)
+
+/**
+ * Reviver for persisted `isPropertyNames` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isPropertyNames}.
+ *
+ * @see {@link Schema.isPropertyNames} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isPropertyNamesReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isPropertyNames",
+  Schema.Null,
+  ({ annotations, schemas }) => Schema.isPropertyNames(schemas[0], annotations)
+)
+
+/**
+ * Reviver for persisted `isUnique` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isUnique}.
+ *
+ * @see {@link Schema.isUnique} for creating the corresponding check
+ *
+ * @category validation
+ * @since 4.0.0
+ */
+export const isUniqueReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isUnique",
+  Schema.Null,
+  ({ annotations }) => Schema.isUnique(annotations)
+)
+
+/**
+ * Reviver for persisted `isUniqueKey` checks.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isUniqueKey}.
+ *
+ * @see {@link Schema.isUniqueKey} for creating the corresponding check
+ * @category validation
+ * @since 4.0.0
+ */
+export const isUniqueKeyReviver: FilterReviver<null> = makeReviverFilter(
+  "effect/schema/isUniqueKey",
+  Schema.Null,
+  ({ annotations }) => Schema.isUniqueKey(annotations)
+)
+
+/**
+ * Reviver for persisted `Option` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.Option}.
+ *
+ * @see {@link Schema.Option} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const OptionReviver: DeclarationReviver<null> = makeReviverDeclaration(
+  "effect/schema/Option",
+  Schema.Null,
+  ({ annotations, typeParameters }) => {
+    const schema = Schema.Option(typeParameters[0])
+    return annotations === undefined ? schema : schema.annotate(annotations)
+  }
+)
+
+/**
+ * Reviver for persisted {@link Schema.Result} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.Result}.
+ *
+ * @see {@link Schema.Result} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ResultReviver: DeclarationReviver<null> = makeReviverDeclaration(
+  "effect/schema/Result",
+  Schema.Null,
+  ({ annotations, typeParameters }) => {
+    const schema = Schema.Result(typeParameters[0], typeParameters[1])
+    return annotations === undefined ? schema : schema.annotate(annotations)
+  }
+)
+
+/**
+ * Reviver for persisted {@link Schema.Redacted} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.Redacted}.
+ *
+ * @see {@link Schema.Redacted} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const RedactedReviver: DeclarationReviver<RedactedRepresentationPayload> = makeReviverDeclaration(
+  "effect/schema/Redacted",
+  RedactedRepresentationPayload,
+  ({ annotations, payload, typeParameters }) => {
+    const schema = Schema.Redacted(typeParameters[0], payload ?? undefined)
+    return annotations === undefined ? schema : schema.annotate(annotations)
+  }
+)
+
+/**
+ * Reviver for persisted `CauseReason` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.CauseReason}.
+ *
+ * @see {@link Schema.CauseReason} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const CauseReasonReviver: DeclarationReviver<null> = makeReviverDeclaration(
+  "effect/schema/CauseReason",
+  Schema.Null,
+  ({ annotations, typeParameters }) => {
+    const schema = Schema.CauseReason(typeParameters[0], typeParameters[1])
+    return annotations === undefined ? schema : schema.annotate(annotations)
+  }
+)
+
+/**
+ * Reviver for persisted `Cause` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.Cause}.
+ *
+ * @see {@link Schema.Cause} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const CauseReviver: DeclarationReviver<null> = makeReviverDeclaration(
+  "effect/schema/Cause",
+  Schema.Null,
+  ({ annotations, typeParameters }) => {
+    const schema = Schema.Cause(typeParameters[0], typeParameters[1])
+    return annotations === undefined ? schema : schema.annotate(annotations)
+  }
+)
+
+/**
+ * Reviver for persisted {@link Schema.ErrorInstance} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.ErrorInstance}.
+ *
+ * @see {@link Schema.ErrorInstance} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ErrorInstanceReviver: DeclarationReviver<ErrorRepresentationPayload> = makeReviverDeclaration(
+  "effect/schema/Error",
+  ErrorRepresentationPayload,
+  ({ annotations, payload }) => {
+    const schema = Schema.ErrorInstance(payload ?? undefined)
+    return annotations === undefined ? schema : schema.annotate(annotations)
+  }
+)
+
+/**
+ * Reviver for persisted `Exit` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.Exit}.
+ *
+ * @see {@link Schema.Exit} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ExitReviver: DeclarationReviver<null> = makeReviverDeclaration(
+  "effect/schema/Exit",
+  Schema.Null,
+  ({ annotations, typeParameters }) => {
+    const schema = Schema.Exit(typeParameters[0], typeParameters[1], typeParameters[2])
+    return annotations === undefined ? schema : schema.annotate(annotations)
+  }
+)
+
+/**
+ * Reviver for persisted {@link Schema.ReadonlyMap} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.ReadonlyMap}.
+ *
+ * @see {@link Schema.ReadonlyMap} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ReadonlyMapReviver: DeclarationReviver<null> = makeReviverDeclaration(
+  "effect/schema/ReadonlyMap",
+  Schema.Null,
+  ({ annotations, typeParameters }) => {
+    const schema = Schema.ReadonlyMap(typeParameters[0], typeParameters[1])
+    return annotations === undefined ? schema : schema.annotate(annotations)
+  }
+)
+
+/**
+ * Reviver for persisted {@link Schema.Graph} declarations.
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const GraphReviver: DeclarationReviver<"directed" | "undirected"> = makeReviverDeclaration(
+  "effect/schema/Graph",
+  Schema.Literals(["directed", "undirected"]),
+  ({ annotations, payload, typeParameters }) => {
+    const schema = Schema.Graph(payload, typeParameters[0], typeParameters[1])
+    return annotations === undefined ? schema : schema.annotate(annotations)
+  }
+)
+
+/**
+ * Reviver for persisted `HashMap` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.HashMap}.
+ *
+ * @see {@link Schema.HashMap} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const HashMapReviver: DeclarationReviver<null> = makeReviverDeclaration(
+  "effect/schema/HashMap",
+  Schema.Null,
+  ({ annotations, typeParameters }) => {
+    const schema = Schema.HashMap(typeParameters[0], typeParameters[1])
+    return annotations === undefined ? schema : schema.annotate(annotations)
+  }
+)
+
+/**
+ * Reviver for persisted {@link Schema.ReadonlySet} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.ReadonlySet}.
+ *
+ * @see {@link Schema.ReadonlySet} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ReadonlySetReviver: DeclarationReviver<null> = makeReviverDeclaration(
+  "effect/schema/ReadonlySet",
+  Schema.Null,
+  ({ annotations, typeParameters }) => {
+    const schema = Schema.ReadonlySet(typeParameters[0])
+    return annotations === undefined ? schema : schema.annotate(annotations)
+  }
+)
+
+/**
+ * Reviver for persisted `HashSet` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.HashSet}.
+ *
+ * @see {@link Schema.HashSet} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const HashSetReviver: DeclarationReviver<null> = makeReviverDeclaration(
+  "effect/schema/HashSet",
+  Schema.Null,
+  ({ annotations, typeParameters }) => {
+    const schema = Schema.HashSet(typeParameters[0])
+    return annotations === undefined ? schema : schema.annotate(annotations)
+  }
+)
+
+/**
+ * Reviver for persisted {@link Schema.Chunk} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain schemas created by {@link Schema.Chunk}.
+ *
+ * @see {@link Schema.Chunk} for creating the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ChunkReviver: DeclarationReviver<null> = makeReviverDeclaration(
+  "effect/schema/Chunk",
+  Schema.Null,
+  ({ annotations, typeParameters }) => {
+    const schema = Schema.Chunk(typeParameters[0])
+    return annotations === undefined ? schema : schema.annotate(annotations)
+  }
+)
+
+/**
+ * Reviver for persisted `RegExp` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.RegExp} schema.
+ *
+ * @see {@link Schema.RegExp} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const RegExpReviver: DeclarationReviver<null> = makeFixedDeclarationReviver(
+  "effect/schema/RegExp",
+  Schema.RegExp
+)
+
+/**
+ * Reviver for persisted `URL` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.URL} schema.
+ *
+ * @see {@link Schema.URL} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const URLReviver: DeclarationReviver<null> = makeFixedDeclarationReviver("effect/schema/URL", Schema.URL)
+
+/**
+ * Reviver for persisted `Date` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.Date} schema.
+ *
+ * @see {@link Schema.Date} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DateReviver: DeclarationReviver<null> = makeFixedDeclarationReviver("effect/schema/Date", Schema.Date)
+
+/**
+ * Reviver for persisted {@link Schema.Duration} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.Duration} schema.
+ *
+ * @see {@link Schema.Duration} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const DurationReviver: DeclarationReviver<null> = makeFixedDeclarationReviver(
+  "effect/schema/Duration",
+  Schema.Duration
+)
+
+/**
+ * Reviver for persisted {@link Schema.ByteSize} declarations.
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const ByteSizeReviver: DeclarationReviver<null> = makeFixedDeclarationReviver(
+  "effect/schema/ByteSize",
+  Schema.ByteSize
+)
+
+/**
+ * Reviver for persisted {@link Schema.BigDecimal} declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.BigDecimal} schema.
+ *
+ * @see {@link Schema.BigDecimal} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const BigDecimalReviver: DeclarationReviver<null> = makeFixedDeclarationReviver(
+  "effect/schema/BigDecimal",
+  Schema.BigDecimal
+)
+
+/**
+ * Reviver for persisted `File` declarations.
+ *
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.File} schema.
+ *
+ * @see {@link Schema.File} for the corresponding schema
+ *
+ * @category schemas
+ * @since 4.0.0
+ */
+export const FileReviver: DeclarationReviver<null> = makeFixedDeclarationReviver("effect/schema/File", Schema.File)
 
 /**
- * A property signature.
- *
- * **Details**
+ * Reviver for persisted `FormData` declarations.
  *
- * The live representation stores the native property key. Persistent codecs
- * add an explicit type discriminator when encoding it.
+ * **When to use**
  *
- * **Gotchas**
+ * Use when reconstructing documents that may contain the {@link Schema.FormData} schema.
  *
- * Local symbols can be represented while the schema is live, but persistent
- * codecs reject them because they cannot be reconstructed by identity.
+ * @see {@link Schema.FormData} for the corresponding schema
  *
- * @category models
+ * @category schemas
  * @since 4.0.0
  */
-export interface PropertySignature {
-  readonly name: PropertyKey
-  readonly type: Representation
-  readonly isOptional: boolean
-  readonly isMutable: boolean
-  readonly annotations?: Schema.Annotations.Annotations | undefined
-}
+export const FormDataReviver: DeclarationReviver<null> = makeFixedDeclarationReviver(
+  "effect/schema/FormData",
+  Schema.FormData
+)
 
 /**
- * An index signature.
+ * Reviver for persisted `URLSearchParams` declarations.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.URLSearchParams} schema.
+ *
+ * @see {@link Schema.URLSearchParams} for the corresponding schema
+ *
+ * @category schemas
  * @since 4.0.0
  */
-export interface IndexSignature {
-  readonly parameter: Representation
-  readonly type: Representation
-}
+export const URLSearchParamsReviver: DeclarationReviver<null> = makeFixedDeclarationReviver(
+  "effect/schema/URLSearchParams",
+  Schema.URLSearchParams
+)
 
 /**
- * An object representation.
+ * Reviver for persisted `Uint8Array` declarations.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.Uint8Array} schema.
+ *
+ * @see {@link Schema.Uint8Array} for the corresponding schema
+ *
+ * @category schemas
  * @since 4.0.0
  */
-export interface Objects extends Keyword<"Objects"> {
-  readonly propertySignatures: ReadonlyArray<PropertySignature>
-  readonly indexSignatures: ReadonlyArray<IndexSignature>
-}
+export const Uint8ArrayReviver: DeclarationReviver<null> = makeFixedDeclarationReviver(
+  "effect/schema/Uint8Array",
+  Schema.Uint8Array
+)
 
 /**
- * A union representation.
+ * Reviver for persisted {@link Schema.DateTimeUtc} declarations.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.DateTimeUtc} schema.
+ *
+ * @see {@link Schema.DateTimeUtc} for the corresponding schema
+ *
+ * @category schemas
  * @since 4.0.0
  */
-export interface Union extends Keyword<"Union"> {
-  readonly types: ReadonlyArray<Representation>
-  readonly mode: "anyOf" | "oneOf"
-}
+export const DateTimeUtcReviver: DeclarationReviver<null> = makeFixedDeclarationReviver(
+  "effect/schema/DateTimeUtc",
+  Schema.DateTimeUtc
+)
 
 /**
- * The structural schema representation.
+ * Reviver for persisted {@link Schema.TimeZoneOffset} declarations.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.TimeZoneOffset} schema.
+ *
+ * @see {@link Schema.TimeZoneOffset} for the corresponding schema
+ *
+ * @category schemas
  * @since 4.0.0
  */
-export type Representation =
-  | Declaration
-  | Reference
-  | Suspend
-  | Null
-  | Undefined
-  | Void
-  | Never
-  | Unknown
-  | Any
-  | String
-  | Number
-  | Boolean
-  | BigInt
-  | Symbol
-  | Literal
-  | UniqueSymbol
-  | ObjectKeyword
-  | Enum
-  | TemplateLiteral
-  | Arrays
-  | Objects
-  | Union
+export const TimeZoneOffsetReviver: DeclarationReviver<null> = makeFixedDeclarationReviver(
+  "effect/schema/TimeZoneOffset",
+  Schema.TimeZoneOffset
+)
 
 /**
- * A structural check.
+ * Reviver for persisted {@link Schema.TimeZoneNamed} declarations.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.TimeZoneNamed} schema.
+ *
+ * @see {@link Schema.TimeZoneNamed} for the corresponding schema
+ *
+ * @category schemas
  * @since 4.0.0
  */
-export type Check = Filter | FilterGroup
+export const TimeZoneNamedReviver: DeclarationReviver<null> = makeFixedDeclarationReviver(
+  "effect/schema/TimeZoneNamed",
+  Schema.TimeZoneNamed
+)
 
 /**
- * An opaque leaf check.
+ * Reviver for persisted {@link Schema.TimeZone} declarations.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.TimeZone} schema.
+ *
+ * @see {@link Schema.TimeZone} for the corresponding schema
+ *
+ * @category schemas
  * @since 4.0.0
  */
-export interface Filter {
-  readonly _tag: "Filter"
-  readonly representation?: CheckRepresentationAnnotation<Representation> | undefined
-  readonly annotations?: Schema.Annotations.Annotations | undefined
-  readonly aborted: boolean
-}
+export const TimeZoneReviver: DeclarationReviver<null> = makeFixedDeclarationReviver(
+  "effect/schema/TimeZone",
+  Schema.TimeZone
+)
 
 /**
- * A non-empty group of checks.
+ * Reviver for persisted {@link Schema.DateTimeZoned} declarations.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.DateTimeZoned} schema.
+ *
+ * @see {@link Schema.DateTimeZoned} for the corresponding schema
+ *
+ * @category schemas
  * @since 4.0.0
  */
-export interface FilterGroup {
-  readonly _tag: "FilterGroup"
-  readonly representation?: CheckRepresentationAnnotation<Representation> | undefined
-  readonly annotations?: Schema.Annotations.Annotations | undefined
-  readonly checks: readonly [Check, ...Array<Check>]
-}
+export const DateTimeZonedReviver: DeclarationReviver<null> = makeFixedDeclarationReviver(
+  "effect/schema/DateTimeZoned",
+  Schema.DateTimeZoned
+)
 
 /**
- * Named representation definitions.
+ * Reviver for persisted `isGreaterThanDate` checks.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isGreaterThanDate}.
+ *
+ * @see {@link Schema.isGreaterThanDate} for creating the corresponding check
+ *
+ * @category validation
  * @since 4.0.0
  */
-export interface References {
-  readonly [$ref: string]: Representation
-}
+export const isGreaterThanDateReviver: FilterReviver<{
+  readonly exclusiveMinimum: globalThis.Date
+}> = makeReviverFilter(
+  "effect/schema/isGreaterThanDate",
+  Schema.Struct({ exclusiveMinimum: Schema.Date }),
+  ({ annotations, payload }) => Schema.isGreaterThanDate(payload.exclusiveMinimum, annotations)
+)
 
 /**
- * A single representation and its definitions.
+ * Reviver for persisted `isGreaterThanOrEqualToDate` checks.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isGreaterThanOrEqualToDate}.
+ *
+ * @see {@link Schema.isGreaterThanOrEqualToDate} for creating the corresponding check
+ *
+ * @category validation
  * @since 4.0.0
  */
-export interface Document {
-  readonly representation: Representation
-  readonly references: References
-}
+export const isGreaterThanOrEqualToDateReviver: FilterReviver<{
+  readonly minimum: globalThis.Date
+}> = makeReviverFilter(
+  "effect/schema/isGreaterThanOrEqualToDate",
+  Schema.Struct({ minimum: Schema.Date }),
+  ({ annotations, payload }) => Schema.isGreaterThanOrEqualToDate(payload.minimum, annotations)
+)
 
 /**
- * Multiple representations sharing definitions.
+ * Reviver for persisted `isLessThanDate` checks.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLessThanDate}.
+ *
+ * @see {@link Schema.isLessThanDate} for creating the corresponding check
+ *
+ * @category validation
  * @since 4.0.0
  */
-export interface MultiDocument {
-  readonly representations: readonly [Representation, ...Array<Representation>]
-  readonly references: References
-}
+export const isLessThanDateReviver: FilterReviver<{
+  readonly exclusiveMaximum: globalThis.Date
+}> = makeReviverFilter(
+  "effect/schema/isLessThanDate",
+  Schema.Struct({ exclusiveMaximum: Schema.Date }),
+  ({ annotations, payload }) => Schema.isLessThanDate(payload.exclusiveMaximum, annotations)
+)
 
 /**
- * Reviver for a declaration.
+ * Reviver for persisted `isLessThanOrEqualToDate` checks.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLessThanOrEqualToDate}.
+ *
+ * @see {@link Schema.isLessThanOrEqualToDate} for creating the corresponding check
+ *
+ * @category validation
  * @since 4.0.0
  */
-export interface DeclarationReviver<P> {
-  readonly id: string
-  readonly payloadSchema: Schema.Decoder<P>
-  readonly revive: (input: {
-    readonly payload: P
-    readonly typeParameters: ReadonlyArray<Schema.Top>
-    readonly annotations: Schema.Annotations.Annotations | undefined
-  }) => Schema.Top
-}
+export const isLessThanOrEqualToDateReviver: FilterReviver<{
+  readonly maximum: globalThis.Date
+}> = makeReviverFilter(
+  "effect/schema/isLessThanOrEqualToDate",
+  Schema.Struct({ maximum: Schema.Date }),
+  ({ annotations, payload }) => Schema.isLessThanOrEqualToDate(payload.maximum, annotations)
+)
 
 /**
- * Reviver for a leaf check.
+ * Reviver for persisted `isBetweenDate` checks.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isBetweenDate}.
+ *
+ * @see {@link Schema.isBetweenDate} for creating the corresponding check
+ *
+ * @category validation
  * @since 4.0.0
  */
-export interface FilterReviver<P> {
-  readonly id: string
-  readonly payloadSchema: Schema.Decoder<P>
-  readonly revive: (input: {
-    readonly payload: P
-    readonly schemas: ReadonlyArray<Schema.Top>
-    readonly annotations: Schema.Annotations.Filter | undefined
-  }) => SchemaAST.Filter<any>
-}
+export const isBetweenDateReviver: FilterReviver<{
+  readonly minimum: globalThis.Date
+  readonly maximum: globalThis.Date
+  readonly exclusiveMinimum?: true | undefined
+  readonly exclusiveMaximum?: true | undefined
+}> = makeReviverFilter(
+  "effect/schema/isBetweenDate",
+  Schema.Struct({
+    minimum: Schema.Date,
+    maximum: Schema.Date,
+    exclusiveMinimum: Schema.optional(Schema.Literal(true)),
+    exclusiveMaximum: Schema.optional(Schema.Literal(true))
+  }),
+  ({ annotations, payload }) => Schema.isBetweenDate(payload, annotations)
+)
 
 /**
- * Reviver for a check group.
+ * Reviver for persisted `isGreaterThanBigInt` checks.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isGreaterThanBigInt}.
+ *
+ * @see {@link Schema.isGreaterThanBigInt} for creating the corresponding check
+ *
+ * @category validation
  * @since 4.0.0
  */
-export interface FilterGroupReviver<P> {
-  readonly id: string
-  readonly payloadSchema: Schema.Decoder<P>
-  readonly revive: (input: {
-    readonly payload: P
-    readonly schemas: ReadonlyArray<Schema.Top>
-    readonly annotations: Schema.Annotations.Filter | undefined
-  }) => SchemaAST.FilterGroup<any>
-}
+export const isGreaterThanBigIntReviver: FilterReviver<{
+  readonly exclusiveMinimum: bigint
+}> = makeReviverFilter(
+  "effect/schema/isGreaterThanBigInt",
+  Schema.Struct({ exclusiveMinimum: Schema.BigInt }),
+  ({ annotations, payload }) => Schema.isGreaterThanBigInt(payload.exclusiveMinimum, annotations)
+)
 
 /**
- * A check reviver.
+ * Reviver for persisted `isGreaterThanOrEqualToBigInt` checks.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isGreaterThanOrEqualToBigInt}.
+ *
+ * @see {@link Schema.isGreaterThanOrEqualToBigInt} for creating the corresponding check
+ *
+ * @category validation
  * @since 4.0.0
  */
-export type CheckReviver<P> = FilterReviver<P> | FilterGroupReviver<P>
+export const isGreaterThanOrEqualToBigIntReviver: FilterReviver<{
+  readonly minimum: bigint
+}> = makeReviverFilter(
+  "effect/schema/isGreaterThanOrEqualToBigInt",
+  Schema.Struct({ minimum: Schema.BigInt }),
+  ({ annotations, payload }) => Schema.isGreaterThanOrEqualToBigInt(payload.minimum, annotations)
+)
 
 /**
- * A typed reviver.
+ * Reviver for persisted `isLessThanBigInt` checks.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLessThanBigInt}.
+ *
+ * @see {@link Schema.isLessThanBigInt} for creating the corresponding check
+ *
+ * @category validation
  * @since 4.0.0
  */
-export type Reviver<P> = DeclarationReviver<P> | CheckReviver<P>
+export const isLessThanBigIntReviver: FilterReviver<{
+  readonly exclusiveMaximum: bigint
+}> = makeReviverFilter(
+  "effect/schema/isLessThanBigInt",
+  Schema.Struct({ exclusiveMaximum: Schema.BigInt }),
+  ({ annotations, payload }) => Schema.isLessThanBigInt(payload.exclusiveMaximum, annotations)
+)
 
 /**
- * A reviver erased only at collection boundaries.
+ * Reviver for persisted `isLessThanOrEqualToBigInt` checks.
  *
- * @category models
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isLessThanOrEqualToBigInt}.
+ *
+ * @see {@link Schema.isLessThanOrEqualToBigInt} for creating the corresponding check
+ *
+ * @category validation
  * @since 4.0.0
  */
-export type AnyReviver = Reviver<any>
+export const isLessThanOrEqualToBigIntReviver: FilterReviver<{
+  readonly maximum: bigint
+}> = makeReviverFilter(
+  "effect/schema/isLessThanOrEqualToBigInt",
+  Schema.Struct({ maximum: Schema.BigInt }),
+  ({ annotations, payload }) => Schema.isLessThanOrEqualToBigInt(payload.maximum, annotations)
+)
 
 /**
- * Creates a declaration reviver while inferring its payload type from `payloadSchema`.
+ * Reviver for persisted `isBetweenBigInt` checks.
  *
- * @category constructors
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain checks created by {@link Schema.isBetweenBigInt}.
+ *
+ * @see {@link Schema.isBetweenBigInt} for creating the corresponding check
+ *
+ * @category validation
  * @since 4.0.0
  */
-export const makeDeclarationReviver: <P>(
-  id: string,
-  payloadSchema: Schema.Decoder<P>,
-  revive: DeclarationReviver<P>["revive"]
-) => DeclarationReviver<P> = InternalSchema.makeDeclarationReviver
+export const isBetweenBigIntReviver: FilterReviver<{
+  readonly minimum: bigint
+  readonly maximum: bigint
+  readonly exclusiveMinimum?: true | undefined
+  readonly exclusiveMaximum?: true | undefined
+}> = makeReviverFilter(
+  "effect/schema/isBetweenBigInt",
+  Schema.Struct({
+    minimum: Schema.BigInt,
+    maximum: Schema.BigInt,
+    exclusiveMinimum: Schema.optional(Schema.Literal(true)),
+    exclusiveMaximum: Schema.optional(Schema.Literal(true))
+  }),
+  ({ annotations, payload }) => Schema.isBetweenBigInt(payload, annotations)
+)
 
 /**
- * Creates a filter reviver while inferring its payload type from `payloadSchema`.
+ * Reviver for persisted `Json` declarations.
  *
- * @category constructors
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.Json} schema.
+ *
+ * @see {@link Schema.Json} for the corresponding immutable JSON schema
+ *
+ * @category schemas
  * @since 4.0.0
  */
-export const makeFilterReviver: <P>(
-  id: string,
-  payloadSchema: Schema.Decoder<P>,
-  revive: FilterReviver<P>["revive"]
-) => FilterReviver<P> = InternalSchema.makeFilterReviver
+export const JsonReviver: DeclarationReviver<null> = makeFixedDeclarationReviver("effect/schema/Json", Schema.Json)
 
 /**
- * Creates a filter group reviver while inferring its payload type from `payloadSchema`.
+ * Reviver for persisted `MutableJson` declarations.
  *
- * @category constructors
+ * **When to use**
+ *
+ * Use when reconstructing documents that may contain the {@link Schema.MutableJson} schema.
+ *
+ * @see {@link Schema.MutableJson} for the corresponding mutable JSON schema
+ *
+ * @category schemas
  * @since 4.0.0
  */
-export const makeFilterGroupReviver: <P>(
-  id: string,
-  payloadSchema: Schema.Decoder<P>,
-  revive: FilterGroupReviver<P>["revive"]
-) => FilterGroupReviver<P> = InternalSchema.makeFilterGroupReviver
+export const MutableJsonReviver: DeclarationReviver<null> = makeFixedDeclarationReviver(
+  "effect/schema/MutableJson",
+  Schema.MutableJson
+)
+
+const jsonSchemaRevivers: ReadonlyArray<AnyReviver> = [
+  JsonReviver,
+  isPatternReviver,
+  isFiniteReviver,
+  isGreaterThanReviver,
+  isGreaterThanOrEqualToReviver,
+  isLessThanReviver,
+  isLessThanOrEqualToReviver,
+  isMultipleOfReviver,
+  isIntReviver,
+  isMinLengthReviver,
+  isMaxLengthReviver,
+  isMinPropertiesReviver,
+  isMaxPropertiesReviver,
+  isPropertyNamesReviver,
+  isUniqueReviver
+]
 
 /**
  * Options for importing JSON Schema Draft 2020-12 documents.
@@ -835,21 +2390,24 @@ export function toMultiDocument(document: Document): MultiDocument {
  *
  * **Details**
  *
- * For representation documents whose validation semantics can be expressed exactly in JSON Schema, importing the
- * emitted document with {@link fromJsonSchemaDocument} reconstructs a schema that accepts the same JSON values. This
- * is a semantic round-trip guarantee; the emitted document and reconstructed representation may have different shapes.
+ * The generated document is intended for preliminary validation. JSON Schema
+ * and Effect checks do not always have identical semantics, so the Effect
+ * decoder remains the final authority. Passing JSON Schema validation does not
+ * guarantee that Effect decoding will succeed.
  *
  * **Gotchas**
  *
  * - Reference allocation is already fixed in the input `Document`. The inherited `referencePolicy` option has no effect
  *   here; pass it to {@link toRepresentation} when creating the document.
- * - Opaque declarations are represented by an unconstrained JSON Schema and are outside the exact round-trip subset.
+ * - String length, RegExp flags, decoded-object property checks, and `oneOf` can differ from Effect validation.
+ * - Opaque declarations are represented by an unconstrained JSON Schema.
  * - Check callback results are used directly, and exceptions raised by a callback pass through unchanged. Callbacks
  *   must treat their input schemas as immutable. Each returned value must be a valid JSON Schema object graph and must
- *   not be mutated after the callback returns.
+ *   not be mutated after the callback returns. The callback author is responsible for the emitted semantics.
  * - Local definition references returned by callbacks are resolved together with compiler-generated references.
- * - Effect decoding may discard excess object properties by default. Use `onExcessProperty: "error"` when comparing
- *   validation semantics with the emitted JSON Schema.
+ *   Invalid JSON Pointer URI fragments throw an `Error`.
+ * - The default `onExcessProperty: "ignore"` matches the decoder default. Use `onExcessProperty: "error"` in both
+ *   places when a closed object contract is required.
  *
  * @see {@link toJsonSchemaMultiDocument} for multiple roots sharing definitions
  *
@@ -877,7 +2435,9 @@ export function toJsonSchemaDocument(
  * - Every definition is compiled, including definitions that are not reachable from a root. Check callbacks must treat
  *   their input schemas as immutable. Each returned value must be a valid JSON Schema object graph and must not be
  *   mutated after the callback returns. Local definition references returned by callbacks are resolved together with
- *   compiler-generated references.
+ *   compiler-generated references. Invalid JSON Pointer URI fragments throw an `Error`.
+ * - String length, RegExp flags, decoded-object property checks, `oneOf`, and custom check callbacks can differ from
+ *   Effect validation, as described by {@link toJsonSchemaDocument}.
  *
  * @see {@link toJsonSchemaDocument} for a single root
  *
@@ -936,10 +2496,12 @@ function pruneAnnotations(
   return Object.keys(out).length === 0 ? Option.none() : Option.some(out)
 }
 
-const AnnotationsSchema = Schema.optional(Schema.Record(Schema.String, Schema.Unknown)).pipe(
+const AnnotationsSchema = Schema.optional(
+  Schema.Record(Schema.String, Schema.Unknown)
+).pipe(
   Schema.encodeTo(Schema.optionalKey(Schema.JsonObject), {
-    decode: SchemaGetter.passthroughSubtype(),
-    encode: SchemaGetter.transformOptional((annotations) =>
+    decode: InternalGetter.passthroughSubtype(),
+    encode: InternalGetter.transformOptional((annotations) =>
       Option.isNone(annotations) || annotations.value === undefined
         ? Option.none()
         : pruneAnnotations(annotations.value)
@@ -990,8 +2552,8 @@ const SuspendSchema = Schema.Struct({
 function makeValueSchema<Type extends string, Value>(type: Type, value: Schema.Codec<Value>) {
   return value.pipe(
     Schema.encodeTo(Schema.Struct({ type: Schema.tag(type), value }), {
-      decode: SchemaGetter.transform((encoded: { readonly type: Type; readonly value: Value }) => encoded.value),
-      encode: SchemaGetter.transform((value: Value) => ({ type, value }))
+      decode: InternalGetter.transform((encoded: { readonly type: Type; readonly value: Value }) => encoded.value),
+      encode: InternalGetter.transform((value: Value) => ({ type, value }))
     })
   )
 }
@@ -1061,7 +2623,9 @@ const UnionSchema = Schema.Struct({
   _tag: Schema.tag("Union"),
   ...KeywordFields,
   types: RepresentationsSchema,
-  mode: Schema.Literals(["anyOf", "oneOf"])
+  options: Schema.optionalKey(Schema.Struct({
+    mode: Schema.optionalKey(Schema.Literals(["anyOf", "oneOf"]))
+  }))
 })
 const ReferenceSchema = Schema.Struct({
   _tag: Schema.tag("Reference"),
@@ -1277,8 +2841,18 @@ export function fromRepresentations(
  *
  * **Gotchas**
  *
- * - Import is best-effort outside the exactly translated subset. Unsupported or ignored keywords are not covered by the
- *   round-trip guarantee.
+ * - `$dynamicRef`, `contains`, `dependentRequired`, `dependentSchemas`, `not`, active `if` / `then` / `else`,
+ *   `unevaluatedItems`, and `unevaluatedProperties` throw an `Unsupported JSON Schema keyword` error. Inactive
+ *   conditional keywords and `minContains` / `maxContains` without `contains` have no validation effect and are ignored.
+ * - Objects and arrays used as `const` values or `enum` members throw an `Unsupported structured JSON Schema value`
+ *   error.
+ * - Intersections of overlapping unions are limited to disjoint root-type partitions and finite primitive `anyOf`
+ *   literal sets. Other union intersections, including cases that would duplicate a nested choice, throw an
+ *   `Unsupported intersection of overlapping unions` error.
+ * - Unknown extension keywords are ignored and their semantics are not enforced.
+ * - Only direct local references to top-level definitions in the form `#/$defs/<escaped-token>` are supported. Root
+ *   references, external references, and pointers below a definition throw an `Unsupported reference` error. A direct
+ *   reference to a missing definition throws an `Invalid reference` error.
  * - Built-in declarations and checks are reconstructed with importer-owned revivers.
  * - Pattern constraints reached during translation cause an error by default. Use `patterns: "apply"` only for trusted
  *   documents, or `patterns: "ignore"` to weaken validation explicitly; ignored patterns are outside the round-trip
@@ -1297,7 +2871,7 @@ export function fromJsonSchemaDocument(
   document: JsonSchema.Document<"draft-2020-12">,
   options?: FromJsonSchemaOptions
 ): Schema.Top {
-  return InternalFromJsonSchemaDocument.fromJsonSchemaDocument(document, options)
+  return InternalFromJsonSchemaDocument.fromJsonSchemaDocument(document, options, jsonSchemaRevivers)
 }
 
 /**
@@ -1309,9 +2883,20 @@ export function fromJsonSchemaDocument(
  *
  * **Gotchas**
  *
- * Only definitions reachable from a root are translated. Pattern constraints reached during translation cause an error
- * by default. Use `patterns: "apply"` only for trusted documents, or `patterns: "ignore"` to weaken validation explicitly.
- * Callback results are used directly, and exceptions raised by a callback pass through unchanged.
+ * - Only definitions reachable from a root are translated.
+ * - Unsupported standard validation and applicator keywords throw an `Unsupported JSON Schema keyword` error. Unknown
+ *   extension keywords are ignored and their semantics are not enforced.
+ * - Objects and arrays used as `const` values or `enum` members throw an `Unsupported structured JSON Schema value`
+ *   error.
+ * - Intersections of overlapping unions are limited to disjoint root-type partitions and finite primitive `anyOf`
+ *   literal sets. Other union intersections, including cases that would duplicate a nested choice, throw an
+ *   `Unsupported intersection of overlapping unions` error.
+ * - Only direct local references to top-level definitions in the form `#/$defs/<escaped-token>` are supported. Root
+ *   references, external references, and pointers below a definition throw an `Unsupported reference` error. A direct
+ *   reference to a missing definition throws an `Invalid reference` error.
+ * - Pattern constraints reached during translation cause an error by default. Use `patterns: "apply"` only for trusted
+ *   documents, or `patterns: "ignore"` to weaken validation explicitly.
+ * - Callback results are used directly, and exceptions raised by a callback pass through unchanged.
  *
  * @see {@link fromJsonSchemaDocument} for a single root
  * @see {@link toRepresentations} for converting the returned schema ASTs to a representation document
@@ -1323,5 +2908,5 @@ export function fromJsonSchemaMultiDocument(
   document: JsonSchema.MultiDocument<"draft-2020-12">,
   options?: FromJsonSchemaOptions
 ): readonly [Schema.Top, ...Array<Schema.Top>] {
-  return InternalFromJsonSchemaDocument.fromJsonSchemaMultiDocument(document, options)
+  return InternalFromJsonSchemaDocument.fromJsonSchemaMultiDocument(document, options, jsonSchemaRevivers)
 }