@ezetgalaxy/titan 26.10.1 → 26.10.3

package/index.js

@@ -427,19 +427,15 @@ export function startProd() {
     const isWin = process.platform === "win32";
     const bin = isWin ? "titan-server.exe" : "titan-server";
     const root = process.cwd();
+    const serverDir = path.join(root, "server");
 
-    const exe = path.join(root, "server", "target", "release", bin);
+    const exe = path.join(serverDir, "target", "release", bin);
 
     if (fs.existsSync(exe)) {
-        execSync(`"${exe}"`, { stdio: "inherit" });
+        execSync(`"${exe}"`, { stdio: "inherit", cwd: serverDir });
     } else {
         // Fallback to pure node start if no rust binary
         const appJs = path.join(root, "app", "app.js");
-        // Actually, typically we run the bundled/compiled app if we don't have rust server?
-        // But wait, the pure TS template runs `node .titan/app.js` in Docker.
-        // But locally `titan start` relies on `app/app.js` being compiled?
-        // In `buildProd` above we compiled to `app/app.js`.
-        // Let's check for `.titan/app.js` which is dev artifact? No, use the prod build artifact.
         execSync(`node "${appJs}"`, { stdio: "inherit" });
     }
 }
@@ -663,7 +659,7 @@ export function runExtension() {
 /* -------------------------------------------------------
  * ROUTER
  * ----------------------------------------------------- */
-const isMainModule = process.argv[1] === fileURLToPath(import.meta.url);
+const isMainModule = fs.realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
 
 if (isMainModule) {
     const args = process.argv.slice(2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "26.10.1",
+  "version": "26.10.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",
@@ -42,6 +42,8 @@
     "super-backend"
   ],
   "scripts": {
+    "cli-helper": "node ./scripts/cli-helper.mjs",
+    "create-ext": "titan create ext",
     "init": "rm -rf build && node index.js init build",
     "build": "cd build && node ../index.js build",
     "dev": "cd build && node ../index.js dev",

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

@@ -1,87 +1,132 @@
-/**
- * TITAN TYPE DEFINITIONS
- * ----------------------
- * These types are globally available in your Titan project.
- */
 
-/**
- * The Titan Request Object passed to actions.
- */
-declare interface TitanRequest {
-    body: any;
-    method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
-    path: string;
-    headers: {
-        host?: string;
-        "content-type"?: string;
-        "user-agent"?: string;
-        authorization?: string;
-        [key: string]: string | undefined;
-    };
-    params: Record<string, string>;
-    query: Record<string, string>;
+// -- Module Definitions (for imports from "titan") --
+
+export interface RouteHandler {
+    reply(value: any): void;
+    action(name: string): void;
 }
 
-interface DbConnection {
-    /**
-     * Execute a SQL query.
-     * @param sql The SQL query string.
-     * @param params (Optional) Parameters for the query ($1, $2, etc).
-     */
-    query(sql: string, params?: any[]): any[];
+export interface TitanBuilder {
+    get(route: string): RouteHandler;
+    post(route: string): RouteHandler;
+    log(module: string, msg: string): void;
+    start(port?: number, msg?: string): Promise<void>;
 }
 
+// The default export from titan.js is the Builder
+declare const builder: TitanBuilder;
+export const Titan: TitanBuilder;
+export default builder;
+
 /**
  * Define a Titan Action with type inference.
- * @example
- * export const hello = defineAction((req) => {
- *   return req.headers;
- * });
  */
-declare function defineAction<T>(actionFn: (req: TitanRequest) => T): (req: TitanRequest) => T;
+export declare function defineAction<T>(actionFn: (req: TitanRequest) => T): (req: TitanRequest) => T;
+
+
+// -- Global Definitions (Runtime Environment) --
+
+declare global {
+    /**
+     * The Titan Request Object passed to actions.
+     */
+    interface TitanRequest {
+        body: any;
+        method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+        path: string;
+        headers: {
+            host?: string;
+            "content-type"?: string;
+            "user-agent"?: string;
+            authorization?: string;
+            [key: string]: string | undefined;
+        };
+        params: Record<string, string>;
+        query: Record<string, string>;
+    }
+
+    interface DbConnection {
+        /**
+         * Execute a SQL query.
+         * @param sql The SQL query string.
+         * @param params (Optional) Parameters for the query ($1, $2, etc).
+         */
+        query(sql: string, params?: any[]): any[];
+    }
 
-/**
- * Titan Runtime Utilities
- */
-declare const t: {
     /**
-     * Log messages to the server console with Titan formatting.
+     * Global defineAction (available without import in runtime)
      */
-    log(...args: any[]): void;
+    function defineAction<T>(actionFn: (req: TitanRequest) => T): (req: TitanRequest) => T;
 
     /**
-     * Read a file contents as string.
-     * @param path Relative path to the file from project root.
+     * Global Request Object
+     * Available automatically in actions.
      */
-    read(path: string): string;
-
-    fetch(url: string, options?: {
-        method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
-        headers?: Record<string, string>;
-        body?: string | object;
-    }): {
-        ok: boolean;
-        status?: number;
-        body?: string;
-        error?: string;
-    };
-
-    jwt: {
-        sign(
-            payload: object,
-            secret: string,
-            options?: { expiresIn?: string | number }
-        ): string;
-        verify(token: string, secret: string): any;
-    };
-
-    password: {
-        hash(password: string): string;
-        verify(password: string, hash: string): boolean;
-    };
-
-    db: {
-        connect(url: string): DbConnection;
-    };
-};
+    var req: TitanRequest;
 
+    /**
+     * Titan Runtime Utilities
+     * (Available globally in the runtime, e.g. inside actions)
+     */
+    interface TitanRuntimeUtils {
+        /**
+         * Log messages to the server console with Titan formatting.
+         */
+        log(...args: any[]): void;
+
+        /**
+         * Read a file contents as string.
+         * @param path Relative path to the file from project root.
+         */
+        read(path: string): string;
+
+        fetch(url: string, options?: {
+            method?: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+            headers?: Record<string, string>;
+            body?: string | object;
+        }): {
+            ok: boolean;
+            status?: number;
+            body?: string;
+            error?: string;
+        };
+
+        jwt: {
+            sign(
+                payload: object,
+                secret: string,
+                options?: { expiresIn?: string | number }
+            ): string;
+            verify(token: string, secret: string): any;
+        };
+
+        password: {
+            hash(password: string): string;
+            verify(password: string, hash: string): boolean;
+        };
+
+        db: {
+            connect(url: string): DbConnection;
+        };
+
+        /**
+         * Titan Validator (Zod-compatible)
+         */
+        valid: any;
+
+        // Allow extensions
+        [key: string]: any;
+    }
+
+    /**
+     * Titan Runtime Utilities
+     * (Available globally in the runtime, e.g. inside actions)
+     */
+    const t: TitanRuntimeUtils;
+
+    /**
+     * Titan Runtime Utilities (Alias for t)
+     */
+    const Titan: TitanRuntimeUtils;
+}

package/templates/extension/README.md

@@ -1,104 +1,65 @@
-# 🪐 Titan Extension: {{name}}
+# Titan Extension Template
 
-> Elevate Titan Planet with custom JavaScript and high-performance Native Rust logic.
+This template provides a starting point for building native extensions for Titan.
 
-Welcome to your new Titan extension! This template provides everything you need to build, test, and deploy powerful additions to the Titan project.
+## Directory Structure
 
----
+- `index.js`: The JavaScript entry point for your extension. It runs within the Titan runtime.
+- `index.d.ts`: TypeScript definitions for your extension. This ensures users get autocompletion when using your extension.
+- `native/`: (Optional) Rust source code for native high-performance logic.
+- `titan.json`: Configuration file defining your extension's native ABI (if using Rust).
 
-## 🛠 Project Structure
+## Type Definitions (`index.d.ts`)
 
-- `index.js`: The JavaScript entry point where you define your extension's API on the global `t` object.
-- `titan.json`: Manifest file defining extension metadata and Native module mappings.
-- `native/`: Directory for Rust source code.
-  - `src/lib.rs`: Your Native function implementations.
-  - `Cargo.toml`: Rust package and dependency configuration.
-- `jsconfig.json`: Enables full IntelliSense for the Titan Runtime API.
+The `index.d.ts` file is crucial for Developer Experience (DX). It allows Titan projects to "see" your extension's API on the global `t` object.
 
----
+### How it works
 
-## 🚀 Quick Start
+Titan uses **Declaration Merging** to extend the global `Titan.Runtime` interface. When a user installs your extension, this file acts as a plugin to their TypeScript environment.
 
-### 1. Install Dependencies
-Get full type support in your IDE:
-```bash
-npm install
-```
-
-### 2. Build Native Module (Optional)
-If your extension uses Rust, compile it to a dynamic library:
-```bash
-cd native
-cargo build --release
-cd ..
-```
-
-### 3. Test the Extension
-Use the Titan SDK to run a local test harness:
-```bash
-titan run ext
-```
-*Tip: Visit `http://localhost:3000/test` after starting the runner to see your extension in action!*
+### Customizing Types
 
----
+Edit `index.d.ts` to match the API you expose in `index.js`.
 
-## 💻 Development Guide
+**Example:**
 
-### Writing JavaScript
-Extensions interact with the global `t` object. It's best practice to namespace your extension:
+If your `index.js` looks like this:
 
 ```javascript
-t.{{name}} = {
-    myMethod: (val) => {
-        t.log("{{name}}", "Doing something...");
-        return val * 2;
-    }
+// index.js
+t.ext.my_cool_ext = {
+    greet: (name) => `Hello, ${name}!`,
+    compute: (x) => x * 2
 };
 ```
 
-### Writing Native Rust Functions
-Native functions should be marked with `#[unsafe(no_mangle)]` and use `extern "C"`:
-
-```rust
-#[unsafe(no_mangle)]
-pub extern "C" fn multiply(a: f64, b: f64) -> f64 {
-    a * b
-}
-```
-
-### Mapping Native Functions in `titan.json`
-Expose your Rust functions to JavaScript by adding them to the `native.functions` section:
-
-```json
-"functions": {
-    "add": {
-        "symbol": "add",
-        "parameters": ["f64", "f64"],
-        "result": "f64"
+Your `index.d.ts` should look like this:
+
+```typescript
+// index.d.ts
+declare global {
+    namespace Titan {
+        interface Runtime {
+            "my-cool-ext": {
+                /**
+                 * Sends a greeting.
+                 */
+                greet(name: string): string;
+
+                /**
+                 * Computes a value.
+                 */
+                compute(x: number): number;
+            }
+        }
     }
 }
+export { };
 ```
 
----
-
-## 🧪 Testing with Titan SDK
-
-The `titan run ext` command automates the testing workflow:
-1. It builds your native code.
-2. It sets up a temporary Titan project environment.
-3. It links your extension into `node_modules`.
-4. It starts the Titan Runtime at `http://localhost:3000`.
-
-You can modify the test harness or add custom test cases by exploring the generated `.titan_test_run` directory (it is git-ignored).
-
----
-
-## 📦 Deployment
-To use your extension in a Titan project:
-1. Publish your extension to npm or link it locally.
-2. In your Titan project: `npm install my-extension`.
-3. The Titan Runtime will automatically detect and load your extension if it contains a `titan.json`.
-
----
+## Native Bindings (Rust)
 
-Happy coding on Titan Planet! 🚀
+If your extension requires native performance or system access, use the `native/` directory.
+1. Define functions in `native/src/lib.rs`.
+2. Map them in `titan.json`.
+3. Call them from `index.js` using `Titan.native.invoke(...)` (or the helper provided in the template).

package/templates/extension/index.d.ts

@@ -0,0 +1,27 @@
+// Type definitions for {{name}}
+// This file facilitates type inference when this extension is installed in a Titan project.
+
+declare global {
+    namespace Titan {
+        interface Runtime {
+            /**
+             * {{name}} Extension
+             */
+            "{{name}}": {
+                /**
+                 * Example hello function
+                 */
+                hello(name: string): string;
+
+                /**
+                 * Example calc function (native wrapper)
+                 */
+                calc(a: number, b: number): number;
+
+                // Add your extension methods here
+            }
+        }
+    }
+}
+
+export { };

package/templates/extension/index.js

@@ -4,6 +4,7 @@
  */
 
 // Define your extension Key
+if (typeof Titan === "undefined") globalThis.Titan = t;
 const EXT_KEY = "{{name}}";
 
 t.log(EXT_KEY, "Extension loading...");

package/templates/extension/package.json

@@ -3,6 +3,7 @@
     "version": "1.0.0",
     "description": "A Titan Planet extension",
     "main": "index.js",
+    "types": "index.d.ts",
     "type": "commonjs",
     "scripts": {
         "test": "echo \"Error: no test specified\" && exit 1"
@@ -19,4 +20,4 @@
         "esbuild": "^0.27.2",
         "titanpl-sdk": "latest"
     }
-}
+}

package/templates/js/jsconfig.json

@@ -14,6 +14,7 @@
         }
     },
     "include": [
-        "app/**/*"
+        "app/**/*",
+        "titan/**/*"
     ]
 }

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

