titanpl 7.0.0-beta → 7.0.0

package/packages/core-source/tests/setup.js

@@ -0,0 +1,325 @@
+/**
+ * tests/setup.js
+ * 
+ * Emulates Rust native functions for testing.
+ * Equivalent to what @t8n/micro-gravity/setup would do.
+ * 
+ * MOCKED:
+ * - DB (PostgreSQL connection) - No way to test without a real DB
+ * 
+ * EMULATED (JS implementation that simulates Rust behavior):
+ * - fs_* (uses Node.js fs)
+ * - crypto_* (uses Node.js crypto)
+ * - ls_* (uses in-memory Map)
+ * - session_* (uses in-memory Map)
+ * - os_*, net_*, proc_*, time_*, path_cwd
+ */
+
+import { vi } from 'vitest';
+import * as nodeFs from 'node:fs';
+import * as nodePath from 'node:path';
+import * as nodeCrypto from 'node:crypto';
+import * as nodeOs from 'node:os';
+
+// In-memory storage for ls and session
+const localStorage = new Map();
+const sessionStorage = new Map();
+
+// Initialize global `t` object with native functions
+globalThis.t = globalThis.t || {};
+globalThis.t["@titanpl/core"] = globalThis.t["@titanpl/core"] || {};
+globalThis.t.native = globalThis.t.native || {};
+globalThis.t.core = globalThis.t.core || {};
+
+const ext = globalThis.t["@titanpl/core"];
+
+// ============================================
+// FILE SYSTEM - Emulation using Node.js fs
+// ============================================
+
+ext.fs_read_file = (path) => {
+    try {
+        return nodeFs.readFileSync(path, 'utf-8');
+    } catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+};
+
+ext.fs_write_file = (path, content) => {
+    nodeFs.writeFileSync(path, content, 'utf-8');
+};
+
+ext.fs_readdir = (path) => {
+    try {
+        return JSON.stringify(nodeFs.readdirSync(path));
+    } catch {
+        return '[]';
+    }
+};
+
+ext.fs_mkdir = (path) => {
+    nodeFs.mkdirSync(path, { recursive: true });
+};
+
+ext.fs_exists = (path) => {
+    return nodeFs.existsSync(path);
+};
+
+ext.fs_stat = (path) => {
+    try {
+        const stat = nodeFs.statSync(path);
+        return JSON.stringify({
+            size: stat.size,
+            isFile: stat.isFile(),
+            isDir: stat.isDirectory(),
+            modified: stat.mtimeMs
+        });
+    } catch {
+        return '{}';
+    }
+};
+
+ext.fs_remove = (path) => {
+    try {
+        const stat = nodeFs.statSync(path);
+        if (stat.isDirectory()) {
+            nodeFs.rmSync(path, { recursive: true });
+        } else {
+            nodeFs.unlinkSync(path);
+        }
+    } catch { }
+};
+
+ext.path_cwd = () => process.cwd();
+
+// ============================================
+// CRYPTO - Emulation using Node.js crypto
+// ============================================
+
+ext.crypto_hash = (algo, data) => {
+    try {
+        const hash = nodeCrypto.createHash(algo);
+        hash.update(data);
+        return hash.digest('hex');
+    } catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+};
+
+ext.crypto_random_bytes = (size) => {
+    return nodeCrypto.randomBytes(size).toString('hex');
+};
+
+ext.crypto_uuid = () => {
+    return nodeCrypto.randomUUID();
+};
+
+ext.crypto_encrypt = (algo, jsonArgs) => {
+    try {
+        const { key, plaintext } = JSON.parse(jsonArgs);
+        const keyBuffer = Buffer.alloc(32);
+        Buffer.from(key).copy(keyBuffer);
+        const iv = nodeCrypto.randomBytes(12);
+        const cipher = nodeCrypto.createCipheriv('aes-256-gcm', keyBuffer, iv);
+        let encrypted = cipher.update(plaintext, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        const authTag = cipher.getAuthTag().toString('hex');
+        return iv.toString('hex') + ':' + authTag + ':' + encrypted;
+    } catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+};
+
+ext.crypto_decrypt = (algo, jsonArgs) => {
+    try {
+        const { key, ciphertext } = JSON.parse(jsonArgs);
+        const [ivHex, authTagHex, encrypted] = ciphertext.split(':');
+        const keyBuffer = Buffer.alloc(32);
+        Buffer.from(key).copy(keyBuffer);
+        const iv = Buffer.from(ivHex, 'hex');
+        const authTag = Buffer.from(authTagHex, 'hex');
+        const decipher = nodeCrypto.createDecipheriv('aes-256-gcm', keyBuffer, iv);
+        decipher.setAuthTag(authTag);
+        let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+    } catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+};
+
+ext.crypto_hash_keyed = (algo, jsonArgs) => {
+    try {
+        const { key, message } = JSON.parse(jsonArgs);
+        const hmac = nodeCrypto.createHmac(algo === 'sha256' ? 'sha256' : 'sha512', key);
+        hmac.update(message);
+        return hmac.digest('hex');
+    } catch (e) {
+        return `ERROR: ${e.message}`;
+    }
+};
+
+ext.crypto_compare = (a, b) => {
+    return nodeCrypto.timingSafeEqual(Buffer.from(a), Buffer.from(b));
+};
+
+// ============================================
+// LOCAL STORAGE - In-memory emulation
+// ============================================
+
+ext.ls_get = (key) => {
+    return localStorage.get(key) || '';
+};
+
+ext.ls_set = (key, value) => {
+    localStorage.set(key, value);
+};
+
+ext.ls_remove = (key) => {
+    localStorage.delete(key);
+};
+
+ext.ls_clear = () => {
+    localStorage.clear();
+};
+
+ext.ls_keys = () => {
+    return JSON.stringify([...localStorage.keys()]);
+};
+
+// Simplified V8 serialization (uses JSON as fallback)
+ext.serialize = (value) => {
+    try {
+        const json = JSON.stringify(value);
+        return new TextEncoder().encode(json);
+    } catch {
+        return null;
+    }
+};
+
+ext.deserialize = (bytes) => {
+    try {
+        const json = new TextDecoder().decode(bytes);
+        return JSON.parse(json);
+    } catch {
+        return null;
+    }
+};
+
+// ============================================
+// SESSION - In-memory emulation
+// ============================================
+
+ext.session_get = (sid, key) => {
+    return sessionStorage.get(`${sid}:${key}`) || '';
+};
+
+ext.session_set = (sid, jsonArgs) => {
+    const { key, value } = JSON.parse(jsonArgs);
+    sessionStorage.set(`${sid}:${key}`, value);
+};
+
+ext.session_delete = (sid, key) => {
+    sessionStorage.delete(`${sid}:${key}`);
+};
+
+ext.session_clear = (sid) => {
+    for (const key of sessionStorage.keys()) {
+        if (key.startsWith(`${sid}:`)) {
+            sessionStorage.delete(key);
+        }
+    }
+};
+
+// ============================================
+// OS - Emulation using Node.js os
+// ============================================
+
+ext.os_info = () => {
+    return JSON.stringify({
+        platform: nodeOs.platform(),
+        cpus: nodeOs.cpus().length,
+        totalMemory: nodeOs.totalmem(),
+        freeMemory: nodeOs.freemem(),
+        tmpdir: nodeOs.tmpdir()
+    });
+};
+
+// ============================================
+// NET - Basic emulation
+// ============================================
+
+ext.net_resolve = (hostname) => {
+    return JSON.stringify(['127.0.0.1']);
+};
+
+ext.net_ip = () => {
+    const interfaces = nodeOs.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        for (const iface of interfaces[name]) {
+            if (iface.family === 'IPv4' && !iface.internal) {
+                return iface.address;
+            }
+        }
+    }
+    return '127.0.0.1';
+};
+
+// ============================================
+// PROC - Basic emulation
+// ============================================
+
+ext.proc_info = () => {
+    return JSON.stringify({
+        pid: process.pid,
+        uptime: process.uptime()
+    });
+};
+
+ext.proc_run = (jsonArgs) => {
+    return JSON.stringify({ ok: false, error: 'Disabled in tests' });
+};
+
+ext.proc_kill = (pid) => {
+    return false;
+};
+
+ext.proc_list = () => {
+    return JSON.stringify([]);
+};
+
+// ============================================
+// TIME
+// ============================================
+
+ext.time_sleep = (ms) => {
+    const end = Date.now() + ms;
+    while (Date.now() < end) { }
+};
+
+// ============================================
+// DATABASE - MOCK (only real mock)
+// ============================================
+
+globalThis.t.db = {
+    connect: vi.fn().mockReturnValue({
+        query: vi.fn().mockResolvedValue({ rows: [] }),
+        execute: vi.fn().mockResolvedValue({ rowCount: 0 }),
+        close: vi.fn()
+    })
+};
+
+// ============================================
+// Helpers to clear state between tests
+// ============================================
+
+export function clearStorage() {
+    localStorage.clear();
+    sessionStorage.clear();
+}
+
+import { beforeEach } from 'vitest';
+
+beforeEach(() => {
+    clearStorage();
+});

