@t8n/ui 1.0.0

package/test-app/server/src/runtime.rs

@@ -0,0 +1,314 @@
+use std::thread;
+use crossbeam::channel::{bounded, Sender};
+use tokio::sync::oneshot;
+use bytes::Bytes;
+use smallvec::SmallVec;
+use crate::extensions::{self, TitanRuntime, WorkerAsyncResult};
+use std::sync::{Arc, Mutex};
+
+// ----------------------------------------------------------------------------
+// TITANVM: HIGH-PERFORMANCE WORKER POOL (SCHEDULER V2)
+// ----------------------------------------------------------------------------
+
+pub enum WorkerCommand {
+    Request(RequestTask),
+    Resume {
+        isolate_id: usize,
+        drift_id: u32,
+        result: WorkerAsyncResult,
+    },
+}
+
+pub struct RequestTask {
+    pub action_name: String,
+    pub body: Option<Bytes>, 
+    pub method: String,
+    pub path: String,
+    pub headers: SmallVec<[(String, String); 8]>,
+    pub params: SmallVec<[(String, String); 4]>,
+    pub query: SmallVec<[(String, String); 4]>,
+    pub response_tx: oneshot::Sender<WorkerResult>,
+}
+
+pub struct WorkerResult {
+    pub json: serde_json::Value,
+    pub timings: Vec<(String, f64)>,
+}
+
+pub struct RuntimeManager {
+    // Normal Priority (New Requests)
+    request_tx: Sender<WorkerCommand>,
+    // High Priority (Drift Resumes)
+    _resume_tx: Sender<WorkerCommand>,
+    
+    _workers: Vec<thread::JoinHandle<()>>,
+}
+
+impl RuntimeManager {
+    pub fn new(project_root: std::path::PathBuf, num_threads: usize) -> Self {
+        // We Use 4x Isolates vs Threads to ensure Drift concurrency can exceed Thread count
+        let num_isolates = std::cmp::max(num_threads * 4, 16); 
+        
+        // Priority Queues
+        let (req_tx, req_rx) = bounded::<WorkerCommand>(10000);
+        let (res_tx, res_rx) = bounded::<WorkerCommand>(10000);
+
+        let tokio_handle = tokio::runtime::Handle::current();
+        let (async_tx, mut async_rx) = tokio::sync::mpsc::channel::<extensions::AsyncOpRequest>(10000);
+        
+        // Global Async Executor (Tokio)
+        tokio_handle.spawn(async move {
+            println!("\x1b[38;5;39m[Titan]\x1b[0m Tokio Async Executor Online");
+            while let Some(req) = async_rx.recv().await {
+                let drift_id = req.drift_id;
+                let respond_tx = req.respond_tx;
+                tokio::spawn(async move {
+                    let start = std::time::Instant::now();
+                    let result = extensions::builtin::run_async_operation(req.op).await;
+                    let duration_ms = start.elapsed().as_secs_f64() * 1000.0;
+                    let _ = respond_tx.send(WorkerAsyncResult {
+                        drift_id,
+                        result,
+                        duration_ms,
+                    });
+                });
+            }
+        });
+
+        // Registry of Isolates
+        // Since V8 Isolates are NOT thread-safe, we must use a Mutex or 1-thread-at-a-time lock.
+        // We use a Vec of Mutexes. The threads will 'pick' an isolate and lock it while working.
+        let mut isolates = Vec::new();
+        for i in 0..num_isolates {
+            let rt = extensions::init_runtime_worker(
+                i,
+                project_root.clone(),
+                res_tx.clone(), // Resumes go back to the high-priority queue
+                tokio_handle.clone(),
+                async_tx.clone(),
+            );
+            isolates.push(Arc::new(Mutex::new(rt)));
+        }
+        
+        // Isolate State Registry
+        let free_isolates = bounded::<usize>(num_isolates);
+        for i in 0..num_isolates {
+            // Set Isolate ID data for the native bridge to use
+            let mut rt = isolates[i].lock().unwrap();
+            let ptr = &mut *rt as *mut extensions::TitanRuntime as *mut std::ffi::c_void;
+            rt.isolate.set_data(0, ptr);
+            free_isolates.0.send(i).unwrap();
+        }
+
+        let isolates = Arc::new(isolates);
+        let free_isolates_rx = free_isolates.1;
+        let free_isolates_tx = free_isolates.0;
+
+        let mut workers = Vec::new();
+        for i in 0..num_threads {
+            let req_rx_c = req_rx.clone();
+            let res_rx_c = res_rx.clone();
+            let isolates_c = isolates.clone();
+            let free_isolates_tx_c = free_isolates_tx.clone();
+            let free_isolates_rx_c = free_isolates_rx.clone();
+
+            let handle = thread::Builder::new()
+                .name(format!("titan-worker-{}", i))
+                .spawn(move || {
+                    loop {
+                        // 1. Check for HIGHEST PRIORITY: Resumes
+                        // Resumes are pinned to specific isolates, but ANY thread can pick them up.
+                        if let Ok(cmd) = res_rx_c.try_recv() {
+                             handle_resume(cmd, &isolates_c);
+                             continue;
+                        }
+
+                        // 2. Regular Requests
+                        // If no resumes, pick a new request IF an isolate is free.
+                        crossbeam::select! {
+                            recv(res_rx_c) -> cmd => {
+                                if let Ok(cmd) = cmd {
+                                    handle_resume(cmd, &isolates_c);
+                                }
+                            }
+                            recv(req_rx_c) -> cmd => {
+                                if let Ok(cmd) = cmd {
+                                    // We need an isolate to handle a new request
+                                    if let Ok(iso_id) = free_isolates_rx_c.recv() {
+                                        handle_new_request(cmd, iso_id, &isolates_c, &free_isolates_tx_c);
+                                    }
+                                } else {
+                                    break; // Channel closed
+                                }
+                            }
+                        }
+                    }
+                })
+                .expect("Failed to spawn worker thread");
+            workers.push(handle);
+        }
+
+        Self {
+            request_tx: req_tx,
+            _resume_tx: res_tx,
+            _workers: workers,
+        }
+    }
+
+    pub async fn execute(
+        &self, 
+        action: String, 
+        method: String, 
+        path: String, 
+        body: Option<Bytes>,
+        headers: SmallVec<[(String, String); 8]>,
+        params: SmallVec<[(String, String); 4]>,
+        query: SmallVec<[(String, String); 4]>,
+    ) -> Result<(serde_json::Value, Vec<(String, f64)>), String> {
+        let (tx, rx) = oneshot::channel();
+        let task = RequestTask {
+            action_name: action,
+            body,
+            method,
+            path,
+            headers,
+            params,
+            query,
+            response_tx: tx,
+        };
+        self.request_tx.send(WorkerCommand::Request(task)).map_err(|e| e.to_string())?;
+        match rx.await {
+            Ok(res) => Ok((res.json, res.timings)),
+            Err(_) => Err("Worker channel closed".to_string()),
+        }
+    }
+}
+
+fn handle_new_request(
+    cmd: WorkerCommand, 
+    iso_id: usize, 
+    isolates: &[Arc<Mutex<TitanRuntime>>],
+    free_tx: &Sender<usize>
+) {
+    if let WorkerCommand::Request(task) = cmd {
+        let mut rt = isolates[iso_id].lock().unwrap();
+        rt.request_counter += 1;
+        let request_id = rt.request_counter;
+        rt.pending_requests.insert(request_id, task.response_tx);
+
+        // Store request data for potential replay
+        let req_data = extensions::RequestData {
+            action_name: task.action_name.clone(),
+            body: task.body.clone(),
+            method: task.method.clone(),
+            path: task.path.clone(),
+            headers: task.headers.iter().map(|(k,v)| (k.clone(), v.clone())).collect(),
+            params: task.params.iter().map(|(k,v)| (k.clone(), v.clone())).collect(),
+            query: task.query.iter().map(|(k,v)| (k.clone(), v.clone())).collect(),
+        };
+        rt.active_requests.insert(request_id, req_data);
+        let drift_count = rt.drift_counter;
+        rt.request_start_counters.insert(request_id, drift_count);
+
+        extensions::execute_action_optimized(
+            &mut rt,
+            request_id,
+            &task.action_name,
+            task.body,
+            &task.method,
+            &task.path,
+            &task.headers,
+            &task.params,
+            &task.query
+        );
+        
+        // After execution, check if finished or suspended.
+        // If finished, pending_requests will not have the key (removed by t._finish_request).
+        // If suspended, it will still have the key.
+        
+        if !rt.pending_requests.contains_key(&request_id) {
+             rt.active_requests.remove(&request_id);
+             rt.request_start_counters.remove(&request_id);
+        }
+        
+        // ALWAYS free the isolate for other work
+        free_tx.send(iso_id).unwrap();
+    }
+}
+
+fn handle_resume(
+    cmd: WorkerCommand, 
+    isolates: &[Arc<Mutex<TitanRuntime>>]
+) {
+    if let WorkerCommand::Resume { isolate_id, drift_id, result } = cmd {
+        let mut rt = isolates[isolate_id].lock().unwrap();
+        
+        // 1. Identify which request this drift belongs to
+        let req_id = rt.drift_to_request.get(&drift_id).copied().unwrap_or(0);
+        
+        // 2. Perform Timing
+        let timing_type = if result.result.get("error").is_some() { "drift_error" } else { "drift" };
+        rt.request_timings.entry(req_id).or_default().push((timing_type.to_string(), result.duration_ms));
+
+        // 3. Store Result for Replay
+        rt.completed_drifts.insert(drift_id, result.result);
+
+        // 4. Reset drift counter for the replay? 
+        // No, we need to match the drift_id.
+        // But if we replay, the action calls drift() again. 
+        // It will increment drift_counter again.
+        // So we must RESET `drift_counter` to the start value for this request?
+        // Or we use a deterministic counter based on call order.
+        // `TitanRuntime.drift_counter` is global monotonic if we don't reset.
+        // IF we use global monotonic, the 2nd run will generate NEW IDs.
+        // So we must use a PER-REQUEST counter (or logic to match).
+        
+        // REPLAY STRATEGY:
+        // We rely on `drift_id` being stable.
+        // If `rt.drift_counter` is global, it is NOT stable across replays.
+        // We need to SAVE `drift_counter` state? Or use a Request-Local counter.
+        // Since we are single-threaded per isolate, we can just reset `drift_counter` if we treat the runtime as fresh for the request?
+        // But `TitanRuntime` handles multiple requests sequentially.
+        
+        // Use `rt.request_drift_counter` map?
+        // Let's assume for now we need to reset the counter for *this* request re-run.
+        // But `drift_counter` is currently U32 on Runtime.
+        // We need to fix that.
+        
+        // 5. Trigger Replay (If we have the data)
+        // Check if we have active request data
+        if let Some(req_data) = rt.active_requests.get(&req_id).cloned() {
+            // Reset counter for deterministic ID generation? 
+            // This is tricky if we interleaved multiple requests on same runtime (we don't, we free isolate after request).
+            // So for a single request on an isolate, we can reset a local counter.
+            // Let's add `rt.last_start_drift_id`?
+            // Actually, if we just use `rt.drift_counter` and don't reset, the Replay will generate `drift_id + 1`.
+            // But we stored result at `drift_id`.
+            // So `drift()` needs to look up `drift_id` or `drift_id + 1`?
+            // NO. The Replay MUST generate the SAME ID.
+            // So `drift_counter` MUST be reset to what it was at start of request.
+            
+            let start_counter = rt.request_start_counters.get(&req_id).copied().unwrap_or(0);
+            rt.drift_counter = start_counter; 
+
+            extensions::execute_action_optimized(
+                &mut rt,
+                req_id,
+                &req_data.action_name,
+                req_data.body,
+                &req_data.method,
+                &req_data.path,
+                &req_data.headers,
+                &req_data.params,
+                &req_data.query
+            );
+        }
+
+        // 6. Check if finished
+        if req_id != 0 && !rt.pending_requests.contains_key(&req_id) {
+            // Clean up request data
+            rt.active_requests.remove(&req_id);
+            rt.request_start_counters.remove(&req_id);
+        }
+    }
+}

