npm - @ezetgalaxy/titan - Versions diffs - 26.8.3 → 26.9.1 - Mend

@ezetgalaxy/titan 26.8.3 → 26.9.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (106) hide show

package/README.md +76 -17
package/index.js +118 -29
package/package.json +1 -2
package/templates/extension/README.md +104 -104
package/templates/extension/index.js +27 -27
package/templates/extension/jsconfig.json +12 -12
package/templates/extension/native/Cargo.toml +9 -9
package/templates/extension/native/src/lib.rs +5 -5
package/templates/extension/package.json +20 -20
package/templates/extension/titan.json +17 -17
package/templates/js/Dockerfile +66 -66
package/templates/js/_dockerignore +3 -3
package/templates/js/_gitignore +1 -0
package/templates/js/app/actions/hello.js +5 -5
package/templates/js/app/titan.d.ts +87 -87
package/templates/js/jsconfig.json +18 -18
package/templates/js/server/src/action_management.rs +131 -131
package/templates/js/server/src/errors.rs +10 -10
package/templates/js/server/src/extensions.rs +989 -989
package/templates/js/server/src/utils.rs +33 -33
package/templates/js/titan/bundle.js +78 -78
package/templates/js/titan/dev.js +9 -1
package/templates/js/titan/titan.js +122 -122
package/templates/{rust → rust-js}/Dockerfile +66 -66
package/templates/{rust → rust-js}/_dockerignore +3 -3
package/templates/{rust → rust-js}/_gitignore +1 -0
package/templates/{rust → rust-js}/app/actions/hello.js +5 -5
package/templates/{rust → rust-js}/app/actions/rust_hello.rs +14 -14
package/templates/{rust → rust-js}/app/titan.d.ts +101 -101
package/templates/{rust → rust-js}/jsconfig.json +18 -18
package/templates/{rust → rust-js}/package.json +1 -1
package/templates/{rust → rust-js}/server/src/action_management.rs +131 -131
package/templates/{rust → rust-js}/server/src/errors.rs +10 -10
package/templates/{rust → rust-js}/server/src/extensions.rs +989 -989
package/templates/{rust → rust-js}/server/src/utils.rs +33 -33
package/templates/{rust → rust-js}/titan/dev.js +9 -1
package/templates/rust-ts/Dockerfile +66 -0
package/templates/rust-ts/_dockerignore +3 -0
package/templates/rust-ts/_gitignore +38 -0
package/templates/rust-ts/app/actions/hello.ts +11 -0
package/templates/rust-ts/app/actions/rust_hello.rs +14 -0
package/templates/rust-ts/app/app.ts +11 -0
package/templates/rust-ts/package.json +14 -0
package/templates/rust-ts/server/Cargo.lock +2869 -0
package/templates/rust-ts/server/Cargo.toml +39 -0
package/templates/rust-ts/server/src/action_management.rs +131 -0
package/templates/rust-ts/server/src/errors.rs +51 -0
package/templates/rust-ts/server/src/extensions.rs +989 -0
package/templates/rust-ts/server/src/main.rs +468 -0
package/templates/rust-ts/server/src/utils.rs +33 -0
package/templates/rust-ts/titan/bundle.js +163 -0
package/templates/rust-ts/titan/dev.js +402 -0
package/templates/rust-ts/titan/titan.d.ts +117 -0
package/templates/rust-ts/titan/titan.js +122 -0
package/templates/rust-ts/tsconfig.json +21 -0
package/templates/ts/Dockerfile +40 -0
package/templates/ts/_dockerignore +3 -0
package/templates/ts/_gitignore +38 -0
package/templates/ts/app/actions/hello.ts +11 -0
package/templates/ts/app/app.ts +10 -0
package/templates/ts/package.json +26 -0
package/templates/ts/server/Cargo.lock +2869 -0
package/templates/ts/server/Cargo.toml +27 -0
package/templates/ts/server/src/action_management.rs +131 -0
package/templates/ts/server/src/errors.rs +51 -0
package/templates/ts/server/src/extensions.rs +989 -0
package/templates/ts/server/src/main.rs +437 -0
package/templates/ts/server/src/utils.rs +33 -0
package/templates/ts/titan/builder.js +121 -0
package/templates/ts/titan/bundle.js +76 -0
package/templates/ts/titan/dev.js +402 -0
package/templates/ts/titan/runtime.js +1 -0
package/templates/ts/titan/titan.d.ts +117 -0
package/templates/ts/titan/titan.js +122 -0
package/templates/ts/tsconfig.json +16 -0
package/titanpl-sdk/README.md +109 -109
package/titanpl-sdk/bin/run.js +251 -254
package/titanpl-sdk/index.d.ts +46 -46
package/titanpl-sdk/index.js +5 -5
package/titanpl-sdk/package.json +32 -32
package/titanpl-sdk/templates/.dockerignore +3 -3
package/titanpl-sdk/templates/Dockerfile +53 -53
package/titanpl-sdk/templates/app/actions/hello.js +5 -5
package/titanpl-sdk/templates/app/titan.d.ts +87 -87
package/titanpl-sdk/templates/jsconfig.json +18 -18
package/titanpl-sdk/templates/server/src/action_management.rs +131 -131
package/titanpl-sdk/templates/server/src/errors.rs +10 -10
package/titanpl-sdk/templates/server/src/extensions.rs +640 -640
package/titanpl-sdk/templates/server/src/utils.rs +33 -33
package/titanpl-sdk/templates/titan/bundle.js +65 -65
package/titanpl-sdk/templates/titan/dev.js +113 -113
package/titanpl-sdk/templates/titan/titan.js +98 -98
package/templates/js/server/action_map.json +0 -3
package/templates/js/server/actions/hello.jsbundle +0 -48
package/templates/js/server/routes.json +0 -16
package/templates/rust/server/action_map.json +0 -3
package/templates/rust/server/actions/hello.jsbundle +0 -47
package/templates/rust/server/routes.json +0 -22
package/templates/rust/server/src/actions_rust/mod.rs +0 -19
package/templates/rust/server/src/actions_rust/rust_hello.rs +0 -14
/package/templates/{rust → rust-js}/app/app.js +0 -0
/package/templates/{rust → rust-js}/server/Cargo.lock +0 -0
/package/templates/{rust → rust-js}/server/Cargo.toml +0 -0
/package/templates/{rust → rust-js}/server/src/main.rs +0 -0
/package/templates/{rust → rust-js}/titan/bundle.js +0 -0
/package/templates/{rust → rust-js}/titan/titan.js +0 -0