package/packages/core-source/tests/time.test.js

@@ -0,0 +1,57 @@
+/**
+ * tests/time.test.js
+ * 
+ * Tests for the time module
+ * time.now() - Pure JS (Date.now())
+ * time.sleep() - Native emulated
+ */
+import { describe, it, expect } from 'vitest';
+import { time } from '../index.js';
+
+describe('time', () => {
+    describe('now()', () => {
+        it('should return current timestamp', () => {
+            const before = Date.now();
+            const result = time.now();
+            const after = Date.now();
+            
+            expect(result).toBeGreaterThanOrEqual(before);
+            expect(result).toBeLessThanOrEqual(after);
+        });
+
+        it('should return number', () => {
+            expect(typeof time.now()).toBe('number');
+        });
+
+        it('should increment over time', async () => {
+            const first = time.now();
+            await new Promise(r => setTimeout(r, 10));
+            const second = time.now();
+            
+            expect(second).toBeGreaterThan(first);
+        });
+    });
+
+    describe('sleep()', () => {
+        it('should pause execution', () => {
+            const start = Date.now();
+            time.sleep(50);
+            const elapsed = Date.now() - start;
+            
+            // Should have passed at least 40ms (margin of error)
+            expect(elapsed).toBeGreaterThanOrEqual(40);
+        });
+
+        it('should accept small values', () => {
+            expect(() => time.sleep(1)).not.toThrow();
+        });
+
+        it('should handle 0ms', () => {
+            const start = Date.now();
+            time.sleep(0);
+            const elapsed = Date.now() - start;
+            
+            expect(elapsed).toBeLessThan(100);
+        });
+    });
+});