package/test-app/server/src/utils.rs

@@ -0,0 +1,33 @@
+pub fn blue(s: &str) -> String {
+    format!("\x1b[38;5;39m{}\x1b[0m", s)
+}
+pub fn white(s: &str) -> String {
+    format!("\x1b[39m{}\x1b[0m", s)
+}
+pub fn yellow(s: &str) -> String {
+    format!("\x1b[33m{}\x1b[0m", s)
+}
+pub fn green(s: &str) -> String {
+    format!("\x1b[32m{}\x1b[0m", s)
+}
+pub fn gray(s: &str) -> String {
+    format!("\x1b[90m{}\x1b[0m", s)
+}
+pub fn red(s: &str) -> String {
+    format!("\x1b[31m{}\x1b[0m", s)
+}
+
+pub fn parse_expires_in(value: &str) -> Option<u64> {
+    let (num, unit) = value.split_at(value.len() - 1);
+    let n: u64 = num.parse().ok()?;
+
+    match unit {
+        "s" => Some(n),
+        "m" => Some(n * 60),
+        "h" => Some(n * 60 * 60),
+        "d" => Some(n * 60 * 60 * 24),
+        _ => None,
+    }
+}
+
+

package/test-app/server/titan_storage.json

@@ -0,0 +1,5 @@
+{
+  "css:../app/static/styles.css": "body{\r\n    background-color: black;\r\n    height: 100vh;\r\n    width: 100%;\r\n}\r\n\r\nh1{\r\n    color: rgb(32, 215, 215);\r\n}",
+  "tpl:../app/static/app.html": "<!DOCTYPE html>\r\n<html lang=\"en\">\r\n<head>\r\n    <meta charset=\"UTF-8\">\r\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\r\n    <title>Document</title>\r\n</head>\r\n<body>\r\n    <h1>tpl{{ name }}</h1>\r\n\r\n</body>\r\n</html>",
+  "html:../app/static/app.html": "<!DOCTYPE html>\r\n<html>\r\n<head>\r\n  tpl{{ css }}\r\n</head>\r\n<body>\r\n  <h1>tpl{{ name }}</h1>\r\n</body>\r\n</html>\r\n"
+}

