if wasm-objdump -xj Import rustpython-without-js/target/wasm32-unknown-unknown/debug/rustpython_without_js.wasm; then
-            echo "ERROR: wasm32-unknown module expects imports from the host environment" >2
+            echo "ERROR: wasm32-unknown module expects imports from the host environment" >&2
           fi

-cargo build --manifest-path rustpython-without-js/Cargo.toml
+cargo build --target wasm32-unknown-unknown --manifest-path rustpython-without-js/Cargo.toml

-#[unsafe(no_mangle)]
-pub unsafe extern "C" fn eval(s: *const u8, l: usize) -> i32 {
-    // let src = unsafe { std::slice::from_raw_parts(s, l) };
-    // let src = std::str::from_utf8(src).unwrap();
-    // TODO: use src
-    let src = "1 + 3";
+#[no_mangle]
+pub unsafe extern "C" fn eval(s: *const u8, l: usize) -> i32 {
+    let src_bytes = std::slice::from_raw_parts(s, l);
+    let src = match std::str::from_utf8(src_bytes) {
+        Ok(s) => s,
+        Err(_) => return -1, // invalid UTF‑8 input
+    };

@@
-    let msg = format!("eval result: {result}");
-
-    unsafe {
-        print(
-            result.as_str().as_ptr() as usize as i32,
-            result.len() as i32,
-        )
-    };
+    let msg = format!("eval result: {result}");
+
+    unsafe {
+        print(
+            msg.as_ptr() as usize as i32,
+            msg.len() as i32,
+        )
+    };

-edition = "2024"
+edition = "2021"

 fn kv_get(mut ctx: FunctionEnvMut<Ctx>, kp: i32, kl: i32, vp: i32, vl: i32) -> i32 {
     let (c, s) = ctx.data_and_store_mut();
     let mut key = vec![0u8; kl as usize];
-    if c.mem
-        .as_ref()
-        .unwrap()
-        .view(&s)
+    let mem = c.mem.as_ref().expect("memory not initialized");
+    if mem.view(&s)
         .read(kp as u64, &mut key)
         .is_err()
     {
         return -1;
     }
     match c.kv.get(&key) {
         Some(val) => {
             let len = val.len().min(vl as usize);
-            if c.mem
-                .as_ref()
-                .unwrap()
-                .view(&s)
+            if mem.view(&s)
                 .write(vp as u64, &val[..len])
                 .is_err()
             {
                 return -1;
             }
             len as i32
         }
         None => 0,
     }
 }

 fn kv_put(mut ctx: FunctionEnvMut<Ctx>, kp: i32, kl: i32, vp: i32, vl: i32) -> i32 {
     let (c, s) = ctx.data_and_store_mut();
     let mut key = vec![0u8; kl as usize];
     let mut val = vec![0u8; vl as usize];
-    let m = c.mem.as_ref().unwrap().view(&s);
+    let m = c.mem.as_ref().expect("memory not initialized").view(&s);
     if m.read(kp as u64, &mut key).is_err() || m.read(vp as u64, &mut val).is_err() {
         return -1;
     }
     c.kv.insert(key, val);
     0
 }

 fn print(mut ctx: FunctionEnvMut<Ctx>, p: i32, l: i32) -> i32 {
     let (c, s) = ctx.data_and_store_mut();
     let mut msg = vec![0u8; l as usize];
-    let m = c.mem.as_ref().unwrap().view(&s);
+    let m = c.mem.as_ref().expect("memory not initialized").view(&s);
     if m.read(p as u64, &mut msg).is_err() {
         return -1;
     }
-    let s = std::str::from_utf8(&msg).expect("print got non-utf8 str");
-    println!("{s}");
-    0
+    match std::str::from_utf8(&msg) {
+        Ok(s) => {
+            println!("{s}");
+            0
+        }
+        Err(_) => {
+            eprintln!("print received non-UTF8 data");
+            -1
+        }
+    }
 }

 fn main() {
+    let wasm_path = std::env::args()
+        .nth(1)
+        .expect("Usage: wasm-runtime <wasm_file_path>");
+    
     let mut store = Store::default();
-    let module = Module::new(
-        &store,
-        &std::fs::read(&std::env::args().nth(1).unwrap()).unwrap(),
-    )
-    .unwrap();
+    let wasm_bytes = std::fs::read(&wasm_path)
+        .expect("Failed to read WASM file");
+    let module = Module::new(&store, &wasm_bytes)
+        .expect("Failed to create WASM module");

-    let inst = Instance::new(&mut store, &module, &imports).unwrap();
+    let inst = Instance::new(&mut store, &module, &imports)
+        .expect("Failed to instantiate WASM module");
     env.as_mut(&mut store).mem = inst.exports.get_memory("memory").ok().cloned();
-    let res = inst
-        .exports
-        .get_function("eval")
-        .unwrap()
-        .call(&mut store, &[wasmer::Value::I32(0), wasmer::Value::I32(0)])
-        .unwrap();
+    let eval_fn = inst
+        .exports
+        .get_function("eval")
+        .expect("WASM module does not export 'eval' function");
+    // TODO: Document what these arguments (0, 0) represent
+    let res = eval_fn
+        .call(&mut store, &[wasmer::Value::I32(0), wasmer::Value::I32(0)])
+        .expect("Failed to call eval function");