package/packages/core-source/tests/url.test.js

@@ -0,0 +1,82 @@
+/**
+ * tests/url.test.js
+ * 
+ * Tests for the url module
+ * Pure JS API - uses native URL and URLSearchParams
+ */
+import { describe, it, expect } from 'vitest';
+import { url } from '../index.js';
+
+describe('url', () => {
+    describe('parse()', () => {
+        it('should parse complete URL', () => {
+            const parsed = url.parse('https://example.com:8080/path?query=value#hash');
+            
+            expect(parsed.protocol).toBe('https:');
+            expect(parsed.hostname).toBe('example.com');
+            expect(parsed.port).toBe('8080');
+            expect(parsed.pathname).toBe('/path');
+            expect(parsed.search).toBe('?query=value');
+            expect(parsed.hash).toBe('#hash');
+        });
+
+        it('should parse simple URL', () => {
+            const parsed = url.parse('https://example.com');
+            
+            expect(parsed.hostname).toBe('example.com');
+            expect(parsed.pathname).toBe('/');
+        });
+
+        it('should return null for invalid URL', () => {
+            expect(url.parse('not-a-url')).toBeNull();
+            expect(url.parse('')).toBeNull();
+        });
+
+        it('should handle query params', () => {
+            const parsed = url.parse('https://api.example.com/search?q=test&page=1');
+            
+            expect(parsed.searchParams.get('q')).toBe('test');
+            expect(parsed.searchParams.get('page')).toBe('1');
+        });
+
+        it('should handle URLs with authentication', () => {
+            const parsed = url.parse('https://user:pass@example.com/path');
+            
+            expect(parsed.username).toBe('user');
+            expect(parsed.password).toBe('pass');
+        });
+    });
+
+    describe('SearchParams', () => {
+        it('should create URLSearchParams instance', () => {
+            const params = new url.SearchParams('foo=bar&baz=qux');
+            
+            expect(params.get('foo')).toBe('bar');
+            expect(params.get('baz')).toBe('qux');
+        });
+
+        it('should serialize to string', () => {
+            const params = new url.SearchParams();
+            params.append('key', 'value');
+            params.append('another', 'test');
+            
+            expect(params.toString()).toContain('key=value');
+            expect(params.toString()).toContain('another=test');
+        });
+
+        it('should handle encoded values', () => {
+            const params = new url.SearchParams();
+            params.set('message', 'Hello World!');
+            
+            expect(params.toString()).toContain('Hello');
+        });
+
+        it('should iterate over entries', () => {
+            const params = new url.SearchParams('a=1&b=2&c=3');
+            const entries = [...params.entries()];
+            
+            expect(entries).toHaveLength(3);
+            expect(entries[0]).toEqual(['a', '1']);
+        });
+    });
+});

