@ezetgalaxy/titan 26.7.0 → 26.7.2

package/README.md

@@ -276,7 +276,7 @@ No exports wiring. No globals. No boilerplate.
 
 # 📦 Version
 
-**Titan v25 — Stable**
+**Titan v26 — Stable**
 
 * Production-ready runtime
 * Safe JS execution

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "26.7.0",
+  "version": "26.7.2",
   "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",

package/templates/titan/dev.js

@@ -10,10 +10,12 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
 let serverProcess = null;
+let isKilling = false;
 
 async function killServer() {
     if (!serverProcess) return;
 
+    isKilling = true;
     const pid = serverProcess.pid;
     const killPromise = new Promise((resolve) => {
         if (serverProcess.exitCode !== null) return resolve();
@@ -34,28 +36,47 @@ async function killServer() {
         await killPromise;
     } catch (e) { }
     serverProcess = null;
+    isKilling = false;
 }
 
-async function startRustServer() {
+async function startRustServer(retryCount = 0) {
+    // If we are retrying, give it more time (2s), otherwise standard 1s (increased from 500ms)
+    const waitTime = retryCount > 0 ? 2000 : 1000;
+
+    // Ensure any previous instance is killed
     await killServer();
 
     // Give the OS a moment to release file locks on the binary
-    await new Promise(r => setTimeout(r, 500));
+    await new Promise(r => setTimeout(r, waitTime));
 
     const serverPath = path.join(process.cwd(), "server");
+    const startTime = Date.now();
+
+    if (retryCount > 0) {
+        console.log(`\x1b[33m[Titan] Retrying Rust server (Attempt ${retryCount})...\x1b[0m`);
+    }
 
-    serverProcess = spawn("cargo", ["run"], {
+    // Windows often has file locking issues during concurrent linking/metadata generation
+    // We force 1 job and disable incremental compilation to be safe.
+    serverProcess = spawn("cargo", ["run", "--jobs", "1"], {
         cwd: serverPath,
         stdio: "inherit",
-        shell: true
+        shell: true,
+        env: { ...process.env, CARGO_INCREMENTAL: "0" }
     });
 
-    serverProcess.on("close", (code) => {
-        if (code !== null && code !== 0 && code !== 1) {
-            // 1 is often just 'terminated' on windows if forced, but also error.
-            // We just log it.
-        }
+    serverProcess.on("close", async (code) => {
+        if (isKilling) return;
+
         console.log(`[Titan] Rust server exited: ${code}`);
+
+        // If exited with error and it was a short run (< 10s), likely a start-up error/lock
+        // Retry up to 3 times
+        const runTime = Date.now() - startTime;
+        if (code !== 0 && code !== null && runTime < 10000 && retryCount < 3) {
+            console.log(`\x1b[31m[Titan] Server crash detected (possibly file lock). Retrying automatically...\x1b[0m`);
+            await startRustServer(retryCount + 1);
+        }
     });
 }
 
@@ -106,8 +127,18 @@ async function startDev() {
                 console.log("\x1b[31m[Titan] Build failed -- waiting for changes...\x1b[0m");
             }
 
-        }, 200);
+        }, 500);
     });
 }
 
+// Handle graceful exit to release file locks
+async function handleExit() {
+    console.log("\n[Titan] Stopping server...");
+    await killServer();
+    process.exit(0);
+}
+
+process.on("SIGINT", handleExit);
+process.on("SIGTERM", handleExit);
+
 startDev();