@ezetgalaxy/titan 26.7.5 → 26.8.2

package/titanpl-sdk/templates/server/src/extensions.rs

@@ -1,22 +1,22 @@
 #![allow(unused)]
-use bcrypt::{DEFAULT_COST, hash, verify};
-use jsonwebtoken::{DecodingKey, EncodingKey, Header, Validation, decode, encode};
+use v8;
 use reqwest::{
     blocking::Client,
     header::{HeaderMap, HeaderName, HeaderValue},
 };
-use serde_json::Value;
-use std::path::PathBuf;
 use std::sync::Once;
+use std::path::PathBuf;
 use std::time::{SystemTime, UNIX_EPOCH};
-use v8;
+use serde_json::Value;
+use jsonwebtoken::{encode, decode, Header, EncodingKey, DecodingKey, Validation};
+use bcrypt::{hash, verify, DEFAULT_COST};
 
 use crate::utils::{blue, gray, green, parse_expires_in};
-use libloading::Library;
+use libloading::{Library};
+use walkdir::WalkDir;
+use std::sync::Mutex;
 use std::collections::HashMap;
 use std::fs;
-use std::sync::Mutex;
-use walkdir::WalkDir;
 
 // ----------------------------------------------------------------------------
 // GLOBAL REGISTRY
@@ -25,7 +25,7 @@ use walkdir::WalkDir;
 static REGISTRY: Mutex<Option<Registry>> = Mutex::new(None);
 #[allow(dead_code)]
 struct Registry {
-    _libs: Vec<Library>,
+    _libs: Vec<Library>, 
     modules: Vec<ModuleDef>,
     natives: Vec<NativeFnEntry>, // Flattened list of all native functions
 }
