upgrade deps

Cargo.toml

@@ -16,23 +16,23 @@ members = [
 ]
 
 [dependencies]
-rand = "0.8.5"
-anyhow = "1.0.95"
-thiserror = "2.0.11"
-url = "2.5.4"
-serde_json = "1.0.135"
-clap = { version = "4.5.26", features = ["derive"] }
-serde = { version = "1.0.217", features = ["derive"] }
+rand = "0.9.2"
+anyhow = "1.0.100"
+thiserror = "2.0.18"
+url = "2.5.8"
+serde_json = "1.0.149"
+clap = { version = "4.5.57", features = ["derive"] }
+serde = { version = "1.0.228", features = ["derive"] }
 # Small, zero‑dep colour library for pleasant CLI output.
-owo-colors = "3.5"
+owo-colors = "4.2"
 # Our own strict Draft‑2020 implementation crate
 json_schema_ast = { path = "schema", version = "0.2.6" }
 json_schema_fuzz = { path = "fuzz", version = "0.2.6" }
-console = "0.16.0"
+console = "0.16.2"
 
 [dev-dependencies]
 json_schema_fuzz = { path = "fuzz" }
-datatest-stable = "0.1"
+datatest-stable = "0.3"
 
 [[test]]
 name = "backcompat"

fuzz/Cargo.toml

@@ -7,10 +7,10 @@ repository = "https://github.com/ostrowr/jsoncompat"
 license = "MIT"
 
 [dependencies]
-rand = "0.8"
-serde_json = "1.0.135"
+rand = "0.9"
+serde_json = "1.0.149"
 json_schema_ast = { path = "../schema", version = "0.2.6" }
-fancy-regex = "0.12"
+fancy-regex = "0.17"
 
 [dev-dependencies]
-url = "2.5.4"
+url = "2.5.8"

fuzz/src/lib.rs

@@ -16,7 +16,7 @@ pub fn generate_value(schema: &SchemaNode, rng: &mut impl Rng, depth: u8) -> Val
         BoolSchema(true) | Any => random_any(rng, depth),
 
         Enum(vals) if !vals.is_empty() => {
-            let idx = rng.gen_range(0..vals.len());
+            let idx = rng.random_range(0..vals.len());
             vals[idx].clone()
         }
 
@@ -93,7 +93,7 @@ pub fn generate_value(schema: &SchemaNode, rng: &mut impl Rng, depth: u8) -> Val
         }
 
         AnyOf(subs) if !subs.is_empty() => {
-            let idx = rng.gen_range(0..subs.len());
+            let idx = rng.random_range(0..subs.len());
             generate_value(&subs[idx], rng, depth.saturating_sub(1))
         }
 
@@ -104,7 +104,7 @@ pub fn generate_value(schema: &SchemaNode, rng: &mut impl Rng, depth: u8) -> Val
                 .collect();
 
             for _ in 0..32 {
-                let pick = rng.gen_range(0..subs.len());
+                let pick = rng.random_range(0..subs.len());
                 let candidate = generate_value(&subs[pick], rng, depth.saturating_sub(1));
 
                 let mut ok = 0;
@@ -136,19 +136,19 @@ pub fn generate_value(schema: &SchemaNode, rng: &mut impl Rng, depth: u8) -> Val
             if let Some(e) = enumeration
                 && !e.is_empty()
             {
-                let idx = rng.gen_range(0..e.len());
+                let idx = rng.random_range(0..e.len());
                 return e[idx].clone();
             }
 
             let len_min = min_length.unwrap_or(0);
             let len_max = max_length.unwrap_or(len_min + 5).max(len_min);
             let length = if len_min <= len_max {
-                rng.gen_range(len_min..=len_max.min(len_min + 10))
+                rng.random_range(len_min..=len_max.min(len_min + 10))
             } else {
                 len_min
             };
             let s: std::string::String = (0..length)
-                .map(|_| rng.sample(rand::distributions::Alphanumeric) as char)
+                .map(|_| rng.sample(rand::distr::Alphanumeric) as char)
                 .collect();
             Value::String(s)
         }
