fix(ci): resolve secondary compilation and KANI installation issues

This commit addresses the remaining CI failures after the primary
blocker was resolved, focusing on memory provider consistency and
KANI toolchain installation.

MEMORY PROVIDER FIXES:
- Fix StacklessEngine memory size inconsistency (1024 vs 4096)
- Use RUNTIME_MEMORY_SIZE constant consistently across std/no_std
- Remove unsafe type casts in StacklessEngine constructor
- Separate std/no_std initialization paths properly

KANI INSTALLATION FIXES:
- Remove non-existent kani-driver installation
- Fix KANI setup to use: cargo install kani-verifier + cargo kani setup
- Update both kani-regression.yml and deploy-verification.yml workflows

TECHNICAL DETAILS:
- StacklessEngine now uses proper types instead of casting BoundedMap to HashMap
- Memory allocation uses RUNTIME_MEMORY_SIZE (4096) instead of hardcoded 1024
- KANI follows official 2025 installation guide from model-checking.github.io

IMPACT:
- Should resolve most Test Default, Integration Tests, and other test job failures
- Should fix all KANI Verification job failures
- Maintains backward compatibility for both std and no_std configurations

These fixes target the type mismatch errors (E0605, E0308) and KANI setup
issues that were blocking CI after the primary SIMD compilation issue was resolved.

Author: avrabe

.github/workflows/deploy-verification.yml

@@ -56,7 +56,7 @@ jobs:
     - name: Install KANI and cargo-wrt
       run: |
         cargo install --locked kani-verifier
-        cargo install --locked kani-driver
+        cargo kani setup
         cargo install --path cargo-wrt --locked
 
     - name: Run pre-deployment verification

.github/workflows/kani-regression.yml

@@ -105,9 +105,10 @@ jobs:
 
     - name: Install KANI Verifier
       run: |
-        # Install KANI from source for latest features
+        # Install KANI verifier
         cargo install --locked kani-verifier
-        cargo install --locked kani-driver
+        # Setup KANI dependencies
+        cargo kani setup
         # Verify installation
         kani --version
 

wrt-build-core/src/wast_execution.rs

@@ -70,13 +70,13 @@ impl WastEngine {
             Module::from_wrt_module(&wrt_module).context("Failed to convert to runtime module")?;
 
         // Create a module instance from the module
-        use wrt_runtime::module_instance::ModuleInstance;
         use std::sync::Arc;
+
+        use wrt_runtime::module_instance::ModuleInstance;
         let module_instance = Arc::new(
-            ModuleInstance::new(module.clone(), 0)
-                .context("Failed to create module instance")?
+            ModuleInstance::new(module.clone(), 0).context("Failed to create module instance")?,
         );
-        
+
         // Set the current module in the engine
         let _instance_idx = self
             .engine

wrt-runtime/src/stackless/engine.rs

@@ -212,14 +212,29 @@ impl StacklessEngine {
         let operand_stack = BoundedVec::new(provider)
             .map_err(|_| wrt_error::Error::runtime_error("Failed to create operand stack"))?;
 
-        Ok(Self {
-            instances:           instances as HashMap<usize, Arc<ModuleInstance>>,
-            next_instance_id:    AtomicU64::new(1),
-            current_instance_id: None,
-            operand_stack:       operand_stack as Vec<Value>,
-            call_frames_count:   0,
-            stats:               ExecutionStats::default(),
-        })
+        #[cfg(any(feature = "std", feature = "alloc"))]
+        {
+            Ok(Self {
+                instances: HashMap::new(),
+                next_instance_id: AtomicU64::new(1),
+                current_instance_id: None,
+                operand_stack: Vec::new(),
+                call_frames_count: 0,
+                stats: ExecutionStats::default(),
+            })
+        }
+        
+        #[cfg(not(any(feature = "std", feature = "alloc")))]
+        {
+            Ok(Self {
+                instances,
+                next_instance_id: AtomicU64::new(1),
+                current_instance_id: None,
+                operand_stack,
+                call_frames_count: 0,
+                stats: ExecutionStats::default(),
+            })
+        }
     }
 
     /// Set the current module for execution
@@ -303,11 +318,12 @@ impl StacklessEngine {
 
         #[cfg(not(any(feature = "std", feature = "alloc")))]
         let mut results = {
+            use crate::bounded_runtime_infra::RUNTIME_MEMORY_SIZE;
             use wrt_foundation::{
                 budget_aware_provider::CrateId,
                 safe_managed_alloc,
             };
-            let provider = safe_managed_alloc!(1024, CrateId::Runtime)?;
+            let provider = safe_managed_alloc!(RUNTIME_MEMORY_SIZE, CrateId::Runtime)?;
             BoundedVec::new(provider)?
         };
         for result_type in &func_type.results {