npm - @ezetgalaxy/titan - Versions diffs - 26.8.2 → 26.9.0 - Mend

@ezetgalaxy/titan 26.8.2 → 26.9.0

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 (97) hide show

package/README.md +65 -25
package/index.js +62 -15
package/package.json +2 -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 +35 -3
package/templates/js/titan/titan.js +122 -122
package/templates/rust/Dockerfile +66 -66
package/templates/rust/_dockerignore +3 -3
package/templates/rust/_gitignore +1 -0
package/templates/rust/app/actions/hello.js +5 -5
package/templates/rust/app/actions/rust_hello.rs +14 -14
package/templates/rust/app/titan.d.ts +101 -101
package/templates/rust/jsconfig.json +18 -18
package/templates/rust/server/src/action_management.rs +131 -131
package/templates/rust/server/src/errors.rs +10 -10
package/templates/rust/server/src/extensions.rs +989 -989
package/templates/rust/server/src/utils.rs +33 -33
package/templates/rust/titan/dev.js +36 -12
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 +5 -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/app/titan.d.ts +101 -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 +157 -0
package/templates/rust-ts/titan/dev.js +402 -0
package/templates/rust-ts/titan/titan.js +122 -0
package/templates/rust-ts/tsconfig.json +21 -0
package/templates/ts/Dockerfile +66 -0
package/templates/ts/_dockerignore +3 -0
package/templates/ts/_gitignore +38 -0
package/templates/ts/app/actions/hello.ts +9 -0
package/templates/ts/app/app.ts +10 -0
package/templates/ts/app/titan.d.ts +102 -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/bundle.js +78 -0
package/templates/ts/titan/dev.js +402 -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 +254 -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/README.md CHANGED Viewed

@@ -13,6 +13,7 @@
 💙 **Enjoy development mode `titan dev`**
 💟 **Titan Planet docs:** https://titan-docs-ez.vercel.app/docs
 🚀 **CLI: `titan` is now the canonical command. `tit` remains supported as an alias.**
+🛡️ **Strict Mode:** Titan now enforces zero type errors before running.
 ---
