titanpl-sdk 2.0.0 → 2.0.2

package/templates/server/src/main.rs

@@ -51,7 +51,9 @@ async fn dynamic_handler_inner(
     // ---------------------------
     let method = req.method().as_str().to_uppercase();
     let path = req.uri().path().to_string();
-    let key = format!("{}:{}", method, path);
+    let strict_key = format!("{}:{}", method, path);
+    // Also try simple path for generic routes
+    // Check strict first, then simple path
 
     // ---------------------------
     // TIMER + LOG META
@@ -101,7 +103,8 @@ async fn dynamic_handler_inner(
     let mut action_name: Option<String> = None;
 
     // Exact route
-    if let Some(route) = state.routes.get(&key) {
+    let route = state.routes.get(&strict_key).or_else(|| state.routes.get(&path));
+    if let Some(route) = route {
         route_kind = "exact";
         if route.r#type == "action" {
             let name = route.value.as_str().unwrap_or("unknown").to_string();
@@ -182,7 +185,8 @@ async fn dynamic_handler_inner(
     // This sends a pointer-sized message through the ring buffer, triggering 
     // the V8 thread to wake up and process the request immediately.
 
-    let result_json = state
+    // Dispatch to the worker pool for V8 execution
+    let (mut result_json, timings) = state
         .runtime
         .execute(
             action_name,
@@ -194,88 +198,118 @@ async fn dynamic_handler_inner(
             query_vec
         )
         .await
-        .unwrap_or_else(|e| serde_json::json!({"error": e}));
+        .unwrap_or_else(|e| {
+            // Log catastrophic runtime errors
+            (serde_json::json!({"error": e}), vec![])
+        });
+
+    // Construct Server-Timing header
+    let server_timing = timings.iter().enumerate().map(|(i, (name, duration))| {
+        format!("{}_{};dur={:.2}", name, i, duration)
+    }).collect::<Vec<_>>().join(", ");
+
+    // Inject timings into JSON if it's an object
+    if let Some(obj) = result_json.as_object_mut() {
+        obj.insert("_titanTimings".to_string(), serde_json::json!(timings));
+    }
 
+    let prefix = if !timings.is_empty() { 
+        format!("{} {}", blue("[Titan"), blue("Drift]"))
+    } else {
+        blue("[Titan]").to_string()
+    };
 
     // ---------------------------
-    // FINAL LOG
+    // ERROR HANDLING
     // ---------------------------
-    let elapsed = start.elapsed();
-
-    // Check for errors in result
     if let Some(err) = result_json.get("error") {
         println!(
             "{} {} {} {}",
-            blue("[Titan]"),
+            prefix,
             red(&format!("{} {}", method, path)), 
             red("→ error"),
-            gray(&format!("in {:.2?}", elapsed))
+            gray(&format!("in {:.2?}", start.elapsed()))
         );
-         println!(
-            "{} {} {} {}",
-            blue("[Titan]"),
+        println!(
+            "{} {} {}",
+            prefix,
             red("Action Error:"),
-            red(err.as_str().unwrap_or("Unknown")),
-            gray(&format!("in {:.2?}", elapsed))
+            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))
-        ),
-        _ => {}
+        let mut response = (StatusCode::INTERNAL_SERVER_ERROR, Json(result_json.clone())).into_response();
+        if !server_timing.is_empty() {
+            response.headers_mut().insert("Server-Timing", server_timing.parse().unwrap());
+        }
+        return response;
     }
 
-    // --------------------------------------------------------------
-// Titan Response Contract: Custom HTTP Handling
-// --------------------------------------------------------------
-if let Some(is_resp) = result_json.get("_isResponse") {
-    if is_resp.as_bool().unwrap_or(false) {
-        let status = result_json
-            .get("status")
-            .and_then(|v| v.as_u64())
-            .unwrap_or(200) as u16;
-
-        let status = StatusCode::from_u16(status).unwrap_or(StatusCode::OK);
-
-        let mut builder = axum::http::Response::builder().status(status);
+    // ---------------------------
+    // RESPONSE CONSTRUCTION
+    // ---------------------------
+    let mut response = if let Some(is_resp) = result_json.get("_isResponse") {
+        if is_resp.as_bool().unwrap_or(false) {
+            let status_u16 = result_json.get("status").and_then(|v| v.as_u64()).unwrap_or(200) as u16;
+            let status = StatusCode::from_u16(status_u16).unwrap_or(StatusCode::OK);
+            let mut builder = axum::http::Response::builder().status(status);
+
+            if let Some(hmap) = result_json.get("headers").and_then(|v| v.as_object()) {
+                for (k, v) in hmap {
+                    if let Some(vs) = v.as_str() {
+                        builder = builder.header(k, vs);
+                    }
+                }
+            }
 
-        if let Some(hmap) = result_json.get("headers").and_then(|v| v.as_object()) {
-            for (k, v) in hmap {
-                if let Some(vs) = v.as_str() {
-                    builder = builder.header(k, vs);
+            let mut is_redirect = false;
+            if let Some(location) = result_json.get("redirect") {
+                if let Some(url) = location.as_str() {
+                    let mut final_status_u16 = status.as_u16();
+                    if final_status_u16 < 300 || final_status_u16 > 399 { final_status_u16 = 302; }
+                    builder = builder.status(StatusCode::from_u16(final_status_u16).unwrap_or(StatusCode::FOUND)).header("Location", url);
+                    is_redirect = true;
                 }
             }
+
+            let body_text = if is_redirect { "".to_string() } else {
+                match result_json.get("body") {
+                    Some(Value::String(s)) => s.clone(),
+                    Some(v) => v.to_string(),
+                    None => "".to_string(),
+                }
+            };
+            builder.body(Body::from(body_text)).unwrap()
+        } else {
+            Json(result_json.clone()).into_response()
         }
+    } else {
+        Json(result_json.clone()).into_response()
+    };
+
+    if !server_timing.is_empty() {
+        response.headers_mut().insert("Server-Timing", server_timing.parse().unwrap());
+    }
 
-        // FIX: Safe body conversion
-        let body_text = match result_json.get("body") {
-            Some(Value::String(s)) => s.clone(),
-            Some(v) => v.to_string(),
-            None => "".to_string(),
-        };
+    // ---------------------------
+    // FINAL LOG (SUCCESS)
+    // ---------------------------
+    let total_elapsed = start.elapsed();
+    let total_elapsed_ms = total_elapsed.as_secs_f64() * 1000.0;
+    let total_drift_ms: f64 = timings.iter().filter(|(n, _)| n == "drift" || n == "drift_error").map(|(_, d)| d).sum();
+    let compute_ms = (total_elapsed_ms - total_drift_ms).max(0.0);
+
+    let timing_info = if !timings.is_empty() {
+        gray(&format!("(active: {:.2}ms, drift: {:.2}ms) in {:.2?}", compute_ms, total_drift_ms, total_elapsed))
+    } else {
+        gray(&format!("in {:.2?}", total_elapsed))
+    };
 
-        return builder.body(Body::from(body_text)).unwrap();
+    match route_kind {
+        "dynamic" => println!("{} {} {} {} {} {}", prefix, green(&format!("{} {}", method, path)), white("→"), green(&route_label), white("(dynamic)"), timing_info),
+        "exact" => println!("{} {} {} {} {}", prefix, white(&format!("{} {}", method, path)), white("→"), yellow(&route_label), timing_info),
+        _ => {}
     }
-}
 
-    Json(result_json).into_response()
+    response
 }
 
 
@@ -284,23 +318,28 @@ if let Some(is_resp) = result_json.get("_isResponse") {
 #[tokio::main]
 async fn main() -> Result<()> {
     dotenvy::dotenv().ok();
-
+    
     // Load routes.json
     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 port = std::env::var("PORT")
+        .ok()
+        .and_then(|p| p.parse::<u64>().ok())
+        .or_else(|| json["__config"]["port"].as_u64())
+        .unwrap_or(3000);
     let thread_count = json["__config"]["threads"].as_u64();
     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();
 
-    // Identify project root (where .ext or node_modules lives)
+    // Identify project root
     let project_root = resolve_project_root();
-
-    // Load extensions (Load definitions globally)
+    
+    // Load extensions and action definitions
     extensions::load_project_extensions(project_root.clone());
+
     
     // Initialize Runtime Manager (Worker Pool)
     let threads = match thread_count {
@@ -308,8 +347,10 @@ async fn main() -> Result<()> {
         _ => num_cpus::get() * 4,   // default
     };
 
+    let stack_mb = json["__config"]["stack_mb"].as_u64().unwrap_or(8);
+    let stack_size = (stack_mb as usize) * 1024 * 1024;
     
-    let runtime_manager = Arc::new(RuntimeManager::new(project_root.clone(), threads));
+    let runtime_manager = Arc::new(RuntimeManager::new(project_root.clone(), threads, stack_size));
 
     let state = AppState {
         routes: Arc::new(map),
@@ -326,9 +367,10 @@ async fn main() -> Result<()> {
 
     
     println!(
-        "\x1b[38;5;39mTitan server running at:\x1b[0m http://localhost:{}  \x1b[90m(Threads: {})\x1b[0m",
+        "\x1b[38;5;39mTitan server running at:\x1b[0m http://localhost:{}  \x1b[90m(Threads: {}, Stack: {}MB)\x1b[0m",
         port,
-        threads
+        threads,
+        stack_mb
     );
     
 

package/templates/server/src/runtime.rs

@@ -1,104 +1,139 @@
-use std::thread;
+use bytes::Bytes;
 use crossbeam::channel::{bounded, Sender};
+use std::thread;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use tokio::sync::mpsc;
 use tokio::sync::oneshot;
-use bytes::Bytes;
 use smallvec::SmallVec;
-use crate::extensions;
 
-// ----------------------------------------------------------------------------
-// TITANVM: HIGH-PERFORMANCE WORKER POOL
-// ----------------------------------------------------------------------------
+use crate::extensions::{self, TitanRuntime, AsyncOpRequest, WorkerAsyncResult};
+
+pub struct RuntimeManager {
+    request_txs: Vec<Sender<WorkerCommand>>,
+    round_robin_counter: AtomicUsize,
+    _resume_txs: Vec<Sender<WorkerCommand>>, // Keep alive
+    _workers: Vec<thread::JoinHandle<()>>,
+}
 
-/// The command sent from the Async Axum thread to the Sync V8 Worker thread.
-/// 
-/// IMPLEMENTATION NOTE: Zero-Copy Design
-/// Instead of passing `String` or `Vec<u8>` which incur heap allocations for every request,
-/// we use:
-/// 1. `Bytes`: An Arc-counted slice of the original TCP buffer. Cloning this is O(1).
-/// 2. `SmallVec`: Stack-allocated vectors for headers/params. 99% of requests fit in standard limits
-///    (8 headers, 4 params), avoiding malloc/free overhead entirely.
 pub enum WorkerCommand {
     Request(RequestTask),
+    Resume {
+        drift_id: u32,
+        result: WorkerAsyncResult,
+    },
 }
 
+#[allow(dead_code)]
 pub struct RequestTask {
     pub action_name: String,
-    
-    // Zero-copy body (Arc-based byte slice)
-    // This slice points directly into the Hyper/Tokio TCP buffer.
-    // It is passed to V8 as an ArrayBuffer BackingStore without copying.
-    pub body: Option<Bytes>, 
-    
-    // Efficient Metadata (No JSON)
+    pub body: Option<Bytes>,
     pub method: String,
     pub path: String,
-    
-    // SmallVec<[T; N]> stores N items inline on the struct (stack memory).
-    // Only unnecessary heap allocation occurs if headers > 8.
     pub headers: SmallVec<[(String, String); 8]>,
     pub params: SmallVec<[(String, String); 4]>,
     pub query: SmallVec<[(String, String); 4]>,
-
-    // Response channel
-    // Used to signal the Async Runtime when the Sync V8 work is done.
     pub response_tx: oneshot::Sender<WorkerResult>,
 }
 
-
 pub struct WorkerResult {
     pub json: serde_json::Value,
-}
-
-pub struct RuntimeManager {
-    sender: Sender<WorkerCommand>,
-    _workers: Vec<thread::JoinHandle<()>>,
+    pub timings: Vec<(String, f64)>,
 }
 
 impl RuntimeManager {
-    pub fn new(project_root: std::path::PathBuf, num_threads: usize) -> Self {
-        let (tx, rx) = bounded::<WorkerCommand>(num_threads * 2000); 
+    pub fn new(project_root: std::path::PathBuf, num_threads: usize, stack_size: usize) -> Self {
+        let (async_tx, mut async_rx) = mpsc::channel::<AsyncOpRequest>(1000);
         
+        let tokio_handle = tokio::runtime::Handle::current();
+
+        // Spawn Tokio Async Handler
+        tokio_handle.spawn(async move {
+            while let Some(req) = async_rx.recv().await {
+                let drift_id = req.drift_id;
+                let respond_tx = req.respond_tx;
+                tokio::spawn(async move {
+                    let start = std::time::Instant::now();
+                    let result = extensions::builtin::run_async_operation(req.op).await;
+                    let duration_ms = start.elapsed().as_secs_f64() * 1000.0;
+                    let _ = respond_tx.send(WorkerAsyncResult {
+                        drift_id,
+                        result,
+                        duration_ms,
+                    });
+                });
+            }
+        });
+
+        let mut worker_txs = Vec::new();
         let mut workers = Vec::new();
-        
-        for i in 0..num_threads {
-            let rx_clone = rx.clone();
-            let tx_clone = tx.clone();
-            let root_clone = project_root.clone();
+
+        // Pass 1: Create channels
+        for _ in 0..num_threads {
+            let (tx, rx) = bounded(100); 
+            worker_txs.push((tx, rx));
+        }
+
+        let mut final_txs = Vec::new();
+        for (tx, _) in &worker_txs {
+            final_txs.push(tx.clone());
+        }
+
+        // Pass 2: Spawn Workers
+        for (i, (tx, rx)) in worker_txs.into_iter().enumerate() {
+            let my_tx = tx.clone(); // The worker needs a way to send commands to ITSELF (for resumes)
+            let root = project_root.clone();
+            let handle = tokio_handle.clone();
+            let async_tx = async_tx.clone();
             
             let handle = thread::Builder::new()
                 .name(format!("titan-worker-{}", i))
+                .stack_size(stack_size)
                 .spawn(move || {
-                    // 1. Thread-Local Event Loop Init
-                    // Initialize independent V8 Isolate for this thread
-                    let mut runtime = extensions::init_runtime_worker(root_clone, tx_clone);
+                    // Start a thread with a pinned V8 isolate. 
+                    // This thread will handle requests for this isolate exclusively.
+                    let mut rt = extensions::init_runtime_worker(
+                        i,
+                        root,
+                        my_tx, 
+                        handle,
+                        async_tx,
+                        stack_size 
+                    );
                     
-                    // 2. Event Loop
-                    let runtime_ptr = &mut runtime as *mut extensions::TitanRuntime as *mut std::ffi::c_void;
-                    runtime.isolate.set_data(0, runtime_ptr);
+                    // Bind the runtime instance to the V8 isolate data slot
+                    // This is CRITICAL because native drift calls use this pointer.
+                    rt.bind_to_isolate();
 
                     loop {
-                        // Strictly synchronous blocking receive
-                        // This makes the worker a dedicated processor for requests from the queue.
-                        // No background event loop is running.
-                        if let Ok(cmd) = rx_clone.recv() {
-                            handle_cmd(cmd, &mut runtime);
-                        } else {
-                            break;
+                        match rx.recv() {
+                            Ok(cmd) => {
+                                match cmd {
+                                    WorkerCommand::Request(task) => {
+                                         handle_new_request(task, &mut rt);
+                                     },
+                                    WorkerCommand::Resume { drift_id, result } => {
+                                         handle_resume(drift_id, result, &mut rt);
+                                     }
+                                }
+                            }
+                            Err(_) => break, // Channel closed
                         }
                     }
                 })
-                .expect("Failed to spawn worker thread");
-            
+                .expect("Failed to spawn worker");
+
             workers.push(handle);
         }
 
         Self {
-            sender: tx,
+            request_txs: final_txs.clone(),
+            round_robin_counter: AtomicUsize::new(0),
+            _resume_txs: final_txs,
             _workers: workers,
         }
-    }
+    
+}
 
-    // Optimized Execute method (Takes maps/vecs instead of JSON strings)
     pub async fn execute(
         &self, 
         action: String, 
@@ -108,9 +143,8 @@ impl RuntimeManager {
         headers: SmallVec<[(String, String); 8]>,
         params: SmallVec<[(String, String); 4]>,
         query: SmallVec<[(String, String); 4]>,
-    ) -> Result<serde_json::Value, String> {
+    ) -> Result<(serde_json::Value, Vec<(String, f64)>), String> {
         let (tx, rx) = oneshot::channel();
-        
         let task = RequestTask {
             action_name: action,
             body,
@@ -122,37 +156,90 @@ impl RuntimeManager {
             response_tx: tx,
         };
         
-        // Dispatch to RingBuffer/Channel
-        self.sender.send(WorkerCommand::Request(task)).map_err(|e| e.to_string())?;
+        // Round Robin Distribution
+        let idx = self.round_robin_counter.fetch_add(1, Ordering::Relaxed) % self.request_txs.len();
+        self.request_txs[idx].send(WorkerCommand::Request(task)).map_err(|e| e.to_string())?;
         
-        // Await Result (Async-Sync Bridge)
         match rx.await {
-            Ok(res) => Ok(res.json),
+            Ok(res) => Ok((res.json, res.timings)),
             Err(_) => Err("Worker channel closed".to_string()),
         }
     }
+}
+
+// ----------------------------------------------------------------------------
+// HANDLERS (Simpler - No Mutex/Vec lookup)
+// ----------------------------------------------------------------------------
 
+fn handle_new_request(task: RequestTask, rt: &mut TitanRuntime) {
+    rt.request_counter += 1;
+    let request_id = rt.request_counter;
+    rt.pending_requests.insert(request_id, task.response_tx);
+
+    let req_data = extensions::RequestData {
+        action_name: task.action_name.clone(),
+        body: task.body.clone(),
+        method: task.method.clone(),
+        path: task.path.clone(),
+        headers: task.headers.iter().map(|(k,v)| (k.clone(), v.clone())).collect(),
+        params: task.params.iter().map(|(k,v)| (k.clone(), v.clone())).collect(),
+        query: task.query.iter().map(|(k,v)| (k.clone(), v.clone())).collect(),
+    };
+    rt.active_requests.insert(request_id, req_data);
+    let drift_count = rt.drift_counter;
+    rt.request_start_counters.insert(request_id, drift_count);
+
+    extensions::execute_action_optimized(
+        rt,
+        request_id,
+        &task.action_name,
+        task.body,
+        &task.method,
+        &task.path,
+        &task.headers,
+        &task.params,
+        &task.query
+    );
+    
+    // Cleanup if sync
+    if !rt.pending_requests.contains_key(&request_id) {
+         rt.active_requests.remove(&request_id);
+         rt.request_start_counters.remove(&request_id);
+    }
 }
 
-fn handle_cmd(cmd: WorkerCommand, runtime: &mut extensions::TitanRuntime) {
-
-     match cmd {
-         WorkerCommand::Request(task) => {
-             // 3. Execution (Zero-Copy)
-             let result = extensions::execute_action_optimized(
-                runtime,
-                &task.action_name,
-                task.body,
-                &task.method,
-                &task.path,
-                &task.headers,
-                &task.params,
-                &task.query
-            );
-            
-            let _ = task.response_tx.send(WorkerResult {
-                json: result,
-            });
-         }
-     }
+fn handle_resume(drift_id: u32, result: WorkerAsyncResult, rt: &mut TitanRuntime) {
+    // 1. Identify which request this drift belongs to
+    let req_id = rt.drift_to_request.get(&drift_id).copied().unwrap_or(0);
+    
+    // 2. Perform Timing
+    let timing_type = if result.result.get("error").is_some() { "drift_error" } else { "drift" };
+    rt.request_timings.entry(req_id).or_default().push((timing_type.to_string(), result.duration_ms));
+
+    // 3. Store Result for Replay
+    rt.completed_drifts.insert(drift_id, result.result);
+    
+    // 4. Trigger Replay
+    if let Some(req_data) = rt.active_requests.get(&req_id).cloned() {
+        let start_counter = rt.request_start_counters.get(&req_id).copied().unwrap_or(0);
+        rt.drift_counter = start_counter; 
+
+        extensions::execute_action_optimized(
+            rt,
+            req_id,
+            &req_data.action_name,
+            req_data.body,
+            &req_data.method,
+            &req_data.path,
+            &req_data.headers,
+            &req_data.params,
+            &req_data.query
+        );
+    }
+
+    // 5. Cleanup
+    if req_id != 0 && !rt.pending_requests.contains_key(&req_id) {
+        rt.active_requests.remove(&req_id);
+        rt.request_start_counters.remove(&req_id);
+    }
 }

package/templates/titan/bundle.js

@@ -158,7 +158,7 @@ export async function bundleFile(options) {
 export async function bundle() {
     const root = process.cwd();
     const actionsDir = path.join(root, 'app', 'actions');
-    const bundleDir = path.join(root, 'server', 'actions');
+    const bundleDir = path.join(root, 'server', 'src', 'actions');
 
     // Ensure bundle directory exists and is clean
     if (fs.existsSync(bundleDir)) {
@@ -197,7 +197,7 @@ export async function bundle() {
                 minify: false,
                 sourcemap: false,
                 banner: {
-                    js: "const defineAction = (fn) => fn; const Titan = t;"
+                    js: "var Titan = t;"
                 },
                 footer: {
                     js: `
@@ -261,4 +261,4 @@ export async function bundle() {
             throw new Error('__TITAN_BUNDLE_FAILED__');
         }
     }
-}
+}

package/templates/titan/titan.js

@@ -72,7 +72,7 @@ const t = {
    * RULE: Only calls bundle() - does NOT handle esbuild errors
    * RULE: If bundle throws __TITAN_BUNDLE_FAILED__, stop immediately without printing
    */
-  async start(port = 3000, msg = "", threads) {
+  async start(port = 3000, msg = "", threads, stack_mb = 8) {
     try {
       console.log(cyan("[Titan] Preparing runtime..."));
 
@@ -91,7 +91,7 @@ const t = {
         routesPath,
         JSON.stringify(
           {
-            __config: { port, threads },
+            __config: { port, threads, stack_mb },
             routes,
             __dynamic_routes: Object.values(dynamicRoutes).flat()
           },