@@ -535,7 +535,13 @@ fn js_from_value<'a>(
     val: serde_json::Value,
 ) -> v8::Local<'a, v8::Value> {
     match ret_type {
-        ReturnType::String => v8::String::new(scope, val.as_str().unwrap_or("")).unwrap().into(),
+        ReturnType::String => {
+            let s = match val.as_str() {
+                Some(x) => x,
+                None => "",
+            };
+            v8::String::new(scope, s).unwrap().into()
+        },
         ReturnType::F64 => v8::Number::new(scope, val.as_f64().unwrap_or(0.0)).into(),
         ReturnType::Bool => v8::Boolean::new(scope, val.as_bool().unwrap_or(false)).into(),
         ReturnType::Json => {
@@ -566,10 +572,32 @@ fn js_from_value<'a>(
 macro_rules! dispatch_ret {
     ($ptr:expr, $ret:expr, ($($arg_ty:ty),*), ($($arg:expr),*)) => {
         match $ret {
-            ReturnType::String => { let f: extern "C" fn($($arg_ty),*) -> String; f = std::mem::transmute($ptr); serde_json::Value::String(f($($arg),*)) },
+            ReturnType::String => { 
+                let f: extern "C" fn($($arg_ty),*) -> *mut std::os::raw::c_char; 
+                f = std::mem::transmute($ptr); 
+                let ptr = f($($arg),*);
+                if ptr.is_null() {
+                    serde_json::Value::String(String::new())
+                } else {
+                    let s = unsafe { std::ffi::CStr::from_ptr(ptr).to_string_lossy().into_owned() };
+                    // We leak the pointer here because we don't have a shared allocator/free function. 
+                    // This prevents the double-free/heap corruption crash.
+                    serde_json::Value::String(s)
+                }
+            },
             ReturnType::F64 => { let f: extern "C" fn($($arg_ty),*) -> f64; f = std::mem::transmute($ptr); serde_json::json!(f($($arg),*)) },
             ReturnType::Bool => { let f: extern "C" fn($($arg_ty),*) -> bool; f = std::mem::transmute($ptr); serde_json::json!(f($($arg),*)) },
-            ReturnType::Json => { let f: extern "C" fn($($arg_ty),*) -> serde_json::Value; f = std::mem::transmute($ptr); f($($arg),*) },
+            ReturnType::Json => { 
+                let f: extern "C" fn($($arg_ty),*) -> *mut std::os::raw::c_char; 
+                f = std::mem::transmute($ptr); 
+                let ptr = f($($arg),*);
+                if ptr.is_null() {
+                    serde_json::Value::Null
+                } else {
+                    let s = unsafe { std::ffi::CStr::from_ptr(ptr).to_string_lossy().into_owned() };
+                    serde_json::from_str(&s).unwrap_or(serde_json::Value::Null)
+                }
+             },
             ReturnType::Buffer => { let f: extern "C" fn($($arg_ty),*) -> Vec<u8>; f = std::mem::transmute($ptr); 
                 let v = f($($arg),*); 
                 serde_json::Value::Array(v.into_iter().map(serde_json::Value::from).collect()) 
@@ -619,10 +647,18 @@ fn native_invoke_extension(scope: &mut v8::HandleScope, args: v8::FunctionCallba
              1 => {
                  let v0 = vals.remove(0);
                  match sig.params[0] {
-                     ParamType::String => { let a0 = v0.as_str().unwrap_or("").to_string(); dispatch_ret!(ptr, sig.ret, (String), (a0)) },
+                     ParamType::String => { 
+                         let s = v0.as_str().unwrap_or("").to_string(); 
+                         let c = std::ffi::CString::new(s).unwrap();
+                         dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char), (c.as_ptr())) 
+                     },
                      ParamType::F64 => { let a0 = v0.as_f64().unwrap_or(0.0); dispatch_ret!(ptr, sig.ret, (f64), (a0)) },
                      ParamType::Bool => { let a0 = v0.as_bool().unwrap_or(false); dispatch_ret!(ptr, sig.ret, (bool), (a0)) },
-                     ParamType::Json => { let a0 = v0; dispatch_ret!(ptr, sig.ret, (serde_json::Value), (a0)) },
+                     ParamType::Json => { 
+                         let s = v0.to_string(); 
+                         let c = std::ffi::CString::new(s).unwrap();
+                         dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char), (c.as_ptr())) 
+                     },
                      ParamType::Buffer => { 
                          // Extract vec u8
                          let a0: Vec<u8> = if let Some(arr) = v0.as_array() {
@@ -637,14 +673,17 @@ fn native_invoke_extension(scope: &mut v8::HandleScope, args: v8::FunctionCallba
                  let v1 = vals.remove(0);
                  match (sig.params[0].clone(), sig.params[1].clone()) { // Clone to satisfy borrow checker if needed
                     (ParamType::String, ParamType::String) => {
-                        let a0 = v0.as_str().unwrap_or("").to_string();
-                        let a1 = v1.as_str().unwrap_or("").to_string();
-                        dispatch_ret!(ptr, sig.ret, (String, String), (a0, a1))
+                        let s0 = v0.as_str().unwrap_or("").to_string();
+                        let c0 = std::ffi::CString::new(s0).unwrap();
+                        let s1 = v1.as_str().unwrap_or("").to_string();
+                        let c1 = std::ffi::CString::new(s1).unwrap();
+                        dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char, *const std::os::raw::c_char), (c0.as_ptr(), c1.as_ptr()))
                     },
                     (ParamType::String, ParamType::F64) => {
-                        let a0 = v0.as_str().unwrap_or("").to_string();
+                        let s0 = v0.as_str().unwrap_or("").to_string();
+                        let c0 = std::ffi::CString::new(s0).unwrap();
                         let a1 = v1.as_f64().unwrap_or(0.0);
-                        dispatch_ret!(ptr, sig.ret, (String, f64), (a0, a1))
+                        dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char, f64), (c0.as_ptr(), a1))
                     },
                     // Add more combinations as needed. 
                      _ => { println!("Unsupported 2-arg signature"); serde_json::Value::Null }
@@ -803,4 +842,4 @@ pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Obje
 
     let t_key = v8_str(scope, "t");
     global.set(scope, t_key.into(), t_obj.into());
-}
+}

package/templates/js/titan/bundle.js

@@ -50,7 +50,7 @@ async function bundleJs() {
       target: "es2020",
       logLevel: "silent",
       banner: {
-        js: "const defineAction = (fn) => fn;"
+        js: "const defineAction = (fn) => fn; const Titan = t;"
       },
 
       footer: {

package/templates/js/titan/titan.js

@@ -119,4 +119,8 @@ const t = {
 };
 
 
+/**
+ * Titan App Builder (Alias for t)
+ */
+export const Titan = t;
 export default t;

package/templates/rust-js/jsconfig.json

@@ -14,6 +14,7 @@
         }
     },
     "include": [
-        "app/**/*"
+        "app/**/*",
+        "titan/**/*"
     ]
 }

package/templates/rust-js/server/src/extensions.rs

@@ -18,6 +18,15 @@ use std::sync::Mutex;
 use std::collections::HashMap;
 use std::fs;
 
+// ----------------------------------------------------------------------------
+// T MODULE (Rust API equivalent to JS t object)
+// ----------------------------------------------------------------------------
+pub mod t {
+    pub fn log(module: &str, msg: &str) {
+        println!("{} {}", crate::utils::blue("[Titan]"), crate::utils::gray(&format!("\x1b[90mlog({})\x1b[0m\x1b[97m: {}\x1b[0m", module, msg)));
+    }
+}
+
 // ----------------------------------------------------------------------------
 // GLOBAL REGISTRY
 // ----------------------------------------------------------------------------
@@ -535,7 +544,13 @@ fn js_from_value<'a>(
     val: serde_json::Value,
 ) -> v8::Local<'a, v8::Value> {
     match ret_type {
-        ReturnType::String => v8::String::new(scope, val.as_str().unwrap_or("")).unwrap().into(),
+        ReturnType::String => {
+            let s = match val.as_str() {
+                Some(x) => x,
+                None => "",
+            };
+            v8::String::new(scope, s).unwrap().into()
+        },
         ReturnType::F64 => v8::Number::new(scope, val.as_f64().unwrap_or(0.0)).into(),
         ReturnType::Bool => v8::Boolean::new(scope, val.as_bool().unwrap_or(false)).into(),
         ReturnType::Json => {
@@ -566,10 +581,32 @@ fn js_from_value<'a>(
 macro_rules! dispatch_ret {
     ($ptr:expr, $ret:expr, ($($arg_ty:ty),*), ($($arg:expr),*)) => {
         match $ret {
-            ReturnType::String => { let f: extern "C" fn($($arg_ty),*) -> String; f = std::mem::transmute($ptr); serde_json::Value::String(f($($arg),*)) },
+            ReturnType::String => { 
+                let f: extern "C" fn($($arg_ty),*) -> *mut std::os::raw::c_char; 
+                f = std::mem::transmute($ptr); 
+                let ptr = f($($arg),*);
+                if ptr.is_null() {
+                    serde_json::Value::String(String::new())
+                } else {
+                    let s = unsafe { std::ffi::CStr::from_ptr(ptr).to_string_lossy().into_owned() };
+                    // We leak the pointer here because we don't have a shared allocator/free function. 
+                    // This prevents the double-free/heap corruption crash.
+                    serde_json::Value::String(s)
+                }
+            },
             ReturnType::F64 => { let f: extern "C" fn($($arg_ty),*) -> f64; f = std::mem::transmute($ptr); serde_json::json!(f($($arg),*)) },
             ReturnType::Bool => { let f: extern "C" fn($($arg_ty),*) -> bool; f = std::mem::transmute($ptr); serde_json::json!(f($($arg),*)) },
-            ReturnType::Json => { let f: extern "C" fn($($arg_ty),*) -> serde_json::Value; f = std::mem::transmute($ptr); f($($arg),*) },
+            ReturnType::Json => { 
+                let f: extern "C" fn($($arg_ty),*) -> *mut std::os::raw::c_char; 
+                f = std::mem::transmute($ptr); 
+                let ptr = f($($arg),*);
+                if ptr.is_null() {
+                    serde_json::Value::Null
+                } else {
+                    let s = unsafe { std::ffi::CStr::from_ptr(ptr).to_string_lossy().into_owned() };
+                    serde_json::from_str(&s).unwrap_or(serde_json::Value::Null)
+                }
+             },
             ReturnType::Buffer => { let f: extern "C" fn($($arg_ty),*) -> Vec<u8>; f = std::mem::transmute($ptr); 
                 let v = f($($arg),*); 
                 serde_json::Value::Array(v.into_iter().map(serde_json::Value::from).collect()) 
@@ -619,10 +656,18 @@ fn native_invoke_extension(scope: &mut v8::HandleScope, args: v8::FunctionCallba
              1 => {
                  let v0 = vals.remove(0);
                  match sig.params[0] {
-                     ParamType::String => { let a0 = v0.as_str().unwrap_or("").to_string(); dispatch_ret!(ptr, sig.ret, (String), (a0)) },
+                     ParamType::String => { 
+                         let s = v0.as_str().unwrap_or("").to_string(); 
+                         let c = std::ffi::CString::new(s).unwrap();
+                         dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char), (c.as_ptr())) 
+                     },
                      ParamType::F64 => { let a0 = v0.as_f64().unwrap_or(0.0); dispatch_ret!(ptr, sig.ret, (f64), (a0)) },
                      ParamType::Bool => { let a0 = v0.as_bool().unwrap_or(false); dispatch_ret!(ptr, sig.ret, (bool), (a0)) },
-                     ParamType::Json => { let a0 = v0; dispatch_ret!(ptr, sig.ret, (serde_json::Value), (a0)) },
+                     ParamType::Json => { 
+                         let s = v0.to_string(); 
+                         let c = std::ffi::CString::new(s).unwrap();
+                         dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char), (c.as_ptr())) 
+                     },
                      ParamType::Buffer => { 
                          // Extract vec u8
                          let a0: Vec<u8> = if let Some(arr) = v0.as_array() {
@@ -637,14 +682,17 @@ fn native_invoke_extension(scope: &mut v8::HandleScope, args: v8::FunctionCallba
                  let v1 = vals.remove(0);
                  match (sig.params[0].clone(), sig.params[1].clone()) { // Clone to satisfy borrow checker if needed
                     (ParamType::String, ParamType::String) => {
-                        let a0 = v0.as_str().unwrap_or("").to_string();
-                        let a1 = v1.as_str().unwrap_or("").to_string();
-                        dispatch_ret!(ptr, sig.ret, (String, String), (a0, a1))
+                        let s0 = v0.as_str().unwrap_or("").to_string();
+                        let c0 = std::ffi::CString::new(s0).unwrap();
+                        let s1 = v1.as_str().unwrap_or("").to_string();
+                        let c1 = std::ffi::CString::new(s1).unwrap();
+                        dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char, *const std::os::raw::c_char), (c0.as_ptr(), c1.as_ptr()))
                     },
                     (ParamType::String, ParamType::F64) => {
-                        let a0 = v0.as_str().unwrap_or("").to_string();
+                        let s0 = v0.as_str().unwrap_or("").to_string();
+                        let c0 = std::ffi::CString::new(s0).unwrap();
                         let a1 = v1.as_f64().unwrap_or(0.0);
-                        dispatch_ret!(ptr, sig.ret, (String, f64), (a0, a1))
+                        dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char, f64), (c0.as_ptr(), a1))
                     },
                     // Add more combinations as needed. 
                      _ => { println!("Unsupported 2-arg signature"); serde_json::Value::Null }
@@ -803,4 +851,4 @@ pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Obje
 
     let t_key = v8_str(scope, "t");
     global.set(scope, t_key.into(), t_obj.into());
-}
+}

package/templates/rust-js/titan/bundle.js

@@ -50,7 +50,7 @@ async function bundleJs() {
       target: "es2020",
       logLevel: "silent",
       banner: {
-        js: "const defineAction = (fn) => fn;"
+        js: "const defineAction = (fn) => fn; const Titan = t;"
       },
 
       footer: {

package/templates/rust-js/titan/titan.js

@@ -119,4 +119,8 @@ const t = {
 };
 
 
+/**
+ * Titan App Builder (Alias for t)
+ */
+export const Titan = t;
 export default t;

package/templates/rust-ts/server/src/extensions.rs

@@ -18,6 +18,15 @@ use std::sync::Mutex;
 use std::collections::HashMap;
 use std::fs;
 
+// ----------------------------------------------------------------------------
+// T MODULE (Rust API equivalent to JS t object)
+// ----------------------------------------------------------------------------
+pub mod t {
+    pub fn log(module: &str, msg: &str) {
+        println!("{} {}", crate::utils::blue("[Titan]"), crate::utils::gray(&format!("\x1b[90mlog({})\x1b[0m\x1b[97m: {}\x1b[0m", module, msg)));
+    }
+}
+
 // ----------------------------------------------------------------------------
 // GLOBAL REGISTRY
 // ----------------------------------------------------------------------------
@@ -535,7 +544,13 @@ fn js_from_value<'a>(
     val: serde_json::Value,
 ) -> v8::Local<'a, v8::Value> {
     match ret_type {
-        ReturnType::String => v8::String::new(scope, val.as_str().unwrap_or("")).unwrap().into(),
+        ReturnType::String => {
+            let s = match val.as_str() {
+                Some(x) => x,
+                None => "",
+            };
+            v8::String::new(scope, s).unwrap().into()
+        },
         ReturnType::F64 => v8::Number::new(scope, val.as_f64().unwrap_or(0.0)).into(),
         ReturnType::Bool => v8::Boolean::new(scope, val.as_bool().unwrap_or(false)).into(),
         ReturnType::Json => {
@@ -566,10 +581,32 @@ fn js_from_value<'a>(
 macro_rules! dispatch_ret {
     ($ptr:expr, $ret:expr, ($($arg_ty:ty),*), ($($arg:expr),*)) => {
         match $ret {
-            ReturnType::String => { let f: extern "C" fn($($arg_ty),*) -> String; f = std::mem::transmute($ptr); serde_json::Value::String(f($($arg),*)) },
+            ReturnType::String => { 
+                let f: extern "C" fn($($arg_ty),*) -> *mut std::os::raw::c_char; 
+                f = std::mem::transmute($ptr); 
+                let ptr = f($($arg),*);
+                if ptr.is_null() {
+                    serde_json::Value::String(String::new())
+                } else {
+                    let s = unsafe { std::ffi::CStr::from_ptr(ptr).to_string_lossy().into_owned() };
+                    // We leak the pointer here because we don't have a shared allocator/free function. 
+                    // This prevents the double-free/heap corruption crash.
+                    serde_json::Value::String(s)
+                }
+            },
             ReturnType::F64 => { let f: extern "C" fn($($arg_ty),*) -> f64; f = std::mem::transmute($ptr); serde_json::json!(f($($arg),*)) },
             ReturnType::Bool => { let f: extern "C" fn($($arg_ty),*) -> bool; f = std::mem::transmute($ptr); serde_json::json!(f($($arg),*)) },
-            ReturnType::Json => { let f: extern "C" fn($($arg_ty),*) -> serde_json::Value; f = std::mem::transmute($ptr); f($($arg),*) },
+            ReturnType::Json => { 
+                let f: extern "C" fn($($arg_ty),*) -> *mut std::os::raw::c_char; 
+                f = std::mem::transmute($ptr); 
+                let ptr = f($($arg),*);
+                if ptr.is_null() {
+                    serde_json::Value::Null
+                } else {
+                    let s = unsafe { std::ffi::CStr::from_ptr(ptr).to_string_lossy().into_owned() };
+                    serde_json::from_str(&s).unwrap_or(serde_json::Value::Null)
+                }
+             },
             ReturnType::Buffer => { let f: extern "C" fn($($arg_ty),*) -> Vec<u8>; f = std::mem::transmute($ptr); 
                 let v = f($($arg),*); 
                 serde_json::Value::Array(v.into_iter().map(serde_json::Value::from).collect()) 
@@ -619,10 +656,18 @@ fn native_invoke_extension(scope: &mut v8::HandleScope, args: v8::FunctionCallba
              1 => {
                  let v0 = vals.remove(0);
                  match sig.params[0] {
-                     ParamType::String => { let a0 = v0.as_str().unwrap_or("").to_string(); dispatch_ret!(ptr, sig.ret, (String), (a0)) },
+                     ParamType::String => { 
+                         let s = v0.as_str().unwrap_or("").to_string(); 
+                         let c = std::ffi::CString::new(s).unwrap();
+                         dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char), (c.as_ptr())) 
+                     },
                      ParamType::F64 => { let a0 = v0.as_f64().unwrap_or(0.0); dispatch_ret!(ptr, sig.ret, (f64), (a0)) },
                      ParamType::Bool => { let a0 = v0.as_bool().unwrap_or(false); dispatch_ret!(ptr, sig.ret, (bool), (a0)) },
-                     ParamType::Json => { let a0 = v0; dispatch_ret!(ptr, sig.ret, (serde_json::Value), (a0)) },
+                     ParamType::Json => { 
+                         let s = v0.to_string(); 
+                         let c = std::ffi::CString::new(s).unwrap();
+                         dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char), (c.as_ptr())) 
+                     },
                      ParamType::Buffer => { 
                          // Extract vec u8
                          let a0: Vec<u8> = if let Some(arr) = v0.as_array() {
@@ -637,14 +682,17 @@ fn native_invoke_extension(scope: &mut v8::HandleScope, args: v8::FunctionCallba
                  let v1 = vals.remove(0);
                  match (sig.params[0].clone(), sig.params[1].clone()) { // Clone to satisfy borrow checker if needed
                     (ParamType::String, ParamType::String) => {
-                        let a0 = v0.as_str().unwrap_or("").to_string();
-                        let a1 = v1.as_str().unwrap_or("").to_string();
-                        dispatch_ret!(ptr, sig.ret, (String, String), (a0, a1))
+                        let s0 = v0.as_str().unwrap_or("").to_string();
+                        let c0 = std::ffi::CString::new(s0).unwrap();
+                        let s1 = v1.as_str().unwrap_or("").to_string();
+                        let c1 = std::ffi::CString::new(s1).unwrap();
+                        dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char, *const std::os::raw::c_char), (c0.as_ptr(), c1.as_ptr()))
                     },
                     (ParamType::String, ParamType::F64) => {
-                        let a0 = v0.as_str().unwrap_or("").to_string();
+                        let s0 = v0.as_str().unwrap_or("").to_string();
+                        let c0 = std::ffi::CString::new(s0).unwrap();
                         let a1 = v1.as_f64().unwrap_or(0.0);
-                        dispatch_ret!(ptr, sig.ret, (String, f64), (a0, a1))
+                        dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char, f64), (c0.as_ptr(), a1))
                     },
                     // Add more combinations as needed. 
                      _ => { println!("Unsupported 2-arg signature"); serde_json::Value::Null }
@@ -803,4 +851,4 @@ pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Obje
 
     let t_key = v8_str(scope, "t");
     global.set(scope, t_key.into(), t_obj.into());
-}
+}

package/templates/rust-ts/titan/bundle.js

@@ -50,7 +50,7 @@ async function bundleJs(actionsDir, outDir) {
       target: "es2020",
       logLevel: "silent",
       banner: {
-        js: "const defineAction = (fn) => fn;"
+        js: "const defineAction = (fn) => fn; const Titan = t;"
       },
 
       footer: {

package/templates/rust-ts/titan/titan.d.ts

@@ -15,6 +15,7 @@ export interface TitanBuilder {
 
 // The default export from titan.js is the Builder
 declare const builder: TitanBuilder;
+export const Titan: TitanBuilder;
 export default builder;
 
 /**
@@ -68,7 +69,7 @@ declare global {
      * Titan Runtime Utilities
      * (Available globally in the runtime, e.g. inside actions)
      */
-    const t: {
+    interface TitanRuntimeUtils {
         /**
          * Log messages to the server console with Titan formatting.
          */
@@ -113,5 +114,16 @@ declare global {
          * Titan Validator (Zod-compatible)
          */
         valid: any;
-    };
+    }
+
+    /**
+     * Titan Runtime Utilities
+     * (Available globally in the runtime, e.g. inside actions)
+     */
+    const t: TitanRuntimeUtils;
+
+    /**
+     * Titan Runtime Utilities (Alias for t)
+     */
+    const Titan: TitanRuntimeUtils;
 }

package/templates/rust-ts/titan/titan.js

@@ -119,4 +119,8 @@ const t = {
     }
 };
 
+/**
+ * Titan App Builder (Alias for t)
+ */
+export const Titan = t;
 export default t;

package/templates/ts/server/src/extensions.rs

@@ -535,7 +535,13 @@ fn js_from_value<'a>(
     val: serde_json::Value,
 ) -> v8::Local<'a, v8::Value> {
     match ret_type {
-        ReturnType::String => v8::String::new(scope, val.as_str().unwrap_or("")).unwrap().into(),
+        ReturnType::String => {
+            let s = match val.as_str() {
+                Some(x) => x,
+                None => "",
+            };
+            v8::String::new(scope, s).unwrap().into()
+        },
         ReturnType::F64 => v8::Number::new(scope, val.as_f64().unwrap_or(0.0)).into(),
         ReturnType::Bool => v8::Boolean::new(scope, val.as_bool().unwrap_or(false)).into(),
         ReturnType::Json => {
@@ -566,10 +572,32 @@ fn js_from_value<'a>(
 macro_rules! dispatch_ret {
     ($ptr:expr, $ret:expr, ($($arg_ty:ty),*), ($($arg:expr),*)) => {
         match $ret {
-            ReturnType::String => { let f: extern "C" fn($($arg_ty),*) -> String; f = std::mem::transmute($ptr); serde_json::Value::String(f($($arg),*)) },
+            ReturnType::String => { 
+                let f: extern "C" fn($($arg_ty),*) -> *mut std::os::raw::c_char; 
+                f = std::mem::transmute($ptr); 
+                let ptr = f($($arg),*);
+                if ptr.is_null() {
+                    serde_json::Value::String(String::new())
+                } else {
+                    let s = unsafe { std::ffi::CStr::from_ptr(ptr).to_string_lossy().into_owned() };
+                    // We leak the pointer here because we don't have a shared allocator/free function. 
+                    // This prevents the double-free/heap corruption crash.
+                    serde_json::Value::String(s)
+                }
+            },
             ReturnType::F64 => { let f: extern "C" fn($($arg_ty),*) -> f64; f = std::mem::transmute($ptr); serde_json::json!(f($($arg),*)) },
             ReturnType::Bool => { let f: extern "C" fn($($arg_ty),*) -> bool; f = std::mem::transmute($ptr); serde_json::json!(f($($arg),*)) },
-            ReturnType::Json => { let f: extern "C" fn($($arg_ty),*) -> serde_json::Value; f = std::mem::transmute($ptr); f($($arg),*) },
+            ReturnType::Json => { 
+                let f: extern "C" fn($($arg_ty),*) -> *mut std::os::raw::c_char; 
+                f = std::mem::transmute($ptr); 
+                let ptr = f($($arg),*);
+                if ptr.is_null() {
+                    serde_json::Value::Null
+                } else {
+                    let s = unsafe { std::ffi::CStr::from_ptr(ptr).to_string_lossy().into_owned() };
+                    serde_json::from_str(&s).unwrap_or(serde_json::Value::Null)
+                }
+             },
             ReturnType::Buffer => { let f: extern "C" fn($($arg_ty),*) -> Vec<u8>; f = std::mem::transmute($ptr); 
                 let v = f($($arg),*); 
                 serde_json::Value::Array(v.into_iter().map(serde_json::Value::from).collect()) 
@@ -619,10 +647,18 @@ fn native_invoke_extension(scope: &mut v8::HandleScope, args: v8::FunctionCallba
              1 => {
                  let v0 = vals.remove(0);
                  match sig.params[0] {
-                     ParamType::String => { let a0 = v0.as_str().unwrap_or("").to_string(); dispatch_ret!(ptr, sig.ret, (String), (a0)) },
+                     ParamType::String => { 
+                         let s = v0.as_str().unwrap_or("").to_string(); 
+                         let c = std::ffi::CString::new(s).unwrap();
+                         dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char), (c.as_ptr())) 
+                     },
                      ParamType::F64 => { let a0 = v0.as_f64().unwrap_or(0.0); dispatch_ret!(ptr, sig.ret, (f64), (a0)) },
                      ParamType::Bool => { let a0 = v0.as_bool().unwrap_or(false); dispatch_ret!(ptr, sig.ret, (bool), (a0)) },
-                     ParamType::Json => { let a0 = v0; dispatch_ret!(ptr, sig.ret, (serde_json::Value), (a0)) },
+                     ParamType::Json => { 
+                         let s = v0.to_string(); 
+                         let c = std::ffi::CString::new(s).unwrap();
+                         dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char), (c.as_ptr())) 
+                     },
                      ParamType::Buffer => { 
                          // Extract vec u8
                          let a0: Vec<u8> = if let Some(arr) = v0.as_array() {
@@ -637,14 +673,17 @@ fn native_invoke_extension(scope: &mut v8::HandleScope, args: v8::FunctionCallba
                  let v1 = vals.remove(0);
                  match (sig.params[0].clone(), sig.params[1].clone()) { // Clone to satisfy borrow checker if needed
                     (ParamType::String, ParamType::String) => {
-                        let a0 = v0.as_str().unwrap_or("").to_string();
-                        let a1 = v1.as_str().unwrap_or("").to_string();
-                        dispatch_ret!(ptr, sig.ret, (String, String), (a0, a1))
+                        let s0 = v0.as_str().unwrap_or("").to_string();
+                        let c0 = std::ffi::CString::new(s0).unwrap();
+                        let s1 = v1.as_str().unwrap_or("").to_string();
+                        let c1 = std::ffi::CString::new(s1).unwrap();
+                        dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char, *const std::os::raw::c_char), (c0.as_ptr(), c1.as_ptr()))
                     },
                     (ParamType::String, ParamType::F64) => {
-                        let a0 = v0.as_str().unwrap_or("").to_string();
+                        let s0 = v0.as_str().unwrap_or("").to_string();
+                        let c0 = std::ffi::CString::new(s0).unwrap();
                         let a1 = v1.as_f64().unwrap_or(0.0);
-                        dispatch_ret!(ptr, sig.ret, (String, f64), (a0, a1))
+                        dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char, f64), (c0.as_ptr(), a1))
                     },
                     // Add more combinations as needed. 
                      _ => { println!("Unsupported 2-arg signature"); serde_json::Value::Null }
@@ -803,4 +842,4 @@ pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Obje
 
     let t_key = v8_str(scope, "t");
     global.set(scope, t_key.into(), t_obj.into());
-}
+}

package/templates/ts/titan/bundle.js

@@ -48,7 +48,7 @@ async function bundleJs(actionsDir, outDir) {
       target: "es2020",
       logLevel: "silent",
       banner: {
-        js: "const defineAction = (fn) => fn;"
+        js: "const defineAction = (fn) => fn; const Titan = t;"
       },
 
       footer: {

package/templates/ts/titan/titan.d.ts

@@ -15,6 +15,7 @@ export interface TitanBuilder {
 
 // The default export from titan.js is the Builder
 declare const builder: TitanBuilder;
+export const Titan: TitanBuilder;
 export default builder;
 
 /**
@@ -68,7 +69,7 @@ declare global {
      * Titan Runtime Utilities
      * (Available globally in the runtime, e.g. inside actions)
      */
-    const t: {
+    interface TitanRuntimeUtils {
         /**
          * Log messages to the server console with Titan formatting.
          */
@@ -113,5 +114,16 @@ declare global {
          * Titan Validator (Zod-compatible)
          */
         valid: any;
-    };
+    }
+
+    /**
+     * Titan Runtime Utilities
+     * (Available globally in the runtime, e.g. inside actions)
+     */
+    const t: TitanRuntimeUtils;
+
+    /**
+     * Titan Runtime Utilities (Alias for t)
+     */
+    const Titan: TitanRuntimeUtils;
 }

package/templates/ts/titan/titan.js

@@ -119,4 +119,5 @@ const t = {
     }
 };
 
+export const Titan = t;
 export default t;

package/titanpl-sdk/index.d.ts

@@ -5,6 +5,10 @@ declare global {
      * Titan Runtime Global Object
      */
     const t: Titan.Runtime;
+    /**
+     * Titan Runtime Global Object 
+     */
+    const Titan: Titan.Runtime;
 }
 
 export namespace Titan {
@@ -18,7 +22,7 @@ export namespace Titan {
          * Read file content
          */
         read(path: string): string;
-        
+
         /**
          * Fetch API wrapper
          */

package/titanpl-sdk/package.json

@@ -1,6 +1,6 @@
 {
     "name": "titanpl-sdk",
-    "version": "0.2.0",
+    "version": "0.2.1",
     "description": "Development SDK for Titan Planet. Provides TypeScript type definitions for the global 't' runtime object and a 'lite' test-harness runtime for building and verifying extensions.",
     "main": "index.js",
     "type": "module",

package/titanpl-sdk/templates/server/src/extensions.rs

@@ -535,7 +535,13 @@ fn js_from_value<'a>(
     val: serde_json::Value,
 ) -> v8::Local<'a, v8::Value> {
     match ret_type {
-        ReturnType::String => v8::String::new(scope, val.as_str().unwrap_or("")).unwrap().into(),
+        ReturnType::String => {
+            let s = match val.as_str() {
+                Some(x) => x,
+                None => "",
+            };
+            v8::String::new(scope, s).unwrap().into()
+        },
         ReturnType::F64 => v8::Number::new(scope, val.as_f64().unwrap_or(0.0)).into(),
         ReturnType::Bool => v8::Boolean::new(scope, val.as_bool().unwrap_or(false)).into(),
         ReturnType::Json => {
@@ -566,10 +572,32 @@ fn js_from_value<'a>(
 macro_rules! dispatch_ret {
     ($ptr:expr, $ret:expr, ($($arg_ty:ty),*), ($($arg:expr),*)) => {
         match $ret {
-            ReturnType::String => { let f: extern "C" fn($($arg_ty),*) -> String; f = std::mem::transmute($ptr); serde_json::Value::String(f($($arg),*)) },
+            ReturnType::String => { 
+                let f: extern "C" fn($($arg_ty),*) -> *mut std::os::raw::c_char; 
+                f = std::mem::transmute($ptr); 
+                let ptr = f($($arg),*);
+                if ptr.is_null() {
+                    serde_json::Value::String(String::new())
+                } else {
+                    let s = unsafe { std::ffi::CStr::from_ptr(ptr).to_string_lossy().into_owned() };
+                    // We leak the pointer here because we don't have a shared allocator/free function. 
+                    // This prevents the double-free/heap corruption crash.
+                    serde_json::Value::String(s)
+                }
+            },
             ReturnType::F64 => { let f: extern "C" fn($($arg_ty),*) -> f64; f = std::mem::transmute($ptr); serde_json::json!(f($($arg),*)) },
             ReturnType::Bool => { let f: extern "C" fn($($arg_ty),*) -> bool; f = std::mem::transmute($ptr); serde_json::json!(f($($arg),*)) },
-            ReturnType::Json => { let f: extern "C" fn($($arg_ty),*) -> serde_json::Value; f = std::mem::transmute($ptr); f($($arg),*) },
+            ReturnType::Json => { 
+                let f: extern "C" fn($($arg_ty),*) -> *mut std::os::raw::c_char; 
+                f = std::mem::transmute($ptr); 
+                let ptr = f($($arg),*);
+                if ptr.is_null() {
+                    serde_json::Value::Null
+                } else {
+                    let s = unsafe { std::ffi::CStr::from_ptr(ptr).to_string_lossy().into_owned() };
+                    serde_json::from_str(&s).unwrap_or(serde_json::Value::Null)
+                }
+             },
             ReturnType::Buffer => { let f: extern "C" fn($($arg_ty),*) -> Vec<u8>; f = std::mem::transmute($ptr); 
                 let v = f($($arg),*); 
                 serde_json::Value::Array(v.into_iter().map(serde_json::Value::from).collect()) 
@@ -619,10 +647,18 @@ fn native_invoke_extension(scope: &mut v8::HandleScope, args: v8::FunctionCallba
              1 => {
                  let v0 = vals.remove(0);
                  match sig.params[0] {
-                     ParamType::String => { let a0 = v0.as_str().unwrap_or("").to_string(); dispatch_ret!(ptr, sig.ret, (String), (a0)) },
+                     ParamType::String => { 
+                         let s = v0.as_str().unwrap_or("").to_string(); 
+                         let c = std::ffi::CString::new(s).unwrap();
+                         dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char), (c.as_ptr())) 
+                     },
                      ParamType::F64 => { let a0 = v0.as_f64().unwrap_or(0.0); dispatch_ret!(ptr, sig.ret, (f64), (a0)) },
                      ParamType::Bool => { let a0 = v0.as_bool().unwrap_or(false); dispatch_ret!(ptr, sig.ret, (bool), (a0)) },
-                     ParamType::Json => { let a0 = v0; dispatch_ret!(ptr, sig.ret, (serde_json::Value), (a0)) },
+                     ParamType::Json => { 
+                         let s = v0.to_string(); 
+                         let c = std::ffi::CString::new(s).unwrap();
+                         dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char), (c.as_ptr())) 
+                     },
                      ParamType::Buffer => { 
                          // Extract vec u8
                          let a0: Vec<u8> = if let Some(arr) = v0.as_array() {
@@ -637,14 +673,17 @@ fn native_invoke_extension(scope: &mut v8::HandleScope, args: v8::FunctionCallba
                  let v1 = vals.remove(0);
                  match (sig.params[0].clone(), sig.params[1].clone()) { // Clone to satisfy borrow checker if needed
                     (ParamType::String, ParamType::String) => {
-                        let a0 = v0.as_str().unwrap_or("").to_string();
-                        let a1 = v1.as_str().unwrap_or("").to_string();
-                        dispatch_ret!(ptr, sig.ret, (String, String), (a0, a1))
+                        let s0 = v0.as_str().unwrap_or("").to_string();
+                        let c0 = std::ffi::CString::new(s0).unwrap();
+                        let s1 = v1.as_str().unwrap_or("").to_string();
+                        let c1 = std::ffi::CString::new(s1).unwrap();
+                        dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char, *const std::os::raw::c_char), (c0.as_ptr(), c1.as_ptr()))
                     },
                     (ParamType::String, ParamType::F64) => {
-                        let a0 = v0.as_str().unwrap_or("").to_string();
+                        let s0 = v0.as_str().unwrap_or("").to_string();
+                        let c0 = std::ffi::CString::new(s0).unwrap();
                         let a1 = v1.as_f64().unwrap_or(0.0);
-                        dispatch_ret!(ptr, sig.ret, (String, f64), (a0, a1))
+                        dispatch_ret!(ptr, sig.ret, (*const std::os::raw::c_char, f64), (c0.as_ptr(), a1))
                     },
                     // Add more combinations as needed. 
                      _ => { println!("Unsupported 2-arg signature"); serde_json::Value::Null }
@@ -803,4 +842,4 @@ pub fn inject_extensions(scope: &mut v8::HandleScope, global: v8::Local<v8::Obje
 
     let t_key = v8_str(scope, "t");
     global.set(scope, t_key.into(), t_obj.into());
-}
+}

package/titanpl-sdk/templates/.dockerignore

@@ -1,3 +0,0 @@
-node_modules
-npm-debug.log
-.git

package/titanpl-sdk/templates/Dockerfile

@@ -1,53 +0,0 @@
-# ================================================================
-# STAGE 1 — Build Titan (JS → Rust)
-# ================================================================
-FROM rust:1.91.1 AS builder
-
-# Install Node for Titan CLI + bundler
-RUN curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
-    && apt-get install -y nodejs
-
-# Install Titan CLI (latest)
-RUN npm install -g @ezetgalaxy/titan@latest
-
-WORKDIR /app
-
-# Copy project files
-COPY . .
-
-# Install JS dependencies (needed for Titan DSL + bundler)
-RUN npm install
-
-# Build Titan metadata + bundle JS actions
-RUN titan build
-
-# Build Rust binary
-RUN cd server && cargo build --release
-
-
-
-# ================================================================
-# STAGE 2 — Runtime Image (Lightweight)
-# ================================================================
-FROM debian:stable-slim
-
-WORKDIR /app
-
-# Copy Rust binary from builder stage
-COPY --from=builder /app/server/target/release/server ./titan-server
-
-# Copy Titan routing metadata
-COPY --from=builder /app/server/routes.json ./routes.json
-COPY --from=builder /app/server/action_map.json ./action_map.json
-
-# Copy Titan JS bundles
-RUN mkdir -p /app/actions
-COPY --from=builder /app/server/actions /app/actions
-
-COPY --from=builder /app/db /app/assets
-
-# Expose Titan port
-EXPOSE 3000
-
-# Start Titan
-CMD ["./titan-server"]