referencing

Added

• str() on Containment, Satisfiability, Distinctness and CanonicalKind members reads as the label.

Changed

• CanonicalSchema.satisfiability() answers YES for a string whose pattern or format a matching value can be built from.
• CanonicalSchema.satisfiability() answers NO where a format takes no string of the length the schema asks for.

Fixed

• CanonicalSchema.negate() taking apart a union that reads a definition through its own if, so a schema and its negation shared a value.
• CanonicalSchema.subtract() dropping a Draft 4 array member an element demand partly takes.
• CanonicalSchema.covers() answering Yes where a Draft 4 element demand refuses a member.
• A string schema whose maxLength is 0 keeping a pattern, format, or content facet unread, so the same constraints written in one object and written as an allOf reached different canonical forms.

Performance

• not over a wide object schema costs its branch count instead of its square.
• not over an object schema is linear in its property count, not quadratic.
• not over an object schema with additionalProperties: false no longer costs cubic time in its property count.

Changed

• CanonicalSchema::satisfiability answers Yes for a string whose pattern or format a matching value can be built from.
• CanonicalSchema::satisfiability answers No where a format takes no string of the length the schema asks for.

Fixed

• CanonicalSchema::negate taking apart a union that reads a definition through its own if, so a schema and its negation shared a value.
• CanonicalSchema::subtract dropping a Draft 4 array member an element demand partly takes.
• CanonicalSchema::covers answering Yes where a Draft 4 element demand refuses a member.
• A string schema whose maxLength is 0 keeping a pattern, format, or content facet unread, so the same constraints written in one object and written as an allOf reached different canonical forms.

Performance

• not over a wide object schema costs its branch count instead of its square.
• not over an object schema is linear in its property count, not quadratic.
• not over an object schema with additionalProperties: false no longer costs cubic time in its property count.

Changed

• CanonicalSchema#satisfiability answers :yes for a string whose pattern or format a matching value can be built from.
• CanonicalSchema#satisfiability answers :no where a format takes no string of the length the schema asks for.

Fixed

• CanonicalSchema#negate taking apart a union that reads a definition through its own if, so a schema and its negation shared a value.
• CanonicalSchema#subtract dropping a Draft 4 array member an element demand partly takes.
• CanonicalSchema#covers answering Yes where a Draft 4 element demand refuses a member.
• A string schema whose maxLength is 0 keeping a pattern, format, or content facet unread, so the same constraints written in one object and written as an allOf reached different canonical forms.

Performance

• not over a wide object schema costs its branch count instead of its square.
• not over an object schema is linear in its property count, not quadratic.
• not over an object schema with additionalProperties: false no longer costs cubic time in its property count.

Changed

• CanonicalSchema::satisfiability answers Yes for a string whose pattern or format a matching value can be built from.
• CanonicalSchema::satisfiability answers No where a format takes no string of the length the schema asks for.

Fixed

• CanonicalSchema::negate taking apart a union that reads a definition through its own if, so a schema and its negation shared a value.
• CanonicalSchema::subtract dropping a Draft 4 array member an element demand partly takes.
• CanonicalSchema::covers answering Yes where a Draft 4 element demand refuses a member.
• A string schema whose maxLength is 0 keeping a pattern, format, or content facet unread, so the same constraints written in one object and written as an allOf reached different canonical forms.

Performance

• not over a wide object schema costs its branch count instead of its square.
• not over an object schema is linear in its property count, not quadratic.
• not over an object schema with additionalProperties: false no longer costs cubic time in its property count.

Added

• CanonicalSchema.union and CanonicalSchema.subtract.
• canonical.UnsupportedResult, raised where the canonical form does not support a set operation's result.
• canonical.IncompatibleOperands where both operands read # and it names a different document on each side.
• canonical.Containment, canonical.Satisfiability, canonical.Distinctness and canonical.CanonicalKind: the possible answers of covers(), satisfiability(), kind and ArrayView.distinctness.

Changed

• CanonicalSchema.is_satisfiable() is now CanonicalSchema.satisfiability(), answering with the canonical.Satisfiability members YES, NO or UNKNOWN - YES wherever a value can be exhibited, not only for the forms listing their members.
• CanonicalSchema.covers() decides through the difference as well: NO where the argument keeps values the receiver rejects, YES where nothing is left over.
• CanonicalSchema.is_subset_of() is now CanonicalSchema.covers(), answering with the canonical.Containment members YES, NO or UNKNOWN for whether the receiver admits every value the argument admits.
• CanonicalSchema.kind and ArrayView.distinctness answer with the canonical.CanonicalKind and canonical.Distinctness members instead of strings.
• CanonicalSchema.negate() raises where it used to return None.
• canonical.UnmodeledOperand is now canonical.UnsupportedOperand, and means only that an operand is a Raw pass-through.

Fixed

