@ezetgalaxy/titan 26.13.0 → 26.13.3

package/index.js

@@ -107,13 +107,13 @@ export function help() {
     console.log(`
  ${bold(cyan("Titan Planet"))}  v${TITAN_VERSION}
 
- ${green("titan init <project> [-t <template>]")}   Create new Titan project
- ${green("titan create ext <name>")} Create new Titan extension
- ${green("titan dev")}              Dev mode (hot reload)
+ ${green("titan init <project> [-t <template>]")}   Create new TitanPl project
+ ${green("titan create ext <name>")} Create new TitanPl extension
+ ${green("titan dev [-c]")}        Dev mode (hot reload) [-c to backward clean]
  ${green("titan build")}            Build production Rust server
  ${green("titan start")}            Start production binary
- ${green("titan update")}           Update Titan engine
- ${green("titan --version")}        Show Titan CLI version
+ ${green("titan update")}           Update TitanPl Framework
+ ${green("titan --version")}        Show TitanPl CLI version
 
  ${yellow("Note: `tit` is supported as a legacy alias.")}
 `);
@@ -282,8 +282,31 @@ export async function initProject(name, templateName) {
 /* -------------------------------------------------------
  * DEV SERVER
  * ----------------------------------------------------- */
-export async function devServer() {
+export async function devServer(args = []) {
     const root = process.cwd();
+
+    // Check for clean cache flag
+    if (args.includes("-c") || args.includes("--clean") || args.includes("--clean-cache")) {
+        console.log(cyan("TitanPl: Clearing cache..."));
+
+        const pathsToClean = [
+            path.join(root, ".titan"),
+            path.join(root, "server", "actions"),
+            path.join(root, "server", "target")
+        ];
+
+        for (const p of pathsToClean) {
+            if (fs.existsSync(p)) {
+                try {
+                    fs.rmSync(p, { recursive: true, force: true });
+                    console.log(gray(`  ✔ Deleted ${path.relative(root, p)}`));
+                } catch (e) {
+                    console.log(yellow(`  ⚠ Could not delete ${path.relative(root, p)}: ${e.message}`));
+                }
+            }
+        }
+        console.log(green("✔ Cache cleared."));
+    }
     const devScript = path.join(root, "titan", "dev.js");
 
     if (!fs.existsSync(devScript)) {
@@ -461,6 +484,8 @@ export function updateTitan() {
     }
 
     const templatesRoot = path.join(__dirname, "templates", templateType);
+    const commonRoot = path.join(__dirname, "templates", "common");
+
     const templateTitan = path.join(templatesRoot, "titan");
     const templateServer = path.join(templatesRoot, "server");
 
@@ -530,11 +555,17 @@ export function updateTitan() {
         "_gitignore": ".gitignore",
         "_dockerignore": ".dockerignore",
         "Dockerfile": "Dockerfile",
-        "jsconfig.json": "jsconfig.json"
+        "jsconfig.json": "jsconfig.json",
+        "tsconfig.json": "tsconfig.json",
+        "eslint.config.js": "eslint.config.js"
     };
 
     for (const [srcName, destName] of Object.entries(rootFiles)) {
-        const src = path.join(templatesRoot, srcName);
+        let src = path.join(templatesRoot, srcName);
+        if (!fs.existsSync(src)) {
+            src = path.join(commonRoot, srcName);
+        }
+
         const dest = path.join(root, destName);
 
         if (fs.existsSync(src)) {
@@ -545,9 +576,10 @@ export function updateTitan() {
 
     // app/titan.d.ts (JS typing contract)
     const appDir = path.join(root, "app");
-    const srcDts = path.join(templateServer, "../app/titan.d.ts");
-    const fallbackDts = path.join(templatesRoot, "app", "titan.d.ts");
-    const finalDtsSrc = fs.existsSync(srcDts) ? srcDts : (fs.existsSync(fallbackDts) ? fallbackDts : null);
+    const templatesDts = path.join(templatesRoot, "app", "titan.d.ts");
+    const commonDts = path.join(commonRoot, "app", "titan.d.ts");
+
+    const finalDtsSrc = fs.existsSync(templatesDts) ? templatesDts : (fs.existsSync(commonDts) ? commonDts : null);
     const destDts = path.join(appDir, "titan.d.ts");
 
     if (finalDtsSrc) {
@@ -686,7 +718,7 @@ if (isMainModule) {
                     await initProject(projName, tpl);
                     break;
                 }
-                case "dev": devServer(); break;
+                case "dev": devServer(process.argv.slice(3)); break;
                 case "build": await buildProd(); break;
                 case "start": startProd(); break;
                 case "update": updateTitan(); break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "26.13.0",
+  "version": "26.13.3",
   "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",
@@ -18,6 +18,10 @@
   ],
   "keywords": [
     "titan",
+    "titanpl",
+    "t8n",
+    "tpl",
+    "tgrv",
     "titanjs",
     "ezetgalaxy",
     "framework",

package/templates/common/Dockerfile

@@ -1,66 +1,89 @@
 # ================================================================
-# STAGE 1 — Build Titan (JS → Rust)
+# STAGE 1 — Build TitanPl
 # ================================================================
-FROM rust:1.91.1 AS builder
+FROM node:20.20.0-slim AS builder
 
-# Install Node for Titan CLI + bundler
-RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
-    && apt-get install -y nodejs
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    curl ca-certificates build-essential pkg-config libssl-dev git bash \
+    && curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | \
+       sh -s -- -y --default-toolchain stable --profile minimal \
+    && rm -rf /var/lib/apt/lists/*
 
-# Install Titan CLI (latest)
-RUN npm install -g @ezetgalaxy/titan@latest
+ENV PATH="/root/.cargo/bin:${PATH}"
+ENV NODE_ENV=production
+ENV RUSTFLAGS="-C target-cpu=native -C strip=symbols"
+
+WORKDIR /app
 
+# ---------- Rust Cache ----------
+RUN mkdir -p server/src
+COPY server/Cargo.toml server/Cargo.lock* server/
+RUN echo "fn main(){}" > server/src/main.rs
+WORKDIR /app/server
+RUN cargo build --release
+RUN rm src/main.rs
 WORKDIR /app
 
-# Copy project files
+# ---------- Node Cache ----------
+COPY package.json package-lock.json* ./
+RUN if [ -f package-lock.json ]; then npm ci --omit=dev; else npm install --omit=dev; fi
+
+RUN npm install -g @ezetgalaxy/titan@latest
+
+# ---------- Copy Project ----------
 COPY . .
 
-# Install JS dependencies (needed for Titan DSL + bundler)
-RUN npm install
+RUN node app/app.js --build
 
+# ---------- Extensions ----------
 SHELL ["/bin/bash", "-c"]
-
-# Extract Titan extensions into .ext
 RUN mkdir -p /app/.ext && \
-    find /app/node_modules -maxdepth 5 -type f -name "titan.json" -print0 | \
+    find /app/node_modules -type f -name "titan.json" -print0 | \
     while IFS= read -r -d '' file; do \
-    pkg_dir="$(dirname "$file")"; \
-    pkg_name="$(basename "$pkg_dir")"; \
-    echo "Copying Titan extension: $pkg_name from $pkg_dir"; \
-    cp -r "$pkg_dir" "/app/.ext/$pkg_name"; \
-    done && \
-    echo "Extensions in .ext:" && \
-    ls -R /app/.ext
-
-# Build Titan metadata + bundle JS actions
-RUN titan build
-
-# Build Rust binary
+        pkg_dir="$(dirname "$file")"; \
+        pkg_name="$(basename "$pkg_dir")"; \
+        cp -r "$pkg_dir" "/app/.ext/$pkg_name"; \
+        rm -rf "/app/.ext/$pkg_name/node_modules"; \
+    done
+
 RUN cd server && cargo build --release
 
 
 
 # ================================================================
-# STAGE 2 — Runtime Image (Lightweight)
+# STAGE 2 — Runtime (Render Safe)
 # ================================================================
-FROM debian:stable-slim
+FROM debian:bookworm-slim
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends ca-certificates curl && \
+    rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app
 
-# Copy Rust binary from builder stage
+# ---- Copy Files as root ----
 COPY --from=builder /app/server/target/release/titan-server ./titan-server
+COPY --from=builder /app/server/routes.json .
+COPY --from=builder /app/server/action_map.json .
+COPY --from=builder /app/server/src/actions ./actions
+COPY --from=builder /app/app/static ./static
+COPY --from=builder /app/.ext ./.ext
 
-# Copy Titan routing metadata
-COPY --from=builder /app/server/routes.json ./routes.json
-COPY --from=builder /app/server/action_map.json ./action_map.json
+# ---- Ensure Executable ----
+RUN chmod +x ./titan-server
 
-# Copy Titan JS bundles
-RUN mkdir -p /app/actions
-COPY --from=builder /app/server/actions /app/actions
+# ---- Create User After Copy ----
+RUN useradd -m titan && chown -R titan:titan /app
+USER titan
 
-# Copy only Titan extensions
-COPY --from=builder /app/.ext ./.ext
+# ---- Platform Defaults ----
+ENV HOST=0.0.0.0
+ENV PORT=5100
+
+# ---- Verify Node Not Present ----
+RUN which node || echo "NodeJS not present ✔"
 
 EXPOSE 5100
 
-CMD ["./titan-server"]
+# ---- Force Foreground Process ----
+ENTRYPOINT ["./titan-server"]

package/templates/common/_dockerignore

@@ -1,3 +1,39 @@
 node_modules
 npm-debug.log
 .git
+.gitignore
+
+package-lock.json
+yarn.lock
+
+# Titan Runtime (Auto-generated - DO NOT COMMIT)
+titan/server-bin*
+.titan/
+server/routes.json
+server/action_map.json
+server/actions/
+server/titan/
+server/src/actions_rust/
+deploy/
+
+# Rust Build Artifacts
+server/target/
+Cargo.lock
+
+# OS Files
+.DS_Store
+Thumbs.db
+*.tmp
+*.bak
+
+# Environment & Secrets
+.env
+.env.local
+.env.*.local
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+

package/templates/common/app/titan.d.ts

@@ -10,7 +10,7 @@ export interface TitanBuilder {
     get(route: string): RouteHandler;
     post(route: string): RouteHandler;
     log(module: string, msg: string): void;
-    start(port?: number, msg?: string): Promise<void>;
+    start(port?: number, msg?: string, threads?: number): Promise<void>;
 }
 
 declare const builder: TitanBuilder;

package/templates/js/server/src/action_management.rs

@@ -34,30 +34,36 @@ pub fn resolve_actions_dir() -> PathBuf {
         return PathBuf::from("/app/actions");
     }
 
-    // Try to walk up from the executing binary to discover `<...>/server/actions`
+    // Try to walk up from the executing binary to discover `<...>/server/src/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");
+                    let candidate = server_dir.join("src").join("actions");
                     if candidate.exists() {
                         return candidate;
                     }
+                    let candidate2 = server_dir.join("actions");
+                    if candidate2.exists() {
+                        return candidate2;
+                    }
                 }
             }
         }
     }
 
-    // Fall back to local ./actions
-    PathBuf::from("./actions")
+    // Fall back to local ./src/actions
+    PathBuf::from("./src/actions")
 }
 
 /// Try to find the directory that contains compiled action bundles.
 pub fn find_actions_dir(project_root: &PathBuf) -> Option<PathBuf> {
     let candidates = [
+        project_root.join("server").join("src").join("actions"),
+        project_root.join("server").join("actions"),
         project_root.join("app").join("actions"),
         project_root.join("actions"),
-        project_root.join("server").join("actions"),
+
         project_root.join("..").join("server").join("actions"),
         PathBuf::from("/app").join("actions"),
         PathBuf::from("actions"),
@@ -139,17 +145,16 @@ pub fn match_dynamic_route(
 pub fn scan_actions(root: &PathBuf) -> HashMap<String, PathBuf> {
     let mut map = HashMap::new();
     
-    // Locate actions dir
-    let actions_dir = resolve_actions_dir();
-    let dir = if actions_dir.exists() {
-        actions_dir
-    } else {
-        match find_actions_dir(root) {
-            Some(d) => d,
-            None => return map, 
+    // Locate actions dir - Priority: project root relative paths
+    let dir = match find_actions_dir(root) {
+        Some(d) => d,
+        None => {
+            let ad = resolve_actions_dir();
+            if ad.exists() { ad } else { return map; }
         }
     };
 
+    // Scanning actions
     if let Ok(entries) = std::fs::read_dir(dir) {
         for entry in entries.flatten() {
             let path = entry.path();
@@ -163,9 +168,10 @@ pub fn scan_actions(root: &PathBuf) -> HashMap<String, PathBuf> {
             let file_stem = path.file_stem().and_then(|s| s.to_str()).unwrap_or("");
             if file_stem.is_empty() { continue; }
             
+            // Found action
             map.insert(file_stem.to_string(), path);
         }
     }
     
     map
-}
+}

package/templates/js/server/src/extensions/builtin.rs

@@ -158,12 +158,64 @@ fn setup_native_utils(scope: &mut v8::HandleScope, t_obj: v8::Local<v8::Object>)
     let fs_read_fn = v8::Function::new(scope, native_read).unwrap();
     let read_key = v8_str(scope, "read");
     fs_obj.set(scope, read_key.into(), fs_read_fn.into());
+
+    let fs_read_sync_fn = v8::Function::new(scope, native_read_sync).unwrap();
+    let read_sync_key = v8_str(scope, "readFile");
+    fs_obj.set(scope, read_sync_key.into(), fs_read_sync_fn.into());
+    
+    // Also Expose as t.readSync
+    let t_read_sync_fn = v8::Function::new(scope, native_read_sync).unwrap();
+    let t_read_sync_key = v8_str(scope, "readSync");
+    t_obj.set(scope, t_read_sync_key.into(), t_read_sync_fn.into());
     
     let fs_key = v8_str(scope, "fs");
     core_obj.set(scope, fs_key.into(), fs_obj.into());
     
-    let core_key = v8_str(scope, "core");
-    t_obj.set(scope, core_key.into(), core_obj.into());
+
+}
+
+fn native_read_sync(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments, mut retval: v8::ReturnValue) {
+    let path_val = args.get(0);
+    if !path_val.is_string() {
+        throw(scope, "readSync/readFile: path is required");
+        return;
+    }
+    let path_str = v8_to_string(scope, path_val);
+
+    let root = super::PROJECT_ROOT.get().cloned().unwrap_or_else(|| std::env::current_dir().unwrap_or_default());
+    let joined = root.join(&path_str);
+    
+    // Security Check
+    if let Ok(target) = joined.canonicalize() {
+        // In Docker, /app/static/index.html vs /app
+        // Canonical paths might resolve symlinks. 
+        // We just ensure it's within root or a subdirectory.
+        // For simplicity in this fix, we trust canonicalize logic if it exists, otherwise strict join.
+        if target.starts_with(&root.canonicalize().unwrap_or(root.clone())) {
+            match std::fs::read_to_string(&target) {
+                Ok(content) => {
+                    let v8_content = v8_str(scope, &content);
+                    retval.set(v8_content.into());
+                },
+                Err(e) => {
+                     // Return null or throw? Node's readFile throws. Titan types say return string.
+                     // The user's code: fs.readFile(...) || "Default"
+                     // This implies it might return undefined/null on failure?
+                     // Or maybe they expect it to succeed. 
+                     // Let's throw to be safe for debugging, or return null if not found?
+                     // "||" handles null/undefined usually.
+                     // But usually readFile throws if file not found.
+                     // Let's print error and return null to avoid crashing entire worker init if optional.
+                     retval.set(v8::null(scope).into());
+                }
+            }
+        } else {
+             retval.set(v8::null(scope).into());
+        }
+    } else {
+        // File doesn't exist usually
+        retval.set(v8::null(scope).into());
+    }
 }
 
 fn native_read(scope: &mut v8::HandleScope, args: v8::FunctionCallbackArguments, mut retval: v8::ReturnValue) {
@@ -684,13 +736,11 @@ fn native_drift_call(scope: &mut v8::HandleScope, mut args: v8::FunctionCallback
     // Trigger Tokio task completion handling in a separate bridge
     let tokio_handle = runtime.tokio_handle.clone();
     let worker_tx = runtime.worker_tx.clone();
-    let isolate_id = runtime.id; 
     
     tokio_handle.spawn(async move {
         if let Ok(res) = rx.await {
             // Signal the pool to RESUME (REPLAY) this specific isolate
             let _ = worker_tx.send(crate::runtime::WorkerCommand::Resume {
-                isolate_id,
                 drift_id,
                 result: res,
             });
@@ -703,7 +753,6 @@ fn native_drift_call(scope: &mut v8::HandleScope, mut args: v8::FunctionCallback
 fn native_finish_request(scope: &mut v8::HandleScope, mut args: v8::FunctionCallbackArguments, _retval: v8::ReturnValue) {
     let request_id = args.get(0).uint32_value(scope).unwrap_or(0);
     let result_val = args.get(1);
-    
     let json = super::v8_to_json(scope, result_val);
 
     let runtime_ptr = unsafe { args.get_isolate() }.get_data(0) as *mut super::TitanRuntime;

package/templates/js/server/src/extensions/external.rs

@@ -104,8 +104,10 @@ pub fn load_project_extensions(root: PathBuf) {
         }
     }
     
-    if node_modules.exists() {
-        for entry in WalkDir::new(&node_modules).follow_links(true).min_depth(1).max_depth(4) {
+    // Generic scanner helper
+    let scan_dir = |path: PathBuf, modules: &mut Vec<ModuleDef>, libs: &mut Vec<Library>, all_natives: &mut Vec<NativeFnEntry>| {
+        if !path.exists() { return; }
+        for entry in WalkDir::new(&path).follow_links(true).min_depth(1).max_depth(4) {
             let entry = match entry { Ok(e) => e, Err(_) => continue };
             if entry.file_type().is_file() && entry.file_name() == "titan.json" {
                 let dir = entry.path().parent().unwrap();
@@ -118,17 +120,28 @@ pub fn load_project_extensions(root: PathBuf) {
                 if let Some(native_conf) = config.native {
                      let lib_path = dir.join(&native_conf.path);
                      unsafe {
-                         if let Ok(lib) = Library::new(&lib_path) {
-                             for (fn_name, fn_conf) in native_conf.functions {
-                                 let params = fn_conf.parameters.iter().map(|p| parse_type(&p.to_lowercase())).collect();
-                                 let ret = parse_return(&fn_conf.result.to_lowercase());
-                                 if let Ok(symbol) = lib.get::<*const ()>(fn_conf.symbol.as_bytes()) {
-                                      let idx = all_natives.len();
-                                      all_natives.push(NativeFnEntry { symbol_ptr: *symbol as usize, sig: Signature { params, ret } });
-                                      mod_natives_map.insert(fn_name, idx);
+                         // Try loading library
+                         let lib_load = Library::new(&lib_path);
+                         // If failed, try resolving relative to current dir or LD_LIBRARY_PATH implicit
+                         // But usually absolute path from `dir` works.
+                         match lib_load {
+                            Ok(lib) => {
+                                 for (fn_name, fn_conf) in native_conf.functions {
+                                     let params = fn_conf.parameters.iter().map(|p| parse_type(&p.to_lowercase())).collect();
+                                     let ret = parse_return(&fn_conf.result.to_lowercase());
+                                     if let Ok(symbol) = lib.get::<*const ()>(fn_conf.symbol.as_bytes()) {
+                                          let idx = all_natives.len();
+                                          all_natives.push(NativeFnEntry { symbol_ptr: *symbol as usize, sig: Signature { params, ret } });
+                                          mod_natives_map.insert(fn_name, idx);
+                                     } else {
+                                          println!("{} {} {} -> {}", blue("[Titan]"), red("Symbol not found:"), fn_conf.symbol, config.name);
+                                     }
                                  }
-                             }
-                             libs.push(lib);
+                                 libs.push(lib);
+                            },
+                            Err(e) => {
+                                println!("{} {} {} -> {:?}", blue("[Titan]"), red("Failed to load native lib:"), config.name, e);
+                            }
                          }
                      }
                 }
@@ -137,7 +150,19 @@ pub fn load_project_extensions(root: PathBuf) {
                 println!("{} {} {}", blue("[Titan]"), green("Extension loaded:"), config.name);
             }
         }
+    };
+
+    // Scan node_modules
+    if node_modules.exists() {
+        scan_dir(node_modules, &mut modules, &mut libs, &mut all_natives);
     }
+
+    // Scan .ext (Production / Docker)
+    let ext_dir = root.join(".ext");
+    if ext_dir.exists() {
+        scan_dir(ext_dir, &mut modules, &mut libs, &mut all_natives);
+    }
+    
     *REGISTRY.lock().unwrap() = Some(Registry { _libs: libs, modules, natives: all_natives });
 }
 

package/templates/js/server/src/extensions/mod.rs

@@ -119,6 +119,13 @@ pub struct RequestData {
 unsafe impl Send for TitanRuntime {}
 unsafe impl Sync for TitanRuntime {}
 
+impl TitanRuntime {
+    pub fn bind_to_isolate(&mut self) {
+        let ptr = self as *mut TitanRuntime as *mut std::ffi::c_void;
+        self.isolate.set_data(0, ptr);
+    }
+}
+
 static V8_INIT: Once = Once::new();
 
 pub fn init_v8() {
@@ -135,17 +142,14 @@ pub fn init_runtime_worker(
     worker_tx: crossbeam::channel::Sender<crate::runtime::WorkerCommand>,
     tokio_handle: tokio::runtime::Handle,
     global_async_tx: tokio::sync::mpsc::Sender<AsyncOpRequest>,
+    stack_size: usize,
 ) -> TitanRuntime {
     init_v8();
 
-    // Memory optimization strategy (v8 0.106.0 limitations):
-    // - V8 snapshots reduce memory footprint by sharing compiled code
-    // - Each isolate still has its own heap, but the snapshot reduces base overhead
-    // - For explicit heap limits, use V8 flags: --max-old-space-size=128
-
+    // Memory optimization strategy
     let params = v8::CreateParams::default();
     let mut isolate = v8::Isolate::new(params);
-
+    
     let (global_context, actions_map) = {
         let handle_scope = &mut v8::HandleScope::new(&mut isolate);
         let context = v8::Context::new(handle_scope, v8::ContextOptions::default());
@@ -165,6 +169,7 @@ pub fn init_runtime_worker(
         let action_files = scan_actions(&root);
         for (name, path) in action_files {
             if let Ok(code) = fs::read_to_string(&path) {
+                // Wrap action in an IIFE to capture its exports and register it globally
                 let wrapped_source =
                     format!("(function() {{ {} }})(); globalThis[\"{}\"];", code, name);
                 let source_str = v8_str(scope, &wrapped_source);
@@ -174,8 +179,22 @@ pub fn init_runtime_worker(
                         if val.is_function() {
                             let func = v8::Local::<v8::Function>::try_from(val).unwrap();
                             map.insert(name.clone(), v8::Global::new(try_catch, func));
+                        } else if id == 0 {
+                            println!("[V8] Action '{}' did not evaluate to a function: {:?}", name, val.to_rust_string_lossy(try_catch));
                         }
+                    } else if id == 0 {
+                        let msg = try_catch
+                            .message()
+                            .map(|m| m.get(try_catch).to_rust_string_lossy(try_catch))
+                            .unwrap_or("Unknown run error".to_string());
+                        println!("[V8] Failed to run action '{}': {}", name, msg);
                     }
+                } else if id == 0 {
+                    let msg = try_catch
+                        .message()
+                        .map(|m| m.get(try_catch).to_rust_string_lossy(try_catch))
+                        .unwrap_or("Unknown compile error".to_string());
+                    println!("[V8] Failed to compile action '{}': {}", name, msg);
                 }
             }
         }
@@ -312,6 +331,7 @@ pub fn execute_action_optimized(
     params: &[(String, String)],
     query: &[(String, String)],
 ) {
+    // Execute action in V8
     let context_global = runtime.context.clone();
     let actions_map = runtime.actions.clone(); // Clone the map of globals (cheap)
     let isolate = &mut runtime.isolate;
@@ -384,21 +404,19 @@ pub fn execute_action_optimized(
         let try_catch = &mut v8::TryCatch::new(scope);
 
         if let Some(_) = action_fn.call(try_catch, global.into(), &[req_obj.into()]) {
-            // JS side is responsible for calling t._finish_request(requestId, result)
-            // Even if the action is NOT async, our JS wrapper in titan_core.js will handle it.
             return;
         }
-
+        
         let msg = try_catch
             .message()
             .map(|m| m.get(try_catch).to_rust_string_lossy(try_catch))
             .unwrap_or("Unknown error".to_string());
         
-        // Check for suspension
         if msg.contains("SUSPEND") {
             return;
         }
 
+        println!("[Isolate {}] Action Error: {}", runtime.id, msg);
         if let Some(tx) = runtime.pending_requests.remove(&request_id) {
              let _ = tx.send(crate::runtime::WorkerResult { 
                  json: serde_json::json!({"error": msg}),