@ezetgalaxy/titan 26.4.1 → 26.6.0

package/README.md

@@ -138,7 +138,7 @@ Titan now includes a **complete runtime engine** with the following built-in cap
 
 ### 🧠 Action Runtime
 
-* JavaScript actions executed inside a Rust runtime (Boa)
+* JavaScript actions executed inside a Rust runtime (v8)
 * Automatic action discovery and execution
 * No `globalThis` required anymore
 * Safe handling of `undefined` returns
@@ -162,7 +162,26 @@ Each action receives a normalized request object:
   "path": "/user/90",
   "params": { "id": "90" },
   "query": {},
-  "body": null
+  "body": null,
+
+  "headers": {
+    "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+    "accept-encoding": "gzip, deflate, br, zstd",
+    "accept-language": "en-US,en;q=0.9",
+    "cache-control": "max-age=0",
+    "connection": "keep-alive",
+    "cookie": "",
+    "host": "localhost:3000",
+    "sec-ch-ua": "\"Google Chrome\";v=\"143\", \"Chromium\";v=\"143\", \"Not A(Brand\";v=\"24\"",
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": "\"Windows\"",
+    "sec-fetch-dest": "document",
+    "sec-fetch-mode": "navigate",
+    "sec-fetch-site": "none",
+    "sec-fetch-user": "?1",
+    "upgrade-insecure-requests": "1",
+    "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36"
+  },
 }
 ```
 

package/index.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 import fs from "fs";
 import path from "path";
 import { execSync, spawn } from "child_process";
@@ -78,15 +78,20 @@ const TITAN_VERSION = pkg.version;
 /* -------------------------------------------------------
  * Utils
  * ----------------------------------------------------- */
-function copyDir(src, dest) {
+function copyDir(src, dest, excludes = []) {
     fs.mkdirSync(dest, { recursive: true });
 
     for (const file of fs.readdirSync(src)) {
+        // Skip excluded files/folders
+        if (excludes.includes(file)) {
+            continue;
+        }
+
         const srcPath = path.join(src, file);
         const destPath = path.join(dest, file);
 
         if (fs.lstatSync(srcPath).isDirectory()) {
-            copyDir(srcPath, destPath);
+            copyDir(srcPath, destPath, excludes);
         } else {
             fs.copyFileSync(srcPath, destPath);
         }
@@ -101,6 +106,7 @@ function help() {
 ${bold(cyan("Titan Planet"))}  v${TITAN_VERSION}
 
 ${green("titan init <project>")}   Create new Titan project
+${green("titan create ext <name>")} Create new Titan extension
 ${green("titan dev")}              Dev mode (hot reload)
 ${green("titan build")}            Build production Rust server
 ${green("titan start")}            Start production binary
@@ -131,9 +137,9 @@ function initProject(name) {
     console.log(cyan(`Creating Titan project → ${target}`));
 
     // ----------------------------------------------------------
-    // 1. Copy full template directory
+    // 1. Copy full template directory (excluding extension folder)
     // ----------------------------------------------------------
-    copyDir(templateDir, target);
+    copyDir(templateDir, target, ["extension"]);
 
     // ----------------------------------------------------------
     // 2. Explicitly install dotfiles
@@ -366,20 +372,223 @@ function updateTitan() {
 
 
 
+/* -------------------------------------------------------
+ * CREATE EXTENSION
+ * ----------------------------------------------------- */
+function createExtension(name) {
+    if (!name) {
+        console.log(red("Usage: titan create ext <name>"));
+        return;
+    }
+
+
+    const folderName = name;
+
+    const target = path.join(process.cwd(), folderName);
+    const templateDir = path.join(__dirname, "templates", "extension");
+
+    if (fs.existsSync(target)) {
+        console.log(yellow(`Folder already exists: ${target}`));
+        return;
+    }
+
+    if (!fs.existsSync(templateDir)) {
+        console.log(red(`Extension template not found at ${templateDir}`));
+        return;
+    }
+
+    console.log(cyan(`Creating Titan extension → ${target}`));
+
+    // 1. Copy template
+    copyDir(templateDir, target);
+
+    // 2. Process templates (replace {{name}})
+    const title = name;
+
+    // 2a. titan.json
+    const titJsonPath = path.join(target, "titan.json");
+    if (fs.existsSync(titJsonPath)) {
+        let content = fs.readFileSync(titJsonPath, "utf8");
+        content = content.replace(/{{name}}/g, title);
+        fs.writeFileSync(titJsonPath, content);
+    }
+
+    // 2b. index.js
+    const idxPath = path.join(target, "index.js");
+    if (fs.existsSync(idxPath)) {
+        let content = fs.readFileSync(idxPath, "utf8");
+        content = content.replace(/{{name}}/g, title);
+        fs.writeFileSync(idxPath, content);
+    }
+
+    // 2c. README.md
+    const readmePath = path.join(target, "README.md");
+    if (fs.existsSync(readmePath)) {
+        let content = fs.readFileSync(readmePath, "utf8");
+        content = content.replace(/{{name}}/g, title);
+        fs.writeFileSync(readmePath, content);
+    }
+
+    // 2d. package.json
+    const pkgPath = path.join(target, "package.json");
+    if (fs.existsSync(pkgPath)) {
+        let content = fs.readFileSync(pkgPath, "utf8");
+        content = content.replace(/{{name}}/g, title);
+        fs.writeFileSync(pkgPath, content);
+    }
+
+    // 2e. native/Cargo.toml
+    const cargoPath = path.join(target, "native", "Cargo.toml");
+    if (fs.existsSync(cargoPath)) {
+        let content = fs.readFileSync(cargoPath, "utf8");
+        content = content.replace(/{{name}}/g, title);
+        fs.writeFileSync(cargoPath, content);
+    }
+
+    console.log(cyan("Installing dependencies..."));
+    try {
+        execSync("npm install", { cwd: target, stdio: "inherit" });
+    } catch (e) {
+        console.log(yellow("Warning: Failed to install dependencies. You may need to run `npm install` manually."));
+    }
+
+    console.log(green("✔ Extension created!"));
+    console.log(`
+Next steps:
+  cd ${name}
+  # If you have native code:
+  cd native && cargo build --release
+  # To test your extension
+  titan run ext
+`);
+}
+
+function runExtension() {
+    const cwd = process.cwd();
+    const manifestPath = path.join(cwd, "titan.json");
+
+    if (!fs.existsSync(manifestPath)) {
+        console.log(red("Error: titan.json not found. Are you in an extension folder?"));
+        return;
+    }
+
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    const name = manifest.name;
+    console.log(cyan(`Preparing to run extension: ${name}`));
+
+    // 1. Build Native if exists
+    const nativeDir = path.join(cwd, "native");
+    if (fs.existsSync(nativeDir)) {
+        console.log(cyan("Building native module..."));
+        try {
+            execSync("cargo build --release", { cwd: nativeDir, stdio: "inherit" });
+        } catch (e) {
+            console.log(red("Native build failed."));
+            return;
+        }
+    }
+
+    // 2. Setup Temporary Runner
+    const runnerDir = path.join(cwd, ".titan_runner");
+    if (fs.existsSync(runnerDir)) {
+        fs.rmSync(runnerDir, { recursive: true, force: true });
+    }
+
+    // We need to create a project environment. 
+    // We can use the templates stored in __dirname
+    const templateDir = path.join(__dirname, "templates");
+
+    console.log(cyan("Setting up test harness..."));
+    fs.mkdirSync(runnerDir);
+
+    // Copy templates/app -> runner/app
+    const runnerApp = path.join(runnerDir, "app");
+    copyDir(path.join(templateDir, "app"), runnerApp);
+
+    // Copy templates/server -> runner/server
+    const runnerServer = path.join(runnerDir, "server");
+    copyDir(path.join(templateDir, "server"), runnerServer);
+
+    // Create a dummy app.js that uses the extension
+    const appJsContent = `
+    const extensionName = "${name}";
+    t.log("TestRunner", "Loading extension: " + extensionName);
+    
+    // Access the extension
+    if (t[extensionName]) {
+        t.log("TestRunner", "Extension found on 't'!");
+        if (t[extensionName].hello) {
+             t[extensionName].hello("Titan User");
+        }
+        if (t[extensionName].calc) {
+             const res = t[extensionName].calc(10, 50);
+             t.log("TestRunner", "Calc Result (10+50): " + res);
+        }
+    } else {
+        t.log("TestRunner", "ERROR: Extension not found on 't'");
+    }
+    `;
+    fs.writeFileSync(path.join(runnerApp, "app.js"), appJsContent);
+
+    // 3. Link Extension
+    // We need to simulate 'node_modules/extension_name'
+    const runnerNodeModules = path.join(runnerDir, "node_modules");
+    fs.mkdirSync(runnerNodeModules, { recursive: true });
+
+    const extLinkPath = path.join(runnerNodeModules, name);
+    // On Windows, symlinks require special permissions, usually. 
+    // Junctions are safer for directories.
+    try {
+        fs.symlinkSync(cwd, extLinkPath, "junction");
+    } catch (e) {
+        // Fallback to copy if symlink fails
+        console.log(yellow("Symlink failed, copying extension..."));
+        copyDir(cwd, extLinkPath);
+    }
+
+    console.log(cyan("Building test harness server... (this may take a minute)"));
+    try {
+        execSync("cargo build --release", { cwd: runnerServer, stdio: "inherit" });
+    } catch (e) {
+        console.log(red("Failed to build test server."));
+        return;
+    }
+
+    // 5. Run it
+    const isWin = process.platform === "win32";
+    const bin = isWin ? "titan-server.exe" : "titan-server";
+    const exe = path.join(runnerServer, "target", "release", bin);
+
+    console.log(bold(green("\n>>> STARTING EXTENSION TEST >>>\n")));
+    try {
+        // Run inside the runner directory so it finds app/, server/, etc.
+        execSync(`"${exe}"`, { cwd: runnerDir, stdio: "inherit" });
+    } catch (e) {
+        console.log(red("\nTest ended with error or was stopped."));
+    }
+}
+
 /* -------------------------------------------------------
  * ROUTER
  * ----------------------------------------------------- */
-switch (cmd) {
-    case "init": initProject(args[1]); break;
-    case "dev": devServer(); break;
-    case "build": buildProd(); break;
-    case "start": startProd(); break;
-    case "update": updateTitan(); break;
-    case "--version":
-    case "-v":
-    case "version":
-        console.log(cyan(`Titan v${TITAN_VERSION}`));
-        break;
-    default:
-        help();
+// "titan create ext <name>" -> args = ["create", "ext", "calc_ext"]
+if (cmd === "create" && args[1] === "ext") {
+    createExtension(args[2]);
+} else if (cmd === "run" && args[1] === "ext") {
+    runExtension();
+} else {
+    switch (cmd) {
+        case "init": initProject(args[1]); break;
+        case "dev": devServer(); break;
+        case "build": buildProd(); break;
+        case "start": startProd(); break;
+        case "update": updateTitan(); break;
+        case "--version":
+        case "-v":
+        case "version":
+            console.log(cyan(`Titan v${TITAN_VERSION}`));
+            break;
+        default:
+            help();
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "26.4.1",
+  "version": "26.6.0",
   "description": "Titan Planet is a JavaScript-first backend framework that embeds JS actions into a Rust + Axum server and ships as a single native binary. Routes are compiled to static metadata; only actions run in the embedded JS runtime. No Node.js. No event loop in production.",
   "license": "ISC",
   "author": "ezetgalaxy",

package/templates/extension/README.md

@@ -0,0 +1,104 @@
+# 🪐 Titan Extension: {{name}}
+
+> Elevate Titan Planet with custom JavaScript and high-performance Native Rust logic.
+
+Welcome to your new Titan extension! This template provides everything you need to build, test, and deploy powerful additions to the Titan project.
+
+---
+
+## 🛠 Project Structure
+
+- `index.js`: The JavaScript entry point where you define your extension's API on the global `t` object.
+- `titan.json`: Manifest file defining extension metadata and Native module mappings.
+- `native/`: Directory for Rust source code.
+  - `src/lib.rs`: Your Native function implementations.
+  - `Cargo.toml`: Rust package and dependency configuration.
+- `jsconfig.json`: Enables full IntelliSense for the Titan Runtime API.
+
+---
+
+## 🚀 Quick Start
+
+### 1. Install Dependencies
+Get full type support in your IDE:
+```bash
+npm install
+```
+
+### 2. Build Native Module (Optional)
+If your extension uses Rust, compile it to a dynamic library:
+```bash
+cd native
+cargo build --release
+cd ..
+```
+
+### 3. Test the Extension
+Use the Titan SDK to run a local test harness:
+```bash
+titan run ext
+```
+*Tip: Visit `http://localhost:3000/test` after starting the runner to see your extension in action!*
+
+---
+
+## 💻 Development Guide
+
+### Writing JavaScript
+Extensions interact with the global `t` object. It's best practice to namespace your extension:
+
+```javascript
+t.{{name}} = {
+    myMethod: (val) => {
+        t.log("{{name}}", "Doing something...");
+        return val * 2;
+    }
+};
+```
+
+### Writing Native Rust Functions
+Native functions should be marked with `#[unsafe(no_mangle)]` and use `extern "C"`:
+
+```rust
+#[unsafe(no_mangle)]
+pub extern "C" fn multiply(a: f64, b: f64) -> f64 {
+    a * b
+}
+```
+
+### Mapping Native Functions in `titan.json`
+Expose your Rust functions to JavaScript by adding them to the `native.functions` section:
+
+```json
+"functions": {
+    "add": {
+        "symbol": "add",
+        "parameters": ["f64", "f64"],
+        "result": "f64"
+    }
+}
+```
+
+---
+
+## 🧪 Testing with Titan SDK
+
+The `titan run ext` command automates the testing workflow:
+1. It builds your native code.
+2. It sets up a temporary Titan project environment.
+3. It links your extension into `node_modules`.
+4. It starts the Titan Runtime at `http://localhost:3000`.
+
+You can modify the test harness or add custom test cases by exploring the generated `.titan_test_run` directory (it is git-ignored).
+
+---
+
+## 📦 Deployment
+To use your extension in a Titan project:
+1. Publish your extension to npm or link it locally.
+2. In your Titan project: `npm install my-extension`.
+3. The Titan Runtime will automatically detect and load your extension if it contains a `titan.json`.
+
+---
+
+Happy coding on Titan Planet! 🚀

