@titanpl/core 2.0.0 → 2.0.2

package/README.md

@@ -49,6 +49,9 @@ Cryptographic utilities using native Rust implementations.
 - `crypto.randomBytes(size: number): string` - Generate random bytes as hex string.
 - `crypto.uuid(): string` - Generate a UUID v4.
 - `crypto.compare(hash: string, target: string): boolean` - Constant-time comparison.
+- `crypto.encrypt(algorithm: string, key: string, plaintext: string): string` - AES-256-GCM Encrypt (Returns Base64).
+- `crypto.decrypt(algorithm: string, key: string, ciphertext: string): string` - AES-256-GCM Decrypt.
+- `crypto.hashKeyed(algo: string, key: string, message: string): string` - HMAC-SHA256/512.
 
 **Example:**
 ```javascript
@@ -59,6 +62,36 @@ const valid = t.core.crypto.compare(
 );
 ```
 
+### `buffer` (Buffer Utilities)
+Utilities for binary data manipulation.
+- `buffer.fromBase64(str: string): Uint8Array` - Decode Base64 string.
+- `buffer.toBase64(bytes: Uint8Array|string): string` - Encode to Base64.
+- `buffer.fromHex(str: string): Uint8Array` - Decode Hex string.
+- `buffer.toHex(bytes: Uint8Array|string): string` - Encode to Hex.
+- `buffer.fromUtf8(str: string): Uint8Array` - Encode UTF-8 string to bytes.
+- `buffer.toUtf8(bytes: Uint8Array): string` - Decode bytes to UTF-8 string.
+
+### `ls` / `localStorage` (Persistent Storage)
+Key-value storage persisted to disk (via Sled).
+- `ls.get(key: string): string|null` - Get value.
+- `ls.set(key: string, value: string): void` - Set value.
+- `ls.remove(key: string): void` - Remove key.
+- `ls.clear(): void` - Clear all storage.
+- `ls.keys(): string[]` - List all keys.
+
+### `session` (Server-side Sessions)
+Session management backed by persistent storage.
+- `session.get(sessionId: string, key: string): string|null` - Get session value.
+- `session.set(sessionId: string, key: string, value: string): void` - Set session value.
+- `session.delete(sessionId: string, key: string): void` - Delete session value.
+- `session.clear(sessionId: string): void` - Clear entire session.
+
+### `cookies` (HTTP Cookies)
+Cookie parsing and serialization.
+- `cookies.get(req: object, name: string): string|null` - Parse cookie from request headers.
+- `cookies.set(res: object, name: string, value: string, options: object): void` - Set `Set-Cookie` header on response. Options: `{ httpOnly, secure, sameSite, path, maxAge }`.
+- `cookies.delete(res: object, name: string): void` - Delete cookie (expire).
+
 ### `os` (Operating System)
 Get system information.
 - `os.platform(): string` - OS platform (e.g., `linux`, `windows`).

package/index.js

