@ezetgalaxy/titan 26.15.0 → 26.15.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ezetgalaxy/titan",
-  "version": "26.15.0",
+  "version": "26.15.1",
   "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",
@@ -65,7 +65,8 @@
     "test:all": "vitest run && vitest run --config vitest.config.e2e.ts"
   },
   "dependencies": {
-    "@titanpl/core": "^1.0.1",
+    "@titanpl/core": "latest",
+    "@titanpl/node": "latest",
     "chokidar": "^5.0.0",
     "esbuild": "^0.27.2",
     "prompts": "^2.4.2"

package/templates/common/Dockerfile

@@ -46,7 +46,7 @@ RUN mkdir -p /app/.ext && \
         rm -rf "/app/.ext/$pkg_name/node_modules"; \
     done
 
-RUN cd server && cargo build --release
+RUN titan build
 
 
 

package/templates/common/app/t.native.d.ts

@@ -1058,6 +1058,8 @@ declare global {
          * @see https://titan-docs-ez.vercel.app/docs/10-extensions — Extensions documentation
          */
         [key: string]: any;
+
+
     }
 
     /**
@@ -1978,6 +1980,64 @@ declare global {
         }
 
     }
+
+    /**
+ * Node-compatible `process` global (Titan Shim).
+ *
+ * This is a lightweight compatibility layer intended
+ * for supporting common Node libraries.
+ *
+ * Internally backed by:
+ * - t.proc
+ * - t.os
+ * - t.time
+ */
+    const process: {
+        /** Process ID */
+        pid: number;
+
+        /** Platform (linux, win32, darwin) */
+        platform: string;
+
+        /** CPU architecture */
+        arch: string;
+
+        /** Node version string (shimmed) */
+        version: string;
+
+        /** Version object */
+        versions: {
+            node: string;
+            titan: string;
+        };
+
+        /** Environment variables */
+        env: Record<string, string | undefined>;
+
+        /** CLI arguments */
+        argv: string[];
+
+        /** Current working directory */
+        cwd(): string;
+
+        /** Uptime in seconds */
+        uptime(): number;
+
+        /** High resolution time */
+        hrtime: {
+            (time?: [number, number]): [number, number];
+            bigint(): bigint;
+        };
+
+        /** Memory usage info */
+        memoryUsage(): Record<string, any>;
+
+        /** No-op event listener (compat only) */
+        on(event: string, listener: (...args: any[]) => void): void;
+
+        /** Exit stub (throws in Titan runtime) */
+        exit(code?: number): never;
+    };
 }
 
 export { };

package/templates/js/package.json

@@ -8,6 +8,7 @@
   },
   "dependencies": {
     "@titanpl/core": "latest",
+    "@titanpl/node": "latest",
     "chokidar": "^5.0.0",
     "esbuild": "^0.27.2"
   },

package/templates/js/titan/bundle.js

@@ -14,193 +14,204 @@ import { renderErrorBox, parseEsbuildError } from './error-box.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 
+// Required for resolving node_modules inside ESM
+const require = createRequire(import.meta.url);
+
+/**
+ * Titan Node Builtin Rewrite Map
+ * Rewrites Node builtins to @titanpl/node shims
+ */
+const NODE_BUILTIN_MAP = {
+  "fs": "@titanpl/node/fs",
+  "node:fs": "@titanpl/node/fs",
+
+  "path": "@titanpl/node/path",
+  "node:path": "@titanpl/node/path",
+
+  "os": "@titanpl/node/os",
+  "node:os": "@titanpl/node/os",
+
+  "crypto": "@titanpl/node/crypto",
+  "node:crypto": "@titanpl/node/crypto",
+
+  "process": "@titanpl/node/process",
+  
+  "util": "@titanpl/node/util",
+  "node:util": "@titanpl/node/util",
+};
+
+/**
+ * Titan Node Compatibility Plugin
+ * Rewrites require/import of Node builtins
+ * Returns absolute paths (required by esbuild)
+ */
+const titanNodeCompatPlugin = {
+  name: "titan-node-compat",
+  setup(build) {
+    build.onResolve({ filter: /.*/ }, args => {
+      if (NODE_BUILTIN_MAP[args.path]) {
+        try {
+          const resolved = require.resolve(NODE_BUILTIN_MAP[args.path]);
+          return { path: resolved };
+        } catch (e) {
+          throw new Error(
+            `[Titan] Failed to resolve Node shim: ${NODE_BUILTIN_MAP[args.path]}`
+          );
+        }
+      }
+    });
+  }
+};
+
 /**
  * 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";
-    }
+  try {
+    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;
-    }
+  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
+ * Validate entry file exists
  */
 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 }