package/templates/extension/index.js

@@ -0,0 +1,26 @@
+/**
+ * Titan Extension Entry Point
+ * You can attach methods to the global `t` object here.
+ */
+
+// Define your extension Key
+const EXT_KEY = "{{name}}";
+
+t.log(EXT_KEY, "Extension loading...");
+
+t[EXT_KEY] = {
+    // Example pure JavaScript function
+    hello: function (name) {
+        t.log(EXT_KEY, `Hello ${name} from ${EXT_KEY}!`);
+        return `Hello ${name}!`;
+    },
+
+    // Example Wrapper for Native function
+    calc: function (a, b) {
+        t.log(EXT_KEY, `Calculating ${a} + ${b} natively...`);
+        // Assumes the native function 'add' is mapped in titan.json
+        return t[EXT_KEY].add(a, b);
+    }
+};
+
+t.log(EXT_KEY, "Extension loaded!");

package/templates/extension/jsconfig.json

@@ -0,0 +1,13 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es2021",
+        "checkJs": false,
+        "allowJs": true,
+        "moduleResolution": "node"
+    },
+    "include": [
+        "index.js",
+        "node_modules/titan-sdk/index.d.ts"
+    ]
+}

package/templates/extension/native/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "{{name}}_native"
+version = "0.1.0"
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]