• Combining nodes of two different documents repointing a $ref to # at the combined result instead of the document it was written in, including one named by a definition the result keeps.
• Intersecting a $ref whose target is true or false, which crashed the interpreter.
• A key constraint left un-narrowed once a run is out of intersections, which crashed the interpreter on the next read of it.
• CanonicalSchema.covers() answering UNKNOWN for a schema against itself, where that schema is a $ref.
• CanonicalSchema.union() keeping a $ref beside the schema it names, where the other three operations read through it.
• CanonicalSchema.covers() and CanonicalSchema.subtract() cancelling two nodes written the same way whose # names a different document.
• Two results accepting the same values comparing unequal over the part of their documents neither reads.
• additionalProperties reaching a key the pattern map matches when a finite key constraint closes the map, which dropped values both operands accept.
• A recursive definition stopping every other pointer in the document from being read through.
• One $defs entry read past a wider schema written out at every use, rather than kept as the pointer it was.
• Set operations rejecting one document canonicalized twice, and a pruned result rejected against the document it came from, where the maps resolve every shared reference the same way.
• Set operations comparing a $ref as a pointer instead of reading through it, so a schema written with a $ref did not cancel against the same schema written out.
• CanonicalSchema.subtract() asking for a complement where the difference is one of the operands or empty, declining on schemas it can subtract.
• Set operations keeping $defs entries the result no longer references, which then showed up in the emitted schema.
• CanonicalSchema.union() declining over an approximated intersection, where the union itself is exact.

Added

• CanonicalSchema::union and CanonicalSchema::subtract.
• CanonicalizationError::UnsupportedResult, reported where the canonical form does not support a set operation's result.
• OperandMismatch::DocumentRoots, reported where both operands read # and it names a different document on each side.
• CLI: jsonschema validate -i INSTANCE without a SCHEMA argument validates each instance against the schema named in its own $schema property. #1470

Changed

• CanonicalSchema::is_satisfiable is now CanonicalSchema::satisfiability, answering Yes, No, or Unknown - Yes wherever a value can be exhibited, not only for the forms listing their members.
• CanonicalSchema::covers decides through the difference as well: No where the argument keeps values the receiver rejects, Yes where nothing is left over.
• CanonicalSchema::is_subset_of is now CanonicalSchema::covers, answering Yes, No, or Unknown for whether the receiver admits every value the argument admits.
• CanonicalSchema::negate returns Result rather than Option.
• CanonicalizationError::UnmodeledOperand is now CanonicalizationError::UnsupportedOperand, and means only that an operand is a Raw pass-through.
• A conjunction over a $ref folds through the body it names, so canonicalizing a document and combining its parts with the set operations reach one form; a document holding a reference cycle keeps the form it had.

Fixed

• Combining nodes of two different documents repointing a $ref to # at the combined result instead of the document it was written in, including one named by a definition the result keeps.
• Intersecting a $ref whose target is true or false, which panicked.
• A key constraint left un-narrowed once a run is out of intersections, which panicked on the next read of it.
• CanonicalSchema::covers answering Unknown for a schema against itself, where that schema is a $ref.
• CanonicalSchema::union keeping a $ref beside the schema it names, where the other three operations read through it.
• CanonicalSchema::covers and CanonicalSchema::subtract cancelling two nodes written the same way whose # names a different document.
• Two results accepting the same values comparing unequal over the part of their documents neither reads.
• additionalProperties reaching a key the pattern map matches when a finite key constraint closes the map, which dropped values both operands accept.
• A recursive definition stopping every other pointer in the document from being read through.
• One $defs entry read past a wider schema written out at every use, rather than kept as the pointer it was.
• Set operations rejecting one document canonicalized twice, and a pruned result rejected against the document it came from, where the maps resolve every shared reference the same way.
• Set operations comparing a $ref as a pointer instead of reading through it, so a schema written with a $ref did not cancel against the same schema written out.
• CanonicalSchema::subtract asking for a complement where the difference is one of the operands or empty, declining on schemas it can subtract.
• Set operations keeping $defs entries the result no longer references, which then showed up in the emitted schema.
• CanonicalSchema::union declining over an approximated intersection, where the union itself is exact.
• Resolving a reference against a base URI that carries a fragment, which happens when a Draft 4-7 $id contains one. #1473
• unevaluatedProperties and unevaluatedItems ignoring an $id on a subschema they walk through, so a relative $ref inside it resolved against the enclosing resource.

Performance

• CLI: ~25% less CPU per run from compile-time meta-schema validators.

• CanonicalSchema#union and CanonicalSchema#subtract.
• JSONSchema::Canonical::UnsupportedResult, raised where the canonical form does not support a set operation's result.
• JSONSchema::Canonical::IncompatibleOperands where both operands read # and it names a different document on each side.
• JSONSchema::Canonical::Containment, Satisfiability, Distinctness and Kind: named constants for the symbols covers, satisfiability, kind and ArrayView#distinctness return, each with an ALL list.

Changed

• CanonicalSchema#satisfiable? is now CanonicalSchema#satisfiability, answering :yes, :no, or :unknown - :yes wherever a value can be exhibited, not only for the forms listing their members.
• CanonicalSchema#covers decides through the difference as well: :no where the argument keeps values the receiver rejects, :yes where nothing is left over.
• CanonicalSchema#is_subset_of is now CanonicalSchema#covers, answering :yes, :no, or :unknown for whether the receiver admits every value the argument admits.
• CanonicalSchema#negate raises where it used to return nil.
• JSONSchema::Canonical::UnmodeledOperand is now JSONSchema::Canonical::UnsupportedOperand, and means only that an operand is a Raw pass-through.

Fixed

