@titanpl/cli 6.0.0 → 7.0.0

package/index.js

@@ -11,6 +11,10 @@ import { migrateCommand } from "./src/commands/migrate.js";
 import { updateCommand } from "./src/commands/update.js";
 import { initCommand } from "./src/commands/init.js";
 
+import { createCommand } from "./src/commands/create.js";
+import { buildExtensionCommand } from "./src/commands/build-ext.js";
+import { runExtensionCommand } from "./src/commands/run-ext.js";
+
 /* -------------------------------------------------------
  * Resolve __dirname (ESM safe)
  * ----------------------------------------------------- */
@@ -54,6 +58,7 @@ ${bold(cyan("╰─────────────────────
     ${cyan("init")}      ${gray("Scaffold a new Titan project")}
     ${cyan("create")}    ${gray("Create a new project or extension (e.g. 'titan create ext my-ext')")}
     ${cyan("build")}     ${gray("Compile actions and build production dist. Use --release or -r for a production-ready folder.")}
+    ${cyan("run")}       ${gray("Run the production Gravity Engine or an extension sandbox")}
     ${cyan("dev")}       ${gray("Start the Gravity Engine in dev/watch mode")}
     ${cyan("start")}     ${gray("Start the production Gravity Engine")}
     ${cyan("update")}    ${gray("Update an existing project to latest Titan version")}
@@ -112,26 +117,35 @@ const cmd = process.argv[2];
       case "create": {
         const type = process.argv[3];
         const name = process.argv[4];
-        if (type === "ext" || type === "extension") {
-          await initCommand(name, "extension");
-        } else {
-          // Fallback to init behavior
-          await initCommand(type, null);
-        }
+        await createCommand(type, name);
         break;
       }
 
-      case "build":
-        const isRelease = process.argv.includes("--release") || process.argv.includes("-r");
-        console.log(cyan(`→ Building Titan project${isRelease ? " (Release mode)" : ""}...`));
-        await buildCommand(isRelease);
-        console.log(green(`✔ ${isRelease ? "Release" : "Build"} complete`));
+      case "build": {
+        if (process.argv[3] === "ext" || process.argv[3] === "extension") {
+          await buildExtensionCommand();
+        } else {
+          const isRelease = process.argv.includes("--release") || process.argv.includes("-r");
+          console.log(cyan(`→ Building Titan project${isRelease ? " (Release mode)" : ""}...`));
+          await buildCommand(isRelease);
+          console.log(green(`✔ ${isRelease ? "Release" : "Build"} complete`));
+        }
         break;
+      }
 
       case "dev":
         await devCommand();
         break;
 
+      case "run":
+        if (process.argv[3] === "ext" || process.argv[3] === "extension") {
+          await runExtensionCommand();
+        } else {
+          console.log(cyan("→ Starting Titan Server..."));
+          startCommand();
+        }
+        break;
+
       case "start":
         console.log(cyan("→ Starting Titan Server..."));
         startCommand();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/cli",
-  "version": "6.0.0",
+  "version": "7.0.0",
   "description": "The unified CLI for Titan Planet. Use it to create, manage, build, and deploy high-performance backend projects.",
   "keywords": [
     "titanpl",
@@ -29,11 +29,11 @@
     "tit": "./index.js"
   },
   "optionalDependencies": {
-    "@titanpl/engine-win32-x64": "6.0.0",
-    "@titanpl/engine-linux-x64": "6.0.0"
+    "@titanpl/engine-win32-x64": "7.0.0",
+    "@titanpl/engine-linux-x64": "7.0.0"
   },
   "dependencies": {
-    "@titanpl/packet": "6.0.0",
+    "@titanpl/packet": "7.0.0",
     "prompts": "^2.4.2",
     "commander": "^11.0.0",
     "chalk": "^4.1.2"

package/src/commands/build-ext.js

@@ -0,0 +1,157 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import chalk from 'chalk';
+
+export async function buildExtensionCommand() {
+    const titanJsonPath = path.join(process.cwd(), 'titan.json');
+    if (!fs.existsSync(titanJsonPath)) {
+        console.log(chalk.red("✖ No titan.json found in current directory."));
+        return;
+    }
+
+    const titanJson = JSON.parse(fs.readFileSync(titanJsonPath, 'utf8'));
+    const type = titanJson.type;
+
+    if (type === 'js') {
+        console.log(chalk.yellow("! JS-only extensions do not require a build step."));
+        return;
+    }
+
+    console.log(chalk.cyan(`\n→ Building ${type.toUpperCase()} extension '${titanJson.name}'...\n`));
+
+    if (type === 'wasm') {
+        await buildWasmExtension(titanJson);
+    } else if (type === 'native') {
+        await buildNativeExtension(titanJson);
+    }
+}
+
+async function buildWasmExtension(titanJson) {
+    const nativeDir = path.join(process.cwd(), 'native');
+    if (!fs.existsSync(nativeDir)) {
+        console.log(chalk.red("✖ native/ directory not found."));
+        return;
+    }
+
+    console.log(chalk.gray("  Compiling Rust to WebAssembly..."));
+    try {
+        // We assume wasm-pack or similar is used, or just bare cargo with wasm32 target
+        // The spec mentions: native/pkg/my_ext.wasm, which is wasm-pack's default
+        execSync('wasm-pack build --target web', { cwd: nativeDir, stdio: 'inherit' });
+    } catch (err) {
+        console.log(chalk.red("✖ Wasm compilation failed. Make sure 'wasm-pack' is installed."));
+        return;
+    }
+
+    console.log(chalk.gray("  Generating bindings..."));
+    const libRsPath = path.join(nativeDir, 'src/lib.rs');
+    const libRs = fs.readFileSync(libRsPath, 'utf8');
+    
+    const exports = [];
+    const exportRegex = /#\[titan::export\]\s+pub\s+fn\s+(\w+)\s*\(([^)]*)\)\s*(?:->\s*([^\{]+))?/g;
+    let match;
+    while ((match = exportRegex.exec(libRs)) !== null) {
+        const name = match[1];
+        const paramsRaw = match[2];
+        const params = paramsRaw.split(',').map(p => p.trim().split(':')[0].trim()).filter(p => p);
+        exports.push({ name, params });
+    }
+
+    const bindingsJs = `// Auto-generated by titan build ext
+import * as wasm from './my_ext_bg.wasm';
+export const { ${exports.map(e => e.name).join(', ')} } = wasm;
+`;
+    
+    const pkgDir = path.join(nativeDir, 'pkg');
+    fs.writeFileSync(path.join(pkgDir, 'bindings.js'), bindingsJs);
+
+    // Update index.js
+    const indexJs = `import { registerExtension } from './utils/registerExtension.js';
+import * as native from './native/pkg/bindings.js';
+
+const myExt = {
+    ${exports.map(e => `${e.name}: (${e.params.join(', ')}) => native.${e.name}(${e.params.join(', ')})`).join(',\n    ')}
+};
+
+registerExtension("${titanJson.name.split('/').pop()}", myExt);
+`;
+    fs.writeFileSync(path.join(process.cwd(), 'index.js'), indexJs);
+
+    // Update titan.json
+    titanJson.wasm = "native/pkg/my_ext_bg.wasm";
+    titanJson.bindings = "native/pkg/bindings.js";
+    fs.writeFileSync(path.join(process.cwd(), 'titan.json'), JSON.stringify(titanJson, null, 2));
+
+    console.log(chalk.green("✔ Wasm build complete."));
+}
+
+async function buildNativeExtension(titanJson) {
+    const nativeDir = path.join(process.cwd(), 'native');
+    if (!fs.existsSync(nativeDir)) {
+        console.log(chalk.red("✖ native/ directory not found."));
+        return;
+    }
+
+    console.log(chalk.gray("  Compiling Rust native library..."));
+    try {
+        execSync('cargo build --release', { cwd: nativeDir, stdio: 'inherit' });
+    } catch (err) {
+        console.log(chalk.red("✖ Native compilation failed."));
+        return;
+    }
+
+    const libName = titanJson.name.split('/').pop().replace(/-/g, '_');
+    const isWindows = process.platform === 'win32';
+    const isMac = process.platform === 'darwin';
+    
+    let binName = `lib${libName}.so`;
+    if (isWindows) binName = `${libName}.dll`;
+    if (isMac) binName = `lib${libName}.dylib`;
+
+    const buildDir = path.join(nativeDir, 'build');
+    if (!fs.existsSync(buildDir)) fs.mkdirSync(buildDir);
+
+    const targetDir = path.join(nativeDir, 'target/release');
+    const srcPath = path.join(targetDir, binName);
+    const destPath = path.join(buildDir, binName);
+
+    if (fs.existsSync(srcPath)) {
+        fs.copyFileSync(srcPath, destPath);
+    }
+
+    // Parse exports for index.js
+    const libRsPath = path.join(nativeDir, 'src/lib.rs');
+    const libRs = fs.readFileSync(libRsPath, 'utf8');
+    const exports = [];
+    const exportRegex = /#\[titan::native_export\]\s+pub\s+extern\s+"C"\s+fn\s+(\w+)\s*\(([^)]*)\)/g;
+    let match;
+    while ((match = exportRegex.exec(libRs)) !== null) {
+        const name = match[1];
+        const paramsRaw = match[2];
+        const params = paramsRaw.split(',').map(p => p.trim().split(':')[0].trim()).filter(p => p);
+        exports.push({ name, params });
+    }
+
+    // Update index.js
+    const indexJs = `import { registerExtension } from './utils/registerExtension.js';
+
+// native bindings are injected by Gravity's NativeHost IPC bridge
+const myExt = {
+    ${exports.map(e => `${e.name}: (${e.params.join(', ')}) => t.__native.call("${titanJson.name}", "${e.name}", [${e.params.join(', ')}])`).join(',\n    ')}
+};
+
+registerExtension("${titanJson.name.split('/').pop()}", myExt);
+`;
+    fs.writeFileSync(path.join(process.cwd(), 'index.js'), indexJs);
+
+    // Update titan.json
+    titanJson.native = {
+        linux: `native/build/lib${libName}.so`,
+        windows: `native/build/${libName}.dll`,
+        macos: `native/build/lib${libName}.dylib`
+    };
+    fs.writeFileSync(path.join(process.cwd(), 'titan.json'), JSON.stringify(titanJson, null, 2));
+
+    console.log(chalk.green("✔ Native build complete."));
+}

package/src/commands/build.js

@@ -1,7 +1,19 @@
 import { build, release } from "@titanpl/packet";
+import fs from 'fs';
+import path from 'path';
 
 export async function buildCommand(isRelease = false) {
   const buildFn = isRelease ? release : build;
   const dist = await buildFn(process.cwd());
+
+  const tanfigPath = path.join(process.cwd(), 'tanfig.json');
+  if (fs.existsSync(tanfigPath)) {
+    fs.copyFileSync(tanfigPath, path.join(dist, 'tanfig.json'));
+  }
+  const pkgPath = path.join(process.cwd(), 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    fs.copyFileSync(pkgPath, path.join(dist, 'package.json'));
+  }
+
   console.log(`✔ ${isRelease ? 'Release' : 'Build'} complete →`, dist);
 }

package/src/commands/create.js

@@ -0,0 +1,160 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import prompts from 'prompts';
+import chalk from 'chalk';
+import { copyDir } from './init.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export async function createCommand(type, name) {
+    if (type === 'ext' || type === 'extension') {
+        await createExtension(name);
+    } else {
+        console.log(chalk.red(`\n✖ Unknown creation type: ${type}`));
+        console.log(chalk.gray(`  Available types: ext\n`));
+    }
+}
+
+async function createExtension(extensionName) {
+    let name = extensionName;
+    if (!name) {
+        const res = await prompts({
+            type: 'text',
+            name: 'name',
+            message: 'Extension name:',
+            initial: 'my-ext'
+        });
+        name = res.name;
+    }
+
+    if (!name) {
+        console.log(chalk.red("✖ Extension name is required."));
+        return;
+    }
+
+    const res = await prompts({
+        type: 'select',
+        name: 'type',
+        message: 'What type of extension do you want to create?',
+        choices: [
+            { title: 'js      — JavaScript only, zero build step, always safe', value: 'js' },
+            { title: 'wasm    — Rust compiled to WebAssembly, sandboxed, auto-bound', value: 'wasm' },
+            { title: 'native  — Rust compiled to .so/.dll, out-of-process, requires allowNative', value: 'native' },
+        ],
+        initial: 0
+    });
+
+    const extType = res.type;
+    if (!extType) return;
+
+    const targetDir = path.resolve(process.cwd(), name);
+    if (fs.existsSync(targetDir)) {
+        console.log(chalk.red(`\n✖ Directory '${name}' already exists.\n`));
+        return;
+    }
+
+    // Find template path (similar to init.js)
+    let templateDir = path.resolve(__dirname, '..', '..', '..', '..', 'templates', 'extension');
+    if (!fs.existsSync(templateDir)) {
+        templateDir = path.resolve(__dirname, '..', '..', 'templates', 'extension');
+    }
+
+    console.log(chalk.cyan(`\n→ Creating ${extType.toUpperCase()} extension '${name}'...\n`));
+
+    if (extType === 'js') {
+        try {
+            console.log(chalk.gray(`  Cloning JS template from https://github.com/t8nlab/extTemplate.git...`));
+            const { execSync } = await import('child_process');
+            execSync(`git clone https://github.com/t8nlab/extTemplate.git "${targetDir}"`, { stdio: 'pipe' });
+            // Remove git history
+            fs.rmSync(path.join(targetDir, '.git'), { recursive: true, force: true });
+        } catch (err) {
+            console.log(chalk.yellow(`  Git clone failed, falling back to local template...`));
+            copyDir(templateDir, targetDir);
+        }
+    } else {
+        // 1. Copy the source template
+        copyDir(templateDir, targetDir);
+    }
+
+    // 2. Perform transformations
+    transformExtension(targetDir, name, extType);
+
+    console.log(chalk.green(`\n✔ Extension '${name}' created successfully!`));
+    console.log(chalk.yellow(`  cd ${name}`));
+    if (extType !== 'js') {
+        console.log(chalk.yellow(`  titan build ext`));
+    }
+    console.log(chalk.yellow(`  titan run ext\n`));
+}
+
+function transformExtension(target, name, type) {
+    // 1. Remove optional native folder if it's a JS extension
+    if (type === 'js') {
+        const nativeDir = path.join(target, 'native');
+        if (fs.existsSync(nativeDir)) {
+            fs.rmSync(nativeDir, { recursive: true, force: true });
+        }
+    }
+
+    // 2. Patch package.json
+    const pkgPath = path.join(target, 'package.json');
+    if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+        pkg.name = name;
+        pkg.version = "1.0.0";
+        // Ensure dependencies
+        pkg.dependencies = pkg.dependencies || {};
+        pkg.dependencies["@titanpl/sdk"] = "2.0.0";
+        fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+    }
+
+    // 3. Patch titan.json
+    const titanPath = path.join(target, 'titan.json');
+    if (fs.existsSync(titanPath)) {
+        const titan = JSON.parse(fs.readFileSync(titanPath, 'utf8'));
+        titan.name = name;
+        titan.type = type;
+        titan.version = "1.0.0";
+        fs.writeFileSync(titanPath, JSON.stringify(titan, null, 2));
+    }
+
+    // 4. Cleanup git if it exists accidentally
+    const gitDir = path.join(target, '.git');
+    if (fs.existsSync(gitDir)) {
+        fs.rmSync(gitDir, { recursive: true, force: true });
+    }
+
+    // 5. Recursive template substitution for any {{name}} in files
+    substituteTemplates(target, name);
+}
+
+function substituteTemplates(dir, name) {
+    for (const file of fs.readdirSync(dir)) {
+        const fullPath = path.join(dir, file);
+        if (fs.lstatSync(fullPath).isDirectory()) {
+            substituteTemplates(fullPath, name);
+        } else {
+            const ext = path.extname(file).toLowerCase();
+            const textExts = ['.js', '.ts', '.json', '.md', '.txt', '.rs', '.toml', '.html', '.css', '.d.ts'];
+            if (textExts.includes(ext)) {
+                let content = fs.readFileSync(fullPath, 'utf8');
+                let changed = false;
+                if (content.includes("{{name}}")) {
+                    content = content.replace(/{{name}}/g, name);
+                    changed = true;
+                }
+                if (content.includes("workspace:*")) {
+                    content = content.replace(/"@titanpl\/sdk": "workspace:\*"/g, '"@titanpl/sdk": "2.0.0"');
+                    content = content.replace(/workspace:\*/g, "6.0.0");
+                    changed = true;
+                }
+                if (changed) {
+                    fs.writeFileSync(fullPath, content);
+                }
+            }
+        }
+    }
+}

package/src/commands/init.js

@@ -176,17 +176,7 @@ export async function initCommand(projectName, templateName) {
         }
     }
 
-    // 4. Ensure tanfig.json exists with default build config
-    const tanfigPath = path.join(target, "tanfig.json");
-    if (!fs.existsSync(tanfigPath)) {
-        const defaultConfig = {
-            name: projName,
-            build: {
-                files: ["public", "static", "db", "config"]
-            }
-        };
-        fs.writeFileSync(tanfigPath, JSON.stringify(defaultConfig, null, 2));
-    }
+    // 4. Substitution is handled below by substitute()
 
 
     // Recursive template substitution
@@ -212,6 +202,10 @@ export async function initCommand(projectName, templateName) {
                         content = content.replace(/{{native_name}}/g, projName.replace(/-/g, '_'));
                         changed = true;
                     }
+                    if (content.includes("workspace:*")) {
+                        content = content.replace(/workspace:\*/g, "6.0.0");
+                        changed = true;
+                    }
                     if (changed) {
                         fs.writeFileSync(fullPath, content);
                     }

package/src/commands/run-ext.js

@@ -0,0 +1,104 @@
+import fs from 'fs';
+import path from 'path';
+import chalk from 'chalk';
+import http from 'node:http';
+
+/**
+ * Runs the extension sandbox using a native Node.js server (zero dependencies).
+ */
+export async function runExtensionCommand() {
+    const titanJsonPath = path.join(process.cwd(), 'titan.json');
+    if (!fs.existsSync(titanJsonPath)) {
+        console.log(chalk.red("✖ No titan.json found in current directory."));
+        return;
+    }
+
+    const titanJson = JSON.parse(fs.readFileSync(titanJsonPath, 'utf8'));
+    const port = 3000;
+
+    const server = http.createServer((req, res) => {
+        if (req.url === '/test' && req.method === 'GET') {
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(`
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Titan Extension Sandbox - ${titanJson.name}</title>
+    <style>
+        body { font-family: 'Inter', sans-serif; background: #0f172a; color: #f8fafc; padding: 2rem; margin: 0; }
+        .container { max-width: 800px; margin: 0 auto; }
+        .card { background: #1e293b; padding: 2rem; border-radius: 1rem; border: 1px solid #334155; box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.3); }
+        h1 { color: #38bdf8; margin-top: 0; display: flex; align-items: center; gap: 1rem; }
+        .badge { background: #0ea5e9; color: white; padding: 0.2rem 0.6rem; border-radius: 9999px; font-size: 0.75rem; text-transform: uppercase; letter-spacing: 0.05em; }
+        .method-list { margin-top: 2rem; }
+        .method-item { background: #334155; padding: 1rem; margin-bottom: 1rem; border-radius: 0.5rem; display: flex; justify-content: space-between; align-items: center; }
+        .method-name { font-family: monospace; font-weight: bold; color: #7dd3fc; }
+        button { background: #38bdf8; color: #0f172a; border: none; padding: 0.5rem 1.25rem; border-radius: 0.375rem; cursor: pointer; font-weight: 600; transition: all 0.2s; }
+        button:hover { background: #7dd3fc; transform: translateY(-1px); }
+        .output-container { margin-top: 2rem; }
+        pre { background: #020617; padding: 1.5rem; border-radius: 0.5rem; border: 1px solid #1e293b; color: #10b981; overflow-x: auto; font-family: 'Fira Code', monospace; line-height: 1.5; }
+        .log-entry { margin-bottom: 0.5rem; }
+        .status-ok { color: #10b981; }
+        .status-call { color: #fbbf24; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="card">
+            <h1>
+                Extension Sandbox 
+                <span class="badge">${titanJson.type}</span>
+            </h1>
+            <p>Testing extension: <code style="color: #38bdf8;">${titanJson.name}</code> v${titanJson.version}</p>
+            
+            <div class="method-list">
+                <div class="method-item">
+                    <span class="method-name">hello()</span>
+                    <button onclick="callMethod('hello', [])">Invoke</button>
+                </div>
+                <!-- Dynamic methods would be listed here -->
+            </div>
+
+            <div class="output-container">
+                <h3>Live Output Log</h3>
+                <pre id="output"><div class="log-entry status-ok">[System] Sandbox ready at localhost:${port}</div></pre>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        const output = document.getElementById('output');
+        function log(msg, type = 'ok') {
+            const entry = document.createElement('div');
+            entry.className = 'log-entry status-' + type;
+            entry.textContent = \`[\${new Date().toLocaleTimeString()}] \${msg}\`;
+            output.appendChild(entry);
+            output.scrollTop = output.scrollHeight;
+        }
+
+        async function callMethod(name, args) {
+            log(\`Calling \${name}...\`, 'call');
+            try {
+                // In a real sandbox this would fetch a /call endpoint
+                const res = "Hello from ${titanJson.name}!";
+                log(\`Result: \${JSON.stringify(res)}\`, 'ok');
+            } catch (e) {
+                log(\`Error: \${e.message}\`, 'error');
+            }
+        }
+    </script>
+</body>
+</html>`);
+        } else {
+            res.writeHead(404);
+            res.end('Not Found');
+        }
+    });
+
+    server.listen(port, () => {
+        console.log(chalk.cyan(`\n🪐 Titan Extension Sandbox running at:`));
+        console.log(chalk.bold(`  http://localhost:${port}/test\n`));
+        console.log(chalk.gray(`  Press Ctrl+C to stop.\n`));
+    });
+}

package/templates/common/_tanfig.json

@@ -1,14 +1,20 @@
-{
-    "name": "{{name}}",
-    "description": "A powerful Titan Planet project",
-    "version": "1.0.0",
-    "build": {
-        "purpose": "test",
-        "files": [
-            "public",
-            "static",
-            "db",
-            "config"
-        ]
-    }
+{
+  "name": "{{name}}",
+  "description": "A powerful TitanPL project",
+  "version": "1.0.0",
+  "extensions": {
+    "allowWasm": true,
+    "allowNative": [
+      "@titanpl/core"
+    ]
+  },
+  "build": {
+    "purpose": "test",
+    "files": [
+      "public",
+      "static",
+      "db",
+      "tanfig.json"
+    ]
+  }
 }

package/templates/extension/index.d.ts

@@ -1,27 +1,31 @@
-// Type definitions for {{name}}
-// This file facilitates type inference when this extension is installed in a Titan project.
+/**
+ * @package ext-template
+ * Professional extension template for the TitanPL framework.
+ */
 
-declare global {
-    namespace Titan {
-        interface Runtime {
-            /**
-             * {{name}} Extension
-             */
-            "{{name}}": {
-                /**
-                 * Example hello function
-                 */
-                hello(name: string): string;
+/** Main configuration interface */
+export interface Config {
+  /** Secure key or secret */
+  secret?: string;
+  /** Custom logging function */
+  log?: (msg: string) => void;
+}
+
+/** Standard Success Response */
+export interface Result {
+  result: string;
+  status: "ok" | "error";
+}
+
+/** Main Extension class */
+declare class Extension {
+  constructor(config?: Config);
 
-                /**
-                 * Example calc function (native wrapper)
-                 */
-                calc(a: number, b: number): number;
+  /** Hash a string synchronously using bcryptjs */
+  hash(data: string): string;
 
-                // Add your extension methods here
-            }
-        }
-    }
+  /** Standard execution for processing input */
+  execute(input: string): Result;
 }
 
-export { };
+export default Extension;

package/templates/extension/index.js

@@ -1,17 +1,17 @@
-// Define your extension Key
-if (typeof Titan === "undefined") globalThis.Titan = t;
-const EXT_KEY = "{{name}}";
+import { registerExtension } from './utils/registerExtension.js';
 
-// Preserve any native functions already attached to this key
-t[EXT_KEY] = Object.assign(t[EXT_KEY] || {}, {
-    // Example pure JavaScript function
-    hello: function (name) {
-        return `Hello ${name} from ${EXT_KEY}!`;
-    },
-
-    // Example Wrapper for Native function
-    calc: function (a, b) {
-        // Assumes the native function 'add' is mapped in titan.json
-        return t[EXT_KEY].add(a, b);
+const myExt = {
+    /**
+     * A sample function that can be called from any Titan Action.
+     */
+    hello: () => {
+        t.log("{{name}}", "Hello from extension!");
+        return "hello";
     }
-});
+};
+
+// If this is a Wasm or Native extension, bindings will be injected here during build.
+// Use 'titan build ext' to generate them.
+
+registerExtension("{{name}}", myExt);
+export default myExt;

package/templates/extension/native/Cargo.toml

@@ -1,9 +1,11 @@
 [package]
-name = "{{native_name}}_native"
-version = "0.1.0"
-edition = "2024"
+name = "my-extension-native"
+version = "1.0.0"
+edition = "2021"
 
 [lib]
 crate-type = ["cdylib"]
 
 [dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"

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

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

package/templates/extension/package.json

@@ -1,26 +1,16 @@
 {
-  "name": "{{name}}",
-  "version": "6.0.0",
-  "description": "A Titan Planet extension",
+  "name": "my-extension",
+  "version": "7.0.0",
+  "description": "A high-performance TitanPL extension.",
+  "type": "module",
   "main": "index.js",
-  "types": "index.d.ts",
-  "type": "commonjs",
-  "scripts": {
-    "test": "microgravity test"
-  },
-  "keywords": [
-    "titan planet",
-    "extension"
+  "files": [
+    "index.js",
+    "titan.json",
+    "jsconfig.json",
+    "README.md"
   ],
-  "author": "",
-  "license": "ISC",
   "dependencies": {
-    "@titanpl/core": "latest",
-    "chokidar": "^5.0.0",
-    "esbuild": "^0.27.2",
-    "titanpl-sdk": "6.0.0"
-  },
-  "devDependencies": {
-    "@tgrv/microgravity": "latest"
+    "@titanpl/sdk": "7.0.0"
   }
 }

package/templates/extension/titan.json

@@ -1,18 +1,7 @@
 {
-    "name": "{{name}}",
-    "main": "index.js",
-    "description": "A Titan extension",
-    "native": {
-        "path": "native/target/release/{{native_name}}_native.dll",
-        "functions": {
-            "add": {
-                "symbol": "add",
-                "parameters": [
-                    "f64",
-                    "f64"
-                ],
-                "result": "f64"
-            }
-        }
-    }
+  "name": "my-extension",
+  "version": "1.0.0",
+  "type": "wasm",
+  "entry": "index.js",
+  "description": "A high-performance TitanPL extension."
 }

package/templates/extension/utils/registerExtension.js

@@ -0,0 +1,44 @@
+// utils/registerExtension.js
+
+/**
+ * Safely registers an extension in the global t object
+ * @param {string} extensionName - Unique name for the extension
+ * @param {any} extensionModule - The extension module/object to register
+ * @returns {boolean} True if registration was successful
+ */
+export function registerExtension(extensionName, extensionModule) {
+    // Check for global t object
+    if (typeof t === 'undefined') {
+        console.warn(`[registerExtension] Global 't' object not available. Cannot register: ${extensionName}`);
+        return false;
+    }
+
+    // Input validation
+    if (!extensionName || typeof extensionName !== 'string') {
+        console.error('[registerExtension] Invalid extension name provided');
+        return false;
+    }
+
+    // Check for naming conflicts
+    if (t[extensionName]) {
+        console.warn(`[registerExtension] '${extensionName}' already exists in global t object, overwriting`);
+    }
+
+    try {
+        // Register the extension
+        t[extensionName] = extensionModule;
+        
+        console.log(`[registerExtension] Successfully registered '${extensionName}'`);
+
+        return true;
+    } catch (error) {
+        // Structured error reporting
+        console.error(`[registerExtension] Failed to register '${extensionName}':`, {
+            error: error.message,
+            extensionName,
+            moduleType: typeof extensionModule
+        });
+
+        return false;
+    }
+}

package/templates/js/package.json

@@ -6,16 +6,16 @@
     "template": "js"
   },
   "dependencies": {
-    "@titanpl/cli": "6.0.0",
-    "@titanpl/route": "6.0.0",
-    "@titanpl/native": "6.0.0",
-    "@titanpl/core": "latest",
+    "@titanpl/cli": "7.0.0",
+    "@titanpl/route": "7.0.0",
+    "@titanpl/native": "7.0.0",
+    "@titanpl/core": "7.0.0",
     "@titanpl/node": "latest",
-    "@titanpl/packet": "6.0.0"
+    "@titanpl/packet": "7.0.0"
   },
   "optionalDependencies": {
-    "@titanpl/engine-linux-x64": "6.0.0",
-    "@titanpl/engine-win32-x64": "6.0.0"
+    "@titanpl/engine-linux-x64": "7.0.0",
+    "@titanpl/engine-win32-x64": "7.0.0"
   },
   "scripts": {
     "build": "titan build",
@@ -28,5 +28,5 @@
     "eslint": "^9.39.2",
     "eslint-plugin-titanpl": "latest"
   },
-  "version": "6.0.0"
+  "version": "7.0.0"
 }

package/templates/rust-js/package.json

@@ -1,16 +1,16 @@
 {
   "name": "titanpl",
-  "version": "6.0.0",
+  "version": "7.0.0",
   "description": "A Titan Planet server",
   "type": "module",
   "titan": {
     "template": "rust-js"
   },
   "dependencies": {
-    "@titanpl/cli": "6.0.0",
-    "@titanpl/route": "6.0.0",
-    "@titanpl/native": "6.0.0",
-    "@titanpl/core": "latest",
+    "@titanpl/cli": "7.0.0",
+    "@titanpl/route": "7.0.0",
+    "@titanpl/native": "7.0.0",
+    "@titanpl/core": "7.0.0",
     "@titanpl/node": "latest"
   },
   "scripts": {

package/templates/rust-ts/package.json

@@ -1,16 +1,16 @@
 {
   "name": "titanpl",
-  "version": "6.0.0",
+  "version": "7.0.0",
   "description": "A Titan Planet server (Rust + TypeScript)",
   "type": "module",
   "titan": {
     "template": "rust-ts"
   },
   "dependencies": {
-    "@titanpl/cli": "6.0.0",
-    "@titanpl/route": "6.0.0",
-    "@titanpl/native": "6.0.0",
-    "@titanpl/core": "latest",
+    "@titanpl/cli": "7.0.0",
+    "@titanpl/route": "7.0.0",
+    "@titanpl/native": "7.0.0",
+    "@titanpl/core": "7.0.0",
     "@titanpl/node": "latest",
     "typescript": "^5.0.0"
   },

package/templates/ts/package.json

@@ -6,18 +6,18 @@
     "template": "ts"
   },
   "dependencies": {
-    "@titanpl/cli": "6.0.0",
-    "@titanpl/route": "6.0.0",
-    "@titanpl/native": "6.0.0",
-    "@titanpl/core": "latest",
+    "@titanpl/cli": "7.0.0",
+    "@titanpl/route": "7.0.0",
+    "@titanpl/native": "7.0.0",
+    "@titanpl/core": "7.0.0",
     "@titanpl/node": "latest",
-    "@titanpl/packet": "6.0.0",
+    "@titanpl/packet": "7.0.0",
     "typescript": "^5.0.0"
   },
   "optionalDependencies": {
     "@titanpl/engine-linux-arm64": "2.0.5",
-    "@titanpl/engine-linux-x64": "6.0.0",
-    "@titanpl/engine-win32-x64": "6.0.0"
+    "@titanpl/engine-linux-x64": "7.0.0",
+    "@titanpl/engine-win32-x64": "7.0.0"
   },
   "scripts": {
     "build": "titan build",
@@ -31,5 +31,5 @@
     "eslint-plugin-titanpl": "latest",
     "@typescript-eslint/parser": "^8.54.0"
   },
-  "version": "6.0.0"
+  "version": "7.0.0"
 }