effect 4.0.5 → 4.0.7

package/src/internal/schema/fromJsonSchemaDocument.ts

@@ -1,41 +1,107 @@
-import * as Iterable from "../../Iterable.ts"
+import { escapeToken, parseUriFragment } from "../../JsonPointer.ts"
 import * as JsonSchema from "../../JsonSchema.ts"
-import { remainder } from "../../Number.ts"
-import type * as Schema from "../../Schema.ts"
+import * as Schema from "../../Schema.ts"
 import * as InternalAST from "../../SchemaAST.ts"
 import type * as SchemaRepresentation from "../../SchemaRepresentation.ts"
 import { errorWithPath } from "../errors.ts"
+import * as InternalJsonSchema from "../jsonSchema.ts"
 import * as InternalRecord from "../record.ts"
-import { fromRepresentation, fromRepresentations } from "./fromRepresentation.ts"
+import * as InternalAnnotations from "./annotations.ts"
+import { ReferenceSlot } from "./fromRepresentation.ts"
 
 type Path = ReadonlyArray<string | number>
-type Representation = SchemaRepresentation.Representation
-type Check = SchemaRepresentation.Check
+type Check = Filter | FilterGroup | PropertyNames
 
-interface Checked {
-  readonly checks: ReadonlyArray<Check>
+interface Filter {
+  readonly _tag: "Filter"
+  readonly filter: InternalAST.Filter<any>
+  readonly annotations?: Schema.Annotations.Filter | undefined
+}
+
+interface PropertyNames {
+  readonly _tag: "PropertyNames"
+  readonly type: ImportedJsonSchemaRepresentation
+  readonly annotations?: Schema.Annotations.Filter | undefined
+}
+
+interface FilterGroup {
+  readonly _tag: "FilterGroup"
+  readonly checks: readonly [Check, ...Array<Check>]
   readonly annotations?: Schema.Annotations.Annotations | undefined
 }
 
-type ImportedJsonSchemaRepresentation = Extract<Representation, {
-  readonly _tag:
-    | "Reference"
-    | "Suspend"
-    | "Never"
-    | "Unknown"
-    | "Null"
-    | "String"
-    | "Number"
-    | "Boolean"
-    | "Literal"
-    | "Arrays"
-    | "Objects"
-    | "Union"
-}>
+interface ImportedAnnotations {
+  // Standard annotations may describe a value or a group of checks. Custom
+  // annotations always describe the value, even when its checks simplify away.
+  readonly annotations?: Schema.Annotations.Annotations | undefined
+  readonly customAnnotations?: Schema.Annotations.Annotations | undefined
+}
+
+interface Checked extends ImportedAnnotations {
+  readonly checks: ReadonlyArray<Check>
+}
+
+interface ImportedKeyword<Tag extends string> extends Checked {
+  readonly _tag: Tag
+}
+
+interface ImportedLiteral extends ImportedKeyword<"Literal"> {
+  readonly literal: string | number | boolean
+}
+
+interface ImportedElement {
+  readonly type: ImportedJsonSchemaRepresentation
+  readonly isOptional: boolean
+}
+
+interface ImportedArrays extends ImportedKeyword<"Arrays"> {
+  readonly elements: ReadonlyArray<ImportedElement>
+  readonly rest: ReadonlyArray<ImportedJsonSchemaRepresentation>
+}
+
+interface ImportedProperty extends ImportedElement {
+  readonly name: string
+}
+
+interface ImportedIndexSignature {
+  readonly parameter: ImportedJsonSchemaRepresentation
+  readonly type: ImportedJsonSchemaRepresentation
+}
+
+interface ImportedReference extends SchemaRepresentation.Reference, ImportedAnnotations {
+  readonly path: Path
+}
+
+interface ImportedObjects extends ImportedKeyword<"Objects"> {
+  readonly propertySignatures: ReadonlyArray<ImportedProperty>
+  readonly indexSignatures: ReadonlyArray<ImportedIndexSignature>
+  readonly scopes: ReadonlyArray<ImportedObjectScope>
+  readonly path: Path
+}
+
+interface ImportedUnion extends ImportedKeyword<"Union"> {
+  readonly types: ReadonlyArray<ImportedJsonSchemaRepresentation>
+  readonly options?: SchemaRepresentation.Union["options"]
+}
+
+// Import nodes keep source metadata and scopes until normalization is complete.
+// Only finalize constructs runtime schemas after normalization.
+type ImportedJsonSchemaRepresentation =
+  | ImportedKeyword<"Never">
+  | ImportedKeyword<"Unknown">
+  | ImportedKeyword<"Null">
+  | ImportedKeyword<"String">
+  | ImportedKeyword<"Number">
+  | ImportedKeyword<"Boolean">
+  | ImportedLiteral
+  | ImportedArrays
+  | ImportedObjects
+  | ImportedUnion
+  | ImportedReference
 
 interface ImportedObjectPattern {
   readonly source: string
-  readonly parameter: SchemaRepresentation.String
+  readonly parameter: ImportedKeyword<"String">
   readonly type: ImportedJsonSchemaRepresentation
 }
 
@@ -54,6 +120,13 @@ interface ImportedObjectScope {
 const never: ImportedJsonSchemaRepresentation = { _tag: "Never", checks: [] }
 const unknown: ImportedJsonSchemaRepresentation = { _tag: "Unknown", checks: [] }
 const string: ImportedJsonSchemaRepresentation = { _tag: "String", checks: [] }
+const primitiveSchemas = {
+  Never: Schema.Never,
+  Null: Schema.Null,
+  String: Schema.String,
+  Number: Schema.Number,
+  Boolean: Schema.Boolean
+}
 const unsupportedStructuredValue = "Only primitive values are supported in \"const\" and \"enum\"."
 const jsonSchemaPatternFlags = "u"
 
@@ -93,6 +166,47 @@ const jsonSchemaTypeSpecificKeys = [
   "maxItems",
   "uniqueItems"
 ]
+
+const jsonSchemaAnnotationExcludedKeys = new Set([
+  ...jsonSchemaTypeSpecificKeys,
+  ...InternalAnnotations.jsonSchemaAnnotationKeys,
+  ...InternalAnnotations.annotationExcludedKeys,
+  "$schema",
+  "$id",
+  "$ref",
+  "$defs",
+  "$anchor",
+  "$dynamicRef",
+  "$dynamicAnchor",
+  "$vocabulary",
+  "$comment",
+  "type",
+  "const",
+  "enum",
+  "allOf",
+  "anyOf",
+  "oneOf",
+  "not",
+  "if",
+  "then",
+  "else",
+  "contains",
+  "minContains",
+  "maxContains",
+  "dependentRequired",
+  "dependentSchemas",
+  "unevaluatedItems",
+  "unevaluatedProperties",
+  "definitions",
+  "dependencies",
+  "additionalItems",
+  "identifier",
+  "expected",
+  "message",
+  "messageMissingKey",
+  "messageUnexpectedKey"
+])
+
 function isImportedJsonSchemaType(input: unknown): input is JsonSchema.Type {
   return input === "integer" || typeof input === "string" && jsonSchemaValueTypes.some((type) => type === input)
 }
@@ -101,36 +215,24 @@ function hasTypeSpecificKeywords(schema: JsonSchema.JsonSchema): boolean {
   return jsonSchemaTypeSpecificKeys.some((key) => schema[key] !== undefined)
 }
 
-function jsonSchemaFilter(
-  id: string,
-  payload: Schema.Json,
-  schemas?: ReadonlyArray<Representation>
-): Check {
-  return {
-    _tag: "Filter",
-    aborted: false,
-    representation: {
-      id,
-      payload,
-      ...(schemas === undefined ? undefined : { schemas })
-    }
-  }
+function makeFilter(filter: InternalAST.Filter<any>): Filter {
+  return { _tag: "Filter", filter }
 }
 
 function addNumberCheck(
   checks: Array<Check>,
   value: unknown,
-  id: string,
-  key: string
+  make: (value: number) => InternalAST.Filter<any>
 ): void {
   if (typeof value === "number") {
-    checks.push(jsonSchemaFilter(id, { [key]: value }))
+    checks.push(makeFilter(make(value)))
   }
 }
 
 function jsonSchemaAnnotations(
-  schema: JsonSchema.JsonSchema
-): Schema.Annotations.Annotations | undefined {
+  schema: JsonSchema.JsonSchema,
+  options: SchemaRepresentation.FromJsonSchemaOptions | undefined
+): ImportedAnnotations {
   const annotations: Record<string, Schema.Json> = {}
   if (typeof schema.title === "string") annotations.title = schema.title
   if (typeof schema.description === "string") annotations.description = schema.description
@@ -142,122 +244,129 @@ function jsonSchemaAnnotations(
   if (typeof schema.contentEncoding === "string") annotations.contentEncoding = schema.contentEncoding
   if (typeof schema.contentMediaType === "string") annotations.contentMediaType = schema.contentMediaType
   if (InternalAST.isJson(schema.contentSchema)) annotations.contentSchema = schema.contentSchema
-  return Object.keys(annotations).length === 0 ? undefined : annotations
-}
-
-function jsonDeclaration(
-  annotations: Schema.Annotations.Annotations | undefined
-): Representation {
-  return {
-    _tag: "Declaration",
-    representation: {
-      id: "effect/schema/Json",
-      payload: null
-    },
-    annotations: {
-      ...annotations,
-      expected: "JSON value"
-    },
-    checks: [],
-    typeParameters: []
+  let customAnnotations: Schema.Annotations.Annotations | undefined
+  if (options?.includeAnnotationKey !== undefined) {
+    for (const key of Object.keys(schema)) {
+      if (
+        key.startsWith("~") ||
+        jsonSchemaAnnotationExcludedKeys.has(key) ||
+        !options.includeAnnotationKey(key)
+      ) continue
+      const value = schema[key]
+      if (InternalAST.isJson(value)) InternalRecord.assignProperty(customAnnotations ??= {}, key, value)
+    }
   }
+  return { annotations: Object.keys(annotations).length === 0 ? undefined : annotations, customAnnotations }
 }
 
-function translateJsonSchemaMultiDocument(
+/** @internal */
+export function fromJsonSchemaMultiDocument(
   document: JsonSchema.MultiDocument<"draft-2020-12">,
   options?: SchemaRepresentation.FromJsonSchemaOptions,
   singleRoot = false
-): SchemaRepresentation.MultiDocument {
+): readonly [Schema.Top, ...Array<Schema.Top>] {
   const definitionCache = new Map<string, ImportedJsonSchemaRepresentation | null>()
-  const reachableDefinitions = new Map<string, Path>()
-  const objectScopesByProperties = new WeakMap<
-    SchemaRepresentation.Objects["propertySignatures"],
-    readonly [ReadonlyArray<ImportedObjectScope>, Path]
-  >()
-  const annotatedReferences: Array<{
-    readonly reference: SchemaRepresentation.Reference
-    readonly path: Path
-  }> = []
+  const validatedAliases = new Set<string>()
   const resolvingChoices = new Set<string>()
-  const finalReferences = new Set<string>()
+  const references = new Map<string, ReferenceSlot>()
   let inNestedResource = false
 
-  function finalize(representation: Representation): Representation {
-    switch (representation._tag) {
+  function finalize(input: ImportedJsonSchemaRepresentation): Schema.Top {
+    const annotations = mergeAnnotations(input.annotations, input.customAnnotations)
+    if (input._tag === "Reference") {
+      if (annotations !== undefined) resolveReference(input, input.path)
+      let slot = references.get(input.$ref)
+      if (slot === undefined) {
+        slot = new ReferenceSlot(input.$ref)
+        references.set(input.$ref, slot)
+        slot.body = finalize(translateDefinition(input.$ref, input.path)).annotate({ identifier: input.$ref })
+      }
+      return annotations === undefined ? slot.body ?? slot.wrapper : slot.wrapper.annotate(annotations)
+    }
+
+    let schema: Schema.Top
+    switch (input._tag) {
       case "Unknown":
-        return jsonDeclaration(representation.annotations)
-      case "Reference":
-        finalReferences.add(representation.$ref)
-        return representation
-      case "Suspend":
-        return { ...representation, thunk: finalize(representation.thunk) }
-      case "Arrays":
-        return {
-          ...representation,
-          elements: representation.elements.map((element) => ({
-            ...element,
-            type: finalize(element.type)
-          })),
-          rest: representation.rest.map(finalize)
-        }
-      case "Objects":
-        // Intersections may reduce open patterns to fixed properties, so reject only
-        // if an open pattern remains in the final representation.
-        const [scopes, path] = objectScopesByProperties.get(representation.propertySignatures)!
+        return Schema.Json.annotate({ ...annotations, expected: "JSON value" })
+      case "Never":
+      case "Null":
+      case "String":
+      case "Number":
+      case "Boolean":
+        schema = primitiveSchemas[input._tag]
+        break
+      case "Literal":
+        schema = Schema.Literal(input.literal)
+        break
+      case "Arrays": {
+        const elements = input.elements.map((element) => {
+          const type = finalize(element.type)
+          return element.isOptional ? Schema.optionalKey(type) : type
+        })
+        const rest = input.rest[0] === undefined ? undefined : finalize(input.rest[0])
+        schema = rest !== undefined
+          ? elements.length === 0
+            ? Schema.Array(rest)
+            : Schema.TupleWithRest(Schema.Tuple(elements), [rest])
+          : Schema.Tuple(elements)
+        break
+      }
+      case "Objects": {
+        // Intersections may remove open patterns, so check the normalized object.
         if (
-          representation.indexSignatures[0]?.parameter === string &&
-          scopes.some((scope) => scope.patterns.length > 0)
+          input.indexSignatures[0]?.parameter === string &&
+          input.scopes.some((scope) => scope.patterns.length > 0)
         ) {
           throw errorWithPath(
             "Cannot import open \"patternProperties\": unmatched keys cannot be typed correctly.",
-            path
+            input.path
           )
         }
-        return {
-          ...representation,
-          propertySignatures: representation.propertySignatures.map((property) => ({
-            ...property,
-            type: finalize(property.type)
-          })),
-          indexSignatures: representation.indexSignatures.map((indexSignature) => ({
-            parameter: finalize(indexSignature.parameter),
-            type: finalize(indexSignature.type)
-          })),
-          checks: representation.checks.map(finalizeCheck)
+        const fields: Record<string, Schema.Top> = {}
+        for (const property of input.propertySignatures) {
+          const type = finalize(property.type)
+          InternalRecord.assignProperty(fields, property.name, property.isOptional ? Schema.optionalKey(type) : type)
         }
+        const index = input.indexSignatures[0]
+        const record = index === undefined
+          ? undefined
+          : Schema.Record(finalize(index.parameter) as Schema.Record.Key, finalize(index.type))
+        schema = record !== undefined
+          ? input.propertySignatures.length === 0
+            ? record
+            : Schema.StructWithRest(Schema.Struct(fields), [record])
+          : Schema.Struct(fields)
+        break
+      }
       case "Union":
-        return { ...representation, types: representation.types.map(finalize) }
-      default:
-        return representation
+        schema = Schema.Union(input.types.map(finalize), input.options)
+        break
     }
+    if (annotations !== undefined) schema = schema.annotate(annotations)
+    const checks = input.checks.map(finalizeCheck)
+    return checks.length > 0 ? schema.check(...checks as [InternalAST.Check<any>]) : schema
   }
 
-  function finalizeCheck(check: Check): Check {
-    const representation = check.representation
-    const schemas = representation?.schemas
-    if (representation === undefined || schemas === undefined) {
-      return check
-    }
-    return {
-      ...check,
-      representation: {
-        ...representation,
-        schemas: schemas.map(finalize)
-      }
+  function finalizeCheck(check: Check): InternalAST.Check<any> {
+    if (check._tag === "FilterGroup") {
+      return Schema.makeFilterGroup(
+        check.checks.map(finalizeCheck) as [InternalAST.Check<any>, ...Array<InternalAST.Check<any>>],
+        check.annotations
+      )
     }
+    const filter = check._tag === "PropertyNames" ? Schema.isPropertyNames(finalize(check.type)) : check.filter
+    return check.annotations === undefined ? filter : filter.annotate(check.annotations)
   }
 
   function annotate(
     representation: ImportedJsonSchemaRepresentation,
-    annotations: Schema.Annotations.Annotations | undefined
+    source: ImportedAnnotations
   ): ImportedJsonSchemaRepresentation {
-    if (annotations === undefined) return representation
-    if (representation._tag === "Reference") {
-      return { _tag: "Suspend", annotations, checks: [], thunk: representation }
-    }
+    if (source.annotations === undefined && source.customAnnotations === undefined) return representation
     return {
       ...representation,
-      annotations: { ...representation.annotations, ...annotations }
+      annotations: mergeAnnotations(representation.annotations, source.annotations),
+      customAnnotations: mergeAnnotations(representation.customAnnotations, source.customAnnotations)
     }
   }
 
@@ -278,13 +387,52 @@ function translateJsonSchemaMultiDocument(
       return cached
     }
     definitionCache.set(key, null)
-    const representation = translateSchema(document.definitions[key], ["definitions", key])
+    const pointer = pointers.get(key)
+    const wasInNestedResource = inNestedResource
+    if (pointer !== undefined) inNestedResource = pointer.crossesResource
+    const representation = pointer === undefined
+      ? translateSchema(document.definitions[key], ["definitions", key])
+      : translateSchema(pointer.target, ["definitions", ...pointer.tokens])
+    inNestedResource = wasInNestedResource
     definitionCache.set(key, representation)
+    if (pointer !== undefined) {
+      validatePointerAliases(representation, path, recursiveReferenceError)
+    }
     return representation
   }
 
+  function validatePointerAliases(
+    representation: ImportedJsonSchemaRepresentation,
+    path: Path,
+    recursiveReferenceError?: string,
+    visiting: Set<string> = new Set()
+  ): void {
+    if (representation._tag === "Reference") {
+      const key = representation.$ref
+      if (validatedAliases.has(key)) return
+      if (visiting.has(key)) {
+        throw errorWithPath(`Definition ${JSON.stringify(key)} is a circular alias.`, [...path, "$ref"])
+      }
+      visiting.add(key)
+      validatePointerAliases(
+        translateDefinition(key, path, recursiveReferenceError),
+        path,
+        recursiveReferenceError,
+        visiting
+      )
+      visiting.delete(key)
+      validatedAliases.add(key)
+    } else if (representation._tag === "Union") {
+      // Alternatives share completed checks, but only ancestors belong to the active path.
+      for (const type of representation.types) {
+        validatePointerAliases(type, path, recursiveReferenceError, visiting)
+      }
+    }
+    // Recursion through object properties or array items consumes a child value.
+  }
+
   function resolveReference(
-    reference: SchemaRepresentation.Reference,
+    reference: ImportedReference,
     path: Path,
     recursiveReferenceError?: string,
     seen: Set<string> = new Set()
@@ -298,17 +446,67 @@ function translateJsonSchemaMultiDocument(
     seen.add(reference.$ref)
     const representation = translateDefinition(reference.$ref, path, recursiveReferenceError)
     if (representation._tag === "Reference") {
-      return resolveReference(representation, path, recursiveReferenceError, seen)
-    }
-    if (representation._tag === "Suspend" && representation.thunk._tag === "Reference") {
       return annotate(
-        resolveReference(representation.thunk, path, recursiveReferenceError, seen),
-        representation.annotations
+        resolveReference(representation, path, recursiveReferenceError, seen),
+        representation
       )
     }
     return representation
   }
 
+  // Pointers below a definition are registered as definitions keyed by their escaped tokens, e.g. "O/properties/v"
+  const pointers = new Map<
+    string,
+    { readonly target: unknown; readonly tokens: ReadonlyArray<string>; readonly crossesResource: boolean }
+  >()
+
+  function resolvePointer($ref: string, path: Path): string {
+    const pointer = $ref.startsWith("#") ? parseUriFragment($ref) : undefined
+    if (pointer === undefined || pointer.length < 3 || pointer[0] !== "$defs") {
+      throw errorWithPath(`Unsupported $ref ${JSON.stringify($ref)}. Use "#/$defs/Name".`, [...path, "$ref"])
+    }
+    const tokens = pointer.slice(1)
+    const key = tokens.map(escapeToken).join("/")
+    if (Object.hasOwn(document.definitions, key)) {
+      throw errorWithPath(
+        `Pointer $ref ${JSON.stringify($ref)} conflicts with definition ${JSON.stringify(key)}.`,
+        [...path, "$ref"]
+      )
+    }
+    if (pointers.has(key)) return key
+    // Walk through the onEnter result of each ancestor schema, as translateSchema would see it
+    let node: unknown = document.definitions
+    let position: "schema" | "container" | "value" = "container"
+    let crossesResource = false
+    for (const token of tokens) {
+      if (position === "container") {
+        position = "schema"
+      } else if (position === "schema" && isObject(node)) {
+        if (options?.onEnter !== undefined) node = options.onEnter(node as JsonSchema.JsonSchema)
+        crossesResource ||= isObject(node) && typeof node.$id === "string"
+        const kind = InternalJsonSchema.getSubschemaKind(token)
+        position = kind === "schema"
+          ? "schema"
+          : kind === undefined
+          ? "value"
+          : "container"
+      } else {
+        position = "value"
+      }
+      node = typeof node === "object" && node !== null && Object.hasOwn(node, token)
+        ? (node as Record<string, unknown>)[token]
+        : undefined
+    }
+    if (!isObject(node) && typeof node !== "boolean") {
+      throw errorWithPath(
+        `Unresolvable $ref ${JSON.stringify($ref)}. Nothing exists at that location.`,
+        [...path, "$ref"]
+      )
+    }
+    pointers.set(key, { target: node, tokens, crossesResource })
+    return key
+  }
+
   function mergeAnnotations(
     left: Schema.Annotations.Annotations | undefined,
     right: Schema.Annotations.Annotations | undefined
@@ -320,34 +518,27 @@ function translateJsonSchemaMultiDocument(
 
   function annotateIntersection(
     representation: ImportedJsonSchemaRepresentation,
-    left: ImportedJsonSchemaRepresentation,
-    right: ImportedJsonSchemaRepresentation
+    left: ImportedAnnotations,
+    right: ImportedAnnotations
   ): ImportedJsonSchemaRepresentation {
-    return annotate(
-      representation,
-      mergeAnnotations(
-        left._tag === "Reference" ? undefined : left.annotations,
-        right._tag === "Reference" ? undefined : right.annotations
-      )
-    )
+    return annotate(annotate(representation, left), right)
   }
 
   function intersectChecks(
     left: Checked,
     right: Checked,
     deduplicate: ReadonlyArray<string> = []
-  ): readonly [ReadonlyArray<Check>, Schema.Annotations.Annotations | undefined] {
+  ): Checked {
     let checks = right.checks
     for (const id of deduplicate) {
-      if (left.checks.some((check) => check._tag === "Filter" && check.representation?.id === id)) {
-        checks = checks.filter((check) => check._tag !== "Filter" || check.representation?.id !== id)
+      if (left.checks.some((check) => check._tag === "Filter" && check.filter.annotations?.representation?.id === id)) {
+        checks = checks.filter((check) =>
+          check._tag !== "Filter" || check.filter.annotations?.representation?.id !== id
+        )
       }
     }
-    if (checks.length === 0) {
-      const annotations = mergeAnnotations(left.annotations, right.annotations)
-      return [left.checks, annotations]
-    }
-    if (right.annotations !== undefined) {
+    const annotations = checks.length === 0 ? mergeAnnotations(left.annotations, right.annotations) : left.annotations
+    if (checks.length > 0 && right.annotations !== undefined) {
       checks = checks.length === 1 && checks[0].annotations === undefined
         ? [{ ...checks[0], annotations: right.annotations }]
         : [{
@@ -356,46 +547,23 @@ function translateJsonSchemaMultiDocument(
           annotations: right.annotations
         }]
     }
-    return [[...left.checks, ...checks], left.annotations]
+    return {
+      checks: [...left.checks, ...checks],
+      annotations,
+      customAnnotations: mergeAnnotations(left.customAnnotations, right.customAnnotations)
+    }
   }
 
-  function satisfiesPrimitiveCheck(check: Check, value: string | number): boolean | undefined {
+  function satisfiesPrimitiveCheck(check: Check, value: string | number): boolean {
     if (check._tag === "FilterGroup") {
       return check.checks.every((check) => satisfiesPrimitiveCheck(check, value))
     }
-    const representation = check.representation!
-    const payload = representation.payload as Record<string, any>
-    switch (representation.id) {
-      case "effect/schema/isMinLength":
-        return (value as string).length >= payload.minLength
-      case "effect/schema/isMinCodePoints":
-        return Iterable.size(value as string) >= payload.minCodePoints
-      case "effect/schema/isMaxCodePoints":
-        return Iterable.size(value as string) <= payload.maxCodePoints
-      case "effect/schema/isPattern":
-        return new RegExp(payload.source as string, payload.flags as string).test(value as string)
-      case "effect/schema/isFinite":
-        return globalThis.Number.isFinite(value as number)
-      case "effect/schema/isInt":
-        return globalThis.Number.isSafeInteger(value as number)
-      case "effect/schema/isMultipleOf":
-        return remainder(value as number, payload.divisor) === 0
-      case "effect/schema/isGreaterThan":
-        return (value as number) > payload.exclusiveMinimum
-      case "effect/schema/isGreaterThanOrEqualTo":
-        return (value as number) >= payload.minimum
-      case "effect/schema/isLessThan":
-        return (value as number) < payload.exclusiveMaximum
-      case "effect/schema/isLessThanOrEqualTo":
-        return (value as number) <= payload.maximum
-    }
+    return check._tag === "Filter" && check.filter.run(value, Schema.Unknown.ast, {}) === undefined
   }
 
   function satisfiesLiteral(
-    representation:
-      | SchemaRepresentation.String
-      | SchemaRepresentation.Number,
-    literal: SchemaRepresentation.Literal
+    representation: ImportedKeyword<"String"> | ImportedKeyword<"Number">,
+    literal: ImportedLiteral
   ): boolean {
     const value = literal.literal
     if (representation._tag === "String" ? typeof value !== "string" : typeof value !== "number") {
@@ -405,11 +573,8 @@ function translateJsonSchemaMultiDocument(
   }
 
   function intersectPrimitiveWithLiteral(
-    primitive:
-      | SchemaRepresentation.String
-      | SchemaRepresentation.Number
-      | SchemaRepresentation.Boolean,
-    literal: SchemaRepresentation.Literal
+    primitive: ImportedKeyword<"String"> | ImportedKeyword<"Number"> | ImportedKeyword<"Boolean">,
+    literal: ImportedLiteral
   ): ImportedJsonSchemaRepresentation {
     const satisfies = primitive._tag === "Boolean"
       ? typeof literal.literal === "boolean"
@@ -418,11 +583,11 @@ function translateJsonSchemaMultiDocument(
   }
 
   function intersectArrays(
-    left: SchemaRepresentation.Arrays,
-    right: SchemaRepresentation.Arrays,
+    left: ImportedArrays,
+    right: ImportedArrays,
     path: Path
-  ): Pick<SchemaRepresentation.Arrays, "elements" | "rest"> | undefined {
-    const elements: Array<SchemaRepresentation.Element> = []
+  ): Pick<ImportedArrays, "elements" | "rest"> | undefined {
+    const elements: Array<ImportedElement> = []
     const length = Math.max(left.elements.length, right.elements.length)
     for (let index = 0; index < length; index++) {
       const leftElement = left.elements[index]
@@ -434,8 +599,8 @@ function translateJsonSchemaMultiDocument(
         return isOptional ? { elements, rest: [] } : undefined
       }
       const type = intersect(
-        leftType as ImportedJsonSchemaRepresentation,
-        rightType as ImportedJsonSchemaRepresentation,
+        leftType,
+        rightType,
         [...path, "elements", index, "type"]
       )
       if (type._tag === "Never") {
@@ -453,8 +618,8 @@ function translateJsonSchemaMultiDocument(
       return { elements, rest: [] }
     }
     const rest = intersect(
-      leftRest as ImportedJsonSchemaRepresentation,
-      rightRest as ImportedJsonSchemaRepresentation,
+      leftRest,
+      rightRest,
       [...path, "rest", 0]
     )
     return { elements, rest: rest._tag === "Never" ? [] : [rest] }
@@ -473,8 +638,7 @@ function translateJsonSchemaMultiDocument(
 
   function lowerObject(
     scopes: ReadonlyArray<ImportedObjectScope>,
-    checks: ReadonlyArray<Check>,
-    annotations: Schema.Annotations.Annotations | undefined,
+    checked: Checked,
     path: Path
   ): ImportedJsonSchemaRepresentation {
     const names = new Set<string>()
@@ -499,7 +663,7 @@ function translateJsonSchemaMultiDocument(
       )
     }
 
-    const properties: Array<SchemaRepresentation.PropertySignature> = []
+    const properties: Array<ImportedProperty> = []
     for (const name of names) {
       let isOptional = true
       const types: Array<ImportedJsonSchemaRepresentation> = []
@@ -520,10 +684,10 @@ function translateJsonSchemaMultiDocument(
       }
       const type = intersectAll(types, [...path, "properties", name])
       if (!isOptional && type._tag === "Never") return never
-      properties.push({ name, type, isOptional, isMutable: false })
+      properties.push({ name, type, isOptional })
     }
 
-    const indexSignatures: ReadonlyArray<SchemaRepresentation.IndexSignature> = closedPattern !== undefined
+    const indexSignatures: ReadonlyArray<ImportedIndexSignature> = closedPattern !== undefined
       ? [{ parameter: closedPattern.parameter, type: closedPattern.type }]
       : !hasFiniteKeyDomain
       ? [{
@@ -536,15 +700,14 @@ function translateJsonSchemaMultiDocument(
       : properties.length === 0
       ? [{ parameter: string, type: never }]
       : []
-    const representation: SchemaRepresentation.Objects = {
+    return {
       _tag: "Objects",
       propertySignatures: properties,
       indexSignatures,
-      checks,
-      annotations
+      scopes,
+      path,
+      ...checked
     }
-    objectScopesByProperties.set(properties, [scopes, path])
-    return representation
   }
 
   const jsonRootTags = ["Null", "String", "Number", "Boolean", "Objects", "Arrays"] as const
@@ -568,12 +731,10 @@ function translateJsonSchemaMultiDocument(
           default:
             return 0
         }
-      case "Suspend":
-        return rootMask(representation.thunk as ImportedJsonSchemaRepresentation)
       case "Union": {
         let out = 0
         for (const type of representation.types) {
-          out |= rootMask(type as ImportedJsonSchemaRepresentation)
+          out |= rootMask(type)
         }
         return out
       }
@@ -589,30 +750,23 @@ function translateJsonSchemaMultiDocument(
         const cached = definitionCache.get(key)
         if (cached === null || resolvingChoices.has(key)) return true
         resolvingChoices.add(key)
-        const out = hasChoices(cached ?? translateDefinition(key, reachableDefinitions.get(key)!))
+        const out = hasChoices(cached ?? translateDefinition(key, representation.path))
         resolvingChoices.delete(key)
         return out
       }
-      case "Suspend":
-        return hasChoices(representation.thunk as ImportedJsonSchemaRepresentation)
       case "Union":
         return representation.types.length > 1 ||
-          representation.types.some((type) => hasChoices(type as ImportedJsonSchemaRepresentation))
+          representation.types.some(hasChoices)
       case "Arrays":
-        return representation.elements.some((element) =>
-          hasChoices(element.type as ImportedJsonSchemaRepresentation)
-        ) || representation.rest.some((type) => hasChoices(type as ImportedJsonSchemaRepresentation))
+        return representation.elements.some((element) => hasChoices(element.type)) ||
+          representation.rest.some(hasChoices)
       case "Objects":
-        return representation.propertySignatures.some((property) =>
-          hasChoices(property.type as ImportedJsonSchemaRepresentation)
-        ) ||
+        return representation.propertySignatures.some((property) => hasChoices(property.type)) ||
           representation.indexSignatures.some((indexSignature) =>
-            hasChoices(indexSignature.parameter as ImportedJsonSchemaRepresentation) ||
-            hasChoices(indexSignature.type as ImportedJsonSchemaRepresentation)
-          ) ||
-          objectScopesByProperties.get(representation.propertySignatures)![0].some((scope) =>
-            scope.patterns.some((pattern) => hasChoices(pattern.type))
+            hasChoices(indexSignature.parameter) ||
+            hasChoices(indexSignature.type)
           ) ||
+          representation.scopes.some((scope) => scope.patterns.some((pattern) => hasChoices(pattern.type))) ||
           representation.checks.some(checkHasChoices)
       default:
         return false
@@ -622,15 +776,15 @@ function translateJsonSchemaMultiDocument(
   function checkHasChoices(check: Check): boolean {
     return check._tag === "FilterGroup"
       ? check.checks.some(checkHasChoices)
-      : check.representation?.schemas?.some((schema) => hasChoices(schema as ImportedJsonSchemaRepresentation)) === true
+      : check._tag === "PropertyNames" && hasChoices(check.type)
   }
 
   function makeUnion(
-    source: SchemaRepresentation.Union,
+    source: ImportedUnion,
     types: ReadonlyArray<ImportedJsonSchemaRepresentation>
   ): ImportedJsonSchemaRepresentation {
     if (types.length === 0) return never
-    if (types.length === 1 && source.checks.length === 0) return annotate(types[0], source.annotations)
+    if (types.length === 1 && source.checks.length === 0) return annotate(types[0], source)
     return { ...source, types }
   }
 
@@ -639,40 +793,39 @@ function translateJsonSchemaMultiDocument(
   ): string | number | boolean | null | undefined {
     if (representation._tag === "Null") return null
     if (representation._tag !== "Literal") return undefined
-    const literal = representation.literal
-    return typeof literal === "string" || typeof literal === "number" || typeof literal === "boolean"
-      ? literal
-      : undefined
+    return representation.literal
   }
 
   function intersectLiteralUnions(
-    left: SchemaRepresentation.Union,
-    right: SchemaRepresentation.Union,
+    left: ImportedUnion,
+    right: ImportedUnion,
     path: Path
   ): ImportedJsonSchemaRepresentation | undefined {
     if ((left.options?.mode ?? "anyOf") !== "anyOf" || (right.options?.mode ?? "anyOf") !== "anyOf") {
       return undefined
     }
     const rightByValue = new Map<string | number | boolean | null, ImportedJsonSchemaRepresentation>()
-    for (const type of right.types) {
-      const representation = type as ImportedJsonSchemaRepresentation
+    for (const representation of right.types) {
       const value = literalValue(representation)
       if (value === undefined) return undefined
-      rightByValue.set(value, representation)
+      const previous = rightByValue.get(value)
+      rightByValue.set(value, {
+        ...representation,
+        customAnnotations: mergeAnnotations(previous?.customAnnotations, representation.customAnnotations)
+      })
     }
     const types: Array<ImportedJsonSchemaRepresentation> = []
-    for (const type of left.types) {
-      const representation = type as ImportedJsonSchemaRepresentation
+    for (const representation of left.types) {
       const value = literalValue(representation)
       if (value === undefined) return undefined
       const match = rightByValue.get(value)
-      if (match !== undefined) types.push(intersect(representation, annotate(match, right.annotations), path))
+      if (match !== undefined) types.push(intersect(representation, annotate(match, right), path))
     }
     return makeUnion(left, types)
   }
 
   function intersectUnionWithType(
-    union: SchemaRepresentation.Union,
+    union: ImportedUnion,
     type: ImportedJsonSchemaRepresentation,
     path: Path,
     unionOnLeft: boolean
@@ -681,14 +834,14 @@ function translateJsonSchemaMultiDocument(
     const members = union.types
       .map((member, index) => ({
         index,
-        type: member as ImportedJsonSchemaRepresentation
+        type: member
       }))
       .filter((member) => (rootMask(member.type) & mask) !== 0)
     if (members.length > 1 && hasChoices(type)) {
       return unsupportedIntersection(path)
     }
     if (members.length === 1 && union.checks.length === 0) {
-      const member = annotate(members[0].type, union.annotations)
+      const member = annotate(members[0].type, union)
       return unionOnLeft
         ? intersect(member, type, [...path, "types", members[0].index])
         : intersect(type, member, [...path, "types", members[0].index])
@@ -705,10 +858,10 @@ function translateJsonSchemaMultiDocument(
     )
   }
 
-  function isTypePartition(union: SchemaRepresentation.Union): boolean {
+  function isTypePartition(union: ImportedUnion): boolean {
     let mask = 0
     for (const type of union.types) {
-      const memberMask = rootMask(type as ImportedJsonSchemaRepresentation)
+      const memberMask = rootMask(type)
       if ((mask & memberMask) !== 0) return false
       mask |= memberMask
     }
@@ -723,13 +876,13 @@ function translateJsonSchemaMultiDocument(
   }
 
   function intersectPartition(
-    partition: SchemaRepresentation.Union,
-    other: SchemaRepresentation.Union,
+    partition: ImportedUnion,
+    other: ImportedUnion,
     path: Path,
     partitionOnLeft: boolean
   ): ImportedJsonSchemaRepresentation {
-    const partitionTypes = partition.types as ReadonlyArray<ImportedJsonSchemaRepresentation>
-    const otherTypes = other.types as ReadonlyArray<ImportedJsonSchemaRepresentation>
+    const partitionTypes = partition.types
+    const otherTypes = other.types
     for (const type of otherTypes) {
       const mask = rootMask(type)
       if (partitionTypes.filter((member) => (rootMask(member) & mask) !== 0).length > 1 && hasChoices(type)) {
@@ -746,8 +899,8 @@ function translateJsonSchemaMultiDocument(
   }
 
   function intersectUnions(
-    left: SchemaRepresentation.Union,
-    right: SchemaRepresentation.Union,
+    left: ImportedUnion,
+    right: ImportedUnion,
     path: Path
   ): ImportedJsonSchemaRepresentation {
     const literals = intersectLiteralUnions(left, right, path)
@@ -766,19 +919,19 @@ function translateJsonSchemaMultiDocument(
     if (right._tag === "Never") return right
     if (left._tag === "Unknown") return annotateIntersection(right, left, right)
     if (right._tag === "Unknown") return annotateIntersection(left, left, right)
-    if (left._tag === "Reference") return intersect(resolveReference(left, path), right, path)
-    if (right._tag === "Reference") return intersect(left, resolveReference(right, path), path)
-    if (left._tag === "Suspend") {
-      return annotate(
-        intersect(left.thunk as ImportedJsonSchemaRepresentation, right, path),
-        left.annotations
-      )
+    if (left._tag === "Reference") {
+      // Resolve an unannotated reference first. An annotated empty definition
+      // could otherwise leave the other reference unresolved during union partitioning.
+      if (
+        (left.annotations !== undefined || left.customAnnotations !== undefined) &&
+        right._tag === "Reference" && right.annotations === undefined && right.customAnnotations === undefined
+      ) {
+        return intersect(left, resolveReference(right, path), path)
+      }
+      return annotate(intersect(resolveReference(left, path), right, path), left)
     }
-    if (right._tag === "Suspend") {
-      return annotate(
-        intersect(left, right.thunk as ImportedJsonSchemaRepresentation, path),
-        right.annotations
-      )
+    if (right._tag === "Reference") {
+      return annotate(intersect(left, resolveReference(right, path), path), right)
     }
     if (left._tag === "Union" && right._tag === "Union") return intersectUnions(left, right, path)
     if (left._tag === "Union") return intersectUnionWithType(left, right, path, true)
@@ -794,18 +947,16 @@ function translateJsonSchemaMultiDocument(
           return intersectPrimitiveWithLiteral(left, right)
         }
         if (right._tag !== "String") return never
-        const [stringChecks, stringAnnotations] = intersectChecks(left, right)
-        return annotate({ _tag: "String", checks: stringChecks }, stringAnnotations)
+        return { _tag: "String", ...intersectChecks(left, right) }
       case "Number":
         if (right._tag === "Literal") {
           return intersectPrimitiveWithLiteral(left, right)
         }
         if (right._tag !== "Number") return never
-        const [numberChecks, numberAnnotations] = intersectChecks(left, right, [
-          "effect/schema/isFinite",
-          "effect/schema/isInt"
-        ])
-        return annotate({ _tag: "Number", checks: numberChecks }, numberAnnotations)
+        return {
+          _tag: "Number",
+          ...intersectChecks(left, right, ["effect/schema/isFinite", "effect/schema/isInt"])
+        }
       case "Boolean":
         if (right._tag === "Literal") {
           return intersectPrimitiveWithLiteral(left, right)
@@ -844,22 +995,12 @@ function translateJsonSchemaMultiDocument(
         if (right._tag !== "Arrays") return never
         const arrays = intersectArrays(left, right, path)
         if (arrays === undefined) return never
-        const [checks, annotations] = intersectChecks(left, right, ["effect/schema/isUnique"])
-        return annotate({ _tag: "Arrays", ...arrays, checks }, annotations)
+        return { _tag: "Arrays", ...arrays, ...intersectChecks(left, right, ["effect/schema/isUnique"]) }
       }
       case "Objects": {
         if (right._tag !== "Objects") return never
-        const [checks, annotations] = intersectChecks(left, right)
-        const scopes = [
-          ...objectScopesByProperties.get(left.propertySignatures)![0],
-          ...objectScopesByProperties.get(right.propertySignatures)![0]
-        ]
-        return lowerObject(
-          scopes,
-          checks,
-          annotations,
-          path
-        )
+        const scopes = [...left.scopes, ...right.scopes]
+        return lowerObject(scopes, intersectChecks(left, right), path)
       }
     }
   }
@@ -882,7 +1023,7 @@ function translateJsonSchemaMultiDocument(
     if (
       isObject(schema.not) &&
       Object.keys(schema.not).length === 0
-    ) return annotate(never, jsonSchemaAnnotations(schema))
+    ) return annotate(never, jsonSchemaAnnotations(schema, options))
     const wasInNestedResource = inNestedResource
     inNestedResource ||= !isRoot && typeof schema.$id === "string"
     for (const keyword of Object.keys(schema)) {
@@ -926,21 +1067,15 @@ function translateJsonSchemaMultiDocument(
           [...path, "$ref"]
         )
       }
-      const $ref = JsonSchema.getReferenceKey(schema.$ref)
-      if ($ref === undefined) {
+      const key = JsonSchema.getReferenceKey(schema.$ref)
+      if (key !== undefined && !Object.hasOwn(document.definitions, key)) {
         throw errorWithPath(
-          `Unsupported $ref ${JSON.stringify(schema.$ref)}. Use "#/$defs/Name".`,
+          `Missing definition ${JSON.stringify(key)} for $ref ${JSON.stringify(schema.$ref)}.`,
           [...path, "$ref"]
         )
       }
-      if (!Object.hasOwn(document.definitions, $ref)) {
-        throw errorWithPath(
-          `Missing definition ${JSON.stringify($ref)} for $ref ${JSON.stringify(schema.$ref)}.`,
-          [...path, "$ref"]
-        )
-      }
-      if (!reachableDefinitions.has($ref)) reachableDefinitions.set($ref, path)
-      const reference: SchemaRepresentation.Reference = { _tag: "Reference", $ref }
+      const $ref = key ?? resolvePointer(schema.$ref, path)
+      const reference: ImportedReference = { _tag: "Reference", $ref, path }
       representation = representation._tag === "Unknown"
         ? reference
         : representation._tag === "Never"
@@ -955,11 +1090,7 @@ function translateJsonSchemaMultiDocument(
           path
         )
     }
-    const annotations = jsonSchemaAnnotations(schema)
-    if (annotations !== undefined && representation._tag === "Reference") {
-      annotatedReferences.push({ reference: representation, path })
-    }
-    representation = annotate(representation, annotations)
+    representation = annotate(representation, jsonSchemaAnnotations(schema, options))
 
     if (Array.isArray(schema.allOf)) {
       for (let index = 0; index < schema.allOf.length; index++) {
@@ -1018,7 +1149,7 @@ function translateJsonSchemaMultiDocument(
         return {
           _tag: "Number",
           checks: [
-            jsonSchemaFilter(type === "number" ? "effect/schema/isFinite" : "effect/schema/isInt", null),
+            makeFilter(type === "number" ? Schema.isFinite() : Schema.isInt()),
             ...collectNumberChecks(schema)
           ]
         }
@@ -1051,7 +1182,7 @@ function translateJsonSchemaMultiDocument(
       }
       case "object": {
         const scope = collectObjectScope(schema, path)
-        return lowerObject([scope], collectObjectChecks(schema, path), undefined, path)
+        return lowerObject([scope], { checks: collectObjectChecks(schema, path) }, path)
       }
       default:
         return unknown
@@ -1074,7 +1205,7 @@ function translateJsonSchemaMultiDocument(
         } catch {
           throw errorWithPath("Cannot import pattern using ECMAScript Unicode mode.", path)
         }
-        return jsonSchemaFilter("effect/schema/isPattern", { source: regex.source, flags: regex.flags })
+        return makeFilter(Schema.isPattern(regex))
       }
     }
   }
@@ -1082,11 +1213,11 @@ function translateJsonSchemaMultiDocument(
   function collectStringChecks(schema: JsonSchema.JsonSchema, path: Path): Array<Check> {
     const checks: Array<Check> = []
     if (schema.minLength === 1) {
-      addNumberCheck(checks, schema.minLength, "effect/schema/isMinLength", "minLength")
+      addNumberCheck(checks, schema.minLength, Schema.isMinLength)
     } else {
-      addNumberCheck(checks, schema.minLength, "effect/schema/isMinCodePoints", "minCodePoints")
+      addNumberCheck(checks, schema.minLength, Schema.isMinCodePoints)
     }
-    addNumberCheck(checks, schema.maxLength, "effect/schema/isMaxCodePoints", "maxCodePoints")
+    addNumberCheck(checks, schema.maxLength, Schema.isMaxCodePoints)
     if (typeof schema.pattern === "string") {
       const check = importPatternCheck(schema.pattern, [...path, "pattern"])
       if (check !== undefined) checks.push(check)
@@ -1096,11 +1227,11 @@ function translateJsonSchemaMultiDocument(
 
   function collectNumberChecks(schema: JsonSchema.JsonSchema): Array<Check> {
     const checks: Array<Check> = []
-    addNumberCheck(checks, schema.minimum, "effect/schema/isGreaterThanOrEqualTo", "minimum")
-    addNumberCheck(checks, schema.maximum, "effect/schema/isLessThanOrEqualTo", "maximum")
-    addNumberCheck(checks, schema.exclusiveMinimum, "effect/schema/isGreaterThan", "exclusiveMinimum")
-    addNumberCheck(checks, schema.exclusiveMaximum, "effect/schema/isLessThan", "exclusiveMaximum")
-    addNumberCheck(checks, schema.multipleOf, "effect/schema/isMultipleOf", "divisor")
+    addNumberCheck(checks, schema.minimum, Schema.isGreaterThanOrEqualTo)
+    addNumberCheck(checks, schema.maximum, Schema.isLessThanOrEqualTo)
+    addNumberCheck(checks, schema.exclusiveMinimum, Schema.isGreaterThan)
+    addNumberCheck(checks, schema.exclusiveMaximum, Schema.isLessThan)
+    addNumberCheck(checks, schema.multipleOf, Schema.isMultipleOf)
     return checks
   }
 
@@ -1110,13 +1241,13 @@ function translateJsonSchemaMultiDocument(
       !Array.isArray(schema.prefixItems) ||
       typeof schema.minItems === "number" && schema.minItems > schema.prefixItems.length
     ) {
-      addNumberCheck(checks, schema.minItems, "effect/schema/isMinLength", "minLength")
+      addNumberCheck(checks, schema.minItems, Schema.isMinLength)
     }
     if (!isMaxItemsRedundant) {
-      addNumberCheck(checks, schema.maxItems, "effect/schema/isMaxLength", "maxLength")
+      addNumberCheck(checks, schema.maxItems, Schema.isMaxLength)
     }
     if (schema.uniqueItems === true) {
-      checks.push(jsonSchemaFilter("effect/schema/isUnique", null))
+      checks.push(makeFilter(Schema.isUnique()))
     }
     return checks
   }
@@ -1170,44 +1301,33 @@ function translateJsonSchemaMultiDocument(
     path: Path
   ): Array<Check> {
     const checks: Array<Check> = []
-    addNumberCheck(checks, schema.minProperties, "effect/schema/isMinProperties", "minProperties")
-    addNumberCheck(checks, schema.maxProperties, "effect/schema/isMaxProperties", "maxProperties")
+    addNumberCheck(checks, schema.minProperties, Schema.isMinProperties)
+    addNumberCheck(checks, schema.maxProperties, Schema.isMaxProperties)
     if (schema.propertyNames !== undefined) {
       const propertyNamesPath = [...path, "propertyNames"]
-      checks.push(jsonSchemaFilter(
-        "effect/schema/isPropertyNames",
-        null,
-        [intersect(
+      checks.push({
+        _tag: "PropertyNames",
+        type: intersect(
           string,
           translateSchema(schema.propertyNames, propertyNamesPath),
           propertyNamesPath
-        )]
-      ))
+        )
+      })
     }
     return checks
   }
 
-  const references: Record<string, Representation> = {}
-  const representations = document.schemas.map((schema, index) =>
+  return document.schemas.map((schema, index) =>
     finalize(translateSchema(schema, singleRoot ? ["schema"] : ["schemas", index], true))
-  ) as [Representation, ...Array<Representation>]
-  // Definitions expanded away by intersections do not need a standalone output schema.
-  for (const key of finalReferences) {
-    InternalRecord.assignProperty(references, key, finalize(translateDefinition(key, reachableDefinitions.get(key)!)))
-  }
-  for (const { reference, path } of annotatedReferences) {
-    resolveReference(reference, path)
-  }
-  return { representations, references }
+  ) as [Schema.Top, ...Array<Schema.Top>]
 }
 
 /** @internal */
 export function fromJsonSchemaDocument(
   document: JsonSchema.Document<"draft-2020-12">,
-  options: SchemaRepresentation.FromJsonSchemaOptions | undefined,
-  revivers: ReadonlyArray<SchemaRepresentation.AnyReviver>
+  options: SchemaRepresentation.FromJsonSchemaOptions | undefined
 ): Schema.Top {
-  const translated = translateJsonSchemaMultiDocument(
+  return fromJsonSchemaMultiDocument(
     {
       dialect: document.dialect,
       schemas: [document.schema],
@@ -1215,18 +1335,5 @@ export function fromJsonSchemaDocument(
     },
     options,
     true
-  )
-  return fromRepresentation({
-    representation: translated.representations[0],
-    references: translated.references
-  }, revivers)
-}
-
-/** @internal */
-export function fromJsonSchemaMultiDocument(
-  document: JsonSchema.MultiDocument<"draft-2020-12">,
-  options: SchemaRepresentation.FromJsonSchemaOptions | undefined,
-  revivers: ReadonlyArray<SchemaRepresentation.AnyReviver>
-): readonly [Schema.Top, ...Array<Schema.Top>] {
-  return fromRepresentations(translateJsonSchemaMultiDocument(document, options), revivers)
+  )[0]
 }