• Combining nodes of two different documents repointing a $ref to # at the combined result instead of the document it was written in, including one named by a definition the result keeps.
• Intersecting a $ref whose target is true or false, which crashed the interpreter.
• A key constraint left un-narrowed once a run is out of intersections, which crashed the interpreter on the next read of it.
• CanonicalSchema#covers answering :unknown for a schema against itself, where that schema is a $ref.
• CanonicalSchema#union keeping a $ref beside the schema it names, where the other three operations read through it.
• CanonicalSchema#covers and CanonicalSchema#subtract cancelling two nodes written the same way whose # names a different document.
• Two results accepting the same values comparing unequal over the part of their documents neither reads.
• additionalProperties reaching a key the pattern map matches when a finite key constraint closes the map, which dropped values both operands accept.
• A recursive definition stopping every other pointer in the document from being read through.
• One $defs entry read past a wider schema written out at every use, rather than kept as the pointer it was.
• Set operations rejecting one document canonicalized twice, and a pruned result rejected against the document it came from, where the maps resolve every shared reference the same way.
• Set operations comparing a $ref as a pointer instead of reading through it, so a schema written with a $ref did not cancel against the same schema written out.
• CanonicalSchema#subtract asking for a complement where the difference is one of the operands or empty, declining on schemas it can subtract.
• Set operations keeping $defs entries the result no longer references, which then showed up in the emitted schema.
• CanonicalSchema#union declining over an approximated intersection, where the union itself is exact.

Added

• CanonicalSchema::union and CanonicalSchema::subtract.
• CanonicalizationError::UnsupportedResult, reported where the canonical form does not support a set operation's result.
• OperandMismatch::DocumentRoots, reported where both operands read # and it names a different document on each side.
• CLI: jsonschema validate -i INSTANCE without a SCHEMA argument validates each instance against the schema named in its own $schema property. #1470

Changed

• CanonicalSchema::is_satisfiable is now CanonicalSchema::satisfiability, answering Yes, No, or Unknown - Yes wherever a value can be exhibited, not only for the forms listing their members.
• CanonicalSchema::covers decides through the difference as well: No where the argument keeps values the receiver rejects, Yes where nothing is left over.
• CanonicalSchema::is_subset_of is now CanonicalSchema::covers, answering Yes, No, or Unknown for whether the receiver admits every value the argument admits.
• CanonicalSchema::negate returns Result rather than Option.
• CanonicalizationError::UnmodeledOperand is now CanonicalizationError::UnsupportedOperand, and means only that an operand is a Raw pass-through.
• A conjunction over a $ref folds through the body it names, so canonicalizing a document and combining its parts with the set operations reach one form; a document holding a reference cycle keeps the form it had.

Fixed

• Combining nodes of two different documents repointing a $ref to # at the combined result instead of the document it was written in, including one named by a definition the result keeps.
• Intersecting a $ref whose target is true or false, which panicked.
• A key constraint left un-narrowed once a run is out of intersections, which panicked on the next read of it.
• CanonicalSchema::covers answering Unknown for a schema against itself, where that schema is a $ref.
• CanonicalSchema::union keeping a $ref beside the schema it names, where the other three operations read through it.
• CanonicalSchema::covers and CanonicalSchema::subtract cancelling two nodes written the same way whose # names a different document.
• Two results accepting the same values comparing unequal over the part of their documents neither reads.
• additionalProperties reaching a key the pattern map matches when a finite key constraint closes the map, which dropped values both operands accept.
• A recursive definition stopping every other pointer in the document from being read through.
• One $defs entry read past a wider schema written out at every use, rather than kept as the pointer it was.
• Set operations rejecting one document canonicalized twice, and a pruned result rejected against the document it came from, where the maps resolve every shared reference the same way.
• Set operations comparing a $ref as a pointer instead of reading through it, so a schema written with a $ref did not cancel against the same schema written out.
• CanonicalSchema::subtract asking for a complement where the difference is one of the operands or empty, declining on schemas it can subtract.
• Set operations keeping $defs entries the result no longer references, which then showed up in the emitted schema.
• CanonicalSchema::union declining over an approximated intersection, where the union itself is exact.
• Resolving a reference against a base URI that carries a fragment, which happens when a Draft 4-7 $id contains one. #1473
• unevaluatedProperties and unevaluatedItems ignoring an $id on a subschema they walk through, so a relative $ref inside it resolved against the enclosing resource.

Performance

• CLI: ~25% less CPU per run from compile-time meta-schema validators.

Added

• Canonicalization of a oneOf whose branches name object targets a required constant tells apart, which degrades to a union.

Changed

• CanonicalSchema::to_json_schema on a definition emits only the definitions that one names, not the whole document's.

Fixed

• Canonicalization running without end on a conjunction over unions; past a ceiling on the meets it takes, the document stays unmodeled.

Added

• Canonicalization of a oneOf whose branches name object targets a required constant tells apart, which degrades to a union.

Changed

• CanonicalSchema::to_json_schema on a definition emits only the definitions that one names, not the whole document's.

Fixed

• Canonicalization running without end on a conjunction over unions; past a ceiling on the meets it takes, the document stays unmodeled.

Performance

• Up to 380x faster canonicalization of a oneOf whose overlapping branches carry many properties, which no longer removes shared regions the exactly-one spelling discards.

Fixed

• Draft detection treating the version-less http://json-schema.org/schema meta-schema URI as a custom dialect, where it names the current draft.
• A patternProperties entry matching every key leaving additionalProperties: false spelled as a key constraint, where it forbids nothing.
• unevaluatedProperties/unevaluatedItems set to true forcing the whole document to stay unmodeled beside an unresolved applicator, where the keyword rejects nothing regardless of the evaluated set.
• unevaluatedProperties/unevaluatedItems beside a $ref forcing the whole document to stay unmodeled, where the reference's own evaluated properties or items are known once it is resolved.

Added