@@ -1,10 +1,118 @@
-// Titan Core Library
-// Provides standard library features using native bindings.
+const b64chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+function local_btoa(input) {
+    let str = String(input);
+    let output = '';
+
+    for (let i = 0; i < str.length; i += 3) {
+        const char1 = str.charCodeAt(i);
+        const char2 = str.charCodeAt(i + 1);
+        const char3 = str.charCodeAt(i + 2);
+
+        const enc1 = char1 >> 2;
+        const enc2 = ((char1 & 3) << 4) | (char2 >> 4);
+        let enc3 = ((char2 & 15) << 2) | (char3 >> 6);
+        let enc4 = char3 & 63;
+
+        if (isNaN(char2)) {
+            enc3 = enc4 = 64;
+        } else if (isNaN(char3)) {
+            enc4 = 64;
+        }
+
+        output += b64chars.charAt(enc1) + b64chars.charAt(enc2);
+        output += (enc3 === 64) ? '=' : b64chars.charAt(enc3);
+        output += (enc4 === 64) ? '=' : b64chars.charAt(enc4);
+    }
+
+    return output;
+}
+
+function local_atob(input) {
+    // Remove whitespace and padding '='
+    let str = String(input).replace(/[\t\n\f\r =]/g, "");
+    let output = '';
+
+    for (let i = 0; i < str.length; i += 4) {
+        const c1Str = str.charAt(i);
+        const c2Str = str.charAt(i + 1);
+        const c3Str = str.charAt(i + 2);
+        const c4Str = str.charAt(i + 3);
+
+        const e1 = b64chars.indexOf(c1Str);
+        const e2 = c2Str ? b64chars.indexOf(c2Str) : -1;
+        const e3 = c3Str ? b64chars.indexOf(c3Str) : -1;
+        const e4 = c4Str ? b64chars.indexOf(c4Str) : -1;
+
+        // e1 and e2 are required
+        if (e1 < 0 || e2 < 0) continue;
+
+        // Shift and mask to reconstruct bytes
+        const c1 = (e1 << 2) | (e2 >> 4);
+        output += String.fromCharCode(c1);
+
+        if (e3 !== -1) {
+            const c2 = ((e2 & 15) << 4) | (e3 >> 2);
+            output += String.fromCharCode(c2);
+        }
+        if (e4 !== -1) {
+            const c3 = ((e3 & 3) << 6) | e4;
+            output += String.fromCharCode(c3);
+        }
+    }
+
+    return output;
+}
+
+function local_utf8_encode(str) {
+    let result = [];
+    for (let i = 0; i < str.length; i++) {
+        let c = str.charCodeAt(i);
+        if (c < 0x80) { result.push(c); }
+        else if (c < 0x800) {
+            result.push(0xc0 | (c >> 6), 0x80 | (c & 0x3f));
+        }
+        else if (c < 0xd800 || c >= 0xe000) {
+            result.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+        }
+        else {
+            i++;
+            c = 0x10000 + (((c & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
+            result.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 0x3f), 0x80 | ((c >> 6) & 0x3f), 0x80 | (c & 0x3f));
+        }
+    }
+    return new Uint8Array(result);
+}
+
+function local_utf8_decode(bytes) {
+    let str = "";
+    let i = 0;
+    while (i < bytes.length) {
+        let c = bytes[i++];
+        if (c > 127) {
+            if (c > 191 && c < 224) {
+                c = ((c & 31) << 6) | (bytes[i++] & 63);
+            } else if (c > 223 && c < 240) {
+                c = ((c & 15) << 12) | ((bytes[i++] & 63) << 6) | (bytes[i++] & 63);
+            } else if (c > 239 && c < 248) {
+                c = ((c & 7) << 18) | ((bytes[i++] & 63) << 12) | ((bytes[i++] & 63) << 6) | (bytes[i++] & 63);
+            }
+        }
+        if (c <= 0xffff) str += String.fromCharCode(c);
+        else if (c <= 0x10ffff) {
+            c -= 0x10000;
+            str += String.fromCharCode(c >> 10 | 0xd800) + String.fromCharCode(c & 0x3ff | 0xdc00);
+        }
+    }
+    return str;
+}
+
 
 // Native bindings are loaded by the runtime into t["@titanpl/core"]
-// We capture them here before defining our high-level API.
 const natives = t["@titanpl/core"] || {};
 
+
+// Native Function bindings
 const native_fs_read_file = natives.fs_read_file;
 const native_fs_write_file = natives.fs_write_file;
 const native_fs_readdir = natives.fs_readdir;
@@ -13,45 +121,70 @@ const native_fs_exists = natives.fs_exists;
 const native_fs_stat = natives.fs_stat;
 const native_fs_remove = natives.fs_remove;
 const native_path_cwd = natives.path_cwd;
+
 const native_crypto_hash = natives.crypto_hash;
 const native_crypto_random_bytes = natives.crypto_random_bytes;
 const native_crypto_uuid = natives.crypto_uuid;
+const native_crypto_encrypt = natives.crypto_encrypt;
+const native_crypto_decrypt = natives.crypto_decrypt;
+const native_crypto_hash_keyed = natives.crypto_hash_keyed;
+const native_crypto_compare = natives.crypto_compare;
+
 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_time_sleep = natives.time_sleep;
 
+const native_ls_get = natives.ls_get;
+const native_ls_set = natives.ls_set;
+const native_ls_remove = natives.ls_remove;
+const native_ls_clear = natives.ls_clear;
+const native_ls_keys = natives.ls_keys;
+
+
+
+const native_session_get = natives.session_get;
+const native_session_set = natives.session_set;
+const native_session_delete = natives.session_delete;
+const native_session_clear = natives.session_clear;
+
 // --- FS ---
+/** File System module */
 const fs = {
+    /** Reads file content as UTF-8 string */
     readFile: (path) => {
         if (!native_fs_read_file) throw new Error("Native fs_read_file not found");
         const res = native_fs_read_file(path);
-        if (res.startsWith("ERROR:")) throw new Error(res);
+        if (res && res.startsWith("ERROR:")) throw new Error(res);
         return res;
     },
+    /** Writes content to file */
     writeFile: (path, content) => {
         if (!native_fs_write_file) throw new Error("Native fs_write_file not found");
         native_fs_write_file(path, content);
     },
+    /** Reads directory contents */
     readdir: (path) => {
         if (!native_fs_readdir) throw new Error("Native fs_readdir not found");
         const res = native_fs_readdir(path);
-        // Runtime might return empty string on error or failures, or "[]"
         try {
             return JSON.parse(res);
         } catch (e) {
             return [];
         }
     },
+    /** Creates direction recursively */
     mkdir: (path) => {
         if (!native_fs_mkdir) throw new Error("Native fs_mkdir not found");
         native_fs_mkdir(path);
     },
+    /** Checks if path exists */
     exists: (path) => {
         if (!native_fs_exists) throw new Error("Native fs_exists not found");
         return native_fs_exists(path);
     },
+    /** Returns file stats */
     stat: (path) => {
         if (!native_fs_stat) throw new Error("Native fs_stat not found");
         const res = native_fs_stat(path);
@@ -61,6 +194,7 @@ const fs = {
             return {};
         }
     },
+    /** Removes file or directory */
     remove: (path) => {
         if (!native_fs_remove) throw new Error("Native fs_remove not found");
         native_fs_remove(path);
@@ -68,15 +202,12 @@ const fs = {
 };
 
 // --- Path ---
-// Basic implementation for POSIX-like paths (Titan mostly runs on servers/containers)
+/** Path manipulation module */
 const path = {
     join: (...args) => {
-        // Normalize to forward slashes for internal join logic, or keep native?
-        // Let's normalize to / for consistency unless user requests native path separator
         return args
             .map((part, i) => {
                 if (!part) return '';
-                // Replace backslashes with forward slashes for easier joining
                 let p = part.replace(/\\/g, '/');
                 if (i === 0) return p.trim().replace(/[\/]*$/g, '');
                 return p.trim().replace(/(^[\/]*|[\/]*$)/g, '');
@@ -90,10 +221,8 @@ const path = {
             resolved = path.join(resolved, arg);
         }
         if (!resolved.startsWith('/')) {
-            // If windows, check for drive letter C:\ or D:\ or start with \
             const isWindowsAbs = /^[a-zA-Z]:\\/.test(resolved) || resolved.startsWith('\\');
             if (!isWindowsAbs && native_path_cwd) {
-                // native_path_cwd returns result of std::env::current_dir()
                 const cwd = native_path_cwd();
                 if (cwd) {
                     resolved = path.join(cwd, resolved);
@@ -115,17 +244,42 @@ const path = {
 };
 
 // --- Crypto ---
+/** Cryptography module */
 const crypto = {
     hash: (algo, data) => native_crypto_hash ? native_crypto_hash(algo, data) : "",
     randomBytes: (size) => native_crypto_random_bytes ? native_crypto_random_bytes(size) : "",
     uuid: () => native_crypto_uuid ? native_crypto_uuid() : "",
     base64: {
-        encode: (str) => btoa(str), // Boa supports btoa/atob
-        decode: (str) => atob(str),
+        encode: (str) => local_btoa(str),
+        decode: (str) => local_atob(str),
+    },
+    // Extended API
+    /** Encrypts data using AES-256-GCM. Returns Base64 string. */
+    encrypt: (algorithm, key, plaintext) => {
+        if (!native_crypto_encrypt) throw new Error("Native crypto_encrypt not found");
+        const res = native_crypto_encrypt(algorithm, JSON.stringify({ key, plaintext }));
+        if (res.startsWith("ERROR:")) throw new Error(res.substring(6));
+        return res;
+    },
+    /** Decrypts data using AES-256-GCM. Returns plaintext string. */
+    decrypt: (algorithm, key, ciphertext) => {
+        if (!native_crypto_decrypt) throw new Error("Native crypto_decrypt not found");
+        const res = native_crypto_decrypt(algorithm, JSON.stringify({ key, ciphertext }));
+        if (res.startsWith("ERROR:")) throw new Error(res.substring(6));
+        return res;
     },
+    /** Computes HMAC-SHA256/512. Returns Hex string. */
+    hashKeyed: (algorithm, key, message) => {
+        if (!native_crypto_hash_keyed) throw new Error("Native crypto_hash_keyed not found");
+        const res = native_crypto_hash_keyed(algorithm, JSON.stringify({ key, message }));
+        if (res.startsWith("ERROR:")) throw new Error(res.substring(6));
+        return res;
+    },
+    /** Constant-time string comparison */
     compare: (a, b) => {
+        if (native_crypto_compare) return native_crypto_compare(a, b);
+        // Fallback insecure
         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));
@@ -134,6 +288,181 @@ const crypto = {
     }
 };
 
+// --- Buffer ---
+// Helper for hex
+function hexToBytes(hex) {
+    const bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+    }
+    return bytes;
+}
+function bytesToHex(bytes) {
+    return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+}
+
+/** Buffer utility module */
+const buffer = {
+    /** Creates Uint8Array from Base64 string */
+    fromBase64: (str) => {
+        const binary = local_atob(str);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        return bytes;
+    },
+    /** encoded Uint8Array or String to Base64 string */
+    toBase64: (bytes) => {
+        let binary = '';
+        if (typeof bytes === 'string') {
+            return local_btoa(bytes);
+        }
+        // Uint8Array
+        const len = bytes.byteLength;
+        for (let i = 0; i < len; i++) {
+            binary += String.fromCharCode(bytes[i]);
+        }
+        return local_btoa(binary);
+    },
+    /** Creates Uint8Array from Hex string */
+    fromHex: (str) => hexToBytes(str),
+    /** Encodes bytes to Hex string */
+    toHex: (bytes) => {
+        if (typeof bytes === 'string') {
+            return bytesToHex(local_utf8_encode(bytes));
+        }
+        return bytesToHex(bytes);
+    },
+    /** Creates Uint8Array from UTF-8 string */
+    fromUtf8: (str) => local_utf8_encode(str),
+    /** Decodes bytes to UTF-8 string */
+    toUtf8: (bytes) => local_utf8_decode(bytes)
+};
+
+// --- Local Storage ---
+/** Persistent Local Storage */
+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; }
+    },
+    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) { }
+    },
+    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) { }
+    },
+    clear: () => {
+        try {
+            fs.writeFile("titan_storage.json", "{}");
+        } catch (e) { }
+    },
+    keys: () => {
+        try {
+            let db = JSON.parse(fs.readFile("titan_storage.json") || "{}");
+            return Object.keys(db);
+        } catch (e) { return []; }
+    }
+};
+
+// --- Sessions ---
+/** Server-side Session Management */
+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; }
+    },
+    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) { }
+    },
+    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) { }
+    },
+    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) { }
+    }
+};
+
+
+// --- Cookies ---
+/** HTTP Cookie Utilities */
+const cookies = {
+    /** Parses cookie from request headers */
+    get: (req, name) => {
+        if (!req || !req.headers) return null;
+        const cookieHeader = req.headers.cookie;
+        if (!cookieHeader) return null;
+        const cookies = cookieHeader.split(';');
+        for (let c of cookies) {
+            const [k, v] = c.trim().split('=');
+            if (k === name) return decodeURIComponent(v);
+        }
+        return null;
+    },
+    /** Sets Set-Cookie header on response */
+    set: (res, name, value, options = {}) => {
+        if (!res || !res.setHeader) return;
+        let cookie = `${name}=${encodeURIComponent(value)}`;
+        if (options.maxAge) cookie += `; Max-Age=${options.maxAge}`;
+        if (options.path) cookie += `; Path=${options.path}`;
+        if (options.httpOnly) cookie += `; HttpOnly`;
+        if (options.secure) cookie += `; Secure`;
+        if (options.sameSite) cookie += `; SameSite=${options.sameSite}`;
+
+        let prev = res.getHeader ? res.getHeader('Set-Cookie') : null;
+        if (prev) {
+            if (Array.isArray(prev)) {
+                prev.push(cookie);
+                res.setHeader('Set-Cookie', prev);
+            } else {
+                res.setHeader('Set-Cookie', [prev, cookie]);
+            }
+        } else {
+            res.setHeader('Set-Cookie', cookie);
+        }
+    },
+    /** Deletes cookie by setting maxAge=0 */
+    delete: (res, name) => {
+        cookies.set(res, name, "", { maxAge: 0, path: '/' });
+    }
+};
+
 // --- OS ---
 const os = {
     platform: () => {
@@ -156,7 +485,7 @@ const os = {
         const info = JSON.parse(native_os_info());
         return info.freeMemory;
     },
-    tmpdir: () => '/tmp' // Default for now, generic
+    tmpdir: () => '/tmp'
 };
 
 // --- Net ---
@@ -166,14 +495,10 @@ const net = {
         return JSON.parse(native_net_resolve(hostname));
     },
     ip: () => native_net_ip ? native_net_ip() : "127.0.0.1",
-    ping: (host) => {
-        // Mock ping or simple verify
-        return true;
-    }
+    ping: (host) => true
 };
 
 // --- Proc ---