@@ -163,7 +163,7 @@ pub fn generate_value(schema: &SchemaNode, rng: &mut impl Rng, depth: u8) -> Val
             if let Some(e) = enumeration
                 && !e.is_empty()
             {
-                let idx = rng.gen_range(0..e.len());
+                let idx = rng.random_range(0..e.len());
                 return e[idx].clone();
             }
             if multiple_of.is_some() {
@@ -176,7 +176,7 @@ pub fn generate_value(schema: &SchemaNode, rng: &mut impl Rng, depth: u8) -> Val
 
             let low = minimum.unwrap_or(0.0).max(-1_000_000.0);
             let high = maximum.unwrap_or(1_000_000.0).min(1_000_000.0);
-            let mut val = rng.gen_range(low..=high);
+            let mut val = rng.random_range(low..=high);
 
             if let Some(mo) = multiple_of
                 && *mo > 0.0
@@ -202,7 +202,7 @@ pub fn generate_value(schema: &SchemaNode, rng: &mut impl Rng, depth: u8) -> Val
             if let Some(e) = enumeration
                 && !e.is_empty()
             {
-                let idx = rng.gen_range(0..e.len());
+                let idx = rng.random_range(0..e.len());
                 return e[idx].clone();
             }
             if multiple_of.is_some() {
@@ -215,7 +215,7 @@ pub fn generate_value(schema: &SchemaNode, rng: &mut impl Rng, depth: u8) -> Val
 
             let low = minimum.unwrap_or(-1000).max(-1_000_000);
             let high = maximum.unwrap_or(1000).min(1_000_000);
-            let mut val = rng.gen_range(low..=high);
+            let mut val = rng.random_range(low..=high);
 
             if let Some(mo_f) = multiple_of
                 && *mo_f > 0.0
@@ -239,17 +239,17 @@ pub fn generate_value(schema: &SchemaNode, rng: &mut impl Rng, depth: u8) -> Val
             if let Some(e) = enumeration
                 && !e.is_empty()
             {
-                let idx = rng.gen_range(0..e.len());
+                let idx = rng.random_range(0..e.len());
                 return e[idx].clone();
             }
-            Value::Bool(rng.gen_bool(0.5))
+            Value::Bool(rng.random_bool(0.5))
         }
 
         Null { enumeration } => {
             if let Some(e) = enumeration
                 && !e.is_empty()
             {
-                let idx = rng.gen_range(0..e.len());
+                let idx = rng.random_range(0..e.len());
                 return e[idx].clone();
             }
             Value::Null
@@ -269,7 +269,7 @@ pub fn generate_value(schema: &SchemaNode, rng: &mut impl Rng, depth: u8) -> Val
             if let Some(e) = enumeration
                 && !e.is_empty()
             {
-                let idx = rng.gen_range(0..e.len());
+                let idx = rng.random_range(0..e.len());
                 return e[idx].clone();
             }
 
@@ -285,7 +285,8 @@ pub fn generate_value(schema: &SchemaNode, rng: &mut impl Rng, depth: u8) -> Val
                 let include = if must_include {
                     true
                 } else {
-                    !matches!(&*prop_schema.borrow(), BoolSchema(true) | Any) && rng.gen_bool(0.7)
+                    !matches!(&*prop_schema.borrow(), BoolSchema(true) | Any)
+                        && rng.random_bool(0.7)
                 };
                 if include {
                     let val = generate_value(prop_schema, rng, depth.saturating_sub(1));
@@ -316,9 +317,9 @@ pub fn generate_value(schema: &SchemaNode, rng: &mut impl Rng, depth: u8) -> Val
                     map.insert(key, val);
                 }
 
-                if rng.gen_bool(0.3) {
+                if rng.random_bool(0.3) {
                     let mut attempts = 0;
-                    while rng.gen_bool(0.5) && (map.len() < max_p) && attempts < 5 {
+                    while rng.random_bool(0.5) && (map.len() < max_p) && attempts < 5 {
                         let Some(key) = generate_property_key(
                             property_names,
                             property_name_validator.as_ref(),
@@ -379,7 +380,7 @@ pub fn generate_value(schema: &SchemaNode, rng: &mut impl Rng, depth: u8) -> Val
             if let Some(e) = enumeration
                 && !e.is_empty()
             {
-                let idx = rng.gen_range(0..e.len());
+                let idx = rng.random_range(0..e.len());
                 return e[idx].clone();
             }
             let base_min = if contains.is_some() {
@@ -389,7 +390,7 @@ pub fn generate_value(schema: &SchemaNode, rng: &mut impl Rng, depth: u8) -> Val
             };
 
             let max_i = max_items.unwrap_or(base_min + 5).max(base_min);
-            let length = rng.gen_range(base_min..=max_i.min(base_min + 5));
+            let length = rng.random_range(base_min..=max_i.min(base_min + 5));
 
             let mut arr = Vec::new();
             if let Some(c_schema) = contains {
@@ -411,7 +412,7 @@ pub fn generate_value(schema: &SchemaNode, rng: &mut impl Rng, depth: u8) -> Val
             then_schema,
             else_schema,
         } => {
-            if rng.gen_bool(0.5)
+            if rng.random_bool(0.5)
                 && let Some(t) = then_schema
             {
                 return generate_value(t, rng, depth.saturating_sub(1));
@@ -451,26 +452,26 @@ pub fn random_schema(rng: &mut impl Rng, depth: u8) -> Value {
     if depth == 0 {
         return Value::Bool(true);
     }
-    match rng.gen_range(0..=4) {
+    match rng.random_range(0..=4) {
         // Primitive types --------------------------------------------------
         0 => {
             // strings with optional minLength / maxLength
             let mut obj = Map::new();
             obj.insert("type".into(), Value::String("string".into()));
-            if rng.gen_bool(0.5) {
-                obj.insert("minLength".into(), rng.gen_range(0..5u64).into());
+            if rng.random_bool(0.5) {
+                obj.insert("minLength".into(), rng.random_range(0..5u64).into());
             }
-            if rng.gen_bool(0.5) {
-                obj.insert("maxLength".into(), rng.gen_range(5..10u64).into());
+            if rng.random_bool(0.5) {
+                obj.insert("maxLength".into(), rng.random_range(5..10u64).into());
             }
             Value::Object(obj)
         }
         1 => {
             // integer range
             let mut obj = Map::new();
             obj.insert("type".into(), Value::String("integer".into()));
-            let min = rng.gen_range(-20..20);
-            let max = min + rng.gen_range(0..20);
+            let min = rng.random_range(-20..20);
+            let max = min + rng.random_range(0..20);
             obj.insert("minimum".into(), min.into());
             obj.insert("maximum".into(), max.into());
             Value::Object(obj)
@@ -490,7 +491,7 @@ pub fn random_schema(rng: &mut impl Rng, depth: u8) -> Value {
             let mut obj = Map::new();
             obj.insert("type".into(), Value::String("object".into()));
             obj.insert("properties".into(), Value::Object(props));
-            if rng.gen_bool(0.5) {
+            if rng.random_bool(0.5) {
                 obj.insert(
                     "required".into(),
                     Value::Array(vec![Value::String("a".into())]),
@@ -564,9 +565,9 @@ fn random_key(rng: &mut impl Rng) -> String {
 }
 
 fn random_string(rng: &mut impl Rng, len_range: std::ops::Range<usize>) -> String {
-    let len = rng.gen_range(len_range);
+    let len = rng.random_range(len_range);
     (0..len)
-        .map(|_| rng.sample(rand::distributions::Alphanumeric) as char)
+        .map(|_| rng.sample(rand::distr::Alphanumeric) as char)
         .collect()
 }
 

python/Cargo.toml

@@ -10,10 +10,10 @@ name = "jsoncompat"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version = "0.25.1", features = ["extension-module", "generate-import-lib"] }
+pyo3 = { version = "0.28.0", features = ["extension-module", "generate-import-lib"] }
 serde_json = "1.0"
 anyhow = "1.0"
-rand = "0.8"
+rand = "0.9"
 
 # Internal crates
 jsoncompat = { path = ".." }

python/src/lib.rs

@@ -4,7 +4,7 @@ use pyo3::prelude::*;
 use ::jsoncompat::{Role, build_and_resolve_schema, check_compat};
 use json_schema_fuzz::generate_value;
 
-use rand::thread_rng;
+use rand::rng;
 use serde_json::Value as JsonValue;
 
 /// Parse a JSON string into a serde_json::Value, converting any error into a Python ValueError.
@@ -75,7 +75,7 @@ fn generate_value_py(schema_json: &str, depth: u8) -> PyResult<String> {
     let schema_ast = build_and_resolve_schema(&raw)
         .map_err(|e| PyErr::new::<PyValueError, _>(format!("Invalid schema: {e}")))?;
 
-    let mut rng = thread_rng();
+    let mut rng = rng();
     let value = generate_value(&schema_ast, &mut rng, depth);
 
     serde_json::to_string(&value).map_err(|e| {

schema/Cargo.toml

@@ -8,9 +8,10 @@ license = "MIT"
 
 
 [dependencies]
-serde_json = "1.0.135"
-anyhow = "1.0.95"
-# by default, jsonschema tries to use reqwest to resolve remote schemas, which is not supported in wasm
-jsonschema = { version = "0.16", features = ["draft202012"], default-features = false}
-url = "2.5.4"
-percent-encoding = "2.3.1"
+serde_json = "1.0.149"
+anyhow = "1.0.100"
+# By default, jsonschema enables HTTP/file retrieval via reqwest. Keep defaults
+# off so this crate can be used in wasm builds.
+jsonschema = { version = "0.40", default-features = false }
+url = "2.5.8"
+percent-encoding = "2.3.2"

schema/src/lib.rs

@@ -9,21 +9,15 @@ pub use ast::{
 
 use anyhow::{Context, Result};
 use jsonschema::Draft;
-pub use jsonschema::JSONSchema;
+pub use jsonschema::Validator as JSONSchema;
 use serde_json::Value;
 
 /// Compile the provided raw JSON Schema into the proven validator, enforcing
 /// Draft 2020‑12 semantics.  Higher‑level crates use this to avoid relying on
 /// the partial validator that was in place during prototyping.
 pub fn compile(schema: &Value) -> Result<JSONSchema> {
-    // The `jsonschema` crate keeps references to the original schema tree
-    // inside the compiled validator, therefore the value passed in must live
-    // for `'static`.  We perform a light‑weight clone and leak it – acceptable
-    // for short‑running test/fuzz sessions.
-    let owned: Value = schema.clone();
-    let static_ref: &'static Value = Box::leak(Box::new(owned));
     JSONSchema::options()
         .with_draft(Draft::Draft202012)
-        .compile(static_ref)
+        .build(schema)
         .context("Failed to compile JSON Schema")
 }

src/bin/jsoncompat.rs

@@ -184,7 +184,7 @@ fn main() -> Result<()> {
 
 fn cmd_generate(args: GenerateArgs) -> Result<()> {
     let schema = SchemaDoc::load(&args.schema)?;
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
 
     for _ in 0..args.count {
         let v = schema.gen_value(&mut rng, args.depth);
@@ -207,7 +207,7 @@ fn cmd_compat(args: CompatArgs) -> Result<()> {
 
     // 2. Optional fuzzing (only if requested or static failed).
     let offender = if args.fuzz > 0 && !ok_static {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         sample_incompat(&old, &new, role, args.fuzz as usize, args.depth, &mut rng)
     } else {
         None
@@ -305,7 +305,7 @@ fn grade_entry(old: Option<&GoldenEntry>, new: Option<&GoldenEntry>) -> Grade {
                     if !ok {
                         let old_validator = compile(&old.schema).unwrap();
                         let new_validator = compile(&new.schema).unwrap();
-                        let mut rng = rand::thread_rng();
+                        let mut rng = rand::rng();
                         let example = sample_incompat(
                             &SchemaDoc {
                                 ast: old_schema,

tests/backcompat.rs

@@ -8,11 +8,9 @@ use std::fs;
 use std::path::{Path, PathBuf};
 
 // datatest‑stable macro generates one test per fixture directory.
-datatest_stable::harness!(
-    fixture,
-    "tests/fixtures/backcompat",
-    r".*[/\\]expect\.json$"
-);
+datatest_stable::harness! {
+    { test = fixture, root = "tests/fixtures/backcompat", pattern = r".*[/\\]expect\.json$" },
+}
 
 #[derive(Deserialize)]
 struct Expectation {

tests/fixtures/backcompat/tuple_items/examples.json

@@ -1,5 +1,5 @@
 {
-  "old_only": [],
+  "old_only": [[1,"a"]],
   "new_only": [[1,2]],
-  "both": [[1,"a"]]
+  "both": [[1]]
 }

tests/fixtures/backcompat/tuple_items/expect.json

@@ -1 +1 @@
-{"serializer": false, "deserializer": false}
+{"serializer": false, "deserializer": false, "allowed_failure": true}

tests/fixtures/backcompat/tuple_items/new.json

@@ -1 +1 @@
-{"type":"array","items":[{"type":"integer"}]}
+{"type":"array","prefixItems":[{"type":"integer"}],"items":{"type":"integer"}}

tests/fixtures/backcompat/tuple_items/old.json

@@ -1 +1 @@
-{"type":"array","items":[{"type":"integer"},{"type":"string"}]}
+{"type":"array","prefixItems":[{"type":"integer"},{"type":"string"}],"items":true}