package/templates/ts/server/src/main.rs ADDED Viewed

@@ -0,0 +1,437 @@
+use anyhow::Result;
+use axum::{
+    Router,
+    body::{Body, to_bytes},
+    extract::State,
+    http::{Request, StatusCode},
+    response::{IntoResponse, Json},
+    routing::any,
+};
+use serde_json::Value;
+use std::time::Instant;
+use std::{collections::HashMap, fs, path::PathBuf, sync::Arc};
+use tokio::net::TcpListener;
+mod utils;
+mod errors;
+mod action_management;
+mod extensions;
+use action_management::{
+    DynamicRoute, RouteVal, find_actions_dir, match_dynamic_route, resolve_actions_dir,
+};
+use extensions::{init_v8, inject_extensions};
+use utils::{blue, gray, green, red, white, yellow};
+#[derive(Clone)]
+struct AppState {
+    routes: Arc<HashMap<String, RouteVal>>,
+    dynamic_routes: Arc<Vec<DynamicRoute>>,
+    project_root: PathBuf,
+}
+// Root/dynamic handlers -----------------------------------------------------
+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_inner(
+    State(state): State<AppState>,
+    req: Request<Body>,
+) -> impl IntoResponse {
+    // ---------------------------
+    // BASIC REQUEST INFO
+    // ---------------------------
+    let method = req.method().as_str().to_uppercase();
+    let path = req.uri().path().to_string();
+    let key = format!("{}:{}", method, path);
+    // ---------------------------
+    // TIMER + LOG META
+    // ---------------------------
+    let start = Instant::now();
+    let mut route_label = String::from("not_found");
+    let mut route_kind = "none"; // exact | dynamic | reply
+    // ---------------------------
+    // QUERY PARSING
+    // ---------------------------
+    let query: HashMap<String, String> = req
+        .uri()
+        .query()
+        .map(|q| {
+            q.split('&')
+                .filter_map(|pair| {
+                    let mut it = pair.splitn(2, '=');
+                    Some((it.next()?.to_string(), it.next().unwrap_or("").to_string()))
+                })
+                .collect()
+        })
+        .unwrap_or_default();
+    // ---------------------------
+    // HEADERS & BODY
+    // ---------------------------
+    let (parts, body) = req.into_parts();
+    let headers = parts
+        .headers
+        .iter()
+        .map(|(k, v)| (k.to_string(), v.to_str().unwrap_or("").to_string()))
+        .collect::<HashMap<String, String>>();
+    let body_bytes = match to_bytes(body, usize::MAX).await {
+        Ok(b) => b,
+        Err(_) => return (StatusCode::BAD_REQUEST, "Failed to read request body").into_response(),
+    };
+    let body_str = String::from_utf8_lossy(&body_bytes).to_string();
+    let body_json: Value = if body_str.is_empty() {
+        Value::Null
+    } else {
+        serde_json::from_str(&body_str).unwrap_or(Value::String(body_str))
+    };
+    // ---------------------------
+    // ROUTE RESOLUTION
+    // ---------------------------
+    let mut params: HashMap<String, String> = HashMap::new();
+    let mut action_name: Option<String> = None;
+    // Exact route
+    if let Some(route) = state.routes.get(&key) {
+        route_kind = "exact";
+        if route.r#type == "action" {
+            let name = route.value.as_str().unwrap_or("unknown").to_string();
+            route_label = name.clone();
+            action_name = Some(name);
+        } else if route.r#type == "json" {
+            let elapsed = start.elapsed();
+            println!(
+                "{} {} {} {}",
+                blue("[Titan]"),
+                white(&format!("{} {}", method, path)),
+                white("→ json"),
+                gray(&format!("in {:.2?}", elapsed))
+            );
+            return Json(route.value.clone()).into_response();
+        } else if let Some(s) = route.value.as_str() {
+            let elapsed = start.elapsed();
+            println!(
+                "{} {} {} {}",
+                blue("[Titan]"),
+                white(&format!("{} {}", method, path)),
+                white("→ reply"),
+                gray(&format!("in {:.2?}", elapsed))
+            );
+            return s.to_string().into_response();
+        }
+    }
+    // Dynamic route
+    if action_name.is_none() {
+        if let Some((action, p)) =
+            match_dynamic_route(&method, &path, state.dynamic_routes.as_slice())
+        {
+            route_kind = "dynamic";
+            route_label = action.clone();
+            action_name = Some(action);
+            params = p;
+        }
+    }
+    let action_name = match action_name {
+        Some(a) => a,
+        None => {
+            let elapsed = start.elapsed();
+            println!(
+                "{} {} {} {}",
+                blue("[Titan]"),
+                white(&format!("{} {}", method, path)),
+                white("→ 404"),
+                gray(&format!("in {:.2?}", elapsed))
+            );
+            return (StatusCode::NOT_FOUND, "Not Found").into_response();
+        }
+    };
+    // ---------------------------
+    // LOAD ACTION
+    // ---------------------------
+    let resolved = resolve_actions_dir();
+    let actions_dir = resolved
+        .exists()
+        .then(|| resolved)
+        .or_else(|| find_actions_dir(&state.project_root))
+        .unwrap();
+    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(_) => return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                Json(
+                    serde_json::json!({"error": "Action bundle not found", "action": action_name}),
+                ),
+            )
+                .into_response(),
+        };
+    // ---------------------------
+    // EXECUTE IN V8
+    // ---------------------------
+    let env_json = std::env::vars()
+        .map(|(k, v)| (k, Value::String(v)))
+        .collect::<serde_json::Map<_, _>>();
+    let injected = format!(
+        r#"
+        globalThis.process = {{ env: {} }};
+        const __titan_req = {{
+            body: {},
+            method: "{}",
+            path: "{}",
+            headers: {},
+            params: {},
+            query: {}
+        }};
+        (function() {{
+            {}
+        }})(); // Run the bundle
+        // Call the action
+        if (typeof globalThis["{}"] === 'function') {{
+            globalThis["{}"](__titan_req);
+        }} else {{
+            throw new Error("Action function '{}' not found in bundle");
+        }}
+        "#,
+        Value::Object(env_json).to_string(),
+        body_json.to_string(),
+        method,
+        path,
+        serde_json::to_string(&headers).unwrap(),
+        serde_json::to_string(&params).unwrap(),
+        serde_json::to_string(&query).unwrap(),
+        js_code,
+        action_name,
+        action_name,
+        action_name
+    );
+    // Run V8 in a blocking task safely?
+    // Axum handlers are async. V8 operations should be blocking.
+    // We can use `task::spawn_blocking`.
+    let root = state.project_root.clone();
+    let action_name_for_v8 = action_name.clone();
+    let result_json: Value = tokio::task::spawn_blocking(move || {
+        let isolate = &mut v8::Isolate::new(v8::CreateParams::default());
+        let handle_scope = &mut v8::HandleScope::new(isolate);
+        let context = v8::Context::new(handle_scope, v8::ContextOptions::default());
+        let scope = &mut v8::ContextScope::new(handle_scope, context);
+        let global = context.global(scope);
+        // Inject extensions (t.read, etc)
+        inject_extensions(scope, global);
+        // Set metadata globals
+        let root_str = v8::String::new(scope, root.to_str().unwrap_or(".")).unwrap();
+        let root_key = v8::String::new(scope, "__titan_root").unwrap();
+        global.set(scope, root_key.into(), root_str.into());
+        let action_str = v8::String::new(scope, &action_name_for_v8).unwrap();
+        let action_key = v8::String::new(scope, "__titan_action").unwrap();
+        global.set(scope, action_key.into(), action_str.into());
+        let try_catch = &mut v8::TryCatch::new(scope);
+        let source = v8::String::new(try_catch, &injected).unwrap();
+        let resource_name = v8::String::new(try_catch, &format!("app/actions/{}.ts", action_name_for_v8)).unwrap();
+        let source_map_url = v8::String::new(try_catch, "").unwrap();
+        let origin = v8::ScriptOrigin::new(
+            try_catch,
+            resource_name.into(),
+            0, // line offset
+            0, // column offset
+            false, // is_shared_cross_origin
+            123, // script_id
+            None, // source_map_url
+            true, // is_opaque
+            false, // is_wasm
+            false, // is_module
+            None,
+        );
+        let script = match v8::Script::compile(try_catch, source, Some(&origin)) {
+            Some(s) => s,
+            None => {
+                let msg = crate::errors::format_v8_error(try_catch, &action_name_for_v8);
+                return serde_json::json!({ "error": msg, "phase": "compile" });
+            }
+        };
+        let result = script.run(try_catch);
+        match result {
+            Some(val) => {
+                // Convert v8 Value to Serde JSON
+                // Minimal impl: stringify
+                let json_obj = v8::json::stringify(try_catch, val).unwrap();
+                let json_str = json_obj.to_rust_string_lossy(try_catch);
+                serde_json::from_str(&json_str).unwrap_or(Value::Null)
+            }
+            None => {
+                let msg = crate::errors::format_v8_error(try_catch, &action_name_for_v8);
+                serde_json::json!({ "error": msg, "phase": "execution" })
+            }
+        }
+    })
+    .await
+    .unwrap_or(serde_json::json!({"error": "V8 task failed"}));
+    // ---------------------------
+    // FINAL LOG
+    // ---------------------------
+    let elapsed = start.elapsed();
+    // Check for errors in result
+    if let Some(err) = result_json.get("error") {
+        println!(
+            "{} {} {} {}",
+            blue("[Titan]"),
+            red(&format!("{} {}", method, path)),
+            red("→ error"),
+            gray(&format!("in {:.2?}", elapsed))
+        );
+        println!("{}", 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))
+        ),
+        _ => {}
+    }
+    Json(result_json).into_response()
+}
+// Entrypoint ---------------------------------------------------------------
+#[tokio::main]
+async fn main() -> Result<()> {
+    dotenvy::dotenv().ok();
+    init_v8(); // Init platform once
+    // 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 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)
+    let project_root = resolve_project_root();
+    let state = AppState {
+        routes: Arc::new(map),
+        dynamic_routes: Arc::new(dynamic_routes),
+        project_root: project_root.clone(),
+    };
+    // Load extensions
+    extensions::load_project_extensions(project_root.clone());
+    let app = Router::new()
+        .route("/", any(root_route))
+        .fallback(any(dynamic_route))
+        .with_state(state);
+    let listener = loop {
+        match TcpListener::bind(format!("0.0.0.0:{}", port)).await {
+            Ok(l) => break l,
+            Err(e) => {
+                if e.kind() == std::io::ErrorKind::AddrInUse {
+                    println!(
+                        "{} {}",
+                        utils::yellow("[Titan]"),
+                        utils::gray("Port in use, waiting for orbit to clear...")
+                    );
+                    tokio::time::sleep(std::time::Duration::from_millis(100)).await;
+                    continue;
+                }
+                return Err(e.into());
+            }
+        }
+    };
+    println!(
+        "\x1b[38;5;39mTitan server running at:\x1b[0m http://localhost:{}",
+        port
+    );
+    axum::serve(listener, app).await?;
+    Ok(())
+}
+fn resolve_project_root() -> PathBuf {
+    // 1. Check CWD (preferred for local dev/tooling)
+    if let Ok(cwd) = std::env::current_dir() {
+        if cwd.join("node_modules").exists()
+            || cwd.join("package.json").exists()
+            || cwd.join(".ext").exists()
+        {
+            return cwd;
+        }
+    }
+    // 2. Check executable persistence (Docker / Production)
+    // Walk up from the executable to find .ext or node_modules
+    if let Ok(exe) = std::env::current_exe() {
+        let mut current = exe.parent();
+        while let Some(dir) = current {
+            if dir.join(".ext").exists() || dir.join("node_modules").exists() {
+                return dir.to_path_buf();
+            }
+            current = dir.parent();
+        }
+    }
+    // 3. Fallback to CWD
+    std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."))
+}