• CanonicalizeOptions::with_retriever to fetch external resources absent from the registry.
• CanonicalizeOptions::with_base_uri to resolve relative references in the root schema.
• Canonicalization of a oneOf whose branches name disjoint targets, which degrades to a union.
• Canonicalization of a vacuous patternProperties entry beside schema-valued additionalProperties, where matching keys escape its value constraint.
• Canonicalization of a Draft 4 closed pattern map with a reference nested under a property.
• Canonicalization of Draft 4 closed pattern maps that meet through an applicator.
• The complement of a reference back to a target already being negated, which stays symbolic instead of declining.
• CanonicalSchema::definition resolving # to the document the handle was read against.

Performance

• Up to 150x faster canonicalization of not over a union of many branches.
• 2% faster emission of canonical schemas, which no longer formats copied string values.
• 5% faster emission of canonical schemas, which no longer formats object keys while copying them.
• Up to 12% faster canonicalization of schemas that repeatedly intersect the same branches.
• 13% faster canonicalization of a non-dynamic OpenAPI document, which no longer scans every schema object for dynamic references.
• Faster canonicalization of schemas with local $defs references, which avoid decoding unescaped definition names.
• 23% faster canonicalization of an object whose keys a finite property-name set spells.
• 3% faster intersection of schemas where one side constrains nothing.
• Up to 31x faster canonicalization of a oneOf whose many branches overlap.
• Up to 14x faster canonicalization of a union whose object branches share no values.
• 7% faster canonicalization of schemas that reach the same pair of nodes repeatedly.
• 5% faster canonicalization of objects, whose property maps no longer reach the allocator.
• Up to 8% faster canonicalization of schemas that reach true and false subschemas repeatedly.
• 2% faster canonicalization of schemas that assert known string formats.

Fixed

• CanonicalSchema::definition and CanonicalSchema::definitions handing out a target that names the document root without that document, where # points at the target instead.
• An items tail beyond an array's length ceiling surviving canonicalization, where it governs no element.
• CanonicalSchema::to_json_schema leaving the document root out of a node emitted below it, where # points at that node instead.

Added

• Canonicalization of a negated uniqueItems, where the complement demands a repeated element under the length floor two elements imply.
• Canonicalization of a negated array tuple, where each position's complement stands under the length that reaches it.
• Canonicalization of contains demands sharing no value, where their counts add up into a length floor.
• CanonicalSchema::negate through references, where the complement of the resolved target takes the reference's place.
• Canonicalization of negated propertyNames and additionalProperties, where the complement spells the violating-key demand instead of a not residual.
• Canonicalization of negated additionalProperties under Draft 4, where the violating-key demand spells the closed property map.
• Canonicalization of not a reference, where the complement of the resolved target takes the pointer's place.
• Canonicalization of a negated oneOf, where the complement spells the values no branch admits beside the values two branches share.
• Canonicalization of negated items under Draft 4, where the violating-element demand spells the barred element schema.

Changed

• ArrayView reports distinctness in three states, so an array demanding a repeated element reads apart from one demanding distinct elements.

Fixed

• CanonicalSchema::negate keeping a root self-reference in the complement, where it points at the complement instead of the source.
• An additionalItems that tails no tuple keeping the whole document unmodeled under Draft 2020-12.

Added

• Canonicalization of not an integer schema under Draft 4, which the number leaf carries as barred integers.
• Canonicalization of not a multipleOf, which numeric leaves carry as barred divisors.
• Canonicalization of not an integer schema, where a barred divisor of one spells the non-integer numbers.
• Canonicalization of not a pattern, which string leaves carry as barred patterns.
• Canonicalization of not a typed value set under Draft 4, such as {"type": "integer", "enum": [1, 2]}.
• CanonicalSchema::is_subset_of, whether the other schema admits every value this one admits.
• Canonicalization of a reference cycle carrying no assertion, which admits every value.

Fixed

• CanonicalSchema::is_subset_of failing to prove a union of array branches a subset of itself.
• CanonicalSchema::intersect admitting values one side rejects when its additionalProperties governs the keys the other side's patternProperties match.
• A satisfiable multipleOf schema collapsing to the empty set when f64 rounds its bounds together.
• Two spellings of one number canonicalizing to different texts under arbitrary-precision when the fraction exceeds the expansion cap.
• Numeric bounds and multipleOf comparing values through a lossy f64 conversion under arbitrary-precision, such as 1e-400 passing {"maximum": 0}.
• A union branch left unabsorbed when a sibling complement shed a conjunct from another branch.
• A union keeping an integer branch beside a number branch that admits every value of it.

Added

• Canonicalization of not a string format, which the string leaf carries as barred formats.
• Canonicalization of not an existential demand, which an array fails exactly when no element matches.
• Canonicalization of not a string value set, which the string leaf carries as excluded values.
• Canonicalization of unevaluatedItems beside contains, where the elements it matches are evaluated and the tail admits either.
• Canonicalization of unevaluated* beside anyOf or oneOf, where every branch evaluating the same keys or indexes pins what is left over.
• Canonicalization of not an array element schema, which an array fails exactly when one element violates it.
• CanonicalSchema::intersect, the values both schemas admit.
• CanonicalSchema::negate, the values a schema rejects.
• CanonicalSchema::definition, one reference target by URI.

Fixed

• An integer past i64 admitted by a fractional bound f64 rounds it onto, such as -10000000000000000000000000 under {"maximum": -10000000000000000000000000.1}.
• An integer past 2^53 admitted by a bound f64 rounds onto it, such as 9007199254740992 under {"minimum": 9007199254740993}.
• A contains subschema beside both minContains and maxContains overwriting a sibling keyword of the same name, such as items.

