@ezetgalaxy/titan 26.9.2 → 26.9.3

package/titanpl-sdk/node_modules/@titanpl/core/README.md

@@ -0,0 +1,127 @@
+# @titanpl/core
+
+The official Core Standard Library for **Titan Planet** - a high-performance JavaScript runtime.
+
+## Installation
+
+```bash
+npm install @titanpl/core
+```
+
+## Overview
+
+`@titanpl/core` provides essential standard library modules for Titan applications:
+
+| Module | Description |
+|--------|-------------|
+| `fs` | File system operations (read, write, mkdir, exists, stat, remove) |
+| `path` | Path manipulation utilities (join, resolve, extname, dirname, basename) |
+| `crypto` | Cryptographic functions (hash, randomBytes, uuid, base64) |
+| `os` | Operating system information (platform, cpus, memory) |
+| `net` | Network utilities (DNS resolve, IP address) |
+| `proc` | Process information (pid, uptime) |
+| `time` | Time utilities (sleep, now, timestamp) |
+| `url` | URL parsing and manipulation |
+
+## Usage
+
+Once installed, the extension automatically attaches to the Titan runtime:
+
+```javascript
+// Access via t.core
+const content = t.core.fs.readFile("config.json");
+const joined = t.core.path.join("foo", "bar", "baz.txt");
+const uuid = t.core.crypto.uuid();
+
+// Or via individual modules on t
+const exists = t.fs.exists("./data");
+const now = t.time.now();
+```
+
+## API Reference
+
+### fs (File System)
+
+```javascript
+t.fs.readFile(path)          // Read file contents as string
+t.fs.writeFile(path, content) // Write string to file
+t.fs.readdir(path)           // List directory contents
+t.fs.mkdir(path)             // Create directory
+t.fs.exists(path)            // Check if path exists
+t.fs.stat(path)              // Get file/directory stats
+t.fs.remove(path)            // Remove file or directory
+```
+
+### path
+
+```javascript
+t.path.join(...parts)        // Join path segments
+t.path.resolve(...parts)     // Resolve to absolute path
+t.path.extname(path)         // Get file extension
+t.path.dirname(path)         // Get directory name
+t.path.basename(path)        // Get file name
+```
+
+### crypto
+
+```javascript
+t.crypto.hash(algo, data)    // Hash data (sha256, sha512, etc.)
+t.crypto.randomBytes(size)   // Generate random bytes
+t.crypto.uuid()              // Generate UUID v4
+t.crypto.base64.encode(str)  // Base64 encode
+t.crypto.base64.decode(str)  // Base64 decode
+t.crypto.compare(a, b)       // Constant-time string comparison
+```
+
+### os
+
+```javascript
+t.os.platform()              // Get OS platform
+t.os.cpus()                  // Get CPU count
+t.os.totalMemory()           // Get total memory
+t.os.freeMemory()            // Get free memory
+t.os.tmpdir()                // Get temp directory path
+```
+
+### net
+
+```javascript
+t.net.resolveDNS(hostname)   // Resolve DNS
+t.net.ip()                   // Get local IP address
+```
+
+### proc
+
+```javascript
+t.proc.pid()                 // Get process ID
+t.proc.uptime()              // Get process uptime
+```
+
+### time
+
+```javascript
+t.time.sleep(ms)             // Sleep for milliseconds
+t.time.now()                 // Get current timestamp (ms)
+t.time.timestamp()           // Get ISO timestamp string
+```
+
+### url
+
+```javascript
+t.url.parse(urlString)       // Parse URL string
+t.url.format(urlObject)      // Format URL object to string
+new t.url.SearchParams(query) // Parse query string
+```
+
+## Native Bindings
+
+This extension includes native Rust bindings for high-performance file system and OS operations. The native library is automatically loaded when available.
+
+## Requirements
+
+- Titan SDK >= 0.1.7
+- Node.js >= 18.0.0 (for development)
+
+## License
+
+ISC © ezetgalaxy

package/titanpl-sdk/node_modules/@titanpl/core/globals.d.ts

@@ -0,0 +1,17 @@
+declare var t: any;
+declare var fs_read_file: any;
+declare var fs_write_file: any;
+declare var fs_readdir: any;
+declare var fs_mkdir: any;
+declare var fs_exists: any;
+declare var fs_stat: any;
+declare var fs_remove: any;
+declare var path_cwd: any;
+declare var crypto_hash: any;
+declare var crypto_random_bytes: any;
+declare var crypto_uuid: any;
+declare var os_info: any;
+declare var net_resolve: any;
+declare var net_ip: any;
+declare var proc_info: any;
+declare var time_sleep: any;