package/templates/ts/server/src/utils.rs ADDED Viewed

@@ -0,0 +1,33 @@
+pub fn blue(s: &str) -> String {
+    format!("\x1b[38;5;39m{}\x1b[0m", s)
+}
+pub fn white(s: &str) -> String {
+    format!("\x1b[39m{}\x1b[0m", s)
+}
+pub fn yellow(s: &str) -> String {
+    format!("\x1b[33m{}\x1b[0m", s)
+}
+pub fn green(s: &str) -> String {
+    format!("\x1b[32m{}\x1b[0m", s)
+}
+pub fn gray(s: &str) -> String {
+    format!("\x1b[90m{}\x1b[0m", s)
+}
+pub fn red(s: &str) -> String {
+    format!("\x1b[31m{}\x1b[0m", s)
+}
+pub fn parse_expires_in(value: &str) -> Option<u64> {
+    let (num, unit) = value.split_at(value.len() - 1);
+    let n: u64 = num.parse().ok()?;
+    match unit {
+        "s" => Some(n),
+        "m" => Some(n * 60),
+        "h" => Some(n * 60 * 60),
+        "d" => Some(n * 60 * 60 * 24),
+        _ => None,
+    }
+}

package/templates/ts/titan/builder.js ADDED Viewed

@@ -0,0 +1,121 @@
+import { bundle } from "./bundle.js";
+import fs from "fs";
+import path from "path";
+const cyan = (t) => `\x1b[36m${t}\x1b[0m`;
+const green = (t) => `\x1b[32m${t}\x1b[0m`;
+const routes = {};
+const dynamicRoutes = {};
+const actionMap = {};
+function addRoute(method, route) {
+    const key = `${method.toUpperCase()}:${route}`;
+    return {
+        reply(value) {
+            routes[key] = {
+                type: typeof value === "object" ? "json" : "text",
+                value
+            };
+        },
+        action(name) {
+            if (route.includes(":")) {
+                if (!dynamicRoutes[method]) dynamicRoutes[method] = [];
+                dynamicRoutes[method].push({
+                    method: method.toUpperCase(),
+                    pattern: route,
+                    action: name
+                });
+            } else {
+                routes[key] = {
+                    type: "action",
+                    value: name
+                };
+                actionMap[key] = name;
+            }
+        }
+    };
+}
+/**
+ * @typedef {Object} RouteHandler
+ * @property {(value: any) => void} reply - Send a direct response
+ * @property {(name: string) => void} action - Bind to a server-side action
+ */
+/**
+ * Titan App Builder
+ */
+const t = {
+    /**
+     * Define a GET route
+     * @param {string} route
+     * @returns {RouteHandler}
+     */
+    get(route) {
+        return addRoute("GET", route);
+    },
+    /**
+     * Define a POST route
+     * @param {string} route
+     * @returns {RouteHandler}
+     */
+    post(route) {
+        return addRoute("POST", route);
+    },
+    log(module, msg) {
+        console.log(`[\x1b[35m${module}\x1b[0m] ${msg}`);
+    },
+    /**
+     * Start the Titan Server
+     * @param {number} [port=3000]
+     * @param {string} [msg=""]
+     */
+    async start(port = 3000, msg = "") {
+        try {
+            console.log(cyan("[Titan] Preparing runtime..."));
+            await bundle();
+            const base = path.join(process.cwd(), "server");
+            if (!fs.existsSync(base)) {
+                fs.mkdirSync(base, { recursive: true });
+            }
+            const routesPath = path.join(base, "routes.json");
+            const actionMapPath = path.join(base, "action_map.json");
+            fs.writeFileSync(
+                routesPath,
+                JSON.stringify(
+                    {
+                        __config: { port },
+                        routes,
+                        __dynamic_routes: Object.values(dynamicRoutes).flat()
+                    },
+                    null,
+                    2
+                )
+            );
+            fs.writeFileSync(
+                actionMapPath,
+                JSON.stringify(actionMap, null, 2)
+            );
+            console.log(green("✔ Titan metadata written successfully"));
+            if (msg) console.log(cyan(msg));
+        } catch (e) {
+            console.error(`\x1b[31m[Titan] Build Error: ${e.message}\x1b[0m`);
+            process.exit(1);
+        }
+    }
+};
+export default t;