Performance

• CanonicalSchema hashing and equality cost the node instead of the whole document.

Added

• Canonicalization of a recursive schema with no finite witness, which now folds to false.
• Canonicalization of $dynamicRef and $recursiveRef, which resolve through the dynamic scope and stay symbolic like any other reference. A dangling $dynamicRef errors rather than staying Raw.
• Canonicalization of minContains under uniqueItems, where a demand asking for more matches than its own schema has distinct values now folds to false.
• Canonicalization of a Draft 4 patternProperties coverage closed by additionalProperties: false, spelled as the closed map it was parsed from.
• Canonicalization of a oneOf whose branches repeat, where a repeated branch can never contribute exactly one match.
• Canonicalization of a $ref whose target is an empty schema, which now folds to false.
• Canonicalization of unevaluatedItems beside allOf, where every branch must pass and so the indexes they evaluate are known without the instance.
• Canonicalization of unevaluatedProperties beside allOf, where every branch must pass and so what they evaluate is known without the instance.
• Canonicalization of a Draft 4 type list holding integer beside other types with enum, which previously modeled only when spelled as an allOf.
• Canonicalization of patternProperties patterns matching finitely many keys, such as ^a$ and ^(a|b)$.
• Canonicalization of unevaluatedProperties and unevaluatedItems when no in-place applicator sits beside them.

Fixed

• additionalItems values that are not schemas silently ignored beside an array-form items (they should fail the build like additionalProperties).
• additionalItems beside a boolean items rejecting every instance, such as {"additionalItems": false, "items": false}.
• additionalItems beside a non-array items value failing schema compilation with an error blaming additionalItems (the keyword should be ignored).
• Draft 4 rejecting a size bound at or past 2^64, such as {"maxItems": 18446744073709551616}.
• An integer past the f64 range admitted by a fractional bound it exceeds, such as 1e400 under {"exclusiveMaximum": 0.1}.
• A $ref at the root of an $id-bearing subresource dropped as a self-reference when its pointer matched the one that reached that subresource.
• Canonicalization reusing one definition's body for a same-named definition in another resource, when the name spells a canonical URI.
• unevaluatedItems counting prefixItems as evaluating elements before Draft 2020-12, where it is not a keyword.

Performance

• Up to 70% faster evaluate by building each location in a single allocation instead of two, reusing the instance location a node already built, and caching evaluation paths across instance nodes.

Performance

• Faster serialization of canonicalized schemas.
• Faster macro code generation for subschemas with many keywords.
• Up to 70x faster canonicalization of multipleOf beside numeric bounds far from zero.

Fixed

• jsonschema-value: Ruby builds on x64-mingw-ucrt.

Added

• Generic JSON input: options_for builds a validator over any instance representation implementing json::Json, so instances validate without conversion to serde_json::Value. #239
• meta::validate_for and meta::is_valid_for for checking a schema document held in any representation implementing json::Json against its meta-schema.
• EXPERIMENTAL: Schema canonicalization via jsonschema::canonicalize. It reduces a reasonable subset of JSON Schemas to their normal forms.

Fixed

• multipleOf incorrectly accepted integers past u64 that are not multiples of the divisor.

Fixed

• Packaging issue again.

Fixed

• Packaging issue.

Changed

• INTERNAL. Extract common JSON Schema semantic into a separate jsonschema-value crate.

Performance

• Avoid map lookups in some properties validators.
• Faster validation of {"type": "array", "items": {...}} schemas.

Performance

• Faster validator compilation by pre-sizing internal caches.

Fixed

• Missing required errors in evaluate() output for schemas with properties and a two-entry required array. #1220
• contentEncoding errors for invalid UTF-8 after decoding incorrectly had empty instance_path and schema_path.

Performance

• Faster code generation for #[jsonschema::validator] (~5% across benchmarked schemas), via aliasing repeated paths in the emitted code.

Added

• iter_errors for #[jsonschema::validator]-generated validators.

Fixed

• Per-branch context on generated anyOf and oneOf validation errors, matching runtime validators.
• $recursiveRef in generated validators incorrectly resolved to the innermost $recursiveAnchor (it should resolve to the outermost one).
• Integer instances just outside the i64/u64 range incorrectly compared against numeric bounds through lossy f64 rounding under arbitrary-precision (e.g. {"minimum": -9223372036854775808} accepted -9223372036854775809).

Changed

