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

package/dist/internal/schema/annotations.js

@@ -38,5 +38,5 @@ export function collectBrands(annotations) {
   return annotations !== undefined && Array.isArray(annotations.brands) ? annotations.brands : [];
 }
 /** @internal */
-export const annotationExcludedKeys = /*#__PURE__*/new Set([SENTINELS_ANNOTATION_KEY, STRUCTURAL_ANNOTATION_KEY, "representation", "arbitrary", "brands", "toJsonSchema", "toCode", "toArbitrary", "toEquivalence", "toFormatter", "toCodec", "toCodecJson", "toCodecStringTree", "toCodecIso"]);
+export const annotationExcludedKeys = /*#__PURE__*/new Set([SENTINELS_ANNOTATION_KEY, STRUCTURAL_ANNOTATION_KEY, "representation", "arbitraryConstraint", "brands", "toJsonSchema", "toCode", "toEquivalence", "toFormatter", "toCodec", "toCodecJson", "toCodecStringTree", "toCodecIso", "toCodecArbitrary"]);
 //# sourceMappingURL=annotations.js.map

package/dist/internal/schema/annotations.js.map

@@ -1 +1 @@
-{"version":3,"file":"annotations.js","names":[],"sources":["../../../src/internal/schema/annotations.ts"],"sourcesContent":[null],"mappings":"AAAA,SAAS,OAAO,QAAQ,mBAAmB;AAI3C;AACA,OAAM,SAAU,OAAO,CAAC,GAAkB;EACxC,OAAO,GAAG,CAAC,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,WAAW,GAAG,GAAG,CAAC,WAAW;AACrF;AAEA;AACA,OAAM,SAAU,SAAS,CAAI,GAAW;EACtC,OAAQ,GAAkB,IAAoB,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAkB;AACpF;AAEA;AACA,OAAO,MAAM,yBAAyB,GAAG,aAAa;AAEtD;AACA,OAAO,MAAM,uBAAuB,GAAG,aAAa;AAEpD;AACA,OAAO,MAAM,wBAAwB,GAAG,YAAY;AAEpD;AACA,OAAO,MAAM,0BAA0B,GAAG,cAAc;AAExD;AACA,OAAO,MAAM,wBAAwB,GAAG,CACtC,OAAO,EACP,aAAa,EACb,SAAS,EACT,UAAU,EACV,UAAU,EACV,WAAW,EACX,QAAQ,EACR,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,CACP;AAEV;AACA,OAAO,MAAM,iBAAiB,gBAAG,SAAS,CAAS,YAAY,CAAC;AAEhE;AACA,OAAO,MAAM,yBAAyB,gBAAG,SAAS,CAAS,uBAAuB,CAAC;AAEnF;AACA,OAAO,MAAM,YAAY,gBAAG,SAAS,CAAS,OAAO,CAAC;AAEtD;AACA,OAAO,MAAM,kBAAkB,gBAAG,SAAS,CAAS,aAAa,CAAC;AAElE;AACA,OAAO,MAAM,aAAa,gBAAG,SAAS,CAAwB,QAAQ,CAAC;AAEvE;AACA,OAAO,MAAM,WAAW,gBAAG,OAAO,CAAE,GAAkB,IAAY;EAChE,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,UAAU;EAC3C,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,OAAO,UAAU;EACrD,OAAO,GAAG,CAAC,WAAW,CAAC,WAAW,CAAC;AACrC,CAAC,CAAC;AAEF;AACA,OAAM,SAAU,aAAa,CAAC,WAAuD;EACnF,OAAO,WAAW,KAAK,SAAS,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,GAAG,EAAE;AACjG;AAEA;AACA,OAAO,MAAM,sBAAsB,gBAAG,IAAI,GAAG,CAAC,CAC5C,wBAAwB,EACxB,yBAAyB,EACzB,gBAAgB,EAChB,WAAW,EACX,QAAQ,EACR,cAAc,EACd,QAAQ,EACR,aAAa,EACb,eAAe,EACf,aAAa,EACb,SAAS,EACT,aAAa,EACb,mBAAmB,EACnB,YAAY,CACb,CAAC","ignoreList":[]}
+{"version":3,"file":"annotations.js","names":[],"sources":["../../../src/internal/schema/annotations.ts"],"sourcesContent":[null],"mappings":"AAAA,SAAS,OAAO,QAAQ,mBAAmB;AAI3C;AACA,OAAM,SAAU,OAAO,CAAC,GAAkB;EACxC,OAAO,GAAG,CAAC,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,WAAW,GAAG,GAAG,CAAC,WAAW;AACrF;AAEA;AACA,OAAM,SAAU,SAAS,CAAI,GAAW;EACtC,OAAQ,GAAkB,IAAoB,OAAO,CAAC,GAAG,CAAC,GAAG,GAAG,CAAkB;AACpF;AAEA;AACA,OAAO,MAAM,yBAAyB,GAAG,aAAa;AAEtD;AACA,OAAO,MAAM,uBAAuB,GAAG,aAAa;AAEpD;AACA,OAAO,MAAM,wBAAwB,GAAG,YAAY;AAEpD;AACA,OAAO,MAAM,0BAA0B,GAAG,cAAc;AAExD;AACA,OAAO,MAAM,wBAAwB,GAAG,CACtC,OAAO,EACP,aAAa,EACb,SAAS,EACT,UAAU,EACV,UAAU,EACV,WAAW,EACX,QAAQ,EACR,iBAAiB,EACjB,kBAAkB,EAClB,eAAe,CACP;AAEV;AACA,OAAO,MAAM,iBAAiB,gBAAG,SAAS,CAAS,YAAY,CAAC;AAEhE;AACA,OAAO,MAAM,yBAAyB,gBAAG,SAAS,CAAS,uBAAuB,CAAC;AAEnF;AACA,OAAO,MAAM,YAAY,gBAAG,SAAS,CAAS,OAAO,CAAC;AAEtD;AACA,OAAO,MAAM,kBAAkB,gBAAG,SAAS,CAAS,aAAa,CAAC;AAElE;AACA,OAAO,MAAM,aAAa,gBAAG,SAAS,CAAwB,QAAQ,CAAC;AAEvE;AACA,OAAO,MAAM,WAAW,gBAAG,OAAO,CAAE,GAAkB,IAAY;EAChE,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,EAAE,UAAU;EAC3C,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,OAAO,UAAU;EACrD,OAAO,GAAG,CAAC,WAAW,CAAC,WAAW,CAAC;AACrC,CAAC,CAAC;AAEF;AACA,OAAM,SAAU,aAAa,CAAC,WAAuD;EACnF,OAAO,WAAW,KAAK,SAAS,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,WAAW,CAAC,MAAM,GAAG,EAAE;AACjG;AAEA;AACA,OAAO,MAAM,sBAAsB,gBAAG,IAAI,GAAG,CAAC,CAC5C,wBAAwB,EACxB,yBAAyB,EACzB,gBAAgB,EAChB,qBAAqB,EACrB,QAAQ,EACR,cAAc,EACd,QAAQ,EACR,eAAe,EACf,aAAa,EACb,SAAS,EACT,aAAa,EACb,mBAAmB,EACnB,YAAY,EACZ,kBAAkB,CACnB,CAAC","ignoreList":[]}

