Skip to content

chore(deps): update rust - #891

Open
renovate[bot] wants to merge 1 commit into
mainfrom
renovate/rust
Open

chore(deps): update rust#891
renovate[bot] wants to merge 1 commit into
mainfrom
renovate/rust

Conversation

@renovate

@renovate renovate Bot commented Sep 21, 2026 •
edited
Loading

Copy link
Copy Markdown
Contributor

Note

This PR body was truncated due to platform limits.

This PR contains the following updates:

Package Type Update Change
chrono dependencies patch 0.4.42 → 0.4.45
data-encoding dependencies minor 2.9.0 → 2.11.1
futures-executor (source) dev-dependencies patch 0.3.31 → 0.3.34
futures-io (source) dependencies patch 0.3.31 → 0.3.34
futures-util (source) dependencies patch 0.3.31 → 0.3.34
ion-rs dependencies minor 1.0.1 → 1.1.0
itoa dependencies patch 1.0.15 → 1.0.18
jsonschema workspace.dependencies minor =0.26.2 → =0.59.0
log dependencies patch 0.4.28 → 0.4.34
regorus workspace.dependencies minor =0.12.0 → =0.13.0
schemars (source) dependencies patch 1.2.2 → 1.2.3
serde (source) dependencies patch 1.0.228 → 1.0.229
serde_json dependencies patch 1.0.145 → 1.0.154
serde_json dependencies patch 1.0.151 → 1.0.154
serde_json workspace.dependencies patch 1.0.151 → 1.0.154
sha2 dependencies patch 0.11.0 → 0.11.1
sha2 workspace.dependencies patch 0.11.0 → 0.11.1
starbase workspace.dependencies patch 0.13.3 → 0.13.4
tempfile (source) dependencies minor 3.23.0 → 3.27.0
termimad dependencies patch 0.35.4 → 0.35.5
thiserror dependencies patch 2.0.17 → 2.0.21
thiserror workspace.dependencies patch 2.0.20 → 2.0.21
tokio (source) dev-dependencies patch 1.53.1 → 1.53.3
tokio (source) dependencies patch 1.53.1 → 1.53.3
toml workspace.dependencies patch 1.1.6+spec-1.1.0 → 1.1.8
tuf dev-dependencies patch =0.3.0-beta14 → =0.3.0-beta9
unicode-normalization workspace.dependencies patch 0.1.25 → 0.1.26
url dependencies patch 2.5.7 → 2.5.8
usage-lib (source) dependencies minor 6.10.0 → 6.12.1
uuid workspace.dependencies minor 1.26.1 → 1.28.0

Release Notes

chronotope/chrono (chrono)

v0.4.45: 0.4.45

Compare Source

What's Changed

v0.4.44: 0.4.44

Compare Source

What's Changed

v0.4.43: 0.4.43

Compare Source

What's Changed

ia0/data-encoding (data-encoding)

v2.11.1

Compare Source

v2.11.0

Compare Source

v2.10.0

Compare Source

rust-lang/futures-rs (futures-executor)

v0.3.34

Compare Source

v0.3.33