package/templates/extension/native/src/lib.rs

@@ -0,0 +1,5 @@
+
+#[unsafe(no_mangle)]
+pub extern "C" fn add(a: f64, b: f64) -> f64 {
+    a + b
+}

package/templates/extension/package.json

@@ -0,0 +1,19 @@
+{
+    "name": "{{name}}",
+    "version": "1.0.0",
+    "description": "A Titan Planet extension",
+    "main": "index.js",
+    "type": "commonjs",
+    "scripts": {
+        "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "keywords": [
+        "titan",
+        "extension"
+    ],
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+        "titan-sdk": "latest"
+    }
+}

package/templates/extension/titan.json

@@ -0,0 +1,18 @@
+{
+    "name": "{{name}}",
+    "main": "index.js",
+    "description": "A Titan extension",
+    "native": {
+        "path": "native/target/release/{{name}}_native.dll",
+        "functions": {
+            "add": {
+                "symbol": "add",
+                "parameters": [
+                    "f64",
+                    "f64"
+                ],
+                "result": "f64"
+            }
+        }
+    }
+}

package/templates/server/Cargo.toml

@@ -23,3 +23,5 @@ regex = "1.10"
 bcrypt = "0.15"
 jsonwebtoken = "9"
 postgres = { version = "0.19", features = ["with-serde_json-1"] }