package/dist/internal/schema/fromJsonSchemaDocument.js

@@ -1,10 +1,8 @@
-import { unescapeToken } from "../../JsonPointer.js";
+import * as JsonSchema from "../../JsonSchema.js";
 import { remainder } from "../../Number.js";
-import * as Schema from "../../Schema.js";
-import * as SchemaAST from "../../SchemaAST.js";
+import * as InternalAST from "../../SchemaAST.js";
 import { errorWithPath } from "../errors.js";
 import * as InternalRecord from "../record.js";
-import * as InternalAnnotations from "./annotations.js";
 import { fromRepresentation, fromRepresentations } from "./fromRepresentation.js";
 const never = {
   _tag: "Never",
@@ -18,30 +16,24 @@ const string = {
   _tag: "String",
   checks: []
 };
-function makeLiteral(literal) {
-  return {
-    _tag: "Literal",
-    literal,
+function makeJsonLiteral(input) {
+  if (input === null) return {
+    _tag: "Null",
     checks: []
   };
+  return typeof input === "string" || typeof input === "number" || typeof input === "boolean" ? {
+    _tag: "Literal",
+    literal: input,
+    checks: []
+  } : undefined;
 }
-const jsonSchemaTypes = /*#__PURE__*/new Set(["null", "string", "number", "integer", "boolean", "object", "array"]);
-const jsonSchemaStringKeys = ["minLength", "maxLength", "pattern", "format", "contentMediaType", "contentSchema"];
-const jsonSchemaNumberKeys = ["minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf"];
-const jsonSchemaObjectKeys = ["properties", "required", "additionalProperties", "patternProperties", "propertyNames", "minProperties", "maxProperties"];
-const jsonSchemaArrayKeys = ["items", "prefixItems", "additionalItems", "minItems", "maxItems", "uniqueItems"];
+const jsonSchemaValueTypes = ["null", "string", "number", "boolean", "object", "array"];
+const jsonSchemaTypeSpecificKeys = ["minLength", "maxLength", "pattern", "minimum", "maximum", "exclusiveMinimum", "exclusiveMaximum", "multipleOf", "properties", "required", "additionalProperties", "patternProperties", "propertyNames", "minProperties", "maxProperties", "items", "prefixItems", "minItems", "maxItems", "uniqueItems"];
 function isImportedJsonSchemaType(input) {
-  return typeof input === "string" && jsonSchemaTypes.has(input);
-}
-function inferJsonSchemaType(schema) {
-  if (jsonSchemaStringKeys.some(key => schema[key] !== undefined)) return "string";
-  if (jsonSchemaNumberKeys.some(key => schema[key] !== undefined)) return "number";
-  if (jsonSchemaObjectKeys.some(key => schema[key] !== undefined)) return "object";
-  if (jsonSchemaArrayKeys.some(key => schema[key] !== undefined)) return "array";
+  return input === "integer" || typeof input === "string" && jsonSchemaValueTypes.some(type => type === input);
 }
-function jsonSchemaReferenceKey($ref) {
-  const token = $ref.slice($ref.lastIndexOf("/") + 1);
-  return token.length === 0 ? undefined : unescapeToken(token);
+function hasTypeSpecificKeywords(schema) {
+  return jsonSchemaTypeSpecificKeys.some(key => schema[key] !== undefined);
 }
 function jsonSchemaFilter(id, payload, schemas) {
   return {
@@ -74,7 +66,7 @@ function jsonSchemaAnnotations(schema) {
   if (typeof schema.format === "string") annotations.format = schema.format;
   if (typeof schema.contentEncoding === "string") annotations.contentEncoding = schema.contentEncoding;
   if (typeof schema.contentMediaType === "string") annotations.contentMediaType = schema.contentMediaType;
-  if (SchemaAST.isJson(schema.contentSchema)) annotations.contentSchema = schema.contentSchema;
+  if (InternalAST.isJson(schema.contentSchema)) annotations.contentSchema = schema.contentSchema;
   return Object.keys(annotations).length === 0 ? undefined : annotations;
 }
 function jsonDeclaration(annotations) {
@@ -151,11 +143,7 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
   const reachableDefinitions = new Map();
   const objectScopesByProperties = new WeakMap();
   const annotatedReferences = [];
-  function getObjectScopes(representation) {
-    const scopes = objectScopesByProperties.get(representation.propertySignatures);
-    if (scopes === undefined) throw new Error("Missing imported object scopes");
-    return scopes;
-  }
+  const resolvingChoices = new Set();
   function annotate(representation, annotations) {
     if (annotations === undefined) return representation;
     if (representation._tag === "Reference") {
@@ -194,19 +182,16 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
     if (seen.has(reference.$ref)) {
       throw errorWithPath(`Invalid reference ${reference.$ref}`, [...path, "$ref"]);
     }
-    const nextSeen = new Set(seen).add(reference.$ref);
+    seen.add(reference.$ref);
     const representation = translateDefinition(reference.$ref, path, options?.recursiveReferenceError);
     if (representation._tag === "Reference") {
-      return resolveReference(representation, path, options, nextSeen);
+      return resolveReference(representation, path, options, seen);
     }
     if (representation._tag === "Suspend" && representation.thunk._tag === "Reference") {
-      return annotate(resolveReference(representation.thunk, path, options, nextSeen), representation.annotations);
+      return annotate(resolveReference(representation.thunk, path, options, seen), representation.annotations);
     }
     return representation;
   }
-  function annotationsOf(representation) {
-    return representation._tag === "Reference" ? undefined : representation.annotations;
-  }
   function mergeAnnotations(left, right) {
     if (left === undefined) return right;
     if (right === undefined) return left;
@@ -216,7 +201,7 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
     };
   }
   function combinedAnnotations(representation, left, right) {
-    return annotate(representation, mergeAnnotations(annotationsOf(left), annotationsOf(right)));
+    return annotate(representation, mergeAnnotations(left._tag === "Reference" ? undefined : left.annotations, right._tag === "Reference" ? undefined : right.annotations));
   }
   function asChecks(checks, annotations) {
     if (checks.length === 0) return undefined;
@@ -414,6 +399,153 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
       annotations
     };
   }
+  const jsonRootTags = ["Null", "String", "Number", "Boolean", "Objects", "Arrays"];
+  const allMasks = (1 << jsonRootTags.length) - 1;
+  function rootMask(representation) {
+    switch (representation._tag) {
+      case "Never":
+        return 0;
+      case "Unknown":
+      case "Reference":
+        return allMasks;
+      case "Literal":
+        switch (typeof representation.literal) {
+          case "string":
+            return 2;
+          case "number":
+            return 4;
+          case "boolean":
+            return 8;
+          default:
+            return 0;
+        }
+      case "Suspend":
+        return rootMask(representation.thunk);
+      case "Union":
+        {
+          let out = 0;
+          for (const type of representation.types) {
+            out |= rootMask(type);
+          }
+          return out;
+        }
+      default:
+        return 1 << jsonRootTags.indexOf(representation._tag);
+    }
+  }
+  function hasChoices(representation) {
+    switch (representation._tag) {
+      case "Reference":
+        {
+          const key = representation.$ref;
+          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)));
+          resolvingChoices.delete(key);
+          return out;
+        }
+      case "Suspend":
+        return hasChoices(representation.thunk);
+      case "Union":
+        return representation.types.length > 1 || representation.types.some(type => hasChoices(type));
+      case "Arrays":
+        return representation.elements.some(element => hasChoices(element.type)) || representation.rest.some(type => hasChoices(type));
+      case "Objects":
+        return representation.propertySignatures.some(property => hasChoices(property.type)) || representation.indexSignatures.some(indexSignature => hasChoices(indexSignature.parameter) || hasChoices(indexSignature.type)) || representation.checks.some(checkHasChoices);
+      default:
+        return false;
+    }
+  }
+  function checkHasChoices(check) {
+    return check._tag === "FilterGroup" ? check.checks.some(checkHasChoices) : check.representation?.schemas?.some(schema => hasChoices(schema)) === true;
+  }
+  function makeUnion(source, types) {
+    if (types.length === 0) return never;
+    if (types.length === 1 && source.checks.length === 0) return annotate(types[0], source.annotations);
+    return {
+      ...source,
+      types
+    };
+  }
+  function literalValue(representation) {
+    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;
+  }
+  function combineLiteralUnions(left, right, path) {
+    if ((left.options?.mode ?? "anyOf") !== "anyOf" || (right.options?.mode ?? "anyOf") !== "anyOf") {
+      return undefined;
+    }
+    const rightByValue = new Map();
+    for (const type of right.types) {
+      const representation = type;
+      const value = literalValue(representation);
+      if (value === undefined) return undefined;
+      rightByValue.set(value, representation);
+    }
+    const types = [];
+    for (const type of left.types) {
+      const representation = type;
+      const value = literalValue(representation);
+      if (value === undefined) return undefined;
+      const match = rightByValue.get(value);
+      if (match !== undefined) types.push(combine(representation, annotate(match, right.annotations), path));
+    }
+    return makeUnion(left, types);
+  }
+  function combineUnionWithType(union, type, path, unionOnLeft) {
+    const mask = rootMask(type);
+    const members = union.types.map((member, index) => ({
+      index,
+      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);
+      return unionOnLeft ? combine(member, type, [...path, "types", members[0].index]) : combine(type, member, [...path, "types", members[0].index]);
+    }
+    return makeUnion(union, members.map(member => unionOnLeft ? combine(member.type, type, [...path, "types", member.index]) : combine(type, member.type, [...path, "types", member.index])).filter(type => type._tag !== "Never"));
+  }
+  function isTypePartition(union) {
+    let mask = 0;
+    for (const type of union.types) {
+      const memberMask = rootMask(type);
+      if ((mask & memberMask) !== 0) return false;
+      mask |= memberMask;
+    }
+    return true;
+  }
+  function unsupportedIntersection(path) {
+    throw errorWithPath("Unsupported intersection of overlapping unions", path);
+  }
+  function combinePartition(partition, other, path, partitionOnLeft) {
+    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)) {
+        return unsupportedIntersection(path);
+      }
+    }
+    const types = [];
+    for (let index = 0; index < partitionTypes.length; index++) {
+      const member = partitionTypes[index];
+      const type = combineUnionWithType(other, member, [...path, "types", index], !partitionOnLeft);
+      if (type._tag !== "Never") types.push(type);
+    }
+    return makeUnion(partition, types);
+  }
+  function combineUnions(left, right, path) {
+    const literals = combineLiteralUnions(left, right, path);
+    if (literals !== undefined) return literals;
+    if (isTypePartition(left)) return combinePartition(left, right, path, true);
+    if (isTypePartition(right)) return combinePartition(right, left, path, false);
+    return unsupportedIntersection(path);
+  }
   function combine(left, right, path) {
     if (left._tag === "Never") return left;
     if (right._tag === "Never") return right;
@@ -427,17 +559,9 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
     if (right._tag === "Suspend") {
       return annotate(combine(left, right.thunk, path), right.annotations);
     }
-    if (left._tag === "Union") {
-      const types = left.types.map((type, index) => combine(type, right, [...path, "types", index])).filter(type => type._tag !== "Never");
-      if (types.length === 0) return never;
-      return annotate({
-        _tag: "Union",
-        types,
-        mode: left.mode,
-        checks: left.checks
-      }, left.annotations);
-    }
-    if (right._tag === "Union") return combine(right, left, path);
+    if (left._tag === "Union" && right._tag === "Union") return combineUnions(left, right, path);
+    if (left._tag === "Union") return combineUnionWithType(left, right, path, true);
+    if (right._tag === "Union") return combineUnionWithType(right, left, path, false);
     switch (left._tag) {
       case "Null":
         return right._tag === "Null" ? combinedAnnotations({
@@ -500,42 +624,70 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
         {
           if (right._tag !== "Objects") return never;
           const objectChecks = combineChecks(left.checks, right.checks, right.annotations);
-          const scopes = [...getObjectScopes(left), ...getObjectScopes(right)];
+          const scopes = [...objectScopesByProperties.get(left.propertySignatures), ...objectScopesByProperties.get(right.propertySignatures)];
           return lowerObject(scopes, objectChecks ?? left.checks, mergeAnnotations(left.annotations, objectChecks === undefined ? right.annotations : undefined), path);
         }
     }
   }
-  function enter(input) {
-    if (typeof input !== "object" || input === null || Array.isArray(input)) {
-      return undefined;
-    }
-    const schema = input;
-    return options?.onEnter === undefined ? schema : options.onEnter(schema);
-  }
   function recur(input, path) {
     if (input === false) {
       return never;
     }
-    const schema = enter(input);
+    if (typeof input !== "object" || input === null || Array.isArray(input)) return unknown;
+    const schema = options?.onEnter === undefined ? input : options.onEnter(input);
     if (schema === undefined) {
       return unknown;
     }
+    const enumIndex = Array.isArray(schema.enum) ? schema.enum.findIndex(value => typeof value === "object" && value !== null) : -1;
+    if (enumIndex !== -1) {
+      throw errorWithPath(`Unsupported structured JSON Schema value for "enum"`, [...path, "enum", enumIndex]);
+    }
+    for (const keyword of Object.keys(schema)) {
+      if (keyword === "if" && !Object.hasOwn(schema, "then") && !Object.hasOwn(schema, "else")) continue;
+      switch (keyword) {
+        case "if":
+        case "$dynamicRef":
+        case "contains":
+        case "dependentRequired":
+        case "dependentSchemas":
+        case "not":
+        case "unevaluatedItems":
+        case "unevaluatedProperties":
+          throw errorWithPath(`Unsupported JSON Schema keyword "${keyword}"`, [...path, keyword]);
+      }
+    }
     let representation = on(schema, path);
-    if (representation._tag === "Reference") {
-      const siblingSchema = {
-        ...schema,
-        $ref: undefined
-      };
-      for (const key of InternalAnnotations.jsonSchemaAnnotationKeys) {
-        delete siblingSchema[key];
+    if (Object.hasOwn(schema, "const")) {
+      const literal = makeJsonLiteral(schema.const);
+      if (literal === undefined && typeof schema.const === "object") {
+        throw errorWithPath(`Unsupported structured JSON Schema value for "const"`, [...path, "const"]);
+      }
+      if (literal !== undefined) representation = combine(representation, literal, [...path, "const"]);
+    }
+    if (Array.isArray(schema.enum)) {
+      const types = schema.enum.map(value => makeJsonLiteral(value) ?? unknown);
+      representation = combine(representation, types.length === 1 ? types[0] : {
+        _tag: "Union",
+        types,
+        checks: []
+      }, [...path, "enum"]);
+    }
+    if (typeof schema.$ref === "string") {
+      const $ref = JsonSchema.getReferenceKey(schema.$ref);
+      if ($ref === undefined) {
+        throw errorWithPath(`Unsupported reference ${JSON.stringify(schema.$ref)}`, [...path, "$ref"]);
       }
-      const sibling = on(siblingSchema, path);
-      if (sibling._tag !== "Unknown") {
-        const reference = representation;
-        representation = combine(resolveReference(reference, path, {
-          recursiveReferenceError: `Unsupported assertion siblings on recursive reference ${reference.$ref}`
-        }), sibling, path);
+      if (!Object.hasOwn(document.definitions, $ref)) {
+        throw errorWithPath(`Invalid reference ${JSON.stringify(schema.$ref)}`, [...path, "$ref"]);
       }
+      if (!reachableDefinitions.has($ref)) reachableDefinitions.set($ref, path);
+      const reference = {
+        _tag: "Reference",
+        $ref
+      };
+      representation = representation._tag === "Unknown" ? reference : representation._tag === "Never" ? never : combine(resolveReference(reference, path, {
+        recursiveReferenceError: `Unsupported assertion siblings on recursive reference ${reference.$ref}`
+      }), representation, path);
     }
     const annotations = jsonSchemaAnnotations(schema);
     if (annotations !== undefined && representation._tag === "Reference") {
@@ -556,7 +708,11 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
         const union = {
           _tag: "Union",
           types: members.map((member, index) => recur(member, [...path, mode, index])),
-          mode,
+          ...(mode === "oneOf" ? {
+            options: {
+              mode
+            }
+          } : {}),
           checks: []
         };
         representation = combine(union, representation, [...path, mode]);
@@ -565,64 +721,18 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
     return representation;
   }
   function on(schema, path) {
-    if (typeof schema.$ref === "string") {
-      const $ref = jsonSchemaReferenceKey(schema.$ref);
-      if ($ref !== undefined) {
-        if (!reachableDefinitions.has($ref)) reachableDefinitions.set($ref, path);
-        return {
-          _tag: "Reference",
-          $ref
-        };
-      }
-    }
-    if (Object.hasOwn(schema, "const")) {
-      if (schema.const === null) {
-        return {
-          _tag: "Null",
-          checks: []
-        };
-      }
-      if (typeof schema.const === "string" || typeof schema.const === "number" || typeof schema.const === "boolean") {
-        return makeLiteral(schema.const);
-      }
-    }
-    if (Array.isArray(schema.enum)) {
-      const types = [];
-      for (let index = 0; index < schema.enum.length; index++) {
-        const value = schema.enum[index];
-        if (value === null) {
-          types.push({
-            _tag: "Null",
-            checks: []
-          });
-        } else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-          types.push(makeLiteral(value));
-        } else {
-          types.push(recur(value, [...path, "enum", index]));
-        }
-      }
-      if (types.length === 1) {
-        return types[0];
-      }
+    const types = Array.isArray(schema.type) && schema.type.every(isImportedJsonSchemaType) ? schema.type : !isImportedJsonSchemaType(schema.type) && hasTypeSpecificKeywords(schema) ? jsonSchemaValueTypes : undefined;
+    if (types !== undefined) {
       return {
         _tag: "Union",
-        types,
-        mode: "anyOf",
-        checks: []
-      };
-    }
-    if (Array.isArray(schema.type) && schema.type.every(isImportedJsonSchemaType)) {
-      return {
-        _tag: "Union",
-        types: schema.type.map(type => on({
+        types: types.map(type => on({
           ...schema,
           type
         }, path)),
-        mode: "anyOf",
         checks: []
       };
     }
-    const type = isImportedJsonSchemaType(schema.type) ? schema.type : inferJsonSchemaType(schema);
+    const type = isImportedJsonSchemaType(schema.type) ? schema.type : undefined;
     switch (type) {
       case "null":
         return {
@@ -704,7 +814,7 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
   }
   function collectArrayChecks(schema, isMaxItemsRedundant) {
     const checks = [];
-    if (schema.prefixItems === undefined) {
+    if (!Array.isArray(schema.prefixItems) || typeof schema.minItems === "number" && schema.minItems > schema.prefixItems.length) {
       addNumberCheck(checks, schema.minItems, "effect/schema/isMinLength", "minLength");
     }
     if (!isMaxItemsRedundant) {
@@ -758,7 +868,8 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
     addNumberCheck(checks, schema.minProperties, "effect/schema/isMinProperties", "minProperties");
     addNumberCheck(checks, schema.maxProperties, "effect/schema/isMaxProperties", "maxProperties");
     if (schema.propertyNames !== undefined) {
-      checks.push(jsonSchemaFilter("effect/schema/isPropertyNames", null, [recur(schema.propertyNames, [...path, "propertyNames"])]));
+      const propertyNamesPath = [...path, "propertyNames"];
+      checks.push(jsonSchemaFilter("effect/schema/isPropertyNames", null, [combine(string, recur(schema.propertyNames, propertyNamesPath), propertyNamesPath)]));
     }
     return checks;
   }
@@ -779,24 +890,19 @@ function translateJsonSchemaMultiDocument(document, options, singleRoot = false)
   };
 }
 /** @internal */
-function toRepresentation(document, options) {
+export function fromJsonSchemaDocument(document, options, revivers) {
   const translated = translateJsonSchemaMultiDocument({
     dialect: document.dialect,
     schemas: [document.schema],
     definitions: document.definitions
   }, options, true);
-  return {
+  return fromRepresentation({
     representation: translated.representations[0],
     references: translated.references
-  };
-}
-const jsonSchemaRevivers = [Schema.JsonReviver, Schema.isPatternReviver, Schema.isFiniteReviver, Schema.isGreaterThanReviver, Schema.isGreaterThanOrEqualToReviver, Schema.isLessThanReviver, Schema.isLessThanOrEqualToReviver, Schema.isMultipleOfReviver, Schema.isIntReviver, Schema.isMinLengthReviver, Schema.isMaxLengthReviver, Schema.isMinPropertiesReviver, Schema.isMaxPropertiesReviver, Schema.isPropertyNamesReviver, Schema.isUniqueReviver];
-/** @internal */
-export function fromJsonSchemaDocument(document, options) {
-  return fromRepresentation(toRepresentation(document, options), jsonSchemaRevivers);
+  }, revivers);
 }
 /** @internal */
-export function fromJsonSchemaMultiDocument(document, options) {
-  return fromRepresentations(translateJsonSchemaMultiDocument(document, options), jsonSchemaRevivers);
+export function fromJsonSchemaMultiDocument(document, options, revivers) {
+  return fromRepresentations(translateJsonSchemaMultiDocument(document, options), revivers);
 }
 //# sourceMappingURL=fromJsonSchemaDocument.js.map