package/packages/core-source/titan-ext.d.ts

@@ -0,0 +1,2 @@
+// titan-ext.d.ts
+/// <reference path="./globals.d.ts" />

package/packages/core-source/titan.json

@@ -0,0 +1,9 @@
+{
+    "name": "@titanpl/core",
+    "type": "native",
+    "entry": "index.js",
+    "native": {
+        "windows": "native/target/release/titan_core.dll",
+        "linux": "native/target/release/libtitan_core.so"
+    }
+}

package/packages/core-source/vitest.config.js

@@ -0,0 +1,8 @@
+// vitest.config.ts
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        setupFiles: ['@tgrv/microgravity/setup'],
+    }
+});

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

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

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

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

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

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

package/packages/native/index.d.ts

@@ -31,8 +31,13 @@ export interface ShareContext {
 }
 
 // Add more as needed based on native/index.js
+export interface WebSocketModule {
+    send(socketId: string, message: string): void;
+    broadcast(message: string): void;
+}
+
 export const db: any;
-export const ws: any;
+export const ws: WebSocketModule;
 export const path: any;
 export const jwt: any;
 export const password: any;
@@ -49,3 +54,13 @@ export const time: any;
 export const url: any;
 export const response: any;
 export const valid: any;
+
+// Serialization
+/** Binary-serializes a JavaScript value using V8's fast internal format. */
+export function serialize(value: any): Uint8Array;
+/** Binary-serializes a JavaScript value using V8's fast internal format. Alias for serialize. */
+export function serialise(value: any): Uint8Array;
+/** Deserializes a Uint8Array back into its original JavaScript value/object. */
+export function deserialize(buffer: Uint8Array): any;
+/** Deserializes a Uint8Array back into its original JavaScript value/object. Alias for deserialize. */
+export function deserialise(buffer: Uint8Array): any;

package/packages/native/index.js

