titanpl 4.0.2 → 7.0.0-beta

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "titanpl",
-  "version": "4.0.2",
+  "version": "7.0.0-beta",
   "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",
   "type": "module",
   "main": "index.js",
   "bin": {
-    "tit": "./packages/cli/index.js",
-    "titan": "./packages/cli/index.js",
-    "t8n": "./packages/cli/index.js"
+    "tit-dev": "node ../../packages/cli/index.js",
+    "titan-dev": "node ../../packages/cli/index.js",
+    "t8n-dev": "node ../../packages/cli/index.js",
+    "test-start": "taskkill /f /im titan-server.exe; ../../engine/target/release/titan-server.exe run dist"
   },
   "workspaces": [
     "packages/*",
-    "testapp"
+    "test-apps/*"
   ],
   "files": [
     "index.js",
@@ -61,6 +62,11 @@
     "help": "cd build && node ../index.js help",
     "update": "cd build && node ../index.js update",
     "publish": "node scripts/publish.mjs",
+    "titan-dev": "node packages/cli/index.js",
+    "tit-dev": "node packages/cli/index.js",
+    "t8n-dev": "node packages/cli/index.js",
+    "engine:build": "cd engine && cargo build --release",
+    "engine:dev": "cd engine && cargo build",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",

package/packages/cli/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/packages/cli/package.json

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

package/packages/cli/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/packages/cli/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/packages/cli/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/packages/cli/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/packages/cli/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/packages/engine-darwin-arm64/README.md

@@ -9,5 +9,3 @@ This package is the compiled core Rust + Axum server embedded with the Boa JavaS
 This package is listed as an "optional dependency" in `@titanpl/cli`. During package installation, your package manager identifies the OS and automatically downloads this binary if it matches `darwin` + `arm64`. You do not need to install it directly. 
 
 When you run `titan start`, the CLI locates this binary and executes it as your web server.
-
-**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux and macOS versions are in development (dev only) for the new architecture and will be launched later.

package/packages/engine-darwin-arm64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/engine-darwin-arm64",
-  "version": "2.0.4",
+  "version": "7.0.0-beta",
   "os": [
     "darwin"
   ],

package/packages/engine-linux-x64/README.md

@@ -7,5 +7,3 @@ This package holds the core Rust + Axum high-performance web server tightly coup
 
 ## How it works
 You don't need to manually interact with this module. It acts as an optional dependency resolved by `#titanpl/cli`. If you run TitanPlanet on a Linux x64 machine, npm/yarn automatically downloads this native binary to run your application.
-
-**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.

package/packages/engine-linux-x64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/engine-linux-x64",
-  "version": "2.0.5",
+  "version": "7.0.0-beta",
   "os": [
     "linux"
   ],

package/packages/engine-win32-x64/README.md

@@ -8,4 +8,3 @@ This module provides the highly concurrent Rust-based server binary (`titan.exe`
 ## How it works
 Like the other engine packages, this works entirely behind the scenes. When `@titanpl/cli` is installed on a Windows instance, it fetches this `.exe` runtime. The CLI then maps your built assets and JS routes into the binary for deployment.
 
-**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.

package/packages/engine-win32-x64/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/engine-win32-x64",
-  "version": "2.0.4",
+  "version": "7.0.0-beta",
   "os": [
     "win32"
   ],

package/packages/native/README.md

@@ -8,4 +8,3 @@ It acts as the low-level communication bridge offering type definitions and util
 ## How it works
 You can import tools and primitives from this package into your server-side actions alongside `@titanpl/core` when you want direct low-level interaction or need access to platform operations that interact directly with the C/Rust engine.
 
-**Important Note:** Currently, Titan Planet and its entire package ecosystem are only for Windows. The Linux version is in development (dev only) for the new architecture and will be launched later.