package/templates/ts/titan/bundle.js ADDED Viewed

@@ -0,0 +1,76 @@
+import fs from "fs";
+import path from "path";
+import esbuild from "esbuild";
+export async function bundle() {
+  const root = process.cwd();
+  const actionsDir = path.join(root, "app", "actions");
+  const outDir = path.join(root, "server", "actions");
+  const start = Date.now();
+  await bundleJs(actionsDir, outDir);
+  // console.log(`[Titan] Bundle finished in ${((Date.now() - start) / 1000).toFixed(2)}s`);
+}
+async function bundleJs(actionsDir, outDir) {
+  // console.log("[Titan] Bundling JS actions...");
+  fs.mkdirSync(outDir, { recursive: true });
+  // Clean old bundles
+  const oldFiles = fs.readdirSync(outDir);
+  for (const file of oldFiles) {
+    fs.unlinkSync(path.join(outDir, file));
+  }
+  const files = fs.readdirSync(actionsDir).filter(f => f.endsWith(".js") || f.endsWith(".ts"));
+  if (files.length === 0) return;
+  // console.log(`[Titan] Bundling ${files.length} JS actions...`);
+  for (const file of files) {
+    const actionName = path.basename(file, path.extname(file));
+    const entry = path.join(actionsDir, file);
+    // Rust runtime expects `.jsbundle` extension — consistent with previous design
+    const outfile = path.join(outDir, actionName + ".jsbundle");
+    // console.log(`[Titan] Bundling ${entry} → ${outfile}`);
+    await esbuild.build({
+      entryPoints: [entry],
+      outfile,
+      bundle: true,
+      format: "iife",
+      globalName: "__titan_exports",
+      platform: "neutral",
+      target: "es2020",
+      logLevel: "silent",
+      banner: {
+        js: "const defineAction = (fn) => fn;"
+      },
+      footer: {
+        js: `
+    (function () {
+      const fn =
+        __titan_exports["${actionName}"] ||
+        __titan_exports.default;
+      if (typeof fn !== "function") {
+        throw new Error("[Titan] Action '${actionName}' not found or not a function");
+      }
+      globalThis["${actionName}"] = function(request_arg) {
+         globalThis.req = request_arg;
+         return fn(request_arg);
+      };
+    })();
+    `
+      }
+    });
+  }
+  // console.log("[Titan] JS Bundling finished.");
+}