package/titanpl-sdk/node_modules/@titanpl/core/index.js

@@ -0,0 +1,250 @@
+// Titan Core Library
+// Provides standard library features using native bindings.
+
+// Native bindings are expected to be available globally or via t.native
+// adjusting based on typical Titan behavior.
+// We bind them to local variables for cleaner usage.
+
+const native_fs_read_file = globalThis.fs_read_file;
+const native_fs_write_file = globalThis.fs_write_file;
+const native_fs_readdir = globalThis.fs_readdir;
+const native_fs_mkdir = globalThis.fs_mkdir;
+const native_fs_exists = globalThis.fs_exists;
+const native_fs_stat = globalThis.fs_stat;
+const native_fs_remove = globalThis.fs_remove;
+const native_path_cwd = globalThis.path_cwd;
+const native_crypto_hash = globalThis.crypto_hash;
+const native_crypto_random_bytes = globalThis.crypto_random_bytes;
+const native_crypto_uuid = globalThis.crypto_uuid;
+const native_os_info = globalThis.os_info;
+const native_net_resolve = globalThis.net_resolve;
+const native_net_ip = globalThis.net_ip;
+const native_proc_info = globalThis.proc_info;
+const native_time_sleep = globalThis.time_sleep;
+
+// --- FS ---
+const fs = {
+    readFile: (path) => {
+        if (!native_fs_read_file) throw new Error("Native fs_read_file not found");
+        return native_fs_read_file(path);
+    },
+    writeFile: (path, content) => {
+        if (!native_fs_write_file) throw new Error("Native fs_write_file not found");
+        native_fs_write_file(path, content);
+    },
+    readdir: (path) => {
+        if (!native_fs_readdir) throw new Error("Native fs_readdir not found");
+        return JSON.parse(native_fs_readdir(path));
+    },
+    mkdir: (path) => {
+        if (!native_fs_mkdir) throw new Error("Native fs_mkdir not found");
+        native_fs_mkdir(path);
+    },
+    exists: (path) => {
+        if (!native_fs_exists) throw new Error("Native fs_exists not found");
+        return native_fs_exists(path);
+    },
+    stat: (path) => {
+        if (!native_fs_stat) throw new Error("Native fs_stat not found");
+        return JSON.parse(native_fs_stat(path));
+    },
+    remove: (path) => {
+        if (!native_fs_remove) throw new Error("Native fs_remove not found");
+        native_fs_remove(path);
+    }
+};
+
+// --- Path ---
+// Basic implementation for POSIX-like paths (Titan mostly runs on servers/containers)
+const path = {
+    join: (...args) => {
+        return args
+            .map((part, i) => {
+                if (i === 0) return part.trim().replace(/[\/]*$/g, '');
+                return part.trim().replace(/(^[\/]*|[\/]*$)/g, '');
+            })
+            .filter(x => x.length)
+            .join('/');
+    },
+    resolve: (...args) => {
+        let resolved = '';
+        for (let arg of args) {
+            resolved = path.join(resolved, arg);
+        }
+        if (!resolved.startsWith('/') && native_path_cwd) {
+            resolved = path.join(native_path_cwd(), resolved);
+        }
+        return resolved;
+    },
+    extname: (p) => {
+        const parts = p.split('.');
+        return parts.length > 1 && !p.startsWith('.') ? '.' + parts.pop() : '';
+    },
+    dirname: (p) => {
+        const parts = p.split('/');
+        parts.pop();
+        return parts.join('/') || '.';
+    },
+    basename: (p) => p.split('/').pop()
+};
+
+// --- Crypto ---
+const crypto = {
+    hash: (algo, data) => native_crypto_hash(algo, data),
+    randomBytes: (size) => native_crypto_random_bytes(size),
+    uuid: () => native_crypto_uuid(),
+    base64: {
+        encode: (str) => btoa(str), // Boa supports btoa/atob
+        decode: (str) => atob(str),
+    },
+    compare: (a, b) => {
+        if (a.length !== b.length) return false;
+        // Constant time comparison not guaranteed here in JS easily without specialized tricks
+        let mismatch = 0;
+        for (let i = 0; i < a.length; ++i) {
+            mismatch |= (a.charCodeAt(i) ^ b.charCodeAt(i));
+        }
+        return mismatch === 0;
+    }
+};
+
+// --- OS ---
+const os = {
+    platform: () => {
+        const info = JSON.parse(native_os_info());
+        return info.platform;
+    },
+    cpus: () => {
+        const info = JSON.parse(native_os_info());
+        return info.cpus;
+    },
+    totalMemory: () => {
+        const info = JSON.parse(native_os_info());
+        return info.totalMemory;
+    },
+    freeMemory: () => {
+        const info = JSON.parse(native_os_info());
+        return info.freeMemory;
+    },
+    tmpdir: () => '/tmp' // Default for now, generic
+};
+
+// --- Net ---
+const net = {
+    resolveDNS: (hostname) => JSON.parse(native_net_resolve(hostname)),
+    ip: () => native_net_ip(),
+    ping: (host) => {
+        // Mock ping or simple verify
+        return true;
+    }
+};
+
+// --- Proc ---
+// Memoize static info if needed, but here we call native
+const proc = {
+    pid: () => {
+        const info = JSON.parse(native_proc_info());
+        return info.pid;
+    },
+    uptime: () => {
+        const info = JSON.parse(native_proc_info());
+        return info.uptime;
+    },
+    memory: () => {
+        // Optional: return full memory usage if possible
+        return {};
+    }
+};
+
+// --- Time ---
+const time = {
+    sleep: (ms) => native_time_sleep(ms),
+    now: () => Date.now(),
+    timestamp: () => new Date().toISOString()
+};
+
+// --- URL ---
+// Simple URLSearchParams polyfill for V8 runtime
+class TitanURLSearchParams {
+    constructor(init = '') {
+        this._params = {};
+        if (typeof init === 'string') {
+            const query = init.startsWith('?') ? init.slice(1) : init;
+            query.split('&').forEach(pair => {
+                const [key, value] = pair.split('=').map(decodeURIComponent);
+                if (key) this._params[key] = value || '';
+            });
+        } else if (typeof init === 'object') {
+            Object.assign(this._params, init);
+        }
+    }
+    get(key) { return this._params[key] || null; }
+    set(key, value) { this._params[key] = String(value); }
+    has(key) { return key in this._params; }
+    delete(key) { delete this._params[key]; }
+    toString() {
+        return Object.entries(this._params)
+            .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+            .join('&');
+    }
+    entries() { return Object.entries(this._params); }
+    keys() { return Object.keys(this._params); }
+    values() { return Object.values(this._params); }
+}
+
+const url = {
+    parse: (str) => {
+        // Basic URL parsing if native URL is available
+        if (typeof URL !== 'undefined') {
+            return new URL(str);
+        }
+        // Simple fallback parser
+        const match = str.match(/^(https?:)\/\/([^/:]+)(?::(\d+))?(\/[^?#]*)?(\?[^#]*)?(#.*)?$/);
+        if (!match) throw new Error('Invalid URL');
+        return {
+            protocol: match[1],
+            hostname: match[2],
+            port: match[3] || '',
+            pathname: match[4] || '/',
+            search: match[5] || '',
+            hash: match[6] || ''
+        };
+    },
+    format: (obj) => obj.toString ? obj.toString() : String(obj),
+    SearchParams: TitanURLSearchParams
+};
+
+
+// Create the main core export object (following titan-valid pattern)
+const core = {
+    fs,
+    path,
+    crypto,
+    os,
+    net,
+    proc,
+    time,
+    url
+};
+
+
+t.fs = fs;
+t.path = path;
+t.crypto = crypto;
+t.os = os;
+t.net = net;
+t.proc = proc;
+t.time = time;
+t.url = url;
+
+// Attach core as unified namespace (main access point)
+t.core = core;
+
+// Register as extension under multiple names for compatibility
+t["titan-core"] = core;
+t["@titanpl/core"] = core;
+
+// Also register in t.exts
+if (!t.exts) t.exts = {};
+t.exts["titan-core"] = core;
+t.exts["@titanpl/core"] = core;

package/titanpl-sdk/node_modules/@titanpl/core/package.json

@@ -0,0 +1,41 @@
+{
+    "name": "@titanpl/core",
+    "version": "1.0.1",
+    "description": "The official Core Standard Library for Titan Planet - provides fs, path, crypto, os, net, proc, time, and url modules",
+    "main": "index.js",
+    "types": "globals.d.ts",
+    "scripts": {
+        "build:native": "cd native && cargo build --release",
+        "test": "tit run ext"
+    },
+    "keywords": [
+        "titan",
+        "titanpl",
+        "titan-planet",
+        "runtime",
+        "core",
+        "fs",
+        "path",
+        "crypto",
+        "os",
+        "extension",
+        "titanpl-sdk"
+    ],
+    "author": "ezetgalaxy",
+    "license": "ISC",
+    "files": [
+        "index.js",
+        "titan.json",
+        "globals.d.ts",
+        "native/target/release/*.dll",
+        "native/target/release/*.so",
+        "native/target/release/*.dylib",
+        "README.md"
+    ],
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "devDependencies": {
+        "esbuild": "^0.27.2"
+    }
+}

package/titanpl-sdk/node_modules/@titanpl/core/titan.json

@@ -0,0 +1,115 @@
+{
+  "name": "@titanpl/core",
+  "description": "The official Core Standard Library for Titan Planet",
+  "version": "1.0.0",
+  "main": "index.js",
+  "native": {
+    "path": "native/target/release/titan_core_native.dll",
+    "functions": {
+      "fs_read_file": {
+        "symbol": "fs_read_file",
+        "parameters": [
+          "string"
+        ],
+        "result": "string"
+      },
+      "fs_write_file": {
+        "symbol": "fs_write_file",
+        "parameters": [
+          "string",
+          "string"
+        ],
+        "result": "void"
+      },
+      "fs_readdir": {
+        "symbol": "fs_readdir",
+        "parameters": [
+          "string"
+        ],
+        "result": "string"
+      },
+      "fs_mkdir": {
+        "symbol": "fs_mkdir",
+        "parameters": [
+          "string"
+        ],
+        "result": "void"
+      },
+      "fs_exists": {
+        "symbol": "fs_exists",
+        "parameters": [
+          "string"
+        ],
+        "result": "bool"
+      },
+      "fs_stat": {
+        "symbol": "fs_stat",
+        "parameters": [
+          "string"
+        ],
+        "result": "string"
+      },
+      "fs_remove": {
+        "symbol": "fs_remove",
+        "parameters": [
+          "string"
+        ],
+        "result": "void"
+      },
+      "path_cwd": {
+        "symbol": "path_cwd",
+        "parameters": [],
+        "result": "string"
+      },
+      "crypto_hash": {
+        "symbol": "crypto_hash",
+        "parameters": [
+          "string",
+          "string"
+        ],
+        "result": "string"
+      },
+      "crypto_random_bytes": {
+        "symbol": "crypto_random_bytes",
+        "parameters": [
+          "f64"
+        ],
+        "result": "string"
+      },
+      "crypto_uuid": {
+        "symbol": "crypto_uuid",
+        "parameters": [],
+        "result": "string"
+      },
+      "os_info": {
+        "symbol": "os_info",
+        "parameters": [],
+        "result": "string"
+      },
+      "net_resolve": {
+        "symbol": "net_resolve",
+        "parameters": [
+          "string"
+        ],
+        "result": "string"
+      },
+      "net_ip": {
+        "symbol": "net_ip",
+        "parameters": [],
+        "result": "string"
+      },
+      "proc_info": {
+        "symbol": "proc_info",
+        "parameters": [],
+        "result": "string"
+      },
+      "time_sleep": {
+        "symbol": "time_sleep",
+        "parameters": [
+          "f64"
+        ],
+        "result": "void"
+      }
+    }
+  }
+}

package/titanpl-sdk/package-lock.json

@@ -0,0 +1,28 @@
+{
+    "name": "titanpl-sdk",
+    "version": "0.1.7",
+    "lockfileVersion": 3,
+    "requires": true,
+    "packages": {
+        "": {
+            "name": "titanpl-sdk",
+            "version": "0.1.7",
+            "license": "ISC",
+            "dependencies": {
+                "@titanpl/core": "^1.0.1"
+            },
+            "bin": {
+                "titanpl-sdk": "bin/run.js"
+            }
+        },
+        "node_modules/@titanpl/core": {
+            "version": "1.0.1",
+            "resolved": "https://registry.npmjs.org/@titanpl/core/-/core-1.0.1.tgz",
+            "integrity": "sha512-5zcDMNnf+oghKkQMiPBFuhLlRy2IASyWMAAMgfqa4AzoXxiw2BzzfN0B2EA76Dy9AhCeK2mY84Zm+FSE7ANVFg==",
+            "license": "ISC",
+            "engines": {
+                "node": ">=18.0.0"
+            }
+        }
+    }
+}

package/titanpl-sdk/package.json

@@ -1,6 +1,6 @@
 {
     "name": "titanpl-sdk",
-    "version": "0.1.7",
+    "version": "0.1.8",
     "description": "Development SDK for Titan Planet. Provides TypeScript type definitions for the global 't' runtime object and a 'lite' test-harness runtime for building and verifying extensions.",
     "main": "index.js",
     "type": "module",
@@ -29,5 +29,8 @@
         "backend-sdk",
         "extension-development"
     ],
-    "license": "ISC"
-}
+    "license": "ISC",
+    "dependencies": {
+        "@titanpl/core": "^1.0.1"
+    }
+}