@@ -21,15 +22,15 @@
 [![npm version](https://img.shields.io/npm/v/@ezetgalaxy/titan.svg?style=flat-square)](https://www.npmjs.com/package/@ezetgalaxy/titan)
-**JavaScript Simplicity. Native Rust Power. Zero Configuration.**
+**TypeScript Precision. JavaScript Simplicity. Native Rust Power. Zero Configuration.**
-Titan Planet is a **JavaScript-first Backend Framework** that compiles your application into a single, high-performance native binary. It embeds a V8 JavaScript runtime directly into a specialized Rust + Axum server.
+Titan Planet is a **JavaScript/TypeScript-first Backend Framework** that compiles your application into a single, high-performance native binary. It embeds a V8 JavaScript runtime directly into a specialized Rust + Axum server.
-**Start with pure JavaScript.**
+**Start with pure TypeScript/JavaScript.**
 **Need raw power? Add Rust actions seamlessly.**
 Titan handles the compilation, bundling, and routing automatically for both.
-Titan = **JavaScript productivity × Rust performance × Zero DevOps**
+Titan = **TS/JS productivity × Rust performance × Zero DevOps**
 ---
@@ -38,8 +39,8 @@ Titan = **JavaScript productivity × Rust performance × Zero DevOps**
 | Feature                              | Titan | Express/Nest | FastAPI | Bun       |
 | ------------------------------------ | ----- | ------------ | ------- | --------- |
 | Native binary output                 | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
-| Hybrid Rust + JS Actions             | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
-| Pure JavaScript developer experience | ✅ Yes | ✅ Yes        | ❌ No    | ❌ Partial |
+| Hybrid Rust + JS/TS Actions          | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
+| Strict TypeScript Enforcement        | ✅ Yes | ❌ Setup Req. | ❌ No    | ❌ Partial |
 | Zero-config Docker deploy            | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
 | Action-based architecture            | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
 | Hot reload dev server                | ✅ Yes | ❌ No         | ❌ No    | ❌ No      |
@@ -62,7 +63,9 @@ npm install -g @ezetgalaxy/titan
 titan init my-app
 # Follow the interactive prompt to choose:
 # - JavaScript (Standard)
+# - TypeScript (Strict)
 # - Rust + JavaScript (Beta)
+# - Rust + TypeScript (Beta)
 ```
 Inside your project:
@@ -73,10 +76,11 @@ titan dev
 You'll see the Titan Dev Server spin up:
 ```
-  Titan Planet   v26.8.0   [ Dev Mode ]
+  Titan Planet   v26.9.0   [ Dev Mode ]
-  Type:        Rust + JS Actions
+  Type:        Rust + TS Actions
   Hot Reload:  Enabled
+  Strict Mode: Active 🛡️
   • Preparing runtime... Done
   • A new orbit is ready for your app in 0.9s
@@ -87,7 +91,25 @@ You'll see the Titan Dev Server spin up:
 # ⚡ Hybrid Action System
-Titan is unique because it allows you to write endpoints in **both** JavaScript and Rust within the same project.
+Titan is unique because it allows you to write endpoints in **JavaScript, TypeScript, and Rust** within the same project.
+### 🔵 TypeScript Actions (`app/actions/hello.ts`)
+Fully typed, strict, and auto-compiled.
+```typescript
+import { Context } from '@ezetgalaxy/titan';
+export function run(req: Context) {
+    t.log("Handling request with strict types...");
+    // Type checking allows safe property access
+    const user = req.body as { name: string };
+    return {
+        message: "Hello from TypeScript!",
+        user_name: user.name
+    };
+}
+```
 ### 🟡 JavaScript Actions (`app/actions/hello.js`)
 Perfect for business logic, rapid prototyping, and IO-bound tasks.
@@ -115,33 +137,50 @@ pub async fn run(req: Request<Body>) -> impl IntoResponse {
 }
 ```
-**Titan automatically detects, compiles, and routes both types.**
+**Titan automatically detects, compiles, and routes all types.**
+* `.ts` files are type-checked and compiled with esbuild.
 * `.js` files are bundled with esbuild.
 * `.rs` files are compiled into the native binary.
-* Both share the same `routes.json` configuration.
+* All share the same `routes.json` configuration.
+---
+# 🛡️ Strict Type Safety & Error Logs
+Titan prioritizes code quality by enforcing **Strict TypeScript** logic during development.
+If `titan dev` detects a type error, the server **will not run**. This ensures you never ship or test broken code.
+### Sample Error Output
+When a type error occurs, Titan pauses execution and provides a clear, actionable log:
+```text
+[Titan] ❌ TypeScript Error:
+app/actions/payment.ts(12,5): error TS2322: Type 'string' is not assignable to type 'number'.
+    10 |    const amount: number = req.body.amount;
+    11 |
+  > 12 |    processPayment( "100" ); // Error here
+       |    ^^^^^^^^^^^^^^^^^^^^^^^
+[Titan] 🛑 Server paused due to type errors. Fix them to resume.
+```
+Once fixed, the server automatically resumes.
 ---
 # ✨ Core Capabilities
 ### 🔌 Unified Runtime API (`t`)
-Both JS and Rust actions have access to the powerful `t` namespace:
+All actions (JS/TS/Rust) have access to the powerful `t` namespace:
 * `t.fetch(url, options)` — High-performance HTTP client
 * `t.log(msg)` — Sandboxed, structured logging
 * `t.jwt.sign / verify` — Fast JWT operations
 * `t.password.hash / verify` — Secure password handling
-* `t.db` — Database access (coming soon)
-### 🛣 Intelligent Routing
-Define your routes in `routes.json`. Titan maps them to the correct action, regardless of language.
-```json
-{
-  "/hello": "hello",         // variable name matches filename (hello.js)
-  "/compute": "compute"      // variable name matches filename (compute.rs)
-}
-```
+* `t.db` — Database access
+---
 ### 🧩 Extensions System
 Extend the runtime with custom Rust engines using **Titan Extensions**.
@@ -152,7 +191,7 @@ Extend the runtime with custom Rust engines using **Titan Extensions**.
 # 📦 Deployment
-Titan compiles your entire app—JS code, Rust code, and server logic—into a **single executable**.
+Titan compiles your entire app—JS/TS code, Rust code, and server logic—into a **single executable**.
 * **Tiny Docker Images**: Alpine-based, ~20MB compressed.
 * **Instant Startup**: No node_modules overhead.
@@ -161,7 +200,7 @@ Titan compiles your entire app—JS code, Rust code, and server logic—into a *
 ---
 # 🧱 Architecture Note
-Titan is **not** a Node.js framework. It is a Rust server that speaks JavaScript.
+Titan is **not** a Node.js framework. It is a Rust server that speaks JavaScript/TypeScript.
 * **No Event Loop** for JS (Request/Response model).
 * **No `require`** (Use raw imports or bundled dependencies).
 * **True Isolation** per request.
@@ -170,6 +209,7 @@ Titan is **not** a Node.js framework. It is a Rust server that speaks JavaScript
 **Titan v26 — Stable**
 * Production-ready Hybrid Runtime
+* Strict TypeScript Support
 * Native Rust Performance
 * Zero-Config Cloud Deployment

package/index.js CHANGED Viewed

@@ -123,37 +123,82 @@ ${yellow("Note: `tit` is supported as a legacy alias.")}
  * INIT
  * ----------------------------------------------------- */
 async function initProject(name, templateName) {
-    if (!name) {
-        console.log(red("Usage: titan init <project> [--template <js|rust>]"));
-        return;
+    let projName = name;
+    if (!projName) {
+        const response = await prompts({
+            type: 'text',
+            name: 'value',
+            message: 'Project name:',
+            initial: 'my-titan-app'
+        });
+        if (!response.value) {
+            console.log(red("✖ Operation cancelled"));
+            return;
+        }
+        projName = response.value;
     }
     let selectedTemplate = templateName;
     if (!selectedTemplate) {
-        const response = await prompts({
+        // 1. Language Selection
+        const langRes = await prompts({
             type: 'select',
             name: 'value',
-            message: 'Select a template:',
+            message: 'Select language:',
             choices: [
-                { title: 'JavaScript', description: 'Standard Titan app with JS actions', value: 'js' },
-                { title: `Rust + JavaScript  ${yellow('(Beta)')}`, description: 'High-performance Rust actions + JS flexibility', value: 'rust' }
+                { title: 'JavaScript', value: 'js' },
+                { title: 'TypeScript', value: 'ts' }
             ],
             initial: 0
         });
-        if (!response.value) {
+        if (!langRes.value) {
+            console.log(red("✖ Operation cancelled"));
+            return;
+        }
+        const lang = langRes.value;
+        // 2. Template Selection
+        const archRes = await prompts({
+            type: 'select',
+            name: 'value',
+            message: 'Select template:',
+            choices: [
+                {
+                    title: `Standard (${lang.toUpperCase()})`,
+                    description: `Standard Titan app with ${lang.toUpperCase()} actions`,
+                    value: 'standard'
+                },
+                {
+                    title: `Rust + ${lang.toUpperCase()} (Hybrid)`,
+                    description: `High-performance Rust actions + ${lang.toUpperCase()} flexibility`,
+                    value: 'hybrid'
+                }
+            ],
+            initial: 0
+        });
+        if (!archRes.value) {
             console.log(red("✖ Operation cancelled"));
             return;
         }
-        selectedTemplate = response.value;
+        const arch = archRes.value;
+        if (lang === 'js') {
+            selectedTemplate = arch === 'standard' ? 'js' : 'rust';
+        } else {
+            selectedTemplate = arch === 'standard' ? 'ts' : 'rust-ts';
+        }
     }
-    const target = path.join(process.cwd(), name);
+    const target = path.join(process.cwd(), projName);
     const templateDir = path.join(__dirname, "templates", selectedTemplate);
     if (!fs.existsSync(templateDir)) {
-        console.log(red(`Template '${selectedTemplate}' not found. Available: js, rust`));
+        console.log(red(`Template '${selectedTemplate}' not found.`));
         return;
     }
@@ -164,7 +209,7 @@ async function initProject(name, templateName) {
     console.log("\n" + bold(cyan("🚀 Initializing Titan Project...")));
     console.log(gray(`   Target:   ${target}`));
-    console.log(gray(`   Template: ${selectedTemplate === 'rust' ? 'Rust + JS (Native Perf)' : 'JavaScript (Standard)'}`));
+    console.log(gray(`   Template: ${selectedTemplate}`));
     // ----------------------------------------------------------
     // 1. Copy full template directory
@@ -198,7 +243,7 @@ async function initProject(name, templateName) {
     console.log(cyan("📦 Installing dependencies..."));
     try {
-        execSync(`npm install esbuild chokidar --silent`, {
+        execSync(`npm install --silent`, {
             cwd: target,
             stdio: "inherit",
         });
@@ -210,7 +255,7 @@ async function initProject(name, templateName) {
     console.log("\n" + bold(green("🎉 You're all set!")));
     console.log(`
   ${gray("Next steps:")}
-    ${cyan(`cd ${name}`)}
+    ${cyan(`cd ${projName}`)}
     ${cyan("titan dev")}
 `);
 }
@@ -335,7 +380,9 @@ function updateTitan() {
     }
     if (!fs.existsSync(templateServer)) {
-        console.log(red("CLI is corrupted — server template missing."));
+        console.log(red(`CLI seems corrupted or incomplete.`));
+        console.log(red(`Expected server template at: ${templateServer}`));
+        console.log(yellow(`If you are running from npx, try clearing cache or installing a specific version.`));
         return;
     }

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "26.8.2",
+  "version": "26.9.0",
   "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",
@@ -52,4 +52,4 @@
     "esbuild": "^0.27.2",
     "prompts": "^2.4.2"
   }
-}
+}

package/templates/extension/README.md CHANGED Viewed

@@ -1,104 +1,104 @@
-# 🪐 Titan Extension: {{name}}
-> Elevate Titan Planet with custom JavaScript and high-performance Native Rust logic.
-Welcome to your new Titan extension! This template provides everything you need to build, test, and deploy powerful additions to the Titan project.
----
-## 🛠 Project Structure
-- `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.
----
-## 🚀 Quick Start
-### 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!*
----
-## 💻 Development Guide
-### Writing JavaScript
-Extensions interact with the global `t` object. It's best practice to namespace your extension:
-```javascript
-t.{{name}} = {
-    myMethod: (val) => {
-        t.log("{{name}}", "Doing something...");
-        return val * 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"
-    }
-}
-```
----
-## 🧪 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`.
----
-Happy coding on Titan Planet! 🚀
+# 🪐 Titan Extension: {{name}}
+> Elevate Titan Planet with custom JavaScript and high-performance Native Rust logic.
+Welcome to your new Titan extension! This template provides everything you need to build, test, and deploy powerful additions to the Titan project.
+---
+## 🛠 Project Structure
+- `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.
+---
+## 🚀 Quick Start
+### 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!*
+---
+## 💻 Development Guide
+### Writing JavaScript
+Extensions interact with the global `t` object. It's best practice to namespace your extension:
+```javascript
+t.{{name}} = {
+    myMethod: (val) => {
+        t.log("{{name}}", "Doing something...");
+        return val * 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"
+    }
+}
+```
+---
+## 🧪 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`.
+---
+Happy coding on Titan Planet! 🚀

package/templates/extension/index.js CHANGED Viewed

@@ -1,27 +1,27 @@
-/**
- * Titan Extension Entry Point
- * You can attach methods to the global `t` object here.
- */
-// Define your extension Key
-const EXT_KEY = "{{name}}";
-t.log(EXT_KEY, "Extension loading...");
-// Preserve any native functions already attached to this key
-t[EXT_KEY] = Object.assign(t[EXT_KEY] || {}, {
-    // Example pure JavaScript function
-    hello: function (name) {
-        t.log(EXT_KEY, `Hello ${name} from ${EXT_KEY}!`);
-        return `Hello ${name}!`;
-    },
-    // Example Wrapper for Native function
-    calc: function (a, b) {
-        t.log(EXT_KEY, `Calculating ${a} + ${b} natively...`);
-        // Assumes the native function 'add' is mapped in titan.json
-        return t[EXT_KEY].add(a, b);
-    }
-});
-t.log(EXT_KEY, "Extension loaded!");
+/**
+ * Titan Extension Entry Point
+ * You can attach methods to the global `t` object here.
+ */
+// Define your extension Key
+const EXT_KEY = "{{name}}";
+t.log(EXT_KEY, "Extension loading...");
+// Preserve any native functions already attached to this key
+t[EXT_KEY] = Object.assign(t[EXT_KEY] || {}, {
+    // Example pure JavaScript function
+    hello: function (name) {
+        t.log(EXT_KEY, `Hello ${name} from ${EXT_KEY}!`);
+        return `Hello ${name}!`;
+    },
+    // Example Wrapper for Native function
+    calc: function (a, b) {
+        t.log(EXT_KEY, `Calculating ${a} + ${b} natively...`);
+        // Assumes the native function 'add' is mapped in titan.json
+        return t[EXT_KEY].add(a, b);
+    }
+});
+t.log(EXT_KEY, "Extension loaded!");

package/templates/extension/jsconfig.json CHANGED Viewed

@@ -1,13 +1,13 @@
-{
-    "compilerOptions": {
-        "module": "commonjs",
-        "target": "es2021",
-        "checkJs": false,
-        "allowJs": true,
-        "moduleResolution": "node"
-    },
-    "include": [
-        "index.js",
-        "node_modules/titan-sdk/index.d.ts"
-    ]
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es2021",
+        "checkJs": false,
+        "allowJs": true,
+        "moduleResolution": "node"
+    },
+    "include": [
+        "index.js",
+        "node_modules/titan-sdk/index.d.ts"
+    ]
 }

package/templates/extension/native/Cargo.toml CHANGED Viewed

@@ -1,9 +1,9 @@
-[package]
-name = "{{native_name}}_native"
-version = "0.1.0"
-edition = "2024"
-[lib]
-crate-type = ["cdylib"]
-[dependencies]
+[package]
+name = "{{native_name}}_native"
+version = "0.1.0"
+edition = "2024"
+[lib]
+crate-type = ["cdylib"]
+[dependencies]

package/templates/extension/native/src/lib.rs CHANGED Viewed

@@ -1,5 +1,5 @@
-#[unsafe(no_mangle)]
-pub extern "C" fn add(a: f64, b: f64) -> f64 {
-    a + b
-}
+#[unsafe(no_mangle)]
+pub extern "C" fn add(a: f64, b: f64) -> f64 {
+    a + b
+}