@ezetgalaxy/titan 25.14.5 → 25.14.7

package/README.md

@@ -1,339 +1,344 @@
-
-```
-████████╗██╗████████╗ █████╗ ███╗   ██╗
-╚══██╔══╝██║╚══██╔══╝██╔══██╗████╗  ██║
-   ██║   ██║   ██║   ███████║██╔██╗ ██║
-   ██║   ██║   ██║   ██╔══██║██║╚██╗██║
-   ██║   ██║   ██║   ██║  ██║██║ ╚████║
-   ╚═╝   ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═══╝
-```
-
-# TITAN PLANET 🚀
-
-**JavaScript Simplicity. Rust Power. Zero Configuration.**
-
-Titan Planet is a JavaScript-first backend framework that compiles your JavaScript routes and actions into a **native Rust + Axum server**.
-
-You write **zero Rust**.
-Titan ships a full backend engine, dev server, bundler, router, action runtime, and Docker deploy pipeline — all powered by Rust under the hood.
-
-Titan = JavaScript productivity × Rust performance × Zero DevOps.
-
----
-
-# 🌌 Why Titan?
-
-| Feature                              | Titan | Express/Nest | FastAPI | Bun       |
-| ------------------------------------ | ----- | ------------ | ------- | --------- |
-| Native binary output                 | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
-| Rust-level performance               | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
-| Pure JavaScript developer experience | ✅ Yes | ✅ Yes        | ❌ No    | ❌ Partial |
-| Zero-config Docker deploy            | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
-| Action-based architecture            | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
-| Hot reload dev server                | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
-
-Titan gives you:
-
-* Native speed
-* JS comfort
-* Cloud-first deployment
-* Full environment variable support
-* Built-in HTTP client (`t.fetch`)
-* Lightweight serverless-like actions
-* Instant hot reload
-* Zero configuration
-* Single deployable binary
-
----
-
-# 🚀 Quick Start
-
-
-# ⚙ Requirements
-
-Install before using Titan:
-
-### 1. Rust (latest stable)
-
-[https://rust-lang.org/tools/install/](https://rust-lang.org/tools/install/)
-
-### 2. Node.js (v18+)
-
-Required for:
-
-* Titan CLI
-* esbuild
-* JS → Rust compilation pipeline
-
-Verify:
-
-```bash
-node -v
-npm -v
-rustc -V
-```
-
----
-
-### Install Titan CLI
-
-```bash
-npm install -g @ezetgalaxy/titan
-```
-
-### Create a new project
-
-```bash
-tit init my-app
-cd my-app
-tit dev
-```
-
-Titan will:
-
-* Build routes
-* Bundle actions
-* Start Rust dev server
-* Watch file changes
-* Trigger instant reload
-
----
-
-# 📁 Project Layout
-
-```
-my-app/
-├── app/                                  # You develop ONLY this folder
-│   ├── app.js                             # Titan routes (DSL)
-│   └── actions/                           # Your custom JS actions
-│       └── hello.js                       # Example Titan action
-
-───────────────────────────────────────────────────────────────
-  Everything below is auto-generated by `tit init`
-  You never modify these folders manually
-───────────────────────────────────────────────────────────────
-
-├── titan/                                # Titan's internal JS engine
-│   ├── titan.js                           # Titan DSL runtime
-│   ├── bundle.js                          # JS → .jsbundle bundler
-│   └── dev.js                             # Hot Reload system
-│
-├── server/                               # Auto-generated Rust backend
-│   ├── Cargo.toml                         # Rust project config
-│   ├── src/                               # Rust source code
-│   ├── actions/                           # Compiled .jsbundle actions
-│   ├── titan/                             # Internal Rust runtime files
-│   ├── routes.json                        # Generated route metadata
-│   ├── action_map.json                    # Maps actions to bundles
-│   └── titan-server                       # Final production Rust binary
-│
-├── Dockerfile                             # Auto-generated production Dockerfile
-├── .dockerignore                          # Auto-generated Docker ignore rules
-├── package.json                           # JS project config (auto)
-└── .gitignore                             # Auto-generated by `tit init`
-
-```
-
----
-
-# 🛣 Example Route
-
-**app/app.js**
-
-```js
-import t from "../titan/titan.js";
-
-t.post("/hello").action("hello");
-t.get("/").reply("Welcome to Titan Planet");
-
-t.start(3000, "Ready to land on Titan 🚀");
-```
-
----
-
-# 🧩 Example Action
-
-**app/actions/hello.js**
-
-```js
-export function hello(req) {
-  return { message: "Hello from Titan!" };
-}
-
-globalThis.hello = hello;
-```
-
----
-
-# ⚡ New: Built-In HTTP Fetch (`t.fetch`)
-
-Titan now includes a built-in server-side `fetch` bridge powered by Rust.
-
-Use it to call any external API:
-
-```js
-export function hello(req) {
-    const body = JSON.stringify({
-        model: "gpt-4.1-mini",
-        messages: [{ role: "user", content: "hii" }]
-    });
-
-    const r = t.fetch("https://api.openai.com/v1/chat/completions", {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-            "Authorization": `Bearer ${process.env.OPENAI_API_KEY}`
-        },
-        body
-    });
-
-    const json = JSON.parse(r.body);
-
-    return {
-        ok: true,
-        message: json.choices[0].message.content
-    };
-}
-
-globalThis.hello = hello;
-```
-
-### `t.fetch` supports:
-
-* GET, POST, PUT, DELETE
-* Custom headers
-* JSON bodies
-* Authorization tokens
-* External / internal APIs
-
----
-
-# 🔥 Hot Reload Dev Server
-
-```bash
-tit dev
-```
-
-Titan’s dev engine:
-
-* Rebuilds routes
-* Rebundil actions
-* Restarts Rust server
-* Updates instantly
-
-
----
-
-# 🧱 Production Build
-
-```bash
-tit build
-```
-
-Output includes:
-
-* `titan-server` native binary
-* JS bundles
-* routing metadata
-
----
-
-# 🐳 Docker Deployment (Zero Config)
-
-Titan generates an optimized **multi-stage Dockerfile**:
-
-Works on:
-
-* Railway
-* Fly.io
-* Render
-* VPS / Dedicated servers
-* Docker Hub
-* Kubernetes
-
----
-
-# ☁ Uploading Titan to GitHub
-
-Titan projects are designed for **direct repository upload**.
-
-Include everything generated by `tit init`:
-
-```
-app/
-titan/
-server/
-Cargo.toml
-Dockerfile
-.gitignore
-package.json
-```
-
-Push to GitHub:
-
-```bash
-git init
-git add .
-git commit -m "Initial Titan project"
-git branch -M main
-git remote add origin <your_repo_url>
-git push -u origin main
-```
-
-Your repo is now fully deployable with Docker.
-
----
-
-# ☁ Zero-Config Deployment with Docker
-
-Once pushed to GitHub, you can deploy anywhere.
-
-## Deploy to Railway
-
-1. Go to Railway
-2. Create New Project → Deploy from GitHub
-3. Select your Titan repo
-4. Railway auto-detects the Dockerfile
-5. It builds + deploys automatically
-
-Railway will:
-
-* Build your Rust server
-* Copy JS bundles
-* Start the `titan-server` binary
-* Expose the correct port
-
-No configuration required.
-
----
-
-# ✨ Updating Titan
-
-```bash
-tit update
-```
-
-Updates:
-
-* Titan CLI
-* DSL
-* Bundler
-* Dev server
-* Rust runtime templates
-* Dockerfile
-
----
-
-# 📦 Version
-
-**Titan v25 — Stable**
-Optimized for production, cloud deployment, and AI workloads.
-
----
-
-# 🤝 Contributing
-
-Pull requests welcome
-https://github.com/ezet-galaxy/-ezetgalaxy-titan
-
----
+
+```
+████████╗██╗████████╗ █████╗ ███╗   ██╗
+╚══██╔══╝██║╚══██╔══╝██╔══██╗████╗  ██║
+   ██║   ██║   ██║   ███████║██╔██╗ ██║
+   ██║   ██║   ██║   ██╔══██║██║╚██╗██║
+   ██║   ██║   ██║   ██║  ██║██║ ╚████║
+   ╚═╝   ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═══╝
+```
+# Notice 
+**Production mode is under development 😞**
+ **Enjoy development mode `tit dev` 💙**
+
+# TITAN PLANET 🚀
+
+**JavaScript Simplicity. Rust Power. Zero Configuration.**
+
+Titan Planet is a JavaScript-first backend framework that compiles your JavaScript routes and actions into a **native Rust + Axum server**.
+
+You write **zero Rust**.
+Titan ships a full backend engine, dev server, bundler, router, action runtime, and Docker deploy pipeline — all powered by Rust under the hood.
+
+Titan = JavaScript productivity × Rust performance × Zero DevOps.
+
+---
+
+# 🌌 Why Titan?
+
+| Feature                              | Titan | Express/Nest | FastAPI | Bun       |
+| ------------------------------------ | ----- | ------------ | ------- | --------- |
+| Native binary output                 | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
+| Rust-level performance               | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
+| Pure JavaScript developer experience | ✅ Yes | ✅ Yes        | ❌ No    | ❌ Partial |
+| Zero-config Docker deploy            | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
+| Action-based architecture            | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
+| Hot reload dev server                | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
+
+Titan gives you:
+
+* Native speed
+* JS comfort
+* Cloud-first deployment
+* Full environment variable support
+* Built-in HTTP client (`t.fetch`)
+* Lightweight serverless-like actions
+* Instant hot reload
+* Zero configuration
+* Single deployable binary
+
+---
+
+# 🚀 Quick Start
+
+
+# ⚙ Requirements
+
+Install before using Titan:
+
+### 1. Rust (latest stable)
+
+[https://rust-lang.org/tools/install/](https://rust-lang.org/tools/install/)
+
+### 2. Node.js (v18+)
+
+Required for:
+
+* Titan CLI
+* esbuild
+* JS → Rust compilation pipeline
+
+Verify:
+
+```bash
+node -v
+npm -v
+rustc -V
+```
+
+---
+
+### Install Titan CLI
+
+```bash
+npm install -g @ezetgalaxy/titan
+```
+
+### Create a new project
+
+```bash
+tit init my-app
+cd my-app
+tit dev
+```
+
+Titan will:
+
+* Build routes
+* Bundle actions
+* Start Rust dev server
+* Watch file changes
+* Trigger instant reload
+
+---
+
+# 📁 Project Layout
+
+```
+my-app/
+├── app/                                  # You develop ONLY this folder
+│   ├── app.js                             # Titan routes (DSL)
+│   └── actions/                           # Your custom JS actions
+│       └── hello.js                       # Example Titan action
+
+───────────────────────────────────────────────────────────────
+  Everything below is auto-generated by `tit init`
+  You never modify these folders manually
+───────────────────────────────────────────────────────────────
+
+├── titan/                                # Titan's internal JS engine
+│   ├── titan.js                           # Titan DSL runtime
+│   ├── bundle.js                          # JS → .jsbundle bundler
+│   └── dev.js                             # Hot Reload system
+│
+├── server/                               # Auto-generated Rust backend
+│   ├── Cargo.toml                         # Rust project config
+│   ├── src/                               # Rust source code
+│   ├── actions/                           # Compiled .jsbundle actions
+│   ├── titan/                             # Internal Rust runtime files
+│   ├── routes.json                        # Generated route metadata
+│   ├── action_map.json                    # Maps actions to bundles
+│   └── titan-server                       # Final production Rust binary
+│
+├── Dockerfile                             # Auto-generated production Dockerfile
+├── .dockerignore                          # Auto-generated Docker ignore rules
+├── package.json                           # JS project config (auto)
+└── .gitignore                             # Auto-generated by `tit init`
+
+```
+
+---
+
+# 🛣 Example Route
+
+**app/app.js**
+
+```js
+import t from "../titan/titan.js";
+
+t.post("/hello").action("hello");
+t.get("/").reply("Welcome to Titan Planet");
+
+t.start(3000, "Ready to land on Titan 🚀");
+```
+
+---
+
+# 🧩 Example Action
+
+**app/actions/hello.js**
+
+```js
+export function hello(req) {
+  return { message: "Hello from Titan!" };
+}
+
+globalThis.hello = hello;
+```
+
+---
+
+# ⚡ New: Built-In HTTP Fetch (`t.fetch`)
+
+Titan now includes a built-in server-side `fetch` bridge powered by Rust.
+
+Use it to call any external API:
+
+```js
+function hello(req) {
+    const API_KEY = process.env.API_KEY || __titan_env.API_KEY;
+
+    const body = JSON.stringify({
+        model: "gpt-4.1-mini",
+        messages: [{ role: "user", content: "hii" }]
+    });
+
+    const r = t.fetch("https://api.openai.com/v1/chat/completions", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Authorization": `Bearer ${API_KEY}`
+        },
+        body
+    });
+
+    const json = JSON.parse(r.body);
+
+    return {
+        ok: true,
+        message: json.choices[0].message.content
+    };
+}
+
+globalThis.hello = hello;
+```
+
+### `t.fetch` supports:
+
+* GET, POST, PUT, DELETE
+* Custom headers
+* JSON bodies
+* Authorization tokens
+* External / internal APIs
+
+---
+
+# 🔥 Hot Reload Dev Server
+
+```bash
+tit dev
+```
+
+Titan’s dev engine:
+
+* Rebuilds routes
+* Rebundil actions
+* Restarts Rust server
+* Updates instantly
+
+
+---
+
+# 🧱 Production Build
+
+```bash
+tit build
+```
+
+Output includes:
+
+* `titan-server` native binary
+* JS bundles
+* routing metadata
+
+---
+
+# 🐳 Docker Deployment (Zero Config)
+
+Titan generates an optimized **multi-stage Dockerfile**:
+
+Works on:
+
+* Railway
+* Fly.io
+* Render
+* VPS / Dedicated servers
+* Docker Hub
+* Kubernetes
+
+---
+
+# ☁ Uploading Titan to GitHub
+
+Titan projects are designed for **direct repository upload**.
+
+Include everything generated by `tit init`:
+
+```
+app/
+titan/
+server/
+Cargo.toml
+Dockerfile
+.gitignore
+package.json
+```
+
+Push to GitHub:
+
+```bash
+git init
+git add .
+git commit -m "Initial Titan project"
+git branch -M main
+git remote add origin <your_repo_url>
+git push -u origin main
+```
+
+Your repo is now fully deployable with Docker.
+
+---
+
+# ☁ Zero-Config Deployment with Docker
+
+Once pushed to GitHub, you can deploy anywhere.
+
+## Deploy to Railway
+
+1. Go to Railway
+2. Create New Project → Deploy from GitHub
+3. Select your Titan repo
+4. Railway auto-detects the Dockerfile
+5. It builds + deploys automatically
+
+Railway will:
+
+* Build your Rust server
+* Copy JS bundles
+* Start the `titan-server` binary
+* Expose the correct port
+
+No configuration required.
+
+---
+
+# ✨ Updating Titan
+
+```bash
+tit update
+```
+
+Updates:
+
+* Titan CLI
+* DSL
+* Bundler
+* Dev server
+* Rust runtime templates
+* Dockerfile
+
+---
+
+# 📦 Version
+
+**Titan v25 — Stable**
+Optimized for production, cloud deployment, and AI workloads.
+
+---
+
+# 🤝 Contributing
+
+Pull requests welcome
+https://github.com/ezet-galaxy/-ezetgalaxy-titan
+
+---

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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "25.14.5",
+  "version": "25.14.7",
   "description": "JavaScript backend framework that compiles your JS into a Rust + Axum server.",
   "license": "ISC",
   "author": "ezetgalaxy",

package/templates/app/actions/hello.js

@@ -1,6 +1,5 @@
 function hello(req) {
-    const name = req.name;
-    return { name: name, msg: `Hello ${name}` }
+    return { "name": `${req.name || "user"}`, msg: `welcome to titan planet ${req.name || "user"}` }
 }
 
 globalThis.hello = hello;

package/templates/server/src/main.rs

@@ -1,34 +1,28 @@
-use std::{collections::HashMap, fs, path::PathBuf, sync::Arc};
+// server/src/main.rs
+use std::{collections::HashMap, env, fs, path::Path, 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 std::path::Path;
-
-use boa_engine::{
-    js_string,
-    native_function::NativeFunction,
-    object::ObjectInitializer,
-    property::Attribute,
-    Context, JsValue, Source,
-};
+use boa_engine::{Context, JsValue, Source, object::ObjectInitializer};
+use boa_engine::{js_string, native_function::NativeFunction, property::Attribute};
 
 use reqwest::blocking::Client;
 use reqwest::header::{HeaderMap, HeaderName, HeaderValue};
 
 use serde::Deserialize;
 use serde_json::Value;
-
 use tokio::net::TcpListener;
 use tokio::task;
 
+/// Route configuration (loaded from routes.json)
 #[derive(Debug, Deserialize)]
 struct RouteVal {
     r#type: String,
@@ -38,245 +32,367 @@ struct RouteVal {
 #[derive(Clone)]
 struct AppState {
     routes: Arc<HashMap<String, RouteVal>>,
+    project_root: PathBuf,
+}
+
+// -------------------------
+// ACTION DIRECTORY RESOLUTION
+// -------------------------
+
+fn resolve_actions_dir() -> PathBuf {
+    // Respect explicit override first
+    if let Ok(override_dir) = env::var("TITAN_ACTIONS_DIR") {
+        return PathBuf::from(override_dir);
+    }
+
+    // Production container layout
+    if Path::new("/app/actions").exists() {
+        return PathBuf::from("/app/actions");
+    }
+
+    // Try to walk up from the executing binary to discover `<...>/server/actions`
+    if let Ok(exe) = std::env::current_exe() {
+        if let Some(parent) = exe.parent() {
+            if let Some(target_dir) = parent.parent() {
+                if let Some(server_dir) = target_dir.parent() {
+                    let candidate = server_dir.join("actions");
+                    if candidate.exists() {
+                        return candidate;
+                    }
+                }
+            }
+        }
+    }
+
+    // Fall back to local ./actions
+    PathBuf::from("./actions")
 }
 
+/// Try to find the directory that contains compiled action bundles.
+///
+/// Checks multiple likely paths to support both dev and production container layouts:
+///  - <project_root>/server/actions
+///  - <project_root>/actions
+///  - <project_root>/../server/actions
+///  - /app/actions
+///  - ./actions
+fn find_actions_dir(project_root: &PathBuf) -> Option<PathBuf> {
+    let candidates = [
+        project_root.join("server").join("actions"),
+        project_root.join("actions"),
+        project_root.join("..").join("server").join("actions"),
+        PathBuf::from("/app").join("actions"),
+        PathBuf::from("actions"),
+    ];
+
+    for p in &candidates {
+        if p.exists() && p.is_dir() {
+            return Some(p.clone());
+        }
+    }
+
+    None
+}
+
+/// Injects a synchronous `t.fetch(url, opts?)` function into the Boa `Context`.
+///
+/// Implementation details:
+///  - Converts JS opts → `serde_json::Value` (owned) using `to_json`.
+///  - Executes reqwest blocking client inside `tokio::task::block_in_place` to avoid blocking async runtime.
+///  - Returns `{ ok: bool, status?: number, body?: string, error?: string }`.
 fn inject_t_fetch(ctx: &mut Context) {
+    // Native function (Boa 0.20) using from_fn_ptr
     let t_fetch_native = NativeFunction::from_fn_ptr(|_this, args, ctx| {
+        // Extract URL (owned string)
         let url = args
             .get(0)
             .and_then(|v| v.to_string(ctx).ok())
             .map(|s| s.to_std_string_escaped())
             .unwrap_or_default();
 
+        // Extract opts -> convert to serde_json::Value (owned)
         let opts_js = args.get(1).cloned().unwrap_or(JsValue::undefined());
-        let opts_json: Value = opts_js.to_json(ctx).unwrap_or(Value::Null);
+        let opts_json: Value = match opts_js.to_json(ctx) {
+            Ok(v) => v,
+            Err(_) => Value::Object(serde_json::Map::new()),
+        };
 
+        // Pull method, body, headers into owned Rust values
         let method = opts_json
             .get("method")
             .and_then(|m| m.as_str())
-            .unwrap_or("GET")
-            .to_string();
+            .map(|s| s.to_string())
+            .unwrap_or_else(|| "GET".to_string());
 
-        let body_opt = opts_json.get("body").cloned();
+        let body_opt = match opts_json.get("body") {
+            Some(Value::String(s)) => Some(s.clone()),
+            Some(other) => Some(other.to_string()),
+            None => None,
+        };
 
-        let mut headers = HeaderMap::new();
+        // headers as Vec<(String,String)>
+        let mut header_pairs: Vec<(String, String)> = Vec::new();
         if let Some(Value::Object(map)) = opts_json.get("headers") {
-            for (k, v) in map {
-                if let Ok(name) = HeaderName::from_bytes(k.as_bytes()) {
-                    if let Ok(val) = HeaderValue::from_str(&v.to_string()) {
-                        headers.insert(name, val);
-                    }
-                }
+            for (k, v) in map.iter() {
+                let v_str = match v {
+                    Value::String(s) => s.clone(),
+                    other => other.to_string(),
+                };
+                header_pairs.push((k.clone(), v_str));
             }
         }
 
-        let out = task::block_in_place(move || {
+        // Perform the blocking HTTP request inside block_in_place to avoid runtime panic
+        let out_json = task::block_in_place(move || {
             let client = Client::new();
-            let mut req = client.request(method.parse().unwrap(), &url);
 
-            req = req.headers(headers);
+            let method_parsed = method.parse().unwrap_or(reqwest::Method::GET);
+            let mut req = client.request(method_parsed, &url);
+
+            if !header_pairs.is_empty() {
+                let mut headers = HeaderMap::new();
+                for (k, v) in header_pairs.into_iter() {
+                    if let (Ok(name), Ok(val)) = (
+                        HeaderName::from_bytes(k.as_bytes()),
+                        HeaderValue::from_str(&v),
+                    ) {
+                        headers.insert(name, val);
+                    }
+                }
+                req = req.headers(headers);
+            }
 
             if let Some(body) = body_opt {
-                req = req.body(body.to_string());
+                req = req.body(body);
             }
 
             match req.send() {
                 Ok(resp) => {
                     let status = resp.status().as_u16();
                     let text = resp.text().unwrap_or_default();
-                    serde_json::json!({ "ok": true, "status": status, "body": text })
+                    serde_json::json!({
+                        "ok": true,
+                        "status": status,
+                        "body": text
+                    })
                 }
-                Err(e) => serde_json::json!({ "ok": false, "error": e.to_string() }),
+                Err(e) => serde_json::json!({
+                    "ok": false,
+                    "error": e.to_string()
+                }),
             }
         });
 
-        Ok(JsValue::from_json(&out, ctx).unwrap())
+        // Convert serde_json::Value -> JsValue
+        Ok(JsValue::from_json(&out_json, ctx).unwrap_or(JsValue::undefined()))
     });
 
+    // Convert native function to JS function object (requires Realm)
     let realm = ctx.realm();
     let t_fetch_js_fn = t_fetch_native.to_js_function(realm);
 
+    // Build `t` object with `.fetch`
     let t_obj = ObjectInitializer::new(ctx)
         .property(js_string!("fetch"), t_fetch_js_fn, Attribute::all())
         .build();
 
     ctx.global_object()
         .set(js_string!("t"), JsValue::from(t_obj), false, ctx)
-        .unwrap();
-}
-
-/// DEV: actions inside project/server/actions  
-/// PROD: actions inside /app/actions
-
-fn detect_project_root() -> PathBuf {
-    let exe = std::env::current_exe().unwrap();
-    let dir = exe.parent().unwrap();         // target/debug
-    let is_release = dir.ends_with("release");
-
-    if is_release {
-        // Production
-        PathBuf::from("/app")
-    } else {
-        // Dev executable location:
-        // <project>/server/target/debug/server.exe
-        dir.parent()              // target
-            .unwrap()
-            .parent()             // server
-            .unwrap()
-            .parent()             // <project>
-            .unwrap()
-            .to_path_buf()
-    }
+        .expect("set global t");
 }
 
+// Root/dynamic handlers -----------------------------------------------------
 
-fn resolve_actions_dir() -> PathBuf {
-    let exe = std::env::current_exe().unwrap_or_else(|_| PathBuf::from("."));
-    let exe_dir = exe.parent().unwrap_or(Path::new("/app")).to_path_buf();
-
-    // Detect production if running from Docker binary location
-    let is_prod = exe_dir.to_string_lossy().contains("/app")
-        || exe.file_name().unwrap_or_default() == "titan-server";
-
-    if is_prod {
-        // Final production directory
-        return PathBuf::from("/app/actions");
-    }
-
-    // DEV: exe = <root>/server/target/debug/server(.exe)
-    exe_dir
-        .parent()                 // target
-        .unwrap_or(Path::new("."))
-        .parent()                 // server
-        .unwrap_or(Path::new("."))
-        .join("actions")
+async fn root_route(state: State<AppState>, req: Request<Body>) -> impl IntoResponse {
+    dynamic_handler_inner(state, req).await
 }
 
+async fn dynamic_route(state: State<AppState>, req: Request<Body>) -> impl IntoResponse {
+    dynamic_handler_inner(state, req).await
+}
 
-
-async fn dynamic_handler(
+/// Main handler: looks up routes.json and executes action bundles using Boa.
+async fn dynamic_handler_inner(
     State(state): State<AppState>,
     req: Request<Body>,
 ) -> impl IntoResponse {
     let method = req.method().as_str().to_uppercase();
-    let path = req.uri().path().to_string();
+    let path = req.uri().path();
     let key = format!("{}:{}", method, path);
 
     let body_bytes = match to_bytes(req.into_body(), usize::MAX).await {
-        Ok(v) => v,
+        Ok(b) => b,
         Err(_) => return (StatusCode::BAD_REQUEST, "Failed to read body").into_response(),
     };
     let body_str = String::from_utf8_lossy(&body_bytes).to_string();
 
-    let route = match state.routes.get(&key) {
-        Some(r) => r,
-        None => return (StatusCode::NOT_FOUND, "Not Found").into_response(),
-    };
-
-    if route.r#type != "action" {
-        if let Some(s) = route.value.as_str() {
-            return s.to_string().into_response();
-        }
-        return Json(route.value.clone()).into_response();
-    }
+    if let Some(route) = state.routes.get(&key) {
+        match route.r#type.as_str() {
+            "action" => {
+                let action_name = route.value.as_str().unwrap_or("").trim();
+                if action_name.is_empty() {
+                    return (StatusCode::INTERNAL_SERVER_ERROR, "Invalid action name")
+                        .into_response();
+                }
 
-    let action_name = route.value.as_str().unwrap().trim().to_string();
-    if action_name.is_empty() {
-        return (
-            StatusCode::INTERNAL_SERVER_ERROR,
-            "Invalid action name",
-        )
-            .into_response();
-    }
+                // Resolve actions directory: prefer resolve_actions_dir(), fall back to heuristic find_actions_dir
+                let resolved = resolve_actions_dir();
+                let actions_dir = if resolved.exists() && resolved.is_dir() {
+                    resolved
+                } else {
+                    match find_actions_dir(&state.project_root) {
+                        Some(p) => p,
+                        None => {
+                            return (
+                                StatusCode::INTERNAL_SERVER_ERROR,
+                                format!("Actions directory not found (checked multiple locations)"),
+                            )
+                                .into_response();
+                        }
+                    }
+                };
 
-    let actions_dir = resolve_actions_dir();
-    let action_path = actions_dir.join(format!("{}.jsbundle", action_name));
+                let action_path = actions_dir.join(format!("{}.jsbundle", action_name));
 
-    if !action_path.exists() {
-        return (
-            StatusCode::NOT_FOUND,
-            format!("Action bundle not found: {:?}", action_path),
-        )
-            .into_response();
-    }
+                if !action_path.exists() {
+                    return (
+                        StatusCode::NOT_FOUND,
+                        format!("Action bundle not found: {:?}", action_path),
+                    )
+                        .into_response();
+                }
 
-    let js_code = match fs::read_to_string(&action_path) {
-        Ok(v) => v,
-        Err(e) => {
-            return (
-                StatusCode::INTERNAL_SERVER_ERROR,
-                format!("Failed reading bundle: {}", e),
-            )
-                .into_response();
-        }
-    };
+                let js_code = match fs::read_to_string(&action_path) {
+                    Ok(v) => v,
+                    Err(e) => {
+                        return (
+                            StatusCode::INTERNAL_SERVER_ERROR,
+                            format!("Failed reading action bundle: {}", e),
+                        )
+                            .into_response();
+                    }
+                };
 
-    let mut env_map = serde_json::Map::new();
-    for (k, v) in std::env::vars() {
-        env_map.insert(k, Value::String(v));
-    }
-    let env_json = Value::Object(env_map);
-
-    let injected = format!(
-        r#"
-        globalThis.process = {{ env: {} }};
-        const __titan_req = {};
-        {};
-        {}(__titan_req);
+                // Build env object
+                let mut env_map: serde_json::Map<String, Value> = serde_json::Map::new();
+                for (k, v) in std::env::vars() {
+                    env_map.insert(k, Value::String(v));
+                }
+                let env_json: Value = Value::Object(env_map);
+
+                // Ensure body_str is valid JS: we will embed it as a JS expression.
+                // If body_str is a JSON object string, embedding it directly is fine.
+                // But to be safe, we create a quoted JS string and parse it in JS if necessary.
+                let safe_body_literal: String =
+                    serde_json::to_string(&body_str).unwrap_or_else(|_| "null".to_string());
+
+                // Injected script: sets process.env, __titan_env, __titan_req and invokes action function.
+                let injected: String = format!(
+                    r#"
+    // Runtime env injected by Titan
+    globalThis.process = {{ env: {} }};
+    globalThis.__titan_env = {};
+    // quick debug so prod logs show whether API key is present
+    try {{
+      console.log('TITAN: runtime API_KEY =', (process && process.env && process.env.API_KEY) || (typeof __titan_env !== 'undefined' && __titan_env.API_KEY) || null);
+    }} catch(e) {{ /* ignore */ }}
+
+    // Parse the incoming request body. If it's a JSON string we parse it into an object.
+    const __titan_req_body_literal = {};
+    let __titan_req;
+    try {{
+      // it's a quoted JSON string in Rust, so first unquote via JSON.parse
+      __titan_req = JSON.parse(__titan_req_body_literal);
+    }} catch (e) {{
+      // if parse fails, fall back to empty object
+      __titan_req = {{}};
+    }}
+
+    // Action code (bundled JS)
+    {};
+    // call exported action function
+    {}(__titan_req);
     "#,
-        env_json.to_string(),
-        body_str,
-        js_code,
-        action_name
-    );
+                    env_json.to_string(), // inserted JSON object for process.env
+                    env_json.to_string(), // inserted also as __titan_env
+                    safe_body_literal,    // quoted JSON string literal of request body
+                    js_code,              // code from the .jsbundle
+                    action_name           // call function
+                );
+
+                let mut ctx: Context = Context::default();
+                inject_t_fetch(&mut ctx);
+
+                let result: JsValue = match ctx.eval(Source::from_bytes(&injected)) {
+                    Ok(v) => v,
+                    Err(e) => return Json(json_error(e.to_string())).into_response(),
+                };
+
+                let result_json: Value = match result.to_json(&mut ctx) {
+                    Ok(v) => v,
+                    Err(e) => json_error(e.to_string()),
+                };
+
+                return Json(result_json).into_response();
+            }
 
-    let mut ctx = Context::default();
-    inject_t_fetch(&mut ctx);
+            "json" => return Json(route.value.clone()).into_response(),
+            _ => {
+                if let Some(s) = route.value.as_str() {
+                    return s.to_string().into_response();
+                }
+                return route.value.to_string().into_response();
+            }
+        }
+    }
 
-    let result = match ctx.eval(Source::from_bytes(&injected)) {
-        Ok(v) => v,
-        Err(e) => return Json(serde_json::json!({ "error": e.to_string() })).into_response(),
-    };
+    (StatusCode::NOT_FOUND, "Not Found").into_response()
+}
 
-    let result_json = result.to_json(&mut ctx).unwrap_or(Value::Null);
-    Json(result_json).into_response()
+fn json_error(msg: String) -> Value {
+    serde_json::json!({ "error": msg })
 }
 
+// Entrypoint ---------------------------------------------------------------
+
 #[tokio::main]
 async fn main() -> Result<()> {
     dotenvy::dotenv().ok();
 
-    let raw = fs::read_to_string("./routes.json").unwrap_or("{}".into());
+    // Load routes.json (expected at runtime root)
+    let raw = fs::read_to_string("./routes.json").unwrap_or_else(|_| "{}".to_string());
     let json: Value = serde_json::from_str(&raw).unwrap_or_default();
 
     let port = json["__config"]["port"].as_u64().unwrap_or(3000);
-    let routes_map: HashMap<String, RouteVal> =
-        serde_json::from_value(json["routes"].clone()).unwrap_or_default();
+    let routes_json = json["routes"].clone();
+    let map: HashMap<String, RouteVal> = serde_json::from_value(routes_json).unwrap_or_default();
 
-        let _project_root = detect_project_root();
+    // Project root — heuristics: try current_dir()
+    let project_root = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
 
-let state = AppState {
-    routes: Arc::new(routes_map),
-};
-
-        
+    let state = AppState {
+        routes: Arc::new(map),
+        project_root,
+    };
 
     let app = Router::new()
-        .route("/", any(dynamic_handler))
-        .fallback(any(dynamic_handler))
+        .route("/", any(root_route))
+        .fallback(any(dynamic_route))
         .with_state(state);
 
     let listener = TcpListener::bind(format!("0.0.0.0:{}", port)).await?;
- // TITAN BANNER
- println!("\n\x1b[38;5;208m████████╗██╗████████╗ █████╗ ███╗   ██╗");
- println!("╚══██╔══╝██║╚══██╔══╝██╔══██╗████╗  ██║");
- println!("   ██║   ██║   ██║   ███████║██╔██╗ ██║");
- println!("   ██║   ██║   ██║   ██╔══██║██║╚██╗██║");
- println!("   ██║   ██║   ██║   ██║  ██║██║ ╚████║");
- println!("   ╚═╝   ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═══╝\x1b[0m\n");
- 
-
-    println!("\x1b[38;5;39mTitan server running at:\x1b[0m http://localhost:{}", port);
+
+    // Banner (yellow-orange) and server info
+    println!("\n\x1b[38;5;208m████████╗██╗████████╗ █████╗ ███╗   ██╗");
+    println!("╚══██╔══╝██║╚══██╔══╝██╔══██╗████╗  ██║");
+    println!("   ██║   ██║   ██║   ███████║██╔██╗ ██║");
+    println!("   ██║   ██║   ██║   ██╔══██║██║╚██╗██║");
+    println!("   ██║   ██║   ██║   ██║  ██║██║ ╚████║");
+    println!("   ╚═╝   ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═══╝\x1b[0m\n");
+    println!(
+        "\x1b[38;5;39mTitan server running at:\x1b[0m http://localhost:{}",
+        port
+    );
 
     axum::serve(listener, app).await?;
     Ok(())

package/templates/titan/bundle.js

@@ -28,12 +28,16 @@ export async function bundle() {
 
     await esbuild.build({
       entryPoints: [entry],
+      outfile: outfile,
       bundle: true,
-      format: "cjs",
+      format: "iife",  
       platform: "neutral",
-      outfile,
-      minify: false,
-    });
+      target: "es2020",
+      banner: {
+          js: ""  
+      }
+  });
+  
   }
 
   console.log("[Titan] Bundling finished.");