-            }]
-        );
-    }
+  const absPath = path.resolve(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 }
-            }]
-        );
-    }
+  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 {
+    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
+ * Bundles a single file
  */
 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 });
+  const {
+    entryPoint,
+    outfile,
+    format = 'iife',
+    minify = false,
+    sourcemap = false,
+    platform = 'neutral',
+    globalName = '__titan_exports',
+    target = 'es2020',
+    banner = {},
+    footer = {}
+  } = options;
 
-    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 || []
-            );
-        }
+  await validateEntryPoint(entryPoint);
 
-    } 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 || []
-            );
-        }
+  const outDir = path.dirname(outfile);
+  await fs.promises.mkdir(outDir, { recursive: true });
+
+  try {
+    const result = await esbuild.build({
+      entryPoints: [entryPoint],
+      bundle: true,
+      outfile,
+      format,
+      globalName,
+      platform,
+      target,
+      banner,
+      footer,
+      minify,
+      sourcemap,
+      logLevel: 'silent',
+      logLimit: 0,
+      write: true,
+      metafile: false,
+      plugins: [titanNodeCompatPlugin],
+    });
+
+    if (result.errors?.length) {
+      throw new BundleError(
+        `Build failed with ${result.errors.length} error(s)`,
+        result.errors,
+        result.warnings || []
+      );
+    }
 
-        // Other unexpected errors
-        throw new BundleError(
-            `Unexpected build error: ${err.message}`,
-            [{
-                text: err.message,
-                location: { file: entryPoint }
-            }]
-        );
+  } catch (err) {
+    if (err.errors?.length) {
+      throw new BundleError(
+        `Build failed with ${err.errors.length} error(s)`,
+        err.errors,
+        err.warnings || []
+      );
     }
+
+    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>}
+ * Main bundler
  */
 export async function bundle() {
-    const root = process.cwd();
-    const actionsDir = path.join(root, 'app', 'actions');
-    const bundleDir = path.join(root, 'server', 'src', 'actions');
+  const root = process.cwd();
+  const actionsDir = path.join(root, 'app', 'actions');
+  const bundleDir = path.join(root, 'server', 'src', '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
-    }
+  if (fs.existsSync(bundleDir)) {
+    fs.rmSync(bundleDir, { recursive: true, force: true });
+  }
+  await fs.promises.mkdir(bundleDir, { recursive: true });
 
-    // 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 (!fs.existsSync(actionsDir)) return;
 
-    if (files.length === 0) {
-        return; // No action files
-    }
+  const files = fs.readdirSync(actionsDir).filter(f =>
+    (f.endsWith('.js') || f.endsWith('.ts')) && !f.endsWith('.d.ts')
+  );
 
-    // 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");
+  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: "var Titan = t;"
-                },
-                footer: {
-                    js: `
+    try {
+      await bundleFile({
+        entryPoint,
+        outfile,
+        format: 'iife',
+        globalName: '__titan_exports',
+        platform: 'node',
+        target: 'es2020',
+        banner: { js: "var Titan = t;" },
+        footer: {
+          js: `
 (function () {
   const fn =
     __titan_exports["${actionName}"] ||
@@ -213,52 +224,36 @@ export async function bundle() {
   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__');
         }
+      });
+
+    } catch (error) {
+
+      console.error();
+
+      const titanVersion = getTitanVersion();
+
+      if (error.isBundleError && error.errors?.length) {
+        for (let i = 0; i < error.errors.length; i++) {
+          const errorInfo = parseEsbuildError(error.errors[i]);
+          if (error.errors.length > 1) {
+            errorInfo.title = `Build Error ${i + 1}/${error.errors.length}`;
+          }
+          errorInfo.titanVersion = titanVersion;
+          console.error(renderErrorBox(errorInfo));
+          console.error();
+        }
+      } else {
+        const errorInfo = {
+          title: 'Build Error',
+          file: entryPoint,
+          message: error.message || 'Unknown error',
+          titanVersion
+        };
+        console.error(renderErrorBox(errorInfo));
+      }
+
+      throw new Error('__TITAN_BUNDLE_FAILED__');
     }
-}
+  }
+}

package/templates/ts/package.json

@@ -8,6 +8,7 @@
   },
   "dependencies": {
     "@titanpl/core": "latest",
+    "@titanpl/node": "latest",
     "chokidar": "^5.0.0",
     "esbuild": "^0.27.2",
     "typescript": "^5.0.0"