titanpl-sdk 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "titanpl-sdk",
-    "version": "0.1.4",
+    "version": "0.1.6",
     "description": "Development SDK for Titan Planet. Provides TypeScript type definitions for the global 't' runtime object and a 'lite' test-harness runtime for building and verifying extensions.",
     "main": "index.js",
     "type": "module",

package/templates/Dockerfile

@@ -18,6 +18,20 @@ COPY . .
 # Install JS dependencies (needed for Titan DSL + bundler)
 RUN npm install
 
+SHELL ["/bin/bash", "-c"]
+
+# Extract Titan extensions into .ext
+RUN mkdir -p /app/.ext && \
+    find /app/node_modules -maxdepth 5 -type f -name "titan.json" -print0 | \
+    while IFS= read -r -d '' file; do \
+    pkg_dir="$(dirname "$file")"; \
+    pkg_name="$(basename "$pkg_dir")"; \
+    echo "Copying Titan extension: $pkg_name from $pkg_dir"; \
+    cp -r "$pkg_dir" "/app/.ext/$pkg_name"; \
+    done && \
+    echo "Extensions in .ext:" && \
+    ls -R /app/.ext
+
 # Build Titan metadata + bundle JS actions
 RUN titan build
 
@@ -34,7 +48,7 @@ FROM debian:stable-slim
 WORKDIR /app
 
 # Copy Rust binary from builder stage
-COPY --from=builder /app/server/target/release/server ./titan-server
+COPY --from=builder /app/server/target/release/titan-server ./titan-server
 
 # Copy Titan routing metadata
 COPY --from=builder /app/server/routes.json ./routes.json
@@ -44,10 +58,9 @@ COPY --from=builder /app/server/action_map.json ./action_map.json
 RUN mkdir -p /app/actions
 COPY --from=builder /app/server/actions /app/actions
 
-COPY --from=builder /app/db /app/assets
+# Copy only Titan extensions
+COPY --from=builder /app/.ext ./.ext
 
-# Expose Titan port
 EXPOSE 3000
 
-# Start Titan
 CMD ["./titan-server"]

package/templates/server/src/extensions.rs

@@ -1,22 +1,22 @@
 #![allow(unused)]
-use v8;
+use bcrypt::{DEFAULT_COST, hash, verify};
+use jsonwebtoken::{DecodingKey, EncodingKey, Header, Validation, decode, encode};
 use reqwest::{
     blocking::Client,
     header::{HeaderMap, HeaderName, HeaderValue},
 };
-use std::sync::Once;
+use serde_json::Value;
 use std::path::PathBuf;
+use std::sync::Once;
 use std::time::{SystemTime, UNIX_EPOCH};
-use serde_json::Value;
-use jsonwebtoken::{encode, decode, Header, EncodingKey, DecodingKey, Validation};
-use bcrypt::{hash, verify, DEFAULT_COST};
+use v8;
 
 use crate::utils::{blue, gray, green, parse_expires_in};
-use libloading::{Library};
-use walkdir::WalkDir;
-use std::sync::Mutex;
+use libloading::Library;
 use std::collections::HashMap;
 use std::fs;
+use std::sync::Mutex;
+use walkdir::WalkDir;
 
 // ----------------------------------------------------------------------------
 // GLOBAL REGISTRY
@@ -25,7 +25,7 @@ use std::fs;
 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,80 +73,188 @@ pub fn load_project_extensions(root: PathBuf) {
     let mut libs = Vec::new();
     let mut all_natives = Vec::new();
 
-    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;
-            }
+    // =====================================================
+    // 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());
         }
     }
-    
-    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 dir = entry.path().parent().unwrap();
-                let config_content = match fs::read_to_string(entry.path()) {
-                    Ok(c) => c,
-                    Err(_) => continue,
-                };
-                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),
-                         }
-                     }
-                }
+    // 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();
 
-                let js_path = dir.join(&config.main);
-                let js_content = fs::read_to_string(js_path).unwrap_or_default();
+    println!("{} Scanning extension directories:", blue("[Titan]"));
+    for d in &search_dirs {
+        println!("   • {}", d.display());
+    }
 
