Fix all Dependabot security alerts: upgrade 5 vulnerable dependencies

- jsonwebtoken 9.2 -> 10.3.0 (medium: type confusion auth bypass)
- pyo3 0.22 -> 0.24.2 (low: buffer overflow in PyString)
- iced 0.13 -> 0.14.0 (fixes lru 0.12.5 -> 0.16.3, low: Stacked Borrows)
- bytes 1.11.0 -> 1.11.1 (medium: integer overflow in BytesMut)
- time 0.3.44 -> 0.3.47 (medium: stack exhaustion DoS)

jsonwebtoken: switched crypto backend from ring to rust_crypto (pure Rust).
pyo3: renamed 31 _bound API calls removed in 0.23+.
iced: migrated to new boot/title application API and canvas::Action return type.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: mivertowski

Cargo.lock

@@ -63,7 +63,7 @@ hkdf = { version = "0.12", optional = true }
 sha2 = { version = "0.10", optional = true }
 
 # Authentication (optional)
-jsonwebtoken = { version = "9.2", optional = true }
+jsonwebtoken = { version = "10", features = ["rust_crypto"], optional = true }
 base64 = { version = "0.21", optional = true }
 
 # Rate limiting (optional)

crates/ringkernel-core/Cargo.toml

@@ -15,8 +15,8 @@ crate-type = ["cdylib"]
 
 [dependencies]
 # PyO3 for Python bindings
-pyo3 = { version = "0.22", features = ["extension-module", "abi3-py38"] }
-pyo3-async-runtimes = { version = "0.22", features = ["tokio-runtime"] }
+pyo3 = { version = "0.24", features = ["extension-module", "abi3-py38"] }
+pyo3-async-runtimes = { version = "0.24", features = ["tokio-runtime"] }
 
 # Async runtime
 tokio = { version = "1.48", features = ["rt-multi-thread", "sync", "time"] }
@@ -27,7 +27,7 @@ ringkernel-cpu = { path = "../ringkernel-cpu" }
 ringkernel-cuda = { path = "../ringkernel-cuda", optional = true }
 
 # NumPy interop
-numpy = { version = "0.22", optional = true }
+numpy = { version = "0.24", optional = true }
 
 # Error handling
 thiserror = "2.0"

crates/ringkernel-python/Cargo.toml