-// Memoize static info if needed, but here we call native
 const proc = {
     pid: () => {
         if (!native_proc_info) return 0;
@@ -185,27 +510,19 @@ const proc = {
         const info = JSON.parse(native_proc_info());
         return info.uptime;
     },
-    memory: () => {
-        // Optional: return full memory usage if possible
-        return {};
-    }
+    memory: () => ({})
 };
 
 // --- Time ---
 const time = {
     sleep: (ms) => {
-        if (native_time_sleep) {
-            native_time_sleep(ms);
-        } else {
-            console.log("[TitanCore] Warn: native_time_sleep missing");
-        }
+        if (native_time_sleep) native_time_sleep(ms);
     },
     now: () => Date.now(),
     timestamp: () => new Date().toISOString()
 };
 
 // --- URL ---
-// Simple URLSearchParams polyfill for V8 runtime
 class TitanURLSearchParams {
     constructor(init = '') {
         this._params = {};
@@ -235,11 +552,9 @@ class TitanURLSearchParams {
 
 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 {
@@ -255,7 +570,6 @@ const url = {
     SearchParams: TitanURLSearchParams
 };
 
-
 // Create the main core export object (following titan-valid pattern)
 const core = {
     fs,
@@ -265,10 +579,13 @@ const core = {
     net,
     proc,
     time,
-    url
+    url,
+    buffer, // t.core.buffer
+    ls,
+    session,
+    cookies
 };
 
-
 t.fs = fs;
 t.path = path;
 t.crypto = crypto;
@@ -278,6 +595,13 @@ t.proc = proc;
 t.time = time;
 t.url = url;
 
+// New Global Modules
+t.buffer = buffer;
+t.ls = ls;
+t.localStorage = ls;
+t.session = session;
+t.cookies = cookies;
+
 // Attach core as unified namespace (main access point)
 t.core = core;
 

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "@titanpl/core",
-    "version": "2.0.0",
+    "version": "2.0.2",
     "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"
+        "test": "titan run ext"
     },
     "keywords": [
         "titan",
@@ -41,4 +41,4 @@
     "dependencies": {
         "@titanpl/valid": "^1.1.1"
     }
-}
+}

package/titan.json

@@ -1,7 +1,7 @@
 {
   "name": "@titanpl/core",
   "description": "The official Core Standard Library for Titan Planet",
-  "version": "1.0.0",
+  "version": "2.0.2",
   "main": "index.js",
   "native": {
     "path": "native/target/release/titan_core.dll",
@@ -10,7 +10,7 @@
         "symbol": "fs_read_file",
         "parameters": [
           "string"
-        ],
+        ],  
         "result": "string"
       },
       "fs_write_file": {
@@ -109,6 +109,101 @@
           "f64"
         ],
         "result": "void"
+      },
+      "crypto_encrypt": {
+        "symbol": "crypto_encrypt",
+        "parameters": [
+          "string",
+          "string"
+        ],
+        "result": "string"
+      },
+      "crypto_decrypt": {
+        "symbol": "crypto_decrypt",
+        "parameters": [
+          "string",
+          "string"
+        ],
+        "result": "string"
+      },
+      "crypto_hash_keyed": {
+        "symbol": "crypto_hash_keyed",
+        "parameters": [
+          "string",
+          "string"
+        ],
+        "result": "string"
+      },
+      "crypto_compare": {
+        "symbol": "crypto_compare",
+        "parameters": [
+          "string",
+          "string"
+        ],
+        "result": "bool"
+      },
+      "ls_get": {
+        "symbol": "ls_get",
+        "parameters": [
+          "string"
+        ],
+        "result": "string"
+      },
+      "ls_set": {
+        "symbol": "ls_set",
+        "parameters": [
+          "string",
+          "string"
+        ],
+        "result": "void"
+      },
+      "ls_remove": {
+        "symbol": "ls_remove",
+        "parameters": [
+          "string"
+        ],
+        "result": "void"
+      },
+      "ls_clear": {
+        "symbol": "ls_clear",
+        "parameters": [],
+        "result": "void"
+      },
+      "ls_keys": {
+        "symbol": "ls_keys",
+        "parameters": [],
+        "result": "string"
+      },
+      "session_get": {
+        "symbol": "session_get",
+        "parameters": [
+          "string",
+          "string"
+        ],
+        "result": "string"
+      },
+      "session_set": {
+        "symbol": "session_set",
+        "parameters": [
+          "string",
+          "string"
+        ],
+        "result": "void"
+      },
+      "session_delete": {
+        "symbol": "session_delete",
+        "parameters": [
+          "string",
+          "string"
+        ],
+        "result": "void"
+      },
+      "session_clear": {
+        "symbol": "session_clear",
+        "parameters": [
+          "string"
+        ],
+        "result": "void"
       }
     }
   }