Compare Source

  • Fix ReadLine's soundness issue regarding to exception safety. (#​3020)
  • Fix unsound Send impl for IterPinRef and Iter. (#​3003)
  • Fix stacked borrows violation in compat01as03 implementation. (#​3012)
  • Fix memory leak in FuturesUnordered::IntoIter. (#​3005)
  • Add portable-atomic-alloc feature and use it in FuturesUnordered. (#​3007)
  • Re-export alloc::task::Wake. (#​3010)
  • Update spin to 0.12. (#​3014)

v0.3.32

Compare Source

  • Bump MSRV of utility crates to 1.71. (#​2989)
  • Soft-deprecate ready! macro in favor of std::task::ready! added in Rust 1.64 (#​2925)
  • Soft-deprecate pin_mut! macro in favor of std::pin::pin! added in Rust 1.68 (#​2929)
  • Add FuturesOrdered::clear (#​2927)
  • Add mpsc::*Receiver::recv (#​2947)
  • Add mpsc::*Receiver::try_recv and deprecate mpsc::*Receiver::::try_next (#​2944)
  • Implement FusedStream for sink::With (#​2948)
  • Add no_std support for shared (#​2868)
  • Make Mutex::new() const (#​2956)
  • Add #[clippy::has_significant_drop] to guards (#​2967)
  • Remove dependency to pin-utils (#​2929)
  • Remove dependency on num_cpus (#​2946)
  • Performance improvements (#​2983)
  • Documentation improvements (#​2925, #​2926, #​2940, #​2971)
amazon-ion/ion-rust (ion-rs)

v1.1.0

Compare Source

What's Changed

This release has smaller and faster in-memory representations for Timestamp, Decimal, Int, UInt, IonError, and Element annotations, plus faster text parsing and binary encoding. It also removes the incomplete Ion 1.1 implementation.

New Features
  • TimestampBuilder::localize_to_offset (#​1055)
  • Experimental: is_inline on Int, UInt, Coefficient, and Decimal (#​1068)
  • Experimental: managed writer instances can be reused (#​1054)
Performance
  • Timestamp is now a 16-byte packed representation (#​1041)
  • Decimal is now 24 bytes, backed by an overflowing-integer Coefficient (#​1044, #​1057)
  • Int and UInt are backed by the same overflowing-integer representation (#​1064)
  • IonError is 32 bytes; large payloads are boxed (#​1043)
  • Element annotations are packed into a single tagged pointer (#​1053)
  • Struct fields are stored in a boxed slice with a lazily built index (#​1048)
  • Faster binary VarUInt/VarInt writers and stack-encoded int/decimal magnitudes (#​1047, #​1049)
  • Reduced whitespace and field-name parsing overhead in the text reader (#​1061)
Breaking change to experimental features
  • The experimental-ion-1-1 Cargo feature and the incomplete Ion 1.1 implementation behind it have been removed (#​1056). Crates that enable experimental-ion-1-1 must remove it from their feature list to build with this release.
Other changes
  • The chrono dependency is now only pulled in by the experimental-chrono feature.
  • CI now checks the stable public API against a committed baseline (#​1042).
New Contributors

Full Changelog: amazon-ion/ion-rust@v1.0.1...v1.1.0

dtolnay/itoa (itoa)

v1.0.18

Compare Source

v1.0.17

Compare Source

  • Documentation improvements

v1.0.16

Compare Source

  • Synchronize algorithm improvements from libcore (#​65)
Stranger6667/jsonschema (jsonschema)

v0.59.0

Added
  • CLI: - as a path reads the schema or an instance from stdin.
  • CLI: -V as the version flag; -v stays as an alias.
Changed
  • CLI: Exit status 3 for errors that prevent a verdict and 2 for usage errors, so 1 always means an invalid instance or schema.
  • CLI: Errors print to stderr instead of stdout.
  • CLI: --version prints jsonschema-cli <VERSION> instead of Version: <VERSION>.
Fixed
  • CLI: Panic when stdout is closed early, as in jsonschema-cli validate ... | head.
  • CLI: Missing file path in the error for an unreadable instance in text output.
  • CLI: jsonschema-cli bundle, jsonschema-cli dereference and jsonschema-cli canonicalize truncating the --output file when the write fails partway.
  • CLI: jsonschema-cli validate --help describing --offline in terms of --resource, which validate does not accept.
  • CLI: Error and warning messages suggesting jsonschema commands instead of the installed jsonschema-cli binary.
  • Canonicalizing several subschemas of one prepared document, where a $ref in a later output could point at another subschema.
  • canonicalize leaving unevaluatedProperties or unevaluatedItems beside anyOf or oneOf raw.
  • canonicalize giving a different form for a oneOf depending on the order of its branches.
  • canonicalize output changing when canonicalized again, for a not over a $ref it cannot fully negate.
  • canonicalize output changing when canonicalized again, for a oneOf whose branches reduce to the same $ref.
  • canonicalize leaving an anyOf over many overlapping objects raw.
  • canonicalize leaving dependencies or dependentRequired raw when their keys form a long chain or cycle.
  • canonicalize treating -0 as a value distinct from 0 under arbitrary-precision.
  • Regex matches the engine cannot finish, such as on reaching the backtrack limit, counted as non-matches, letting not or patternProperties accept invalid instances. #​1715
  • canonicalize treating regex matches the engine cannot finish as non-matches.
Performance
  • canonicalize giving up sooner on an allOf over unions too wide to model.

v0.58.6

Fixed
  • \s in pattern missing most Unicode space separators and U+2028.
  • ECMA regex character class literals being interpreted as Rust set operators.

v0.58.5

Fixed
  • canonicalize keeping a reference to a cycle of bare references under not or oneOf instead of treating it as accepting every value.

v0.58.4

Fixed
  • Validator::draft returning the default draft instead of the one $schema declares.
  • unevaluatedProperties and unevaluatedItems beside a $recursiveRef ignoring what the reference target evaluates.
  • unevaluatedProperties ignoring the configured regex engine and its limits for patternProperties.
  • Absolute keyword location and schemaLocation of keywords a $ref JSON Pointer reaches through a subschema with its own $id.
  • type, minItems and maxItems ignored beside items when the applicator vocabulary is disabled.
  • Absolute keyword location and schemaLocation of keywords inside a nested $id resource counting from the document root.
  • required beside properties ignored when the applicator vocabulary is disabled, and required, minContains and maxContains applied when the validation vocabulary is disabled.
  • Absolute keyword location and evaluation output of type errors in a type-only items subschema pointing at items instead of the failing element's type.
  • Absolute keyword location of patternProperties annotations missing its JSON Pointer fragment.
  • Evaluation output of type: array beside schema-form items omitting passing type, minItems and maxItems units and nesting failing ones under items.
  • Evaluation output schemaLocation and absolute keyword location of $ref, $dynamicRef and $recursiveRef nodes not pointing at the reference target.
  • Evaluation output schemaLocation URIs not percent-encoding their fragment, such as a space in a property name.
  • Absolute keyword location of errors and annotations from a whole subschema, such as false, missing its JSON Pointer fragment.
  • Absolute keyword location of required, minContains and maxContains errors pointing at a sibling keyword.
  • Evaluation annotations from $ref siblings in Draft 4, 6 and 7 schemas.
  • Masked additionalItems messages counting allowed items instead of extra ones, and "1 items" in masked unevaluatedItems messages.
  • $dynamicRef and $recursiveRef resolving in the dynamic scope of another path to the same schema, depending on property order.
  • unevaluatedProperties and unevaluatedItems ignoring what then or else evaluates when if is true or false.
  • Stack overflow when building validators for long $ref chains.
  • format: "regex" and meta-schema validation rejecting escaped punctuation such as \- in patterns.
  • Build errors for an invalid patternProperties regex reporting the subschema instead of the pattern and its location.

v0.58.3

Fixed
  • Keywords of a subschema declaring a Draft 2019-09+ $schema under a Draft 4, 6 or 7 root being ignored.
  • Evaluation annotations including those from subschemas of a failing schema (a failing schema produces no annotations).
  • Embedded resources declaring their own $schema being checked against the root's meta-schema.

v0.58.2

Fixed
  • $dynamicRef targets in another document resolving relative references and reporting absolute keyword locations against the referencing document.
  • $ref to an $anchor or fragment $id validating against another anchor in the same document. #​1668
  • schema_path of errors under a $ref or $dynamicRef to a named schema pointing at the resource root instead of that schema.

v0.58.1

Fixed
  • Crash in Pyo3 validators when an Enum member's value override emptied a list or dict holding the instance being read.
Performance
  • uri and uri-reference formats check the syntax directly instead of parsing each value into a URI.
  • Enum members read their stored value directly instead of calling the value property in Pyo3 validators.

v0.58.0

Added
  • backend = Pyo3 on #[jsonschema::validator], generating a validator that reads Python objects in place.
  • backend = Magnus on #[jsonschema::validator], generating a validator that reads Ruby objects in place.
  • jsonschema::meta::pyo3, the bundled meta-schema validators for a schema held as a Python object.
  • jsonschema::meta::magnus, the bundled meta-schema validators for a schema held as a Ruby object.
  • methods = { ... } on #[jsonschema::validator], selecting which of is_valid, validate, and iter_errors are generated.
  • json::Jsonb, validating a Postgres jsonb value in place, behind the jsonb feature.
Performance
  • oneOf and anyOf whose branches each require a property fixed to a distinct string validate only the branch matching the instance's value.
  • Generated validate checks required in the same pass over an object as properties, instead of looking up each required name.
Fixed
  • A oneOf over $ref branches beside a sibling none of them admits, which canonicalized to an allOf instead of false.
  • multipleOf incorrectly accepted 1e-400 and other magnitudes below the smallest f64 subnormal with arbitrary-precision (they are not zero).
  • Numeric keywords panicked on a custom representation holding a number past f64 without arbitrary-precision.

v0.57.0

Added
  • PreparedDocument::unsatisfiable, naming the keywords that leave each unsatisfiable subschema empty and where they are.
Changed
  • PreparedDocument::unsatisfiable_pointers is replaced by PreparedDocument::unsatisfiable.
Fixed
  • The instance path of a schema build error, which was empty instead of naming the keyword location that failed to compile.
  • PreparedDocument::unsatisfiable_pointers passed over a subschema that admits no value only once its references resolve, such as an allOf over two $refs.
Performance
  • Canonicalizing several subschemas of one prepared document parses each definition body once for the document instead of once per call.

v0.56.0

Added
  • canonical::RawReason, what stopped a run from modeling a document, and canonical::RawView, carrying it beside the document and a pointer to the subschema the run stopped on.
  • ValidationOptions::is_known_format, whether a format of that name is checked under a draft.
Changed
  • BREAKING: canonical::CanonicalView::Raw carries a canonical::RawView in place of the document alone.
  • Canonicalization of a oneOf whose branches share a region too wide to expand, which spent the document's whole intersection allowance on that choice and kept the document Raw.
Performance
  • Preparing or building a schema that names no base URI parses the default one once for the process instead of once per schema.
  • Canonicalizing several subschemas of one prepared document compiles each pattern once for the document instead of once per call.
  • Canonicalization reads the facets no checker covers once per node instead of once per containment query.

v0.55.1

Changed
  • Canonicalization of an anyOf over an allOf through a $ref to a union, which left that union nested inside the outer one.
  • Canonicalization of an anyOf whose branch narrowing runs out of intersections, which left true as a branch inside the union.

v0.55.0

Changed
  • BREAKING: canonical::ObjectViolationView gained the PatternValueFails variant, which negation records for a patternProperties entry.
  • Canonicalization of not over patternProperties, which kept the entry under not instead of recording the demand a key breaks.
  • Canonicalization of unevaluated* beside a conditional reaching no key or index the node already evaluates, which spent a case on it.
  • Canonicalization of a conditional split outgrowing its per-node case budget, which kept documents like the Open API 3.2 meta-schema Raw.
  • Canonicalization of an anyOf over objects sharing a properties key under patternProperties, which settled only on a second pass.
  • Canonicalization of not over an allOf folded through a reference, which settled only on a second pass.
  • Canonicalization of a multipleOf divisor past f64 precision, which was not taken to divide itself.
  • Canonicalization of an anyOf over a value beside a window pinned to it, which settled only on a second pass.
  • Canonicalization of minProperties: 1 beside a not that already demands a key, which settled only on a second pass.
Fixed
  • absolute_keyword_location naming the sibling keyword whose validator carries the check: maxLength beside minLength, minItems, maxItems or type beside items, and a two-name required beside properties. #​1579
  • schemaLocation in evaluate output naming minLength for a maxLength failure. #​1579

v0.54.0

Added
  • backend = SerdeJson on #[jsonschema::validator], generating a validator that reads serde_json::Value.
  • PreparedDocument::unsatisfiable_pointers, listing every subschema no value satisfies.
Changed
  • Canonicalization of unevaluated* beside dependentSchemas or if/then/else, which kept the document Raw.
  • Canonicalization of not over patternProperties, which kept the document Raw.
Performance
  • validate and iter_errors check each assertion keyword with the is_valid path and build an error only for a failing one.
  • evaluate holds its output tree in one allocation instead of one per node.
  • A pattern of ^\S*$ scans bytes instead of decoding every character.
  • validate on properties beside a two-name required confirms both names in the pass that checks the properties, instead of looking each up first.
  • A string enum compares an option's length and first and last eight bytes before its full text.
  • A JSON Pointer segment is scanned for ~ and / eight bytes at a time before it is copied.
  • Canonicalization cloning leaves per intersection and the definition map per settled target.
Fixed
  • type: array with items and minItems/maxItems checking the built-in length bound even when a custom keyword overrides minItems or maxItems, so the bound was evaluated twice.
  • A custom keyword overriding type, required or maxLength not replacing the built-in check for that keyword.
  • A custom keyword overriding items, minLength, properties or additionalProperties leaving its sibling keywords unchecked.
  • #[jsonschema::validator] generated code that named serde_json directly, so it needed the consumer crate to depend on serde_json too.
  • Canonicalization of not over an object with properties, patternProperties and additionalProperties, which applied additionalProperties to the keys listed in properties.

v0.53.0

Added
  • Location::segments, iterating the segments without collecting them.
  • CanonicalizeOptions::prepare, canonicalizing any number of a document's subschemas by JSON Pointer, with the document indexed once.
  • CLI: the --at POINTER flag of jsonschema canonicalize, canonicalizing only the subschema at that pointer without breaking its references into the rest of the document.
  • CLI: jsonschema canonicalize reads YAML schemas (.yaml/.yml) as well as JSON.
  • canonical::{ArrayView, IntegerView, NumberView, ObjectView, StringView, TypedGroupView}, the payload types of CanonicalView, so consumers can name them in signatures.
Fixed
  • jsonschema-value failing to build with default-features = false.
  • jsonschema-value failing to build for wasm32-unknown-unknown, which needs getrandom's wasm_js backend.
  • Draft 4 type: integer accepting numbers written with an exponent, like 1e2.
  • Draft 4 type: integer answering differently for the same number across representations.
  • uniqueItems accepting 0 alongside -0.0 in arrays of more than 15 items.
Performance
  • Canonicalizing an allOf of object schemas walks their property maps once instead of looking every key up.
  • properties and required compare short names without memcmp.
  • Building a schema is up to 5% faster, from cheaper cache sharing and resolving each $ref target once.
  • Building a schema with an $id is up to 15% faster, from encoding each absolute location once.
  • required scans small objects once instead of looking up each key.
  • enum listing strings or integers, with or without null, matches against a set instead of comparing each candidate.
  • evaluate is up to 33% faster, from rendering each node's locations once.
  • CLI: 1.4-1.5x faster on large schemas, from reading files before parsing them.
  • Draft 4 type: integer with arbitrary-precision no longer allocates a string per number.
  • type: integer, and type sets containing it, are up to 54x faster on float-heavy instances with arbitrary-precision.
  • Draft 4 type: integer is up to 20x faster for the Pyo3 and Magnus representations.

v0.52.1

Fixed
  • multipleOf rejecting valid values like 1070468.14 for 0.01 without arbitrary-precision.
Performance
  • minLength and maxLength together now scan the string once.
  • multipleOf with a fractional divisor is 8-16x faster.
  • unevaluatedProperties is up to 2.9x faster.
  • evaluate is up to 27% faster on reference-heavy schemas.

v0.52.0

Added
  • Evaluation::is_valid.
  • Location::is_empty.
  • Display for ErrorEntry.
  • ValidationOptions::offline and canonical::CanonicalizeOptions::offline, refusing to fetch references outside the registry.
  • idna Cargo feature, enabled by default, gating the idn-hostname and idn-email formats. #​1313
  • CLI: the --offline flag of jsonschema validate, jsonschema bundle and jsonschema dereference.
Changed
  • ValidationErrors' Display gained the instance path of each error.
  • BREAKING: With default-features = false, the idn-hostname and idn-email formats now require the new idna feature. Without it they are unknown formats, which are accepted by default, or rejected at build time under should_ignore_unknown_formats(false). Add idna to the feature list to keep the previous behavior.
Fixed
  • Canonicalization not idempotent where a patternProperties $ref matches a key properties names.
  • is_valid disagreeing with validate, iter_errors, and evaluate on a schema that reaches its own $ref twice, one of them under not.
  • format: email and format: idn-email rejecting an empty quoted string as the local part (it should be accepted).
  • format: email and format: idn-email rejecting an address literal whose IPv6: tag is not written in that exact case (the tag is case-insensitive).
  • format: email accepting a non-ASCII character in the local part (it should be rejected).
  • ValidationOptions::with_draft gating keywords on the vocabularies of the $schema it overrides, so the validator accepted every instance.
Performance
  • iter_errors collects into a single buffer instead of allocating and re-boxing an iterator at every schema node.

v0.51.0

Added
  • ValidationOptions::with_vocabulary and the vocabularies attribute on jsonschema::validator, declaring support for a vocabulary this crate does not implement.
  • The --vocabulary flag of jsonschema validate.
Changed
  • Vocabulary gained the FormatAssertion variant, which its Draft 2020-12 URI parses to instead of Vocabulary::Custom, and is marked non_exhaustive.
Fixed
  • The uniqueItems length ceiling not reading an items or contains schema written as a $ref.
  • The Draft 2020-12 Format-Assertion vocabulary read as an annotation, so a meta-schema requiring it accepted values its format rejects.
  • An unrecognized format accepted under a meta-schema requiring the Format-Assertion vocabulary (it should be rejected).
  • A meta-schema requiring a vocabulary this crate does not implement accepted (it should be rejected).
  • The Draft 2019-09 Format vocabulary declared true read as an annotation, so a meta-schema requiring it accepted values its format rejects.
  • The bundled https://json-schema.org/draft/2020-12/meta/format-assertion meta-schema not declaring its vocabulary, so a schema written against it annotated format instead of asserting it.
  • A meta-schema without $id keeping its $vocabulary unread, so a schema written against it got every Draft 2020-12 vocabulary.
  • A schema naming a bundled vocabulary meta-schema as its $schema rejected as an unknown meta-schema (it should build).
  • The regex format reading the Rust regex dialect (it should read the ECMA-262 dialect in Unicode mode).
  • The uri-template format rejecting an apostrophe in a literal (it should accept it, per RFC 6570 errata 6937).
  • The duration format accepting weeks combined with a time part, such as P1WT1H (it should reject it).
  • Stack overflow compiling unevaluatedProperties or unevaluatedItems beside a $ref that cycles back to the node, written as #, through its $id, or through a chain of definitions.
Performance
  • Building unevaluatedProperties or unevaluatedItems over a deep allOf or $ref chain costs its depth instead of its square.

v0.50.1

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.

v0.50.0

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.

v0.49.9

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.

v0.49.8

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.

v0.49.7

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.

v0.49.6

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.

v0.49.5

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.

v0.49.4

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.

v0.49.3

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.

v0.49.2

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.

v0.49.1

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

v0.49.0

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.

v0.48.5

Fixed
  • Packaging issue again.

v0.48.2

Performance
  • Faster validator compilation by pre-sizing internal caches.

[v0.48.1](https://redirect.github.com/Stranger6667/jsonschema/blob/HEAD/CHANG

[!IMPORTANT]
✂ PR body was truncated to here.

Configuration

📅 Schedule: (UTC)

  • Branch creation
    • At any time (no schedule defined)
  • Automerge
    • At any time (no schedule defined)

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

👻 Immortal: This PR will be recreated if closed unmerged. Get config help if that's undesired.

  • If you want to rebase/retry this PR, check this box

This PR was generated by Mend Renovate. View the repository job log.

@netlify

netlify Bot commented Sep 21, 2026 •
edited
Loading

Copy link
Copy Markdown

✅ Deploy Preview for angry-raman-7c44f6 canceled.

Name Link
🔨 Latest commit 6b566fa
🔍 Latest deploy log https://app.netlify.com/projects/angry-raman-7c44f6/deploys/6ad30e355575a0991690ab4c

@renovate
renovate Bot force-pushed the renovate/rust branch 11 times, most recently from 677f698 to c5d9431 Compare September 21, 2026 16:17
@renovate renovate Bot changed the title chore(deps): update rust crate jsonschema to v0.56.0 chore(deps): update rust Sep 21, 2026
@renovate
renovate Bot force-pushed the renovate/rust branch 17 times, most recently from 1271c51 to 6a8f48f Compare September 23, 2026 02:44
@renovate
renovate Bot force-pushed the renovate/rust branch 28 times, most recently from df56396 to a78c0b4 Compare September 25, 2026 00:32
@renovate

renovate Bot commented Oct 17, 2026

Copy link
Copy Markdown
Contributor Author

⚠️ Artifact update problem

Renovate failed to update an artifact related to this branch. You probably do not want to merge this PR as-is.

♻ Renovate will retry this branch, including artifacts, only when one of the following happens:

  • any of the package files in this branch needs updating, or
  • the branch becomes conflicted, or
  • you click the rebase/retry checkbox if found above, or
  • you rename this PR's title to start with "rebase!" to trigger it manually

The artifact failure details are included below:

File name: Cargo.lock
    Updating crates.io index
error: failed to select a version for the requirement `ion-rs = "=1.0.1"`
candidate versions found which didn't match: 1.1.0
location searched: crates.io index
required by package `morphir-extension-sdk v0.2.0 (/tmp/renovate/repos/github/finos/morphir/ecosystem/morphir-rust/crates/morphir-extension-sdk)`

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Reviewers

No reviews

Assignees

No one assigned

Labels

None yet

Projects

None yet

Milestone

No milestone

Development

Successfully merging this pull request may close these issues.

0 participants