@@ -941,7 +941,7 @@ impl PyBenchmarkBaseline {
 /// Register benchmark types with the Python module.
 pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
     // Create benchmark submodule
-    let benchmark = PyModule::new_bound(m.py(), "benchmark")?;
+    let benchmark = PyModule::new(m.py(), "benchmark")?;
 
     // Configuration types
     benchmark.add_class::<PyBenchmarkConfig>()?;

crates/ringkernel-python/src/benchmark/mod.rs

@@ -283,7 +283,7 @@ impl PyHlcClock {
 /// Register HLC types with the Python module.
 pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
     // Create hlc submodule
-    let hlc = PyModule::new_bound(m.py(), "hlc")?;
+    let hlc = PyModule::new(m.py(), "hlc")?;
     hlc.add_class::<PyHlcTimestamp>()?;
     hlc.add_class::<PyHlcClock>()?;
 

crates/ringkernel-python/src/core/hlc.rs

@@ -316,7 +316,7 @@ impl PyK2KBroker {
 /// Register K2K types with the Python module.
 pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
     // Create k2k submodule
-    let k2k = PyModule::new_bound(m.py(), "k2k")?;
+    let k2k = PyModule::new(m.py(), "k2k")?;
     k2k.add_class::<PyK2KConfig>()?;
     k2k.add_class::<PyDeliveryStatus>()?;
     k2k.add_class::<PyDeliveryReceipt>()?;

crates/ringkernel-python/src/core/k2k.rs

@@ -494,7 +494,7 @@ impl PyMessageEnvelope {
     /// Get the payload bytes.
     #[getter]
     fn payload<'py>(&self, py: Python<'py>) -> Bound<'py, PyBytes> {
-        PyBytes::new_bound(py, &self.inner.payload)
+        PyBytes::new(py, &self.inner.payload)
     }
 
     /// Total size in bytes (header + payload).
@@ -508,7 +508,7 @@ impl PyMessageEnvelope {
     /// Returns:
     ///     The envelope as a contiguous byte buffer.
     fn to_bytes<'py>(&self, py: Python<'py>) -> Bound<'py, PyBytes> {
-        PyBytes::new_bound(py, &self.inner.to_bytes())
+        PyBytes::new(py, &self.inner.to_bytes())
     }
 
     /// Deserialize an envelope from bytes.

crates/ringkernel-python/src/core/message.rs

@@ -490,7 +490,7 @@ impl From<PartitionedQueueStats> for PyPartitionedQueueStats {
 /// Register queue types with the Python module.
 pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
     // Create queue submodule
-    let queue = PyModule::new_bound(m.py(), "queue")?;
+    let queue = PyModule::new(m.py(), "queue")?;
     queue.add_class::<PyQueueStats>()?;
     queue.add_class::<PyQueueTier>()?;
     queue.add_class::<PyQueueHealth>()?;

crates/ringkernel-python/src/core/queue.rs

@@ -715,7 +715,7 @@ impl From<RustStreamPoolStats> for PyStreamPoolStats {
 /// Register CUDA types with the Python module.
 pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
     // Create cuda submodule
-    let cuda = PyModule::new_bound(m.py(), "cuda")?;
+    let cuda = PyModule::new(m.py(), "cuda")?;
 
     // Device functions
     cuda.add_function(wrap_pyfunction!(is_cuda_available, &cuda)?)?;

crates/ringkernel-python/src/cuda/mod.rs

@@ -435,54 +435,54 @@ impl<T, E: Into<PyRingKernelError>> IntoPyResult<T> for Result<T, E> {
 /// Register exception types with the Python module.
 pub fn register_exceptions(py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
     // Create exceptions module
-    let exceptions = PyModule::new_bound(py, "exceptions")?;
+    let exceptions = PyModule::new(py, "exceptions")?;
 
     // Add base exception
-    exceptions.add("RingKernelError", py.get_type_bound::<RingKernelError>())?;
+    exceptions.add("RingKernelError", py.get_type::<RingKernelError>())?;
 
     // Memory errors
-    exceptions.add("MemoryLimitError", py.get_type_bound::<MemoryLimitError>())?;
+    exceptions.add("MemoryLimitError", py.get_type::<MemoryLimitError>())?;
 
     // Kernel errors
-    exceptions.add("KernelError", py.get_type_bound::<KernelError>())?;
-    exceptions.add("KernelStateError", py.get_type_bound::<KernelStateError>())?;
+    exceptions.add("KernelError", py.get_type::<KernelError>())?;
+    exceptions.add("KernelStateError", py.get_type::<KernelStateError>())?;
 
     // CUDA errors
-    exceptions.add("CudaError", py.get_type_bound::<CudaError>())?;
-    exceptions.add("CudaDeviceError", py.get_type_bound::<CudaDeviceError>())?;
-    exceptions.add("CudaMemoryError", py.get_type_bound::<CudaMemoryError>())?;
+    exceptions.add("CudaError", py.get_type::<CudaError>())?;
+    exceptions.add("CudaDeviceError", py.get_type::<CudaDeviceError>())?;
+    exceptions.add("CudaMemoryError", py.get_type::<CudaMemoryError>())?;
 
     // Queue errors
-    exceptions.add("QueueError", py.get_type_bound::<QueueError>())?;
-    exceptions.add("QueueFullError", py.get_type_bound::<QueueFullError>())?;
-    exceptions.add("QueueEmptyError", py.get_type_bound::<QueueEmptyError>())?;
+    exceptions.add("QueueError", py.get_type::<QueueError>())?;
+    exceptions.add("QueueFullError", py.get_type::<QueueFullError>())?;
+    exceptions.add("QueueEmptyError", py.get_type::<QueueEmptyError>())?;
 
     // K2K errors
-    exceptions.add("K2KError", py.get_type_bound::<K2KError>())?;
-    exceptions.add("K2KDeliveryError", py.get_type_bound::<K2KDeliveryError>())?;
+    exceptions.add("K2KError", py.get_type::<K2KError>())?;
+    exceptions.add("K2KDeliveryError", py.get_type::<K2KDeliveryError>())?;
 
     // Benchmark errors
-    exceptions.add("BenchmarkError", py.get_type_bound::<BenchmarkError>())?;
+    exceptions.add("BenchmarkError", py.get_type::<BenchmarkError>())?;
 
     // Hybrid errors
-    exceptions.add("HybridError", py.get_type_bound::<HybridError>())?;
+    exceptions.add("HybridError", py.get_type::<HybridError>())?;
     exceptions.add(
         "GpuNotAvailableError",
-        py.get_type_bound::<GpuNotAvailableError>(),
+        py.get_type::<GpuNotAvailableError>(),
     )?;
 
     // Resource errors
-    exceptions.add("ResourceError", py.get_type_bound::<ResourceError>())?;
-    exceptions.add("ReservationError", py.get_type_bound::<ReservationError>())?;
+    exceptions.add("ResourceError", py.get_type::<ResourceError>())?;
+    exceptions.add("ReservationError", py.get_type::<ReservationError>())?;
 
     // Add exceptions module to main module
     m.add_submodule(&exceptions)?;
 
     // Also add commonly-used exceptions at top level
-    m.add("RingKernelError", py.get_type_bound::<RingKernelError>())?;
-    m.add("CudaError", py.get_type_bound::<CudaError>())?;
-    m.add("KernelError", py.get_type_bound::<KernelError>())?;
-    m.add("MemoryLimitError", py.get_type_bound::<MemoryLimitError>())?;
+    m.add("RingKernelError", py.get_type::<RingKernelError>())?;
+    m.add("CudaError", py.get_type::<CudaError>())?;
+    m.add("KernelError", py.get_type::<KernelError>())?;
+    m.add("MemoryLimitError", py.get_type::<MemoryLimitError>())?;
 
     Ok(())
 }