@titanpl/core 2.0.9 → 2.1.1

package/index.js

@@ -111,6 +111,9 @@ function local_utf8_decode(bytes) {
 // Native bindings are loaded by the runtime into t["@titanpl/core"]
 const natives = t["@titanpl/core"] || {};
 
+console.log("[TitanCore] Available natives:", Object.keys(natives));
+
+
 
 // Native Function bindings
 const native_fs_read_file = natives.fs_read_file;
@@ -134,6 +137,9 @@ const native_os_info = natives.os_info;
 const native_net_resolve = natives.net_resolve;
 const native_net_ip = natives.net_ip;
 const native_proc_info = natives.proc_info;
+const native_proc_run = natives.proc_run;
+const native_proc_kill = natives.proc_kill;
+const native_proc_list = natives.proc_list;
 const native_time_sleep = natives.time_sleep;
 
 const native_ls_get = natives.ls_get;
@@ -341,81 +347,53 @@ const buffer = {
 };
 
 // --- Local Storage ---
-/** Persistent Local Storage */
+/** High-performance in-memory Local Storage (backed by native RwLock<HashMap>) */
 const ls = {
     get: (key) => {
-        try {
-            const content = fs.readFile("titan_storage.json");
-            const db = JSON.parse(content || "{}");
-            return db[key] || null;
-        } catch (e) { return null; }
+        if (!native_ls_get) throw new Error("Native ls_get not found");
+        return native_ls_get(key);
     },
     set: (key, value) => {
-        try {
-            let db = {};
-            try { db = JSON.parse(fs.readFile("titan_storage.json") || "{}"); } catch (e) { }
-            db[key] = String(value);
-            fs.writeFile("titan_storage.json", JSON.stringify(db));
-        } catch (e) { }
+        if (!native_ls_set) throw new Error("Native ls_set not found");
+        native_ls_set(key, String(value));
     },
     remove: (key) => {
-        try {
-            let db = {};
-            try { db = JSON.parse(fs.readFile("titan_storage.json") || "{}"); } catch (e) { }
-            delete db[key];
-            fs.writeFile("titan_storage.json", JSON.stringify(db));
-        } catch (e) { }
+        if (!native_ls_remove) throw new Error("Native ls_remove not found");
+        native_ls_remove(key);
     },
     clear: () => {
-        try {
-            fs.writeFile("titan_storage.json", "{}");
-        } catch (e) { }
+        if (!native_ls_clear) throw new Error("Native ls_clear not found");
+        native_ls_clear();
     },
     keys: () => {
+        if (!native_ls_keys) throw new Error("Native ls_keys not found");
+        const result = native_ls_keys();
         try {
-            let db = JSON.parse(fs.readFile("titan_storage.json") || "{}");
-            return Object.keys(db);
-        } catch (e) { return []; }
+            return JSON.parse(result);
+        } catch (e) {
+            return [];
+        }
     }
 };
 
 // --- Sessions ---
-/** Server-side Session Management */
+/** High-performance in-memory Session Management (backed by native RwLock<HashMap>) */
 const session = {
     get: (sessionId, key) => {
-        try {
-            const content = fs.readFile("titan_sessions.json");
-            const db = JSON.parse(content || "{}");
-            const sessionData = db[sessionId] || {};
-            return sessionData[key] || null;
-        } catch (e) { return null; }
+        if (!native_session_get) throw new Error("Native session_get not found");
+        return native_session_get(sessionId, key);
     },
     set: (sessionId, key, value) => {
-        try {
-            let db = {};
-            try { db = JSON.parse(fs.readFile("titan_sessions.json") || "{}"); } catch (e) { }
-            if (!db[sessionId]) db[sessionId] = {};
-            db[sessionId][key] = String(value);
-            fs.writeFile("titan_sessions.json", JSON.stringify(db));
-        } catch (e) { }
+        if (!native_session_set) throw new Error("Native session_set not found");
+        native_session_set(sessionId, key, String(value));
     },
     delete: (sessionId, key) => {
-        try {
-            let db = {};
-            try { db = JSON.parse(fs.readFile("titan_sessions.json") || "{}"); } catch (e) { }
-            if (db[sessionId]) {
-                delete db[sessionId][key];
-                fs.writeFile("titan_sessions.json", JSON.stringify(db));
-            }
-        } catch (e) { }
+        if (!native_session_delete) throw new Error("Native session_delete not found");
+        native_session_delete(sessionId, key);
     },
     clear: (sessionId) => {
-        try {
-            let db = {};
-            try { db = JSON.parse(fs.readFile("titan_sessions.json") || "{}"); } catch (e) { }
-            delete db[sessionId];
-            fs.writeFile("titan_sessions.json", JSON.stringify(db));
-        } catch (e) { }
+        if (!native_session_clear) throw new Error("Native session_clear not found");
+        native_session_clear(sessionId);
     }
 };
 