@@ -40,4 +40,10 @@ export const url = t.url;
 export const response = t.response;
 export const valid = t.valid;
 
+// Serialization
+export const serialize = t.serialize;
+export const serialise = t.serialise;
+export const deserialize = t.deserialize;
+export const deserialise = t.deserialise;
+
 export const defineAction = (handler) => handler;

package/packages/native/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@titanpl/native",
-  "version": "7.0.0-beta",
+  "version": "7.0.0",
   "description": "Titan native utilities package",
   "type": "module",
   "keywords": [
@@ -20,7 +20,7 @@
     }
   },
   "dependencies": {
-    "@titanpl/core": "latest",
+    "@titanpl/core": "7.0.0",
     "@titanpl/node": "latest"
   }
 }

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

@@ -233,6 +233,34 @@ export const password: typeof t.password;
  */
 export const db: typeof t.db;
 
+/**
+ * WebSocket communication utilities.
+ *
+ * Re-exported from the `t` global for module-style imports.
+ * @see {@link TitanRuntimeUtils.ws} for full documentation.
+ */
+export const ws: typeof t.ws;
+
+/**
+ * Binary serialization using V8's fast format.
+ *
+ * Re-exported from the `t` global for module-style imports.
+ * @see {@link TitanRuntimeUtils.serialize}
+ */
+export const serialize: typeof t.serialize;
+/** Alias for serialize. @see {@link TitanRuntimeUtils.serialise} */
+export const serialise: typeof t.serialise;
+
+/**
+ * Binary deserialization for V8 buffers.
+ *
+ * Re-exported from the `t` global for module-style imports.
+ * @see {@link TitanRuntimeUtils.deserialize}
+ */
+export const deserialize: typeof t.deserialize;
+/** Alias for deserialize. @see {@link TitanRuntimeUtils.deserialise} */
+export const deserialise: typeof t.deserialise;
+
 /**
  * Async file system operations (read, write, mkdir, stat, etc.).
  *
@@ -647,6 +675,55 @@ declare global {
             body?: string;
             error?: string;
         }>;
+        
+        /**
+         * Fast binary serialization using V8's internal value format.
+         *
+         * Highly efficient for complex JavaScript objects including `Date`, `Map`, 
+         * `Set`, and `TypedArrays`. The resulting `Uint8Array` is stable and
+         * can be safely stored in databases (e.g. `t.ls`) or transmitted.
+         *
+         * @param value - The JavaScript value/object to serialize.
+         * @returns A `Uint8Array` containing the binary-serialized representation.
+         *
+         * @example
+         * ```js
+         * const complex = { date: new Date(), map: new Map([["a", 1]]) };
+         * const bytes = t.serialize(complex);
+         * // Store bytes in database or pass to another action
+         * ```
+         */
+        serialize(value: any): Uint8Array;
+
+        /** 
+         * Binary serialization. Alias for `t.serialize`. 
+         * @see {@link TitanRuntimeUtils.serialize}
+         */
+        serialise(value: any): Uint8Array;
+
+        /**
+         * Deserializes a binary buffer back into its original JavaScript value.
+         *
+         * Restores full object fidelity including native types like `Date` and `Buffer`.
+         * Performance is significantly faster than `JSON.parse` for large objects.
+         *
+         * @param buffer - A `Uint8Array` created by `t.serialize()`.
+         * @returns The restored JavaScript value or object.
+         * @throws If the buffer is invalid or contains corrupted V8 header data.
+         *
+         * @example
+         * ```js
+         * const restored = t.deserialize(bytes);
+         * console.log(restored.date instanceof Date); // true
+         * ```
+         */
+        deserialize(buffer: Uint8Array): any;
+
+        /** 
+         * Binary deserialization. Alias for `t.deserialize`. 
+         * @see {@link TitanRuntimeUtils.deserialize}
+         */
+        deserialise(buffer: Uint8Array): any;
 
         /**
          * WebSocket communication utilities.