@@ -73,189 +73,81 @@ pub fn load_project_extensions(root: PathBuf) {
     let mut libs = Vec::new();
     let mut all_natives = Vec::new();
 
-    // =====================================================
-    // 1. Resolve all extension search directories
-    // =====================================================
-
-    let mut search_dirs = Vec::new();
-
-    let ext_dir = root.join(".ext"); // Production
-    let nm_root = root.join("node_modules"); // Dev
-    let nm_parent = root.parent().map(|p| p.join("node_modules")); // Monorepo
-
-    // 1) Production
-    if ext_dir.exists() {
-        search_dirs.push(ext_dir);
-    }
-
-    // 2) Dev: project node_modules
-    if nm_root.exists() {
-        search_dirs.push(nm_root.clone());
-    }
-
-    // 3) Dev monorepo: parent/node_modules
-    if let Some(nmp) = &nm_parent {
-        if nmp.exists() {
-            search_dirs.push(nmp.clone());
+    let mut node_modules = root.join("node_modules");
+    if !node_modules.exists() {
+        if let Some(parent) = root.parent() {
+            let parent_modules = parent.join("node_modules");
+            if parent_modules.exists() {
+                node_modules = parent_modules;
+            }
         }
     }
-
-    // 4) Never return empty — add root/node_modules even if missing
-    if search_dirs.is_empty() {
-        search_dirs.push(nm_root);
-    }
-
-    // Normalize and dedupe
-    search_dirs.sort();
-    search_dirs.dedup();
-
-    println!("{} Scanning extension directories:", blue("[Titan]"));
-    for d in &search_dirs {
-        println!("   • {}", d.display());
-    }
-
-    // =====================================================
-    // 2. Walk and locate titan.json inside search paths
-    // =====================================================
-    for dir in &search_dirs {
-        if !dir.exists() {
-            println!("   {} Skipping non-existent directory: {}", crate::utils::yellow("⚠"), dir.display());
-            continue;
-        }
-
-        for entry in WalkDir::new(&dir)
-            .min_depth(1)
-            .max_depth(5) // Increased depth
-            .follow_links(true)
-        {
-            let entry = match entry {
-                Ok(e) => e,
-                Err(_) => continue,
-            };
-
-            // Only accept titan.json files
+    
+    if node_modules.exists() {
+        for entry in WalkDir::new(&node_modules).follow_links(true).min_depth(1).max_depth(4) {
+            let entry = match entry { Ok(e) => e, Err(_) => continue };
             if entry.file_type().is_file() && entry.file_name() == "titan.json" {
-                let path = entry.path();
-                // Load config file
-                let config_content = match fs::read_to_string(path) {
-                   Ok(c) => c,
-                   Err(e) => {
-                       println!("{} Failed to read {}: {}", crate::utils::red("[Titan]"), path.display(), e);
-                       continue;
-                   }
-               };
-   
-               let config: TitanConfig = match serde_json::from_str(&config_content) {
-                   Ok(c) => c,
-                   Err(e) => {
-                        println!("{} Failed to parse {}: {}", crate::utils::red("[Titan]"), path.display(), e);
-                        continue;
-                   }
-               };
-   
-               let pkg_dir = path.parent().unwrap();
-               let mut mod_natives_map = HashMap::new();
-   
-               // =====================================================
-               // 3. Load native extension (optional)
-               // =====================================================
-               if let Some(native_conf) = config.native {
-                   let lib_path = pkg_dir.join(&native_conf.path);
-   
-                   unsafe {
-                       match Library::new(&lib_path) {
-                           Ok(lib) => {
-                               for (fn_name, fn_conf) in native_conf.functions {
-                                   let sig = if fn_conf.parameters == ["f64", "f64"]
-                                       && fn_conf.result == "f64"
-                                   {
-                                       Signature::F64TwoArgsRetF64
-                                   } else {
-                                       Signature::Unknown
-                                   };
-   
-                                   if let Ok(symbol) = lib.get::<*const ()>(fn_conf.symbol.as_bytes())
-                                   {
-                                       let idx = all_natives.len();
-                                       all_natives.push(NativeFnEntry {
-                                           ptr: *symbol as usize,
-                                           sig,
-                                       });
-                                       mod_natives_map.insert(fn_name, idx);
-                                   }
-                               }
-                               libs.push(lib);
-                           }
-                           Err(e) => println!(
-                               "{} Failed to load native library {} ({})",
-                               blue("[Titan]"),
-                               lib_path.display(),
-                                e
-                           ),
-                       }
-                   }
-               }
-   
-               // =====================================================
-               // 4. Load JS module file
-               // =====================================================
-               let js_path = pkg_dir.join(&config.main);
-               let js_content = match fs::read_to_string(&js_path) {
+                let dir = entry.path().parent().unwrap();
+                let config_content = match fs::read_to_string(entry.path()) {
                     Ok(c) => c,
-                    Err(e) => {
-                         println!("{} Failed to read JS main {} for extension {}: {}", 
-                            crate::utils::red("[Titan]"), 
-                            js_path.display(), 
-                            config.name, 
-                            e
-                        );
-                        continue;
-                    }
+                    Err(_) => continue,
                 };
-   
-               modules.push(ModuleDef {
-                   name: config.name.clone(),
-                   js: js_content,
-                   native_indices: mod_natives_map,
-               });
-   
-               println!(
-                   "{} {} {}",
-                   blue("[Titan]"),
-                   green("Extension loaded:"),
-                   config.name
-               );
+                let config: TitanConfig = match serde_json::from_str(&config_content) {
+                    Ok(c) => c,
+                    Err(_) => continue,
+                };
+
+                let mut mod_natives_map = HashMap::new();
+                
+                if let Some(native_conf) = config.native {
+                     let lib_path = dir.join(&native_conf.path);
+                     unsafe {
+                         match Library::new(&lib_path) {
+                             Ok(lib) => {
+                                 for (fn_name, fn_conf) in native_conf.functions {
+                                     let sig = if fn_conf.parameters.len() == 2 
+                                        && fn_conf.parameters[0] == "f64" 
+                                        && fn_conf.parameters[1] == "f64"
+                                        && fn_conf.result == "f64" {
+                                            Signature::F64TwoArgsRetF64
+                                     } else {
+                                            Signature::Unknown
+                                     };
+                                     
+                                     if let Ok(symbol) = lib.get::<*const ()>(fn_conf.symbol.as_bytes()) {
+                                          let idx = all_natives.len();
+                                          all_natives.push(NativeFnEntry {
+                                              ptr: *symbol as usize,
+                                              sig
+                                          });
+                                          mod_natives_map.insert(fn_name, idx);
+                                     }
+                                 }
+                                 libs.push(lib);
+                             },
+                             Err(e) => println!("Failed to load extension library {}: {}", lib_path.display(), e),
+                         }
+                     }
+                }
+
+                let js_path = dir.join(&config.main);
+                let js_content = fs::read_to_string(js_path).unwrap_or_default();
+
+                modules.push(ModuleDef {
+                    name: config.name.clone(),
+                    js: js_content,
+                    native_indices: mod_natives_map,
+                });
+                
+                println!("{} {} {}", blue("[Titan]"), green("Extension loaded:"), config.name);
             }
         }
     }
 
-    // =====================================================
-    // 5. Store registry globally
-    // =====================================================
-    if modules.is_empty() {
-         println!("{} {}", blue("[Titan]"), crate::utils::yellow("No extensions loaded."));
-         // Debug: list files in search dirs to assist debugging
-         for dir in &search_dirs {
-             if dir.exists() {
-                 println!("{} Listing contents of {}:", blue("[Titan]"), dir.display());
-                 for entry in WalkDir::new(dir).max_depth(5) {
-                      if let Ok(e) = entry {
-                          println!("   - {}", e.path().display());
-                      }
-                 }
-             } else {
-                 println!("{} Directory not found: {}", blue("[Titan]"), dir.display());
-             }
-         }
-    }
-
-    *REGISTRY.lock().unwrap() = Some(Registry {
-        _libs: libs,
-        modules,
-        natives: all_natives,
-    });
+    *REGISTRY.lock().unwrap() = Some(Registry { _libs: libs, modules, natives: all_natives });
 }
 
+
 static V8_INIT: Once = Once::new();
 
 pub fn init_v8() {
@@ -284,11 +176,7 @@ fn throw(scope: &mut v8::HandleScope, msg: &str) {
 // NATIVE CALLBACKS
 // ----------------------------------------------------------------------------
 
-fn native_read(
-    scope: &mut v8::HandleScope,
-    args: v8::FunctionCallbackArguments,
-    mut retval: v8::ReturnValue,
-) {
+fn native_read(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments, mut retval: v8::ReturnValue) {
     let path_val = args.get(0);
     // 1. Read argument
     if !path_val.is_string() {
@@ -307,7 +195,7 @@ fn native_read(
     let global = context.global(scope);
     let root_key = v8_str(scope, "__titan_root");
     let root_val = global.get(scope, root_key.into()).unwrap();
-
+    
     let root_str = if root_val.is_string() {
         v8_to_string(scope, root_val)
     } else {
@@ -338,18 +226,14 @@ fn native_read(
     match std::fs::read_to_string(&target) {
         Ok(content) => {
             retval.set(v8_str(scope, &content).into());
-        }
+        },
         Err(e) => {
             throw(scope, &format!("t.read failed: {}", e));
         }
     }
 }
 
-fn native_log(
-    scope: &mut v8::HandleScope,
-    args: v8::FunctionCallbackArguments,
-    mut _retval: v8::ReturnValue,
-) {
+fn native_log(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments, mut _retval: v8::ReturnValue) {
     let context = scope.get_current_context();
     let global = context.global(scope);
     let action_key = v8_str(scope, "__titan_action");
@@ -360,38 +244,30 @@ fn native_log(
     for i in 0..args.length() {
         let val = args.get(i);
         let mut appended = false;
-
+        
         // Try to JSON stringify objects so they are readable in logs
         if val.is_object() && !val.is_function() {
-            if let Some(json) = v8::json::stringify(scope, val) {
-                parts.push(json.to_rust_string_lossy(scope));
-                appended = true;
-            }
+             if let Some(json) = v8::json::stringify(scope, val) {
+                 parts.push(json.to_rust_string_lossy(scope));
+                 appended = true;
+             }
         }
-
+        
         if !appended {
             parts.push(v8_to_string(scope, val));
         }
     }
-
+    
     println!(
         "{} {}",
         blue("[Titan]"),
-        gray(&format!(
-            "\x1b[90mlog({})\x1b[0m\x1b[97m: {}\x1b[0m",
-            action_name,
-            parts.join(" ")
-        ))
+        gray(&format!("\x1b[90mlog({})\x1b[0m\x1b[97m: {}\x1b[0m", action_name, parts.join(" ")))
     );
 }
 
-fn native_fetch(
-    scope: &mut v8::HandleScope,
-    args: v8::FunctionCallbackArguments,
-    mut retval: v8::ReturnValue,
-) {
+fn native_fetch(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments, mut retval: v8::ReturnValue) {
     let url = v8_to_string(scope, args.get(0));
-
+    
     // Check for options (method, headers, body)
     let mut method = "GET".to_string();
     let mut body_str = None;
@@ -400,7 +276,7 @@ fn native_fetch(
     let opts_val = args.get(1);
     if opts_val.is_object() {
         let opts_obj = opts_val.to_object(scope).unwrap();
-
+        
         // method
         let m_key = v8_str(scope, "method");
         if let Some(m_val) = opts_obj.get(scope, m_key.into()) {
@@ -408,18 +284,18 @@ fn native_fetch(
                 method = v8_to_string(scope, m_val);
             }
         }
-
+        
         // body
         let b_key = v8_str(scope, "body");
         if let Some(b_val) = opts_obj.get(scope, b_key.into()) {
             if b_val.is_string() {
                 body_str = Some(v8_to_string(scope, b_val));
             } else if b_val.is_object() {
-                let json_obj = v8::json::stringify(scope, b_val).unwrap();
-                body_str = Some(json_obj.to_rust_string_lossy(scope));
+                 let json_obj = v8::json::stringify(scope, b_val).unwrap();
+                 body_str = Some(json_obj.to_rust_string_lossy(scope));
             }
         }
-
+        
         // headers
         let h_key = v8_str(scope, "headers");
         if let Some(h_val) = opts_obj.get(scope, h_key.into()) {
@@ -429,61 +305,57 @@ fn native_fetch(
                     for i in 0..keys.length() {
                         let key = keys.get_index(scope, i).unwrap();
                         let val = h_obj.get(scope, key).unwrap();
-                        headers_vec.push((v8_to_string(scope, key), v8_to_string(scope, val)));
+                        headers_vec.push((
+                            v8_to_string(scope, key),
+                            v8_to_string(scope, val),
+                        ));
                     }
                 }
             }
         }
     }
 
-    let client = Client::builder()
-        .use_rustls_tls()
-        .tcp_nodelay(true)
-        .build()
-        .unwrap_or(Client::new());
-
+    let client = Client::builder().use_rustls_tls().tcp_nodelay(true).build().unwrap_or(Client::new());
+    
     let mut req = client.request(method.parse().unwrap_or(reqwest::Method::GET), &url);
-
+    
     for (k, v) in headers_vec {
-        if let (Ok(name), Ok(val)) = (
-            HeaderName::from_bytes(k.as_bytes()),
-            HeaderValue::from_str(&v),
-        ) {
+        if let (Ok(name), Ok(val)) = (HeaderName::from_bytes(k.as_bytes()), HeaderValue::from_str(&v)) {
             let mut map = HeaderMap::new();
             map.insert(name, val);
             req = req.headers(map);
         }
     }
-
+    
     if let Some(b) = body_str {
         req = req.body(b);
     }
-
+    
     let res = req.send();
-
+    
     let obj = v8::Object::new(scope);
     match res {
         Ok(r) => {
             let status = r.status().as_u16();
             let text = r.text().unwrap_or_default();
-
+            
             let status_key = v8_str(scope, "status");
             let status_val = v8::Number::new(scope, status as f64);
             obj.set(scope, status_key.into(), status_val.into());
-
+            
             let body_key = v8_str(scope, "body");
             let body_val = v8_str(scope, &text);
             obj.set(scope, body_key.into(), body_val.into());
-
+            
             let ok_key = v8_str(scope, "ok");
             let ok_val = v8::Boolean::new(scope, true);
             obj.set(scope, ok_key.into(), ok_val.into());
-        }
+        }, 
         Err(e) => {
             let ok_key = v8_str(scope, "ok");
             let ok_val = v8::Boolean::new(scope, false);
             obj.set(scope, ok_key.into(), ok_val.into());
-
+            
             let err_key = v8_str(scope, "error");
             let err_val = v8_str(scope, &e.to_string());
             obj.set(scope, err_key.into(), err_val.into());
@@ -492,46 +364,33 @@ fn native_fetch(
     retval.set(obj.into());
 }
 
-fn native_jwt_sign(
-    scope: &mut v8::HandleScope,
-    args: v8::FunctionCallbackArguments,
-    mut retval: v8::ReturnValue,
-) {
+fn native_jwt_sign(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments, mut retval: v8::ReturnValue) {
     // payload, secret, options
     let payload_val = args.get(0);
     // Parse payload to serde_json::Map
-    let json_str = v8::json::stringify(scope, payload_val)
-        .unwrap()
-        .to_rust_string_lossy(scope);
-    let mut payload: serde_json::Map<String, Value> =
-        serde_json::from_str(&json_str).unwrap_or_default();
+    let json_str = v8::json::stringify(scope, payload_val).unwrap().to_rust_string_lossy(scope);
+    let mut payload: serde_json::Map<String, Value> = serde_json::from_str(&json_str).unwrap_or_default();
 
     let secret = v8_to_string(scope, args.get(1));
-
+    
     let opts_val = args.get(2);
     if opts_val.is_object() {
         let opts_obj = opts_val.to_object(scope).unwrap();
         let exp_key = v8_str(scope, "expiresIn");
-
+        
         if let Some(val) = opts_obj.get(scope, exp_key.into()) {
-            let seconds = if val.is_number() {
-                Some(val.to_number(scope).unwrap().value() as u64)
-            } else if val.is_string() {
-                parse_expires_in(&v8_to_string(scope, val))
-            } else {
-                None
-            };
-
-            if let Some(sec) = seconds {
-                let now = SystemTime::now()
-                    .duration_since(UNIX_EPOCH)
-                    .unwrap()
-                    .as_secs();
-                payload.insert(
-                    "exp".to_string(),
-                    Value::Number(serde_json::Number::from(now + sec)),
-                );
-            }
+             let seconds = if val.is_number() {
+                 Some(val.to_number(scope).unwrap().value() as u64)
+             } else if val.is_string() {
+                 parse_expires_in(&v8_to_string(scope, val))
+             } else {
+                 None
+             };
+             
+             if let Some(sec) = seconds {
+                let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
+                payload.insert("exp".to_string(), Value::Number(serde_json::Number::from(now + sec)));
+             }
         }
     }
 
@@ -547,41 +406,33 @@ fn native_jwt_sign(
     }
 }
 
-fn native_jwt_verify(
-    scope: &mut v8::HandleScope,
-    args: v8::FunctionCallbackArguments,
-    mut retval: v8::ReturnValue,
-) {
+fn native_jwt_verify(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments, mut retval: v8::ReturnValue) {
     let token = v8_to_string(scope, args.get(0));
     let secret = v8_to_string(scope, args.get(1));
-
+    
     let mut validation = Validation::default();
     validation.validate_exp = true;
-
+    
     let data = decode::<Value>(
         &token,
         &DecodingKey::from_secret(secret.as_bytes()),
         &validation,
     );
-
+    
     match data {
         Ok(d) => {
-            // Convert claim back to V8 object via JSON
-            let json_str = serde_json::to_string(&d.claims).unwrap();
-            let v8_json_str = v8_str(scope, &json_str);
-            if let Some(val) = v8::json::parse(scope, v8_json_str) {
-                retval.set(val);
-            }
-        }
+             // Convert claim back to V8 object via JSON
+             let json_str = serde_json::to_string(&d.claims).unwrap();
+             let v8_json_str = v8_str(scope, &json_str);
+             if let Some(val) = v8::json::parse(scope, v8_json_str) {
+                 retval.set(val);
+             }
+        },
         Err(e) => throw(scope, &format!("Invalid or expired JWT: {}", e)),
     }
 }
 
-fn native_password_hash(
-    scope: &mut v8::HandleScope,
-    args: v8::FunctionCallbackArguments,
-    mut retval: v8::ReturnValue,
-) {
+fn native_password_hash(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments, mut retval: v8::ReturnValue) {
     let pw = v8_to_string(scope, args.get(0));
     match hash(pw, DEFAULT_COST) {
         Ok(h) => retval.set(v8_str(scope, &h).into()),
@@ -589,23 +440,15 @@ fn native_password_hash(
     }
 }
 
-fn native_password_verify(
-    scope: &mut v8::HandleScope,
-    args: v8::FunctionCallbackArguments,
-    mut retval: v8::ReturnValue,
-) {
+fn native_password_verify(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments, mut retval: v8::ReturnValue) {
     let pw = v8_to_string(scope, args.get(0));
     let hash_str = v8_to_string(scope, args.get(1));
-
+    
     let ok = verify(pw, &hash_str).unwrap_or(false);
     retval.set(v8::Boolean::new(scope, ok).into());
 }
 
-fn native_define_action(
-    _scope: &mut v8::HandleScope,
-    args: v8::FunctionCallbackArguments,
-    mut retval: v8::ReturnValue,
-) {
+fn native_define_action(_scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments, mut retval: v8::ReturnValue) {
     retval.set(args.get(0));
 }
 
@@ -615,17 +458,13 @@ fn native_define_action(
 
 // generic wrappers could go here if needed
 
-fn native_invoke_extension(
-    scope: &mut v8::HandleScope,
-    args: v8::FunctionCallbackArguments,
-    mut retval: v8::ReturnValue,
-) {
+fn native_invoke_extension(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments, mut retval: v8::ReturnValue) {
     let fn_idx = args.get(0).to_integer(scope).unwrap().value() as usize;
 
     // Get pointer from registry
     let mut ptr = 0;
     let mut sig = Signature::Unknown;
-
+    
     if let Ok(guard) = REGISTRY.lock() {
         if let Some(registry) = &*guard {
             if let Some(entry) = registry.natives.get(fn_idx) {
@@ -634,39 +473,33 @@ fn native_invoke_extension(
             }
         }
     }
-
+    
     if ptr == 0 {
-        throw(scope, "Native function not found");
-        return;
+         throw(scope, "Native function not found");
+         return;
     }
 
     match sig {
         Signature::F64TwoArgsRetF64 => {
-            let a = args
-                .get(1)
-                .to_number(scope)
-                .unwrap_or(v8::Number::new(scope, 0.0))
-                .value();
-            let b = args
-                .get(2)
-                .to_number(scope)
-                .unwrap_or(v8::Number::new(scope, 0.0))
-                .value();
-
-            unsafe {
-                let func: extern "C" fn(f64, f64) -> f64 = std::mem::transmute(ptr);
-                let res = func(a, b);
-                retval.set(v8::Number::new(scope, res).into());
-            }
-        }
+             let a = args.get(1).to_number(scope).unwrap_or(v8::Number::new(scope, 0.0)).value();
+             let b = args.get(2).to_number(scope).unwrap_or(v8::Number::new(scope, 0.0)).value();
+             
+             unsafe {
+                 let func: extern "C" fn(f64, f64) -> f64 = std::mem::transmute(ptr);
+                 let res = func(a, b);
+                 retval.set(v8::Number::new(scope, res).into());
+             }
+        },
         _ => throw(scope, "Unsupported signature"),
     }
 }
 
+
 // ----------------------------------------------------------------------------
 // INJECTOR
 // ----------------------------------------------------------------------------
 
+
 pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Object>) {
     // Ensure globalThis reference
     let gt_key = v8_str(scope, "globalThis");
@@ -675,15 +508,13 @@ pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Obje
     let t_obj = v8::Object::new(scope);
     let t_key = v8_str(scope, "t");
     // Use create_data_property to guarantee definition
-    global
-        .create_data_property(scope, t_key.into(), t_obj.into())
-        .unwrap();
+    global.create_data_property(scope, t_key.into(), t_obj.into()).unwrap();
 
     // defineAction (identity function for clean typing)
     let def_fn = v8::Function::new(scope, native_define_action).unwrap();
     let def_key = v8_str(scope, "defineAction");
     global.set(scope, def_key.into(), def_fn.into());
-
+    
     // t.read
     let read_fn = v8::Function::new(scope, native_read).unwrap();
     let read_key = v8_str(scope, "read");
@@ -693,7 +524,7 @@ pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Obje
     let log_fn = v8::Function::new(scope, native_log).unwrap();
     let log_key = v8_str(scope, "log");
     t_obj.set(scope, log_key.into(), log_fn.into());
-
+    
     // t.fetch
     let fetch_fn = v8::Function::new(scope, native_fetch).unwrap();
     let fetch_key = v8_str(scope, "fetch");
@@ -703,12 +534,12 @@ pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Obje
     let jwt_obj = v8::Object::new(scope);
     let sign_fn = v8::Function::new(scope, native_jwt_sign).unwrap();
     let verify_fn = v8::Function::new(scope, native_jwt_verify).unwrap();
-
+    
     let sign_key = v8_str(scope, "sign");
     jwt_obj.set(scope, sign_key.into(), sign_fn.into());
     let verify_key = v8_str(scope, "verify");
     jwt_obj.set(scope, verify_key.into(), verify_fn.into());
-
+    
     let jwt_key = v8_str(scope, "jwt");
     t_obj.set(scope, jwt_key.into(), jwt_obj.into());
 
@@ -716,15 +547,16 @@ pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Obje
     let pw_obj = v8::Object::new(scope);
     let hash_fn = v8::Function::new(scope, native_password_hash).unwrap();
     let pw_verify_fn = v8::Function::new(scope, native_password_verify).unwrap();
-
+    
     let hash_key = v8_str(scope, "hash");
     pw_obj.set(scope, hash_key.into(), hash_fn.into());
     let pw_verify_key = v8_str(scope, "verify");
     pw_obj.set(scope, pw_verify_key.into(), pw_verify_fn.into());
-
+    
     let pw_key = v8_str(scope, "password");
     t_obj.set(scope, pw_key.into(), pw_obj.into());
 
+
     // Inject __titan_invoke_native
     let invoke_fn = v8::Function::new(scope, native_invoke_extension).unwrap();
     let invoke_key = v8_str(scope, "__titan_invoke_native");
@@ -742,97 +574,60 @@ pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Obje
     };
 
     for module in modules {
-        // 1. Prepare Native Wrappers
-        let natives_obj = v8::Object::new(scope);
-        for (fn_name, &idx) in &module.native_indices {
-            let code = format!(
-                "(function(a, b) {{ return __titan_invoke_native({}, a, b); }})",
-                idx
-            );
-            let source = v8_str(scope, &code);
-            // Compile wrappers
-            if let Some(script) = v8::Script::compile(scope, source, None) {
-                if let Some(val) = script.run(scope) {
-                    let key = v8_str(scope, fn_name);
-                    natives_obj.set(scope, key.into(), val);
-                }
-            }
-        }
-
-        // 2. Prepare JS Wrapper (CommonJS shim)
-        // We pass 't' and 'native' (the object we just made) to the module.
-        let wrapper_src = format!(
-            r#"(function(t, native) {{
-                var module = {{ exports: {{}} }};
-                var exports = module.exports;
-                {}
-                return module.exports;
-            }})"#,
-            module.js
-        );
-
-        let source = v8_str(scope, &wrapper_src);
-        let tc = &mut v8::TryCatch::new(scope);
-
-        // 3. Compile and Run
-        if let Some(script) = v8::Script::compile(tc, source, None) {
-            if let Some(factory_val) = script.run(tc) {
-                if let Ok(factory) = v8::Local::<v8::Function>::try_from(factory_val) {
-                    let recv = v8::undefined(&mut *tc).into();
-                    // Pass t_obj and natives_obj
-                    let args = [t_obj.into(), natives_obj.into()];
-
-                    if let Some(exports_val) = factory.call(&mut *tc, recv, &args) {
-                        // 4. Assign exports to t.<extName>
-                        let mod_key = v8_str(&mut *tc, &module.name);
-                        t_obj.set(&mut *tc, mod_key.into(), exports_val);
-
-                        // println!(
-                        //     "{} {} {}",
-                        //     crate::utils::blue("[Titan]"),
-                        //     crate::utils::green("Injected extension:"),
-                        //     module.name
-                        // );
-                    } else {
-                        // Execution error
-                        if let Some(msg) = tc.message() {
-                            let text = msg.get(&mut *tc).to_rust_string_lossy(&mut *tc);
-                            println!(
-                                "{} {} {} -> {}",
-                                crate::utils::blue("[Titan]"),
-                                crate::utils::red("Error running extension"),
-                                module.name,
-                                text
-                            );
-                        }
-                    }
-                }
-            } else {
-                 // Runtime error during script run
-                 if let Some(msg) = tc.message() {
-                    let text = msg.get(&mut *tc).to_rust_string_lossy(&mut *tc);
-                    println!(
-                        "{} {} {} -> {}",
-                        crate::utils::blue("[Titan]"),
-                        crate::utils::red("Error evaluating extension wrapper"),
-                        module.name,
-                        text
-                    );
-                }
-            }
-        } else {
-            // Compile error
-            if let Some(msg) = tc.message() {
-                let text = msg.get(&mut *tc).to_rust_string_lossy(&mut *tc);
-                println!(
-                    "{} {} {} -> {}",
-                    crate::utils::blue("[Titan]"),
-                    crate::utils::red("Syntax Error in extension"),
-                    module.name,
-                    text
-                );
-            }
-        }
+         let mod_obj = v8::Object::new(scope);
+         
+         // Generate JS wrappers
+         for (fn_name, &idx) in &module.native_indices {
+              let code = format!("(function(a, b) {{ return __titan_invoke_native({}, a, b); }})", idx);
+              let source = v8_str(scope, &code);
+              if let Some(script) = v8::Script::compile(scope, source, None) {
+                  if let Some(val) = script.run(scope) {
+                       let key = v8_str(scope, fn_name);
+                       mod_obj.set(scope, key.into(), val);
+                  }
+              }
+         }
+         
+         // Inject t.<module_name>
+         let mod_key = v8_str(scope, &module.name);
+         t_obj.set(scope, mod_key.into(), mod_obj.into());
+
+         // Set context for logging
+         let action_key = v8_str(scope, "__titan_action");
+         let action_val = v8_str(scope, &module.name);
+         global.set(scope, action_key.into(), action_val.into());
+         
+         // Execute JS
+         // Wrap in IIFE passing 't' to ensure visibility
+         let wrapped_js = format!("(function(t) {{ {} }})", module.js);
+         let source = v8_str(scope, &wrapped_js);
+         let tc = &mut v8::TryCatch::new(scope);
+         
+         if let Some(script) = v8::Script::compile(tc, source, None) {
+             if let Some(func_val) = script.run(tc) {
+                 // func_val is the function. Call it with [t_obj]
+                 if let Ok(func) = v8::Local::<v8::Function>::try_from(func_val) {
+                     let receiver = v8::undefined(&mut *tc).into();
+                     let args = [t_obj.into()];
+                     // Pass tc (which is a scope) 
+                     if func.call(&mut *tc, receiver, &args).is_none() {
+                         println!("{} {}", crate::utils::blue("[Titan]"), crate::utils::red("Extension Execution Failed"));
+                         if let Some(msg) = tc.message() {
+                             let text = msg.get(&mut *tc).to_rust_string_lossy(&mut *tc);
+                             println!("{} {}", crate::utils::red("Error details:"), text);
+                         }
+                     }
+                 }
+             } else {
+                 let msg = tc.message().unwrap();
+                 let text = msg.get(&mut *tc).to_rust_string_lossy(&mut *tc);
+                 println!("{} {} {}", crate::utils::blue("[Titan]"), crate::utils::red("Extension JS Error:"), text);
+             }
+         } else {
+             let msg = tc.message().unwrap();
+             let text = msg.get(&mut *tc).to_rust_string_lossy(&mut *tc);
+             println!("{} {} {}", crate::utils::blue("[Titan]"), crate::utils::red("Extension Compile Error:"), text);
+         }
     }
 
     // t.db (Stub for now)