• One canonical number spelling from canonical::json::to_string under arbitrary-precision ("1e-2" becomes "0.01", "1.50" becomes "1.5") and correctly-rounded float parsing (serde_json's float_roundtrip).

Performance

• Faster multipleOf validation for integer instances with integer divisors, via integer arithmetic instead of floating-point modulo.

Added

• #[jsonschema::validator] attribute macro (behind the macros feature) that compiles a JSON Schema into is_valid and validate implementations at build time.
• Keyword::iter_errors for reporting multiple validation errors from a single custom keyword. #1071

Changed

• Bump MSRV to 1.85.0.

Performance

• Faster meta-schema validation and schema compilation with the macros feature, via compile-time meta-schema validators.

Fixed

• type under items asserted with the Validation vocabulary disabled.
• Disabled vocabularies ignored for $ref targets without their own $schema (e.g. $defs entries).

Fixed

• Stack overflow with a self-referential $dynamicRef combined with unevaluatedProperties or unevaluatedItems.
• Incorrect unevaluatedProperties and unevaluatedItems results when a meta-schema disables the Applicator vocabulary.

Fixed

• multipleOf incorrectly rounds integer instances above 2^53 to f64 before the divisibility check on builds without the arbitrary-precision feature.
• Stack overflow while preparing a registry containing deeply nested schema documents.

Fixed

• idn-email format rejected non-ASCII characters in quoted local parts (e.g. "δοκιμή"@example.com).

Fixed

• idn-hostname format accepted A-labels that decode to a disallowed code point (e.g. xn--7a).

Added

• IntoRegistryResource for Arc<Value>. #1129

Fixed

• prefixItems incorrectly recognised as a known keyword in Draft 2019-09 and earlier (it is 2020-12 only).
• pattern validation errors displayed the internally translated regex instead of the original schema pattern. #1149

Fixed

• Percent-encoded characters in $ref URI fragments (e.g. #/$defs/Request%20class) are now decoded when stored as schema_path.

Fixed

• Panic in the regex engine when matching against patterns with very large {0,N} quantifiers.

Fixed

• Memory not reclaimed when a Validator for a schema with recursive $ref or $dynamicRef is dropped. #1125
• Compilation failure on wasm32-wasip1 and wasm32-unknown-emscripten targets.

Fixed

• required not enforced when additionalProperties is a schema object and required lists exactly 2 keys.

Fixed

• required not enforced when properties has 15 or more entries and required lists exactly 2 keys.

Added

• ValidatorMap for validating instances against subschemas identified by URI-fragment JSON pointer. #1075
• CLI: Accept multiple values after -i/--instance (e.g. jsonschema validate schema.json -i *.json). #1085
• dereference function to recursively inline $ref references. #422
• CLI: jsonschema dereference subcommand to dereference a schema from the command line.

Breaking Changes

• Registry construction now uses an explicit prepare step, and with_registry now borrows the prepared registry. ValidationOptions::with_resource and ValidationOptions::with_resources were removed in favor of building a Registry first. See the Migration Guide for the details.

Performance

• Avoid registry clones and document clones during validator construction. This improves real-world schema compilation by roughly 10-20% in internal benchmarks.

Fixed

• Incorrect handling of multipleOf validation for negative numeric instances.
• Incorrect handling of duration format when hours and seconds appear without minutes, or years and days without months.

Added

• bundle(schema) / async_bundle(schema) / ValidationOptions::bundle: produce a Compound Schema Document with external $ref targets embedded in a draft-appropriate container (definitions for Draft 4/6/7, $defs for Draft 2019-09/2020-12) while preserving $ref values. #791.
• CLI: jsonschema validate and jsonschema bundle subcommands. Flat invocation (jsonschema schema.json -i …) is deprecated — use jsonschema validate instead. #791.
• ValidationError::absolute_keyword_location() to get the absolute keyword location URI of the schema node that produced the error. #737.

Changed

• ValidationError::into_parts() now returns ValidationErrorParts instead of a tuple.

Fixed

• hostname format now applies legacy RFC 1034 semantics in Draft 4/6 and keeps IDNA A-label validation in Draft 7+.

Added

• canonical::json::to_string(value) for canonical JSON serialization (stable key ordering and numeric normalization), useful for deduplicating equivalent JSON Schemas.

Fixed

• Do not produce annotations for non-string instances from contentMediaType, contentEncoding, and contentSchema keywords.

Performance

• Optimize pattern and patternProperties for ^(a|b|c)$ alternations via linear array scan.
• Optimize ^\S*$ patterns by replacing regex with a direct ECMA-262 whitespace check.

Fixed

• anyOf, format, unevaluatedProperties, and unevaluatedItems now correctly collect annotations per spec.

Fixed

• SWAR digit parser accepted bytes :–? (0x3A–0x3F) as valid digits during date, time, and date-time format validation, potentially allowing malformed values to pass.

Performance

• Extend pattern prefix optimization to handle escaped slashes (^\/) and exact-match patterns (^\$ref$).
• Specialize enum for cases when all variants are strings.

Performance

• Reduce dynamic dispatch overhead for non-recursive $ref resolution.
• Cache ECMA regex transformations during format: "regex" validation.

Added

• JsonType::as_str method for zero-allocation type name access.
• ValidationErrorKind::keyword is now public.
• tls-ring feature flag to opt into using ring as the TLS crypto provider instead of the default aws-lc-rs. #997
• CLI: Support YAML (.yaml/.yml) instance files in text output mode. #988

Changed

• BREAKING: Default TLS crypto provider switched back to aws-lc-rs. Users who need ring can opt in via the tls-ring feature flag. This resolves potential conflicts with other libraries using aws-lc-rs. #997

Fixed

• Panic when validating $ref targets that resolve to boolean schemas.

Performance

• Cache formatted schema locations with OnceLock to avoid repeated formatting during evaluate().

Performance

• Replace regex-based uri-template format validation with a hand-rolled RFC 6570 parser.
• Specialize items keyword for simple type schemas ({"type": "string"}, {"type": "number"}, etc.) to eliminate dynamic dispatch overhead.
• Precompute regex matches on known properties.
• Faster unevaluatedProperties validation via O(1) property lookup and short-circuit oneOf evaluation.
• Use HashMap for large set of properties.
• Lower HashMap threshold from 40 to 15 properties for faster property lookups.

Changed

• Exclude internal tracker field from ValidationError Debug output.
• Switch HTTP client TLS crypto backend from aws-lc-rs to ring to simplify building from source on some Linux distributions. #957

Fixed

• type: integer validation in Draft 4 now correctly accepts large integers outside the i64/u64 range when arbitrary-precision feature is enabled.

Changed

• ValidationErrorKind::Custom now includes a keyword field containing the custom keyword name.

Performance

• Faster validation via cost-based keyword ordering.
• Faster patternProperties for simple prefix patterns (e.g., ^x-).

Added

• HttpOptions and ValidationOptions::with_http_options() for configuring HTTP client behavior (timeouts, TLS verification, custom CA certificates) when fetching external schemas.
• CLI: --timeout, --connect-timeout, --insecure, and --cacert flags for HTTP configuration.

Added

• ValidationError::evaluation_path() for the dynamic path including $ref traversals.

Changed

• BREAKING: Simplified custom keyword API - Keyword::validate no longer receives path parameters, and ValidationError::custom only takes a message.

Fixed

• schemaLocation in evaluation output now excludes $ref/$dynamicRef/$recursiveRef per JSON Schema spec.

Performance

• evaluate(): 4.5-30x faster on complex schemas, 12-89% faster overall.
• Recursive schemas with oneOf/anyOf: ~4000x faster via memoization. #930

Fixed

• multipleOf validation for integer values between 2^53 and i64::MAX with arbitrary-precision feature.

Added

• EmailOptions for configuring email format validation. #903

Fixed

• Use-after-free in async $ref resolution when multiple refs target the same external URL with different fragments. #906
• multipleOf validation for large u64 values beyond i64::MAX with arbitrary-precision feature.
• Validator not being Send + Sync on WASM targets. #915

Fixed

• Stack overflow during validation of schemas with circular $ref chains (e.g., a -> b -> a).
• Local $ref resolution within fragment-extracted external resources. #892

Removed

• Deprecated PrimitiveType & PrimitiveTypesBitMap.

Fixed

• External resources not discovered within subresources of local $ref targets. #892

Added

• JsonTypeSet::len() and JsonTypeSet::remove() helpers for managing type sets.

Fixed

• External resources not discovered through chained local $ref references. #892

Fixed

• Stack overflow on empty $ref value. #886

Added

• evaluate() top-level function for convenient access to structured validation output.
• CLI: Schema-only validation now also validates all referenced schemas. #804
• Support for additional contentEncoding values per RFC 4648: base64url, base32, base32hex, and base16. These encodings are now validated alongside the existing base64 support in Draft 6 and 7. #26
• validator.iter_errors(instance).into_errors(). It returns a ValidationErrors type that collects validation errors and implements std::error::Error. #451

Changed

• BREAKING: ValidationError fields are private; use instance(), kind(), instance_path(), and schema_path() instead of accessing struct fields directly.
• BREAKING: ErrorIterator is now a newtype wrapper instead of Box<dyn ValidationErrorIterator>.

Performance

• validate and other APIs returning Result<_, ValidationError> are 5–10% faster in some workloads due to the smaller error handle.
• evaluate: Avoiding deep clones of unmatched keyword values (e.g., title, description, examples) on every schema node evaluation by using Arc internally. Can be multiple times faster for schemas with large annotations.

Added

• CLI: Structured --output flag|list|hierarchical modes now stream newline-delimited JSON records with schema/instance metadata plus JSON Schema Output v1 payloads (default text output remains human-readable).
• CLI: --errors-only flag to suppress successful validation output and only show failures.
• CLI: When invoked with only a schema file (no instances), validates the schema against its meta-schema. #804
• New Validator::evaluate() API exposes JSON Schema Output v1 (flag/list/hierarchical) reports along with iterator helpers for annotations and errors.
• meta::validator_for() function to build validators for meta-schema validation with full Validator API access.
• Validator now implements Clone. #809

Removed

• Validator::apply(), Output, and BasicOutput types have been removed in favor of the richer evaluate() API.

Added

• Support for custom meta-schemas. Schemas with custom $schema URIs can now be used by registering their meta-schemas in the Registry via jsonschema::options().with_registry(). #664
• arbitrary-precision feature for exact numeric validation of large integers and decimals beyond standard floating-point limits. #103
• Support for HTTPS $schema URIs for drafts 04, 06, and 07 (e.g., https://json-schema.org/draft-07/schema). #802

Changed

• BREAKING: meta::is_valid now panics for unknown $schema values instead of defaulting to Draft 2020-12. meta::validate returns an error for unknown $schema values. Use meta::options().with_registry() to validate schemas against custom meta-schemas.
• BREAKING: Resource::from_contents no longer returns Result and always succeeds, since draft detection no longer fails for unknown $schema values.

Removed

• BREAKING: meta::try_is_valid and meta::try_validate. Use meta::is_valid and meta::validate instead.
• BREAKING: primitive_type module (deprecated since 0.30.0). Use jsonschema::types instead.

Performance

• required: short-circuit when the instance object has fewer properties than required keys.

Changed

• BREAKING: BasicOutput and Annotations no longer have lifetime parameters. Update type annotations from BasicOutput<'a> to BasicOutput and Annotations<'a> to Annotations.
• referencing: URI caching now avoids hash collisions and reduces lock contention.
• Update fluent-uri to 0.4.1.
• Bump MSRV to 1.83.0.
• Drop the Send + Sync bounds from Retrieve/AsyncRetrieve on wasm32.
• Use the new draftX::meta::validator() helper so meta-schema validators lazy-init on wasm32 while native targets keep borrowing the cached jsonschema::meta::MetaValidator.

Fixed

• Hostname and IDN hostname formats now decode xn-- labels, reject leading combining marks/uppercase prefixes, and enforce the latest JSON Schema punycode context rules.
• Restore wasm32-unknown-unknown support. #785

Performance

• apply now reuses cached schema locations, URI fragments, and buffers for up to ~2.5x faster validation.
• Recursive and regular $ref compilation deduplicates validator nodes, which decreases the memory usage and improves performance.
• Validator compilation restores the regex cache for faster builds on regex-heavy schemas and precomputes absolute schema locations, trading a bit of compile time for faster apply on location-heavy workloads.
• Large schema compilation is significantly faster. #755
• unevaluatedProperties validation is 25-35% faster through optimized property marking and early-exit paths.
• unevaluatedProperties memory usage drastically reduced by eliminating redundant registry clones during compilation.
• unevaluatedItems validation is ~10% faster through early-exit optimizations and eliminating redundant validations in combinators.

Removed

• BREAKING: Validator::config to reduce the memory footprint.
• BREAKING: Public DRAFT4_META_VALIDATOR, DRAFT6_META_VALIDATOR, DRAFT7_META_VALIDATOR, DRAFT201909_META_VALIDATOR, and DRAFT202012_META_VALIDATOR statics. Use draftX::meta::validator() helper functions instead (e.g., draft7::meta::validator()).

Fixed

• BREAKING: instance_path segments are now unescaped when iterating. LocationSegment::Property now holds Cow<'_, str> and LocationSegment is no longer Copy. #788

Changed

• Bump fancy-regex to 0.16.

Added

• Added missing context field to ValidationErrorKind::OneOfMultipleValid.

Changed

• Improved error message for enum.

Added

• CLI: flag -d, --draft <4|6|7|2019|2020> to enforce a specific JSON Schema draft.
• CLI: flags --assert-format and --no-assert-format to toggle validation of format keywords.
• Added context for ValidationErrorKind::AnyOf and ValidationErrorKind::OneOfNotValid which contains errors for all subschemas, each inside a separate vector with an index matching subschema ID.

Fixed

• Improve the precision of multipleOf for float values.

Changed

• Bump fancy-regex to 0.15.

Added

• JsonType and JsonTypeSet.
• ValidationOptions::with_base_uri that allows for specifying a base URI for all relative references in the schema.
• Configuration options for the underlying regex engine used by pattern and patternProperties keywords.

Changed

• Better error messages for relative $ref without base URI.

Fixed

• CLI: Inability to load relative file $ref. #725

Removed

• Internal cache for regular expressions.

Deprecated

• PrimitiveType and PrimitiveTypesBitMap.

Added

• Hash, PartialOrd, Ord and serde::Serialize for Location.
• Make Location::join public.

Breaking Changes

• All builder methods on ValidationOptions now take ownership of self instead of &mut self. This change enables better support for non-blocking retrieval of external resources during the process of building a validator. Update your code to chain the builder methods instead of reusing the options instance:

  // Before (0.28.x)
  let mut options = jsonschema::options();
  options.with_draft(Draft::Draft202012);
  options.with_format("custom", my_format);
  let validator = options.build(&schema)?;
  
  // After (0.29.0)
  let validator = jsonschema::options()
      .with_draft(Draft::Draft202012)
      .with_format("custom", my_format)
      .build(&schema)?;
  
  

• The Retrieve trait's retrieve method now accepts URI references as &Uri<String> instead of &Uri<&str>. This aligns with the async version and simplifies internal URI handling. The behavior and available methods remain the same, this is purely a type-level change.

  // Before
  fn retrieve(&self, uri: &Uri<&str>) -> Result<Value, Box<dyn std::error::Error + Send + Sync>>
  
  // After
  fn retrieve(&self, uri: &Uri<String>) -> Result<Value, Box<dyn std::error::Error + Send + Sync>>
  

• Simplified Registry creation API:

  • Removed RegistryOptions::try_new and RegistryOptions::try_from_resources in favor of Registry::build
  • Removed Registry::try_with_resource_and_retriever - use Registry::options().retriever() instead
  • Registry creation is now consistently done through the builder pattern

  // Before (0.28.x)
  let registry = Registry::options()
      .draft(Draft::Draft7)
      .try_new(
          "http://example.com/schema",
          resource
      )?;
  
  let registry = Registry::options()
      .draft(Draft::Draft7)
      .try_from_resources([
          ("http://example.com/schema", resource)
      ].into_iter())?;
    
  let registry = Registry.try_with_resource_and_retriever(
      "http://example.com/schema",
      resource,
      retriever
  )?;
  
  // After (0.29.0)
  let registry = Registry::options()
      .draft(Draft::Draft7)
      .build([
          ("http://example.com/schema", resource)
      ])?;
  
  let registry = Registry::options()
      .draft(Draft::Draft7)
      .build([
          ("http://example.com/schema", resource)
      ])?;
  
  let registry = Registry::options()
      .retriever(retriever)
      .build(resources)?;
  
  

Added

• Support non-blocking retrieval for external resources during schema resolution via the new resolve-async feature. #385
• Re-export referencing::Registry as jsonschema::Registry.
• ValidationOptions::with_registry that allows for providing a predefined referencing::Registry. #682

Performance

• Significantly improved validator compilation speed by using pointer-based references to schema fragments instead of cloning them during traversal.
• Faster anchors & sub-resources lookups during validator compilation.