package/test-app/titan/bundle.js

@@ -0,0 +1,264 @@
+/**
+ * Bundle.js
+ * Handles esbuild bundling with comprehensive error reporting
+ * RULE: This file handles ALL esbuild errors and prints error boxes directly
+ */
+
+import esbuild from 'esbuild';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import { renderErrorBox, parseEsbuildError } from './error-box.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Get Titan version for error branding
+ */
+function getTitanVersion() {
+    try {
+        const require = createRequire(import.meta.url);
+        const pkgPath = require.resolve("@ezetgalaxy/titan/package.json");
+        return JSON.parse(fs.readFileSync(pkgPath, "utf-8")).version;
+    } catch (e) {
+        return "0.1.0";
+    }
+}
+
+/**
+ * Custom error class for bundle errors
+ */
+export class BundleError extends Error {
+    constructor(message, errors = [], warnings = []) {
+        super(message);
+        this.name = 'BundleError';
+        this.errors = errors;
+        this.warnings = warnings;
+        this.isBundleError = true;
+    }
+}
+
+/**
+ * Validates that the entry point exists and is readable
+ * @param {string} entryPoint - Entry file path
+ * @throws {BundleError} If file doesn't exist or isn't readable
+ */
+async function validateEntryPoint(entryPoint) {
+    const absPath = path.resolve(entryPoint);
+
+    if (!fs.existsSync(absPath)) {
+        throw new BundleError(
+            `Entry point does not exist: ${entryPoint}`,
+            [{
+                text: `Cannot find file: ${absPath}`,
+                location: { file: entryPoint }
+            }]
+        );
+    }
+
+    try {
+        await fs.promises.access(absPath, fs.constants.R_OK);
+    } catch (err) {
+        throw new BundleError(
+            `Entry point is not readable: ${entryPoint}`,
+            [{
+                text: `Cannot read file: ${absPath}`,
+                location: { file: entryPoint }
+            }]
+        );
+    }
+}
+
+/**
+ * Bundles a single JavaScript/TypeScript file using esbuild
+ * @param {Object} options - Bundle options
+ * @returns {Promise<void>}
+ * @throws {BundleError} If bundling fails
+ */
+export async function bundleFile(options) {
+    const {
+        entryPoint,
+        outfile,
+        format = 'iife',
+        minify = false,
+        sourcemap = false,
+        platform = 'neutral',
+        globalName = '__titan_exports',
+        target = 'es2020',
+        banner = {},
+        footer = {}
+    } = options;
+
+    // Validate entry point exists
+    await validateEntryPoint(entryPoint);
+
+    // Ensure output directory exists
+    const outDir = path.dirname(outfile);
+    await fs.promises.mkdir(outDir, { recursive: true });
+
+    try {
+        // Run esbuild with error logging enabled
+        const result = await esbuild.build({
+            entryPoints: [entryPoint],
+            bundle: true,
+            outfile,
+            format,
+            globalName,
+            platform,
+            target,
+            banner,
+            footer,
+            minify,
+            sourcemap,
+            logLevel: 'silent', // We handle all errors ourselves
+            logLimit: 0,
+            color: false,
+            write: true,
+            metafile: false,
+        });
+
+        // Check for errors in the result
+        if (result.errors && result.errors.length > 0) {
+            throw new BundleError(
+                `Build failed with ${result.errors.length} error(s)`,
+                result.errors,
+                result.warnings || []
+            );
+        }
+
+    } catch (err) {
+        if (err.errors && err.errors.length > 0) {
+            // This is an esbuild error with detailed error information
+            throw new BundleError(
+                `Build failed with ${err.errors.length} error(s)`,
+                err.errors,
+                err.warnings || []
+            );
+        }
+
+        // Other unexpected errors
+        throw new BundleError(
+            `Unexpected build error: ${err.message}`,
+            [{
+                text: err.message,
+                location: { file: entryPoint }
+            }]
+        );
+    }
+}
+
+/**
+ * Main bundle function - scans app/actions and bundles all files
+ * RULE: This function handles ALL esbuild errors and prints error boxes directly
+ * RULE: After printing error box, throws Error("__TITAN_BUNDLE_FAILED__")
+ * @returns {Promise<void>}
+ */
+export async function bundle() {
+    const root = process.cwd();
+    const actionsDir = path.join(root, 'app', 'actions');
+    const bundleDir = path.join(root, 'server', 'actions');
+
+    // Ensure bundle directory exists and is clean
+    if (fs.existsSync(bundleDir)) {
+        fs.rmSync(bundleDir, { recursive: true, force: true });
+    }
+    await fs.promises.mkdir(bundleDir, { recursive: true });
+
+    // Check if actions directory exists
+    if (!fs.existsSync(actionsDir)) {
+        return; // No actions to bundle
+    }
+
+    // Get all JS/TS files in actions directory
+    const files = fs.readdirSync(actionsDir).filter(f =>
+        (f.endsWith('.js') || f.endsWith('.ts')) && !f.endsWith('.d.ts')
+    );
+
+    if (files.length === 0) {
+        return; // No action files
+    }
+
+    // Bundle each action file
+    for (const file of files) {
+        const actionName = path.basename(file, path.extname(file));
+        const entryPoint = path.join(actionsDir, file);
+        const outfile = path.join(bundleDir, actionName + ".jsbundle");
+
+        try {
+            await bundleFile({
+                entryPoint,
+                outfile,
+                format: 'iife',
+                globalName: '__titan_exports',
+                platform: 'neutral',
+                target: 'es2020',
+                minify: false,
+                sourcemap: false,
+                banner: {
+                    js: "const defineAction = (fn) => fn; const Titan = t;"
+                },
+                footer: {
+                    js: `
+(function () {
+  const fn =
+    __titan_exports["${actionName}"] ||
+    __titan_exports.default;
+
+  if (typeof fn !== "function") {
+    throw new Error("[Titan] Action '${actionName}' not found or not a function");
+  }
+
+  globalThis["${actionName}"] = globalThis.defineAction(fn);
+})();
+`
+                }
+            });
+        } catch (error) {
+            // RULE: Handle esbuild errors HERE and print error boxes
+            if (error.isBundleError && error.errors && error.errors.length > 0) {
+                // Print error box for each esbuild error
+                console.error(); // Empty line for spacing
+
+                const titanVersion = getTitanVersion();
+
+                for (let i = 0; i < error.errors.length; i++) {
+                    const esbuildError = error.errors[i];
+                    const errorInfo = parseEsbuildError(esbuildError);
+
+                    // Add error number to title if multiple errors
+                    if (error.errors.length > 1) {
+                        errorInfo.title = `Build Error ${i + 1}/${error.errors.length}`;
+                    }
+
+                    // Add Titan version
+                    errorInfo.titanVersion = titanVersion;
+
+                    // Print the error box
+                    console.error(renderErrorBox(errorInfo));
+
+                    if (i < error.errors.length - 1) {
+                        console.error(); // Empty line between errors
+                    }
+                }
+
+                console.error(); // Empty line after all errors
+            } else {
+                // Other errors
+                console.error();
+                const errorInfo = {
+                    title: 'Build Error',
+                    file: entryPoint,
+                    message: error.message || 'Unknown error',
+                    titanVersion: getTitanVersion()
+                };
+                console.error(renderErrorBox(errorInfo));
+                console.error();
+            }
+
+            // RULE: Throw special error to signal bundle failure
+            throw new Error('__TITAN_BUNDLE_FAILED__');
+        }
+    }
+}