+libloading = "0.8"
+walkdir = "2"

package/templates/server/src/errors.rs

@@ -1,6 +1,6 @@
 use v8::JsError;
 
-// A helper to Format Boa Errors
+// A helper to Format v8 Errors
 pub fn format_js_error(err: JsError, action: &str) -> String {
     format!(
         "Action: {}\n{}",

package/templates/server/src/extensions.rs

@@ -1,3 +1,4 @@
+#![allow(unused)]
 use v8;
 use reqwest::{
     blocking::Client,
@@ -10,7 +11,142 @@ use serde_json::Value;
 use jsonwebtoken::{encode, decode, Header, EncodingKey, DecodingKey, Validation};
 use bcrypt::{hash, verify, DEFAULT_COST};
 
-use crate::utils::{blue, gray, parse_expires_in};
+use crate::utils::{blue, gray, green, parse_expires_in};
+use libloading::{Library};
+use walkdir::WalkDir;
+use std::sync::Mutex;
+use std::collections::HashMap;
+use std::fs;
+
+// ----------------------------------------------------------------------------
+// GLOBAL REGISTRY
+// ----------------------------------------------------------------------------
+
+static REGISTRY: Mutex<Option<Registry>> = Mutex::new(None);
+#[allow(dead_code)]
+struct Registry {
+    _libs: Vec<Library>, 
+    modules: Vec<ModuleDef>,
+    natives: Vec<NativeFnEntry>, // Flattened list of all native functions
+}
+
+#[derive(Clone)]
+struct ModuleDef {
+    name: String,
+    js: String,
+    native_indices: HashMap<String, usize>, // Function Name -> Index in REGISTRY.natives
+}
+
+struct NativeFnEntry {
+    ptr: usize,
+    sig: Signature,
+}
+
+#[derive(Clone, Copy)]
+enum Signature {
+    F64TwoArgsRetF64,
+    Unknown,
+}
+
+#[derive(serde::Deserialize)]
+struct TitanConfig {
+    name: String,
+    main: String,
+    native: Option<TitanNativeConfig>,
+}
+#[derive(serde::Deserialize)]
+struct TitanNativeConfig {
+    path: String,
+    functions: HashMap<String, TitanNativeFunc>,
+}
+#[derive(serde::Deserialize)]
+struct TitanNativeFunc {
+    symbol: String,
+    #[serde(default)]
+    parameters: Vec<String>,
+    #[serde(default)]
+    result: String,
+}
+
+pub fn load_project_extensions(root: PathBuf) {
+    let mut modules = Vec::new();
+    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;
+            }
+        }
+    }
+    
+    if node_modules.exists() {
+        for entry in WalkDir::new(&node_modules).min_depth(1).max_depth(2) {
+            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),
+                         }
+                     }
+                }
+
+                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);
+            }
+        }
+    }
+
+    *REGISTRY.lock().unwrap() = Some(Registry { _libs: libs, modules, natives: all_natives });
+}
+
 
 static V8_INIT: Once = Once::new();
 
