titanpl 7.0.0 → 7.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "titanpl",
-  "version": "7.0.0",
+  "version": "7.0.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",

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/cli",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "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": "7.0.0",
-    "@titanpl/engine-linux-x64": "7.0.0"
+    "@titanpl/engine-win32-x64": "7.0.1",
+    "@titanpl/engine-linux-x64": "7.0.1"
   },
   "dependencies": {
-    "@titanpl/packet": "7.0.0",
+    "@titanpl/packet": "7.0.1",
     "prompts": "^2.4.2",
     "commander": "^11.0.0",
     "chalk": "^4.1.2"

package/packages/cli/src/commands/build-ext.js

@@ -38,10 +38,23 @@ async function buildWasmExtension(titanJson) {
     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' });
+        console.log(chalk.gray("  Running wasm-pack..."));
+        execSync('wasm-pack build --target web --no-typescript', { cwd: nativeDir, stdio: 'ignore' });
     } catch (err) {
-        console.log(chalk.red("✖ Wasm compilation failed. Make sure 'wasm-pack' is installed."));
-        return;
+        console.log(chalk.yellow("! wasm-pack failed, attempting raw cargo build..."));
+        try {
+            execSync('cargo build --target wasm32-unknown-unknown --release', { cwd: nativeDir, stdio: 'ignore' });
+            const pkgDir = path.join(nativeDir, 'pkg');
+            if (!fs.existsSync(pkgDir)) fs.mkdirSync(pkgDir);
+            
+            const targetWasm = path.join(nativeDir, `target/wasm32-unknown-unknown/release/${crateName}.wasm`);
+            const destWasm = path.join(pkgDir, `${crateName}_bg.wasm`);
+            fs.copyFileSync(targetWasm, destWasm);
+            console.log(chalk.green("✔ Raw Wasm compilation successful."));
+        } catch (cargoErr) {
+            console.log(chalk.red("✖ Wasm compilation failed. Make sure Rust and wasm32-unknown-unknown target are installed."));
+            return;
+        }
     }
 
     console.log(chalk.gray("  Generating bindings..."));
@@ -95,7 +108,7 @@ async function buildNativeExtension(titanJson) {
 
     console.log(chalk.gray("  Compiling Rust native library..."));
     try {
-        execSync('cargo build --release', { cwd: nativeDir, stdio: 'inherit' });
+        execSync('cargo build --release', { cwd: nativeDir, stdio: 'ignore' });
     } catch (err) {
         console.log(chalk.red("✖ Native compilation failed."));
         return;

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

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

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

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

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

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

package/packages/native/index.d.ts

@@ -37,6 +37,21 @@ export interface WebSocketModule {
 }
 
 export const db: any;
+/**
+ * WebSocket communication utilities.
+ *
+ * @example
+ * ```js
+ * import { ws } from "@titanpl/native";
+ * 
+ * export default function chat(req) {
+ *   if (req.event === "open") {
+ *     ws.send(req.socketId, "Welcome!");
+ *     ws.broadcast("Someone joined.");
+ *   }
+ * }
+ * ```
+ */
 export const ws: WebSocketModule;
 export const path: any;
 export const jwt: any;
@@ -52,6 +67,18 @@ export const net: any;
 export const proc: any;
 export const time: any;
 export const url: any;
+/**
+ * HTTP Response builder utilities.
+ *
+ * @example
+ * ```js
+ * import { response } from "@titanpl/native";
+ * 
+ * export function get(req) {
+ *   return response.json({ hello: "world" });
+ * }
+ * ```
+ */
 export const response: any;
 export const valid: any;
 

package/packages/native/index.js

@@ -39,6 +39,7 @@ export const time = t.time;
 export const url = t.url;
 export const response = t.response;
 export const valid = t.valid;
+export const drift = globalThis.drift;
 
 // Serialization
 export const serialize = t.serialize;

package/packages/native/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/native",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "description": "Titan native utilities package",
   "type": "module",
   "keywords": [

package/packages/native/t.native.d.ts

@@ -236,6 +236,18 @@ export const db: typeof t.db;
 /**
  * WebSocket communication utilities.
  *
+ * @example
+ * ```js
+ * import { ws } from "@titanpl/native";
+ * 
+ * export default function chat(req) {
+ *   if (req.event === "open") {
+ *     ws.send(req.socketId, "Welcome!");
+ *     ws.broadcast("Someone joined.");
+ *   }
+ * }
+ * ```
+ *
  * Re-exported from the `t` global for module-style imports.
  * @see {@link TitanRuntimeUtils.ws} for full documentation.
  */
@@ -373,6 +385,23 @@ export const time: typeof t.time;
  */
 export const url: typeof t.url;
 
+/**
+ * HTTP Response builder utilities.
+ *
+ * @example
+ * ```js
+ * import { response } from "@titanpl/native";
+ * 
+ * export function get(req) {
+ *   return response.json({ hello: "world" });
+ * }
+ * ```
+ *
+ * Re-exported from the `t` global for module-style imports.
+ * @see {@link TitanRuntimeUtils.response} for full documentation.
+ */
+export const response: typeof t.response;
+
 /**
  * Runtime validation utilities.
  *
@@ -732,10 +761,12 @@ declare global {
          *
          * @example
          * ```js
+         * import { ws } from "@titanpl/native";
+         * 
          * export default function chat(req) {
          *   if (req.event === "open") {
-         *     t.ws.send(req.socketId, "Welcome!");
-         *     t.ws.broadcast("Someone joined.");
+         *     ws.send(req.socketId, "Welcome!");
+         *     ws.broadcast("Someone joined.");
          *   }
          * }
          * ```
@@ -1178,6 +1209,26 @@ declare global {
         url: TitanCore.URLModule;
 
         /**
+         * HTTP Response builder utilities.
+         *
+         * Provides helpers for crafting standardized HTTP responses, such as JSON,
+         * HTML, redirects, or raw text.
+         *
+         * @example
+         * ```js
+         * import { response } from "@titanpl/native";
+         * 
+         * export function get(req) {
+         *   if (!req.headers.authorization) {
+         *     return response.json({ error: "Unauthorized" }, 401);
+         *   }
+         *   return response.html("<h1>Welcome</h1>");
+         * }
+         * ```
+         *
+         * @see https://titanpl.vercel.app/docs/how-to-use/05-runtime-apis — Runtime APIs (t.response)
+         */
+        response: TitanCore.ResponseModule;
 
         /**
          * Runtime validation utilities.
@@ -1249,6 +1300,51 @@ declare global {
         interface TitanResponse {
             readonly __titan_response: true;
         }
+
+        /**
+         * Response builder interfaces.
+         */
+        interface ResponseModule {
+            /**
+             * Return a JSON response with an optional status code and headers.
+             * 
+             * @param data - The object or value to serialize to JSON.
+             * @param status - The HTTP status code (default: 200).
+             * @param headers - Optional custom headers.
+             * @returns A standard Titan response.
+             */
+            json(data: any, status?: number, headers?: Record<string, string>): TitanResponse;
+
+            /**
+             * Return an HTML response with an optional status code and headers.
+             * 
+             * @param html - The HTML string to return.
+             * @param status - The HTTP status code (default: 200).
+             * @param headers - Optional custom headers.
+             * @returns A standard Titan response.
+             */
+            html(html: string, status?: number, headers?: Record<string, string>): TitanResponse;
+            
+            /**
+             * Return a plain text response with an optional status code and headers.
+             * 
+             * @param text - The string to return.
+             * @param status - The HTTP status code (default: 200).
+             * @param headers - Optional custom headers.
+             * @returns A standard Titan response.
+             */
+            text(text: string, status?: number, headers?: Record<string, string>): TitanResponse;
+            
+            /**
+             * Issue an HTTP redirect to a specific URL.
+             * 
+             * @param url - The destination URL.
+             * @param status - The redirect status code (default: 302).
+             * @param headers - Optional custom headers.
+             * @returns A standard Titan response.
+             */
+            redirect(url: string, status?: number, headers?: Record<string, string>): TitanResponse;
+        }
         /**
          * Asynchronous file system operations.
          *
@@ -2200,7 +2296,7 @@ declare global {
  * - t.os
  * - t.time
  */
-    const process: {
+    var process: {
         /** Process ID */
         pid: number;
 

package/packages/packet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/packet",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "description": "The bundler for TitanPl servers.",
   "keywords": [
     "bundler",

package/packages/route/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/route",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "description": "Titan routing DSL",
   "type": "module",
   "main": "index.js",

package/packages/sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/sdk",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "description": "The official SDK for Titan Planet extensions and testing.",
   "type": "module",
   "main": "index.js",

package/templates/extension/README_WASM.md

@@ -0,0 +1,38 @@
+# TitanPL Native & WebAssembly Extensions
+
+One of the definitive features of TitanPL v7+ is its dynamic, zero-configuration native extension bridge. You no longer have to manually define function signatures or types within `titan.json`.
+
+## The Hybrid IPC Native Bridge
+
+The `NativeHost` bridge natively detects argument types over IPC at runtime. Whether you pass floating-point numbers (`f64`), complex strings, or JSON-stringified objects:
+
+1. **Dynamic C-ABI Interop:** The host inspects the payload dynamically and generates the correct C-struct register combinations on-the-fly (`f64`, `*const c_char`, combinations).
+2. **Safe Void execution:** Memory protections natively peek at returned pointer segments, preventing SEGFAULT crashes. `void` returns are safely handled transparently.
+   
+### Writing WebAssembly (WASM) 
+
+Because Titan CLI utilizes `wasm-pack` without unnecessary logs, compiling WebAssembly plugins from Rust is completely silent and incredibly robust.
+
+To build a fresh, silent WASM extension:
+```bash
+titan build ext
+```
+The CLI suppresses stdout output (`stdio: 'ignore'`) allowing clean build processes unless a fatal compiler failure occurs.
+
+### Best Practices: The `@titanpl/native` Namespace
+
+Never use the globally injected `t.*` prefixes in Modern TitanPL scripts (unless deploying backward-compatible code). Instead, simply use the modular native imports:
+
+```js
+// BEFORE (Not Recommended)
+const data = t.fs.readFile("example.txt");
+const hash = t.crypto.hash("sha256", "test");
+
+// AFTER (Recommended)
+import { fs, crypto, drift } from "@titanpl/native";
+
+const data = fs.readFile("example.txt");
+const hash = crypto.hash("sha256", "test");
+```
+
+By transitioning to `@titanpl/native`, you gain absolute Type Completion (via the newly restructured `d.ts` declaration maps) explicitly tailored to ESM semantics.

package/templates/extension/package.json

@@ -1,6 +1,6 @@
 {
   "name": "my-extension",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "description": "A high-performance TitanPL extension.",
   "type": "module",
   "main": "index.js",
@@ -11,6 +11,6 @@
     "README.md"
   ],
   "dependencies": {
-    "@titanpl/sdk": "7.0.0"
+    "@titanpl/sdk": "7.0.1"
   }
 }

package/templates/js/package.json

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

package/templates/rust-js/package.json

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

package/templates/rust-ts/package.json

@@ -1,15 +1,15 @@
 {
   "name": "titanpl",
-  "version": "7.0.0",
+  "version": "7.0.1",
   "description": "A Titan Planet server (Rust + TypeScript)",
   "type": "module",
   "titan": {
     "template": "rust-ts"
   },
   "dependencies": {
-    "@titanpl/cli": "7.0.0",
-    "@titanpl/route": "7.0.0",
-    "@titanpl/native": "7.0.0",
+    "@titanpl/cli": "7.0.1",
+    "@titanpl/route": "7.0.1",
+    "@titanpl/native": "7.0.1",
     "@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": "7.0.0",
-    "@titanpl/route": "7.0.0",
-    "@titanpl/native": "7.0.0",
+    "@titanpl/cli": "7.0.1",
+    "@titanpl/route": "7.0.1",
+    "@titanpl/native": "7.0.1",
     "@titanpl/core": "7.0.0",
     "@titanpl/node": "latest",
-    "@titanpl/packet": "7.0.0",
+    "@titanpl/packet": "7.0.1",
     "typescript": "^5.0.0"
   },
   "optionalDependencies": {
     "@titanpl/engine-linux-arm64": "2.0.5",
-    "@titanpl/engine-linux-x64": "7.0.0",
-    "@titanpl/engine-win32-x64": "7.0.0"
+    "@titanpl/engine-linux-x64": "7.0.1",
+    "@titanpl/engine-win32-x64": "7.0.1"
   },
   "scripts": {
     "build": "titan build",
@@ -31,5 +31,5 @@
     "eslint-plugin-titanpl": "latest",
     "@typescript-eslint/parser": "^8.54.0"
   },
-  "version": "7.0.0"
+  "version": "7.0.1"
 }

package/packages/core-source/LICENSE

@@ -1,15 +0,0 @@
-ISC License
-
-Copyright (c) 2025, Ezet Galaxy
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/packages/core-source/README.md

@@ -1,128 +0,0 @@
-# @titanpl/core
-
-The official Core Standard Library for Titan Planet - a high-performance JavaScript runtime extension. This library bridges high-performance Rust native implementations with an easy-to-use JavaScript API.
-
-## Overview
-
-`@titanpl/core` provides essential standard library modules for Titan applications, covering file system operations, cryptography, process management, networking, and more. All modules are implemented as native Rust extensions for maximum performance.
-
-## Installation
-
-```bash
-npm install @titanpl/core
-```
-
-## Usage
-
-The extension automatically attaches to the Titan runtime.
-
-### Modern ESM Import (Highly Recommended)
-Best for IDE support, autocompletion, and type checking.
-```javascript
-import { fs, crypto, ls } from "@titanpl/core";
-
-const content = fs.readFile("config.json");
-```
-
----
-
-## API Reference
-
-### `fs` (File System)
-Synchronous file system operations.
-- `fs.readFile(path: string): string` - Read file content as UTF-8 string.
-- `fs.writeFile(path: string, content: string): void` - Write string content to file.
-- `fs.exists(path: string): boolean` - Check if a path exists.
-- `fs.mkdir(path: string): void` - Create a directory (recursive).
-- `fs.remove(path: string): void` - Remove file or directory.
-- `fs.readdir(path: string): string[]` - List directory contents.
-- `fs.stat(path: string): object` - Get file statistics `{ isFile: boolean, isDir: boolean, size: number, modified: number }`.
-
-### `path` (Path Manipulation)
-Utilities for handling file paths.
-- `path.join(...parts: string[]): string` - Join path segments using platform-specific separators.
-- `path.resolve(...parts: string[]): string` - Resolve path to an absolute path.
-- `path.dirname(path: string): string` - Get the directory name of a path.
-- `path.basename(path: string): string` - Get the base name (filename) of a path.
-- `path.extname(path: string): string` - Get the extension of a path (including the dot).
-
-### `crypto` (Cryptography)
-Secure cryptographic utilities.
-- `crypto.hash(algo: string, data: string): string` - Hash data (e.g., `sha256`, `sha512`).
-- `crypto.randomBytes(size: number): string` - Generate random bytes as a hex string.
-- `crypto.uuid(): string` - Generate a UUID v4.
-- `crypto.encrypt(algorithm: string, key: string, plaintext: string): string` - Encrypt text using native Rust implementations.
-- `crypto.decrypt(algorithm: string, key: string, ciphertext: string): string` - Decrypt text.
-- `crypto.hashKeyed(algo: string, key: string, message: string): string` - Keyed-hash (HMAC) support.
-- `crypto.compare(hash: string, target: string): boolean` - Securely compare two strings in constant time.
-
-### `buffer` (Buffer Utilities)
-Utilities for binary and data encoding.
-- `buffer.fromBase64(str: string): Uint8Array` - Decode Base64 string to bytes.
-- `buffer.toBase64(bytes: Uint8Array|string): string` - Encode bytes or string to Base64.
-
-### `os` (Operating System)
-Retrieve system-level information.
-- `os.platform(): string` - OS platform (e.g., `linux`, `windows`, `darwin`).
-- `os.cpus(): number` - Number of logical CPU cores.
-- `os.totalMemory(): number` - Total system memory in bytes.
-- `os.freeMemory(): number` - Free system memory in bytes.
-- `os.tmpdir(): string` - Path to the system temporary directory.
-
-### `net` (Network)
-Basic network utilities.
-- `net.resolveDNS(hostname: string): string[]` - Resolve a hostname to IP addresses.
-- `net.ip(): string` - Get the local system IP address.
-
-### `proc` (Process Management)
-Manage and query system processes.
-- `proc.pid(): number` - Get the Process ID of the current Titan runtime.
-- `proc.info(): object` - Get basic info about the current process.
-- `proc.run(command: string, args?: string[], cwd?: string): object` - Spawn a background process.
-- `proc.kill(pid: number): boolean` - Terminate a process by PID.
-- `proc.list(): object[]` - List all running system processes with CPU and memory usage.
-
-### `time` (Time Utilities)
-- `time.sleep(ms: number): void` - Synchronously block execution for `ms` milliseconds.
-- `time.now(): number` - Returns `Date.now()`.
-
-### `ls` (Persistent Local Storage)
-High-performance key-value storage persisted to disk.
-- `ls.get(key: string): string|null` - Retrieve a string value.
-- `ls.set(key: string, value: string): void` - Persist a string value.
-- `ls.remove(key: string): void` - Delete a key.
-- `ls.clear(): void` - Clear all stored data.
-- `ls.keys(): string[]` - List all stored keys.
-- `ls.setObject(key: string, value: any): void` - Store a complex JS object using native V8 serialization.
-- `ls.getObject(key: string): any` - Retrieve and restore a complex JS object.
-- `ls.serialize(value: any): Uint8Array` - Native V8 serialization (supports Map, Set, Date, Uint8Array).
-- `ls.deserialize(bytes: Uint8Array): any` - Native V8 deserialization.
-
-### `session` (Session Management)
-- `session.get(sid: string, key: string): string|null` - Get session data.
-- `session.set(sid: string, key: string, value: string): void` - Set session data.
-- `session.delete(sid: string, key: string): void` - Delete session data.
-- `session.clear(sid: string): void` - Clear an entire session.
-
-### `cookies` (HTTP Cookies)
-- `cookies.get(req: object, name: string): string|null` - Extract cookie value from request.
-- `cookies.set(res: object, name: string, value: string, options?: object): void` - Attach `Set-Cookie` to response.
-
-### `url` (URL Parsing)
-- `url.parse(str: string): URL` - Parse a URL string into a native URL object.
-- `new url.SearchParams(init?: string)` - Construct query parameters.
-
-### `response` (HTTP Response Builder)
-Helper for constructing standardized Titan responses.
-- `response.text(content: string, options?: object): object` - Create a plain text response.
-- `response.json(data: any, options?: object): object` - Create a JSON response.
-- `response.html(content: string, options?: object): object` - Create an HTML response.
-- `response.redirect(url: string, status?: number): object` - Create a redirect response.
-
----
-
-## Native Bindings
-This extension includes native Rust bindings for high-performance operations. The native binary is automatically loaded by the Titan Runtime during initialization.
-
-## License
-ISC