@@ -463,6 +441,64 @@ const cookies = {
     }
 };
 
+
+
+// --- Response ---
+/** Advanced HTTP Response Management */
+const response = (options) => {
+    return {
+        _isResponse: true,
+        status: options.status || 200,
+        headers: options.headers || {},
+        body: options.body || ""
+    };
+};
+
+response.text = (content, options = {}) => {
+    return {
+        _isResponse: true,
+        status: options.status || 200,
+        headers: { "Content-Type": "text/plain", ...(options.headers || {}) },
+        body: content
+    };
+};
+
+response.html = (content, options = {}) => {
+    return {
+        _isResponse: true,
+        status: options.status || 200,
+        headers: { "Content-Type": "text/html; charset=utf-8", ...(options.headers || {}) },
+        body: content
+    };
+};
+
+response.json = (content, options = {}) => {
+    return {
+        _isResponse: true,
+        status: options.status || 200,
+        headers: { "Content-Type": "application/json", ...(options.headers || {}) },
+        body: JSON.stringify(content)
+    };
+};
+
+response.redirect = (url, status = 302) => {
+    return {
+        _isResponse: true,
+        status: status,
+        headers: { "Location": url },
+        body: ""
+    };
+};
+
+response.empty = (status = 204) => {
+    return {
+        _isResponse: true,
+        status: status,
+        headers: {},
+        body: ""
+    };
+};
+
 // --- OS ---
 const os = {
     platform: () => {
@@ -518,7 +554,26 @@ const proc = {
         const info = JSON.parse(native_proc_info());
         return info.uptime;
     },
-    memory: () => ({})
+    memory: () => ({}),
+    run: (command, args = []) => {
+        if (!native_proc_run) throw new Error("Native proc_run not found");
+        const res = native_proc_run(command, JSON.stringify(args));
+        if (typeof res === 'string' && res.startsWith("ERROR:")) throw new Error(res);
+        try {
+            return JSON.parse(res);
+        } catch (e) { return {}; }
+    },
+    kill: (pid) => {
+        if (!native_proc_kill) return false;
+        return native_proc_kill(pid);
+    },
+    list: () => {
+        if (!native_proc_list) return [];
+        const res = native_proc_list();
+        try {
+            return JSON.parse(res);
+        } catch (e) { return []; }
+    }
 };
 
 // --- Time ---
@@ -591,7 +646,8 @@ const core = {
     buffer, // t.core.buffer
     ls,
     session,
-    cookies
+    cookies,
+    response
 };
 
 t.fs = fs;
@@ -609,6 +665,7 @@ t.ls = ls;
 t.localStorage = ls;
 t.session = session;
 t.cookies = cookies;
+t.response = response;
 
 // Attach core as unified namespace (main access point)
 t.core = core;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@titanpl/core",
-    "version": "2.0.9",
+    "version": "2.1.1",
     "description": "The official Core Standard Library for Titan Planet - provides fs, path, crypto, os, net, proc, time, and url modules",
     "main": "index.js",
     "type": "module",

package/titan.json

@@ -1,10 +1,10 @@
 {
   "name": "@titanpl/core",
   "description": "The official Core Standard Library for Titan Planet",
-  "version": "2.0.7",
+  "version": "2.1.1",
   "main": "index.js",
   "native": {
-    "path": "native/target/release/libtitan_core.so",
+    "path": "native/target/release/titan_core.dll",
     "functions": {
       "fs_read_file": {
         "symbol": "fs_read_file",
@@ -103,6 +103,26 @@
         "parameters": [],
         "result": "string"
       },
+      "proc_run": {
+        "symbol": "proc_run",
+        "parameters": [
+          "string",
+          "string"
+        ],
+        "result": "string"
+      },
+      "proc_kill": {
+        "symbol": "proc_kill",
+        "parameters": [
+          "f64"
+        ],
+        "result": "bool"
+      },
+      "proc_list": {
+        "symbol": "proc_list",
+        "parameters": [],
+        "result": "string"
+      },
       "time_sleep": {
         "symbol": "time_sleep",
         "parameters": [