-                modules.push(ModuleDef {
-                    name: config.name.clone(),
-                    js: js_content,
-                    native_indices: mod_natives_map,
-                });
-                
-                println!("{} {} {}", blue("[Titan]"), green("Extension loaded:"), config.name);
+    // =====================================================
+    // 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 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) {
+                    Ok(c) => c,
+                    Err(e) => {
+                         println!("{} Failed to read JS main {} for extension {}: {}", 
+                            crate::utils::red("[Titan]"), 
+                            js_path.display(), 
+                            config.name, 
+                            e
+                        );
+                        continue;
+                    }
+                };
+   
+               modules.push(ModuleDef {
+                   name: config.name.clone(),
+                   js: js_content,
+                   native_indices: mod_natives_map,
+               });
+   
+               println!(
+                   "{} {} {}",
+                   blue("[Titan]"),
+                   green("Extension loaded:"),
+                   config.name
+               );
             }
         }
     }
 
-    *REGISTRY.lock().unwrap() = Some(Registry { _libs: libs, modules, natives: all_natives });
-}
+    // =====================================================
+    // 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,
+    });
+}
 
 static V8_INIT: Once = Once::new();
 
@@ -176,7 +284,11 @@ 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() {
@@ -195,7 +307,7 @@ fn native_read(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments,
     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 {
@@ -226,14 +338,18 @@ fn native_read(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments,
     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");
@@ -244,30 +360,38 @@ fn native_log(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments,
     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;
@@ -276,7 +400,7 @@ fn native_fetch(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments
     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()) {
@@ -284,18 +408,18 @@ fn native_fetch(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments
                 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()) {
@@ -305,57 +429,61 @@ fn native_fetch(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments
                     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());
@@ -364,33 +492,46 @@ fn native_fetch(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments
     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)),
+                );
+            }
         }
     }
 
@@ -406,33 +547,41 @@ fn native_jwt_sign(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArgume
     }
 }
 
-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()),
@@ -440,15 +589,23 @@ fn native_password_hash(scope: &mut v8::HandleScope, args: v8::FunctionCallbackA
     }
 }
 
-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));
 }
 
@@ -458,13 +615,17 @@ fn native_define_action(_scope: &mut v8::HandleScope, args: v8::FunctionCallback
 
 // 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) {
@@ -473,33 +634,39 @@ fn native_invoke_extension(scope: &mut v8::HandleScope, args: v8::FunctionCallba
             }
         }
     }
-    
+
     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");
@@ -508,13 +675,15 @@ 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");
@@ -524,7 +693,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");
@@ -534,12 +703,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());
 
@@ -547,16 +716,15 @@ 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");
@@ -574,60 +742,97 @@ pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Obje
     };
 
     for module in modules {
-         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);
-         }
+        // 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
+                );
+            }
+        }
     }
 
     // t.db (Stub for now)

package/templates/server/src/main.rs

@@ -1,28 +1,27 @@
-use std::{collections::HashMap, fs, path::PathBuf, sync::Arc};
 use anyhow::Result;
 use axum::{
-    body::{to_bytes, Body},
+    Router,
+    body::{Body, to_bytes},
     extract::State,
     http::{Request, StatusCode},
     response::{IntoResponse, Json},
     routing::any,
-    Router,
 };
 use serde_json::Value;
-use tokio::net::TcpListener;
 use std::time::Instant;
+use std::{collections::HashMap, fs, path::PathBuf, sync::Arc};
+use tokio::net::TcpListener;
 
 mod utils;
 
-mod extensions;
 mod action_management;
+mod extensions;
 
-use utils::{blue, white, yellow, green, gray, red};
-use extensions::{init_v8, inject_extensions};
 use action_management::{
-    resolve_actions_dir, find_actions_dir, match_dynamic_route, 
-    DynamicRoute, RouteVal
+    DynamicRoute, RouteVal, find_actions_dir, match_dynamic_route, resolve_actions_dir,
 };