@@ -316,12 +452,63 @@ fn native_define_action(_scope: &mut v8::HandleScope, args: v8::FunctionCallback
     retval.set(args.get(0));
 }
 
+// ----------------------------------------------------------------------------
+// NATIVE CALLBACKS (EXTENSIONS)
+// ----------------------------------------------------------------------------
+
+// generic wrappers could go here if needed
+
+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) {
+                ptr = entry.ptr;
+                sig = entry.sig;
+            }
+        }
+    }
+    
+    if ptr == 0 {
+         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());
+             }
+        },
+        _ => 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");
+    global.set(scope, gt_key.into(), global.into());
+
     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();
 
     // defineAction (identity function for clean typing)
     let def_fn = v8::Function::new(scope, native_define_action).unwrap();
@@ -369,6 +556,80 @@ pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Obje
     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");
+    global.set(scope, invoke_key.into(), invoke_fn.into());
+
+    // Inject Loaded Extensions
+    let modules = if let Ok(guard) = REGISTRY.lock() {
+        if let Some(registry) = &*guard {
+            registry.modules.clone()
+        } else {
+            Vec::new()
+        }
+    } else {
+        Vec::new()
+    };
+
+    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);
+         }
+    }
+
     // t.db (Stub for now)
     let db_obj = v8::Object::new(scope);
     let db_key = v8_str(scope, "db");

package/templates/server/src/main.rs

@@ -156,7 +156,14 @@ async fn dynamic_handler_inner(
         .or_else(|| find_actions_dir(&state.project_root))
         .unwrap();
 
-    let action_path = actions_dir.join(format!("{}.jsbundle", action_name));
+    let mut action_path = actions_dir.join(format!("{}.jsbundle", action_name));
+    if !action_path.exists() {
+        let js_path = actions_dir.join(format!("{}.js", action_name));
+        if js_path.exists() {
+            action_path = js_path;
+        }
+    }
+
     let js_code = match fs::read_to_string(&action_path) {
         Ok(c) => c,
         Err(_) => {
@@ -311,10 +318,14 @@ async fn main() -> Result<()> {
     let state = AppState {
         routes: Arc::new(map),
         dynamic_routes: Arc::new(dynamic_routes),
-        project_root,
+        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);

package/templates/titan/dev.js

@@ -2,6 +2,7 @@ import chokidar from "chokidar";
 import { spawn, execSync } from "child_process";
 import path from "path";
 import { fileURLToPath } from "url";
+import fs from "fs";
 import { bundle } from "./bundle.js";
 
 // Required for __dirname in ES modules
@@ -17,8 +18,6 @@ async function killServer() {
     const killPromise = new Promise((resolve) => {
         if (serverProcess.exitCode !== null) return resolve();
         serverProcess.once("close", resolve);
-        // Fallback timeout in case close never fires? 
-        // usually close fires after kill.
     });
 
     if (process.platform === "win32") {
@@ -68,6 +67,10 @@ async function rebuild() {
 async function startDev() {
     console.log("[Titan] Dev mode starting...");
 
+    if (fs.existsSync(path.join(process.cwd(), ".env"))) {
+        console.log("\x1b[33m[Titan] Env Configured\x1b[0m");
+    }
+
     // FIRST BUILD
     try {
         await rebuild();
@@ -76,7 +79,7 @@ async function startDev() {
         console.log("\x1b[31m[Titan] Initial build failed. Waiting for changes...\x1b[0m");
     }
 
-    const watcher = chokidar.watch("app", {
+    const watcher = chokidar.watch(["app", ".env"], {
         ignoreInitial: true
     });
 
@@ -86,7 +89,11 @@ async function startDev() {
         if (timer) clearTimeout(timer);
 
         timer = setTimeout(async () => {
-            console.log(`[Titan] Change detected: ${file}`);
+            if (file.includes(".env")) {
+                console.log("\x1b[33m[Titan] Env Refreshed\x1b[0m");
+            } else {
+                console.log(`[Titan] Change detected: ${file}`);
+            }
 
             try {
                 await rebuild();