+use extensions::{init_v8, inject_extensions};
+use utils::{blue, gray, green, red, white, yellow};
 
 #[derive(Clone)]
 struct AppState {
@@ -45,7 +44,6 @@ async fn dynamic_handler_inner(
     State(state): State<AppState>,
     req: Request<Body>,
 ) -> impl IntoResponse {
-
     // ---------------------------
     // BASIC REQUEST INFO
     // ---------------------------
@@ -70,10 +68,7 @@ async fn dynamic_handler_inner(
             q.split('&')
                 .filter_map(|pair| {
                     let mut it = pair.splitn(2, '=');
-                    Some((
-                        it.next()?.to_string(),
-                        it.next().unwrap_or("").to_string(),
-                    ))
+                    Some((it.next()?.to_string(), it.next().unwrap_or("").to_string()))
                 })
                 .collect()
         })
@@ -83,7 +78,7 @@ async fn dynamic_handler_inner(
     // HEADERS & BODY
     // ---------------------------
     let (parts, body) = req.into_parts();
-    
+
     let headers = parts
         .headers
         .iter()
@@ -92,9 +87,7 @@ async fn dynamic_handler_inner(
 
     let body_bytes = match to_bytes(body, usize::MAX).await {
         Ok(b) => b,
-        Err(_) => {
-            return (StatusCode::BAD_REQUEST, "Failed to read request body").into_response()
-        }
+        Err(_) => return (StatusCode::BAD_REQUEST, "Failed to read request body").into_response(),
     };
 
     let body_str = String::from_utf8_lossy(&body_bytes).to_string();
@@ -119,18 +112,32 @@ async fn dynamic_handler_inner(
             action_name = Some(name);
         } else if route.r#type == "json" {
             let elapsed = start.elapsed();
-            println!("{} {} {} {}", blue("[Titan]"), white(&format!("{} {}", method, path)), white("→ json"), gray(&format!("in {:.2?}", elapsed)));
+            println!(
+                "{} {} {} {}",
+                blue("[Titan]"),
+                white(&format!("{} {}", method, path)),
+                white("→ json"),
+                gray(&format!("in {:.2?}", elapsed))
+            );
             return Json(route.value.clone()).into_response();
         } else if let Some(s) = route.value.as_str() {
             let elapsed = start.elapsed();
-            println!("{} {} {} {}", blue("[Titan]"), white(&format!("{} {}", method, path)), white("→ reply"), gray(&format!("in {:.2?}", elapsed)));
+            println!(
+                "{} {} {} {}",
+                blue("[Titan]"),
+                white(&format!("{} {}", method, path)),
+                white("→ reply"),
+                gray(&format!("in {:.2?}", elapsed))
+            );
             return s.to_string().into_response();
         }
     }
 
     // Dynamic route
     if action_name.is_none() {
-        if let Some((action, p)) = match_dynamic_route(&method, &path, state.dynamic_routes.as_slice()) {
+        if let Some((action, p)) =
+            match_dynamic_route(&method, &path, state.dynamic_routes.as_slice())
+        {
             route_kind = "dynamic";
             route_label = action.clone();
             action_name = Some(action);
@@ -142,7 +149,13 @@ async fn dynamic_handler_inner(
         Some(a) => a,
         None => {
             let elapsed = start.elapsed();
-            println!("{} {} {} {}", blue("[Titan]"), white(&format!("{} {}", method, path)), white("→ 404"), gray(&format!("in {:.2?}", elapsed)));
+            println!(
+                "{} {} {} {}",
+                blue("[Titan]"),
+                white(&format!("{} {}", method, path)),
+                white("→ 404"),
+                gray(&format!("in {:.2?}", elapsed))
+            );
             return (StatusCode::NOT_FOUND, "Not Found").into_response();
         }
     };
@@ -151,7 +164,8 @@ async fn dynamic_handler_inner(
     // LOAD ACTION
     // ---------------------------
     let resolved = resolve_actions_dir();
-    let actions_dir = resolved.exists()
+    let actions_dir = resolved
+        .exists()
         .then(|| resolved)
         .or_else(|| find_actions_dir(&state.project_root))
         .unwrap();
@@ -164,17 +178,24 @@ async fn dynamic_handler_inner(
         }
     }
 
-    let js_code = match fs::read_to_string(&action_path) {
-        Ok(c) => c,
-        Err(_) => {
-             return (StatusCode::INTERNAL_SERVER_ERROR, Json(serde_json::json!({"error": "Action bundle not found", "action": action_name}))).into_response()
-        }
-    };
+    let js_code =
+        match fs::read_to_string(&action_path) {
+            Ok(c) => c,
+            Err(_) => return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(
+                    serde_json::json!({"error": "Action bundle not found", "action": action_name}),
+                ),
+            )
+                .into_response(),
+        };
 
     // ---------------------------
     // EXECUTE IN V8
     // ---------------------------
-    let env_json = std::env::vars().map(|(k, v)| (k, Value::String(v))).collect::<serde_json::Map<_, _>>();
+    let env_json = std::env::vars()
+        .map(|(k, v)| (k, Value::String(v)))
+        .collect::<serde_json::Map<_, _>>();
 
     let injected = format!(
         r#"
@@ -215,43 +236,42 @@ async fn dynamic_handler_inner(
     // We can use `task::spawn_blocking`.
     let root = state.project_root.clone();
     let action_name_for_v8 = action_name.clone();
-    
+
     let result_json: Value = tokio::task::spawn_blocking(move || {
         let isolate = &mut v8::Isolate::new(v8::CreateParams::default());
         let handle_scope = &mut v8::HandleScope::new(isolate);
         let context = v8::Context::new(handle_scope, v8::ContextOptions::default());
         let scope = &mut v8::ContextScope::new(handle_scope, context);
-        
+
         let global = context.global(scope);
 
         // Inject extensions (t.read, etc)
         inject_extensions(scope, global);
-        
-        // Set metadata globals
+
         // Set metadata globals
         let root_str = v8::String::new(scope, root.to_str().unwrap_or(".")).unwrap();
         let root_key = v8::String::new(scope, "__titan_root").unwrap();
         global.set(scope, root_key.into(), root_str.into());
-        
+
         let action_str = v8::String::new(scope, &action_name_for_v8).unwrap();
         let action_key = v8::String::new(scope, "__titan_action").unwrap();
         global.set(scope, action_key.into(), action_str.into());
-        
+
         let source = v8::String::new(scope, &injected).unwrap();
-        
+
         let try_catch = &mut v8::TryCatch::new(scope);
-        
+
         let script = match v8::Script::compile(try_catch, source, None) {
-             Some(s) => s,
-             None => {
-                 let err = try_catch.message().unwrap();
-                 let msg = err.get(try_catch).to_rust_string_lossy(try_catch);
-                 return serde_json::json!({ "error": msg, "phase": "compile" });
-             }
+            Some(s) => s,
+            None => {
+                let err = try_catch.message().unwrap();
+                let msg = err.get(try_catch).to_rust_string_lossy(try_catch);
+                return serde_json::json!({ "error": msg, "phase": "compile" });
+            }
         };
-        
+
         let result = script.run(try_catch);
-        
+
         match result {
             Some(val) => {
                 // Convert v8 Value to Serde JSON
@@ -259,37 +279,59 @@ async fn dynamic_handler_inner(
                 let json_obj = v8::json::stringify(try_catch, val).unwrap();
                 let json_str = json_obj.to_rust_string_lossy(try_catch);
                 serde_json::from_str(&json_str).unwrap_or(Value::Null)
-            },
+            }
             None => {
-                 let err = try_catch.message().unwrap();
-                 let msg = err.get(try_catch).to_rust_string_lossy(try_catch);
-                 serde_json::json!({ "error": msg, "phase": "execution" })
+                let err = try_catch.message().unwrap();
+                let msg = err.get(try_catch).to_rust_string_lossy(try_catch);
+                serde_json::json!({ "error": msg, "phase": "execution" })
             }
         }
-    }).await.unwrap_or(serde_json::json!({"error": "V8 task failed"}));
+    })
+    .await
+    .unwrap_or(serde_json::json!({"error": "V8 task failed"}));
 
     // ---------------------------
     // FINAL LOG
     // ---------------------------
     let elapsed = start.elapsed();
-    
+
     // Check for errors in result
     if let Some(err) = result_json.get("error") {
-        println!("{} {} {} {}", blue("[Titan]"), red(&format!("{} {}", method, path)), red("→ error"), gray(&format!("in {:.2?}", elapsed)));
+        println!(
+            "{} {} {} {}",
+            blue("[Titan]"),
+            red(&format!("{} {}", method, path)),
+            red("→ error"),
+            gray(&format!("in {:.2?}", elapsed))
+        );
         println!("{}", red(err.as_str().unwrap_or("Unknown")));
         return (StatusCode::INTERNAL_SERVER_ERROR, Json(result_json)).into_response();
     }
 
     match route_kind {
-        "dynamic" => println!("{} {} {} {} {} {}", blue("[Titan]"), green(&format!("{} {}", method, path)), white("→"), green(&route_label), white("(dynamic)"), gray(&format!("in {:.2?}", elapsed))),
-        "exact" => println!("{} {} {} {} {}", blue("[Titan]"), white(&format!("{} {}", method, path)), white("→"), yellow(&route_label), gray(&format!("in {:.2?}", elapsed))),
+        "dynamic" => println!(
+            "{} {} {} {} {} {}",
+            blue("[Titan]"),
+            green(&format!("{} {}", method, path)),
+            white("→"),
+            green(&route_label),
+            white("(dynamic)"),
+            gray(&format!("in {:.2?}", elapsed))
+        ),
+        "exact" => println!(
+            "{} {} {} {} {}",
+            blue("[Titan]"),
+            white(&format!("{} {}", method, path)),
+            white("→"),
+            yellow(&route_label),
+            gray(&format!("in {:.2?}", elapsed))
+        ),
         _ => {}
     }
 
     Json(result_json).into_response()
 }
 
-
 // Entrypoint ---------------------------------------------------------------
 
 #[tokio::main]
@@ -304,28 +346,22 @@ async fn main() -> Result<()> {
     let port = json["__config"]["port"].as_u64().unwrap_or(3000);
     let routes_json = json["routes"].clone();
     let map: HashMap<String, RouteVal> = serde_json::from_value(routes_json).unwrap_or_default();
-    let dynamic_routes: Vec<DynamicRoute> = serde_json::from_value(json["__dynamic_routes"].clone()).unwrap_or_default();
+    let dynamic_routes: Vec<DynamicRoute> =
+        serde_json::from_value(json["__dynamic_routes"].clone()).unwrap_or_default();
 
-    // Project root — heuristics
-    let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
-    // Ensure we find the 'app' directory as sibling if running from 'server'
-    let project_root = if cwd.join("../app").exists() {
-        cwd.join("../app")
-    } else {
-        cwd
-    };
+    // Identify project root (where .ext or node_modules lives)
+    let project_root = resolve_project_root();
 
     let state = AppState {
         routes: Arc::new(map),
         dynamic_routes: Arc::new(dynamic_routes),
         project_root: project_root.clone(),
     };
-    
+
     // Load extensions
     extensions::load_project_extensions(project_root.clone());
 
     let app = Router::new()
-
         .route("/", any(root_route))
         .fallback(any(dynamic_route))
         .with_state(state);
@@ -338,8 +374,38 @@ async fn main() -> Result<()> {
     println!("   ██║   ██║   ██║   ██╔══██║██║╚██╗██║");
     println!("   ██║   ██║   ██║   ██║  ██║██║ ╚████║");
     println!("   ╚═╝   ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═══╝\x1b[0m\n");
-    println!("\x1b[38;5;39mTitan server running at:\x1b[0m http://localhost:{}", port);
+    println!(
+        "\x1b[38;5;39mTitan server running at:\x1b[0m http://localhost:{}",
+        port
+    );
 
     axum::serve(listener, app).await?;
     Ok(())
 }
+
+fn resolve_project_root() -> PathBuf {
+    // 1. Check CWD (preferred for local dev/tooling)
+    if let Ok(cwd) = std::env::current_dir() {
+        if cwd.join("node_modules").exists()
+            || cwd.join("package.json").exists()
+            || cwd.join(".ext").exists()
+        {
+            return cwd;
+        }
+    }
+
+    // 2. Check executable persistence (Docker / Production)
+    // Walk up from the executable to find .ext or node_modules
+    if let Ok(exe) = std::env::current_exe() {
+        let mut current = exe.parent();
+        while let Some(dir) = current {
+            if dir.join(".ext").exists() || dir.join("node_modules").exists() {
+                return dir.to_path_buf();
+            }
+            current = dir.parent();
+        }
+    }
+
+    // 3. Fallback to CWD
+    std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
+}