@holoscript/core 1.0.0-alpha.2 → 2.0.1

package/src/HoloScriptRuntime.test.js

@@ -0,0 +1,351 @@
+/**
+ * HoloScript Runtime Tests
+ *
+ * Comprehensive test suite for the HoloScript runtime engine.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { HoloScriptRuntime } from './HoloScriptRuntime';
+import { HoloScriptCodeParser } from './HoloScriptCodeParser';
+describe('HoloScriptRuntime', () => {
+    let runtime;
+    let parser;
+    beforeEach(() => {
+        runtime = new HoloScriptRuntime();
+        parser = new HoloScriptCodeParser();
+    });
+    describe('Basic Execution', () => {
+        it('should create an orb', async () => {
+            const orbNode = {
+                type: 'orb',
+                name: 'testOrb',
+                properties: { message: 'Hello World' },
+                methods: [],
+                position: { x: 1, y: 2, z: 3 },
+                hologram: { shape: 'orb', color: '#00ffff', size: 1, glow: true, interactive: true },
+            };
+            const result = await runtime.executeNode(orbNode);
+            expect(result.success).toBe(true);
+            expect(result.output).toBeDefined();
+            expect(result.spatialPosition).toEqual({ x: 1, y: 2, z: 3 });
+        });
+        it('should define a function', async () => {
+            const funcNode = {
+                type: 'method',
+                name: 'testFunc',
+                parameters: [{ type: 'parameter', name: 'x', dataType: 'number' }],
+                body: [],
+                position: { x: 0, y: 0, z: 0 },
+            };
+            const result = await runtime.executeNode(funcNode);
+            expect(result.success).toBe(true);
+            expect(result.output).toContain('testFunc');
+        });
+        it('should create a connection', async () => {
+            // First create two orbs
+            const orb1 = { type: 'orb', name: 'source', properties: {}, methods: [], position: { x: 0, y: 0, z: 0 } };
+            const orb2 = { type: 'orb', name: 'target', properties: {}, methods: [], position: { x: 5, y: 0, z: 0 } };
+            await runtime.executeNode(orb1);
+            await runtime.executeNode(orb2);
+            const connNode = {
+                type: 'connection',
+                from: 'source',
+                to: 'target',
+                dataType: 'number',
+                bidirectional: false,
+            };
+            const result = await runtime.executeNode(connNode);
+            expect(result.success).toBe(true);
+            expect(result.output).toContain('source');
+            expect(result.output).toContain('target');
+        });
+    });
+    describe('Expression Evaluation', () => {
+        it('should evaluate number literals', () => {
+            expect(runtime.evaluateExpression('42')).toBe(42);
+            expect(runtime.evaluateExpression('-3.14')).toBe(-3.14);
+            expect(runtime.evaluateExpression('0')).toBe(0);
+        });
+        it('should evaluate string literals', () => {
+            expect(runtime.evaluateExpression('"hello"')).toBe('hello');
+            expect(runtime.evaluateExpression("'world'")).toBe('world');
+        });
+        it('should evaluate boolean literals', () => {
+            expect(runtime.evaluateExpression('true')).toBe(true);
+            expect(runtime.evaluateExpression('false')).toBe(false);
+        });
+        it('should evaluate array literals', () => {
+            expect(runtime.evaluateExpression('[]')).toEqual([]);
+            expect(runtime.evaluateExpression('[1, 2, 3]')).toEqual([1, 2, 3]);
+            expect(runtime.evaluateExpression('["a", "b"]')).toEqual(['a', 'b']);
+        });
+        it('should evaluate object literals', () => {
+            expect(runtime.evaluateExpression('{}')).toEqual({});
+            expect(runtime.evaluateExpression('{x: 1, y: 2}')).toEqual({ x: 1, y: 2 });
+        });
+        it('should evaluate arithmetic operations', () => {
+            runtime.setVariable('a', 10);
+            runtime.setVariable('b', 3);
+            expect(runtime.evaluateExpression('a + b')).toBe(13);
+            expect(runtime.evaluateExpression('a - b')).toBe(7);
+            expect(runtime.evaluateExpression('a * b')).toBe(30);
+            expect(runtime.evaluateExpression('a / b')).toBeCloseTo(3.33, 1);
+        });
+    });
+    describe('Built-in Functions', () => {
+        it('should execute math functions', async () => {
+            const result1 = await runtime.callFunction('add', [5, 3]);
+            expect(result1.success).toBe(true);
+            expect(result1.output).toBe(8);
+            const result2 = await runtime.callFunction('multiply', [4, 7]);
+            expect(result2.success).toBe(true);
+            expect(result2.output).toBe(28);
+            const result3 = await runtime.callFunction('abs', [-42]);
+            expect(result3.success).toBe(true);
+            expect(result3.output).toBe(42);
+        });
+        it('should execute string functions', async () => {
+            const result1 = await runtime.callFunction('concat', ['Hello', ' ', 'World']);
+            expect(result1.success).toBe(true);
+            expect(result1.output).toBe('Hello World');
+            const result2 = await runtime.callFunction('uppercase', ['test']);
+            expect(result2.success).toBe(true);
+            expect(result2.output).toBe('TEST');
+            const result3 = await runtime.callFunction('length', ['hello']);
+            expect(result3.success).toBe(true);
+            expect(result3.output).toBe(5);
+        });
+        it('should execute array functions', async () => {
+            const arr = [1, 2, 3];
+            const result1 = await runtime.callFunction('push', [arr, 4]);
+            expect(result1.success).toBe(true);
+            expect(result1.output).toEqual([1, 2, 3, 4]);
+            const result2 = await runtime.callFunction('length', [[1, 2, 3, 4, 5]]);
+            expect(result2.success).toBe(true);
+            expect(result2.output).toBe(5);
+        });
+        it('should execute type checking functions', async () => {
+            expect((await runtime.callFunction('isNumber', [42])).output).toBe(true);
+            expect((await runtime.callFunction('isNumber', ['hello'])).output).toBe(false);
+            expect((await runtime.callFunction('isString', ['hello'])).output).toBe(true);
+            expect((await runtime.callFunction('isArray', [[1, 2, 3]])).output).toBe(true);
+        });
+    });
+    describe('Variable Scoping', () => {
+        it('should set and get variables', () => {
+            runtime.setVariable('x', 100);
+            expect(runtime.getVariable('x')).toBe(100);
+            runtime.setVariable('y', 'hello');
+            expect(runtime.getVariable('y')).toBe('hello');
+        });
+        it('should handle nested property access', () => {
+            runtime.setVariable('obj', { nested: { value: 42 } });
+            expect(runtime.getVariable('obj.nested.value')).toBe(42);
+        });
+        it('should set nested properties', () => {
+            runtime.setVariable('data.x', 10);
+            runtime.setVariable('data.y', 20);
+            expect(runtime.getVariable('data')).toEqual({ x: 10, y: 20 });
+        });
+    });
+    describe('Gate Execution', () => {
+        it('should execute true path when condition is true', async () => {
+            runtime.setVariable('value', 10);
+            const gateNode = {
+                type: 'gate',
+                condition: 'value > 5',
+                truePath: [],
+                falsePath: [],
+                position: { x: 0, y: 0, z: 0 },
+            };
+            const result = await runtime.executeNode(gateNode);
+            expect(result.success).toBe(true);
+            expect(result.output).toContain('true');
+        });
+        it('should execute false path when condition is false', async () => {
+            runtime.setVariable('value', 3);
+            const gateNode = {
+                type: 'gate',
+                condition: 'value > 5',
+                truePath: [],
+                falsePath: [],
+                position: { x: 0, y: 0, z: 0 },
+            };
+            const result = await runtime.executeNode(gateNode);
+            expect(result.success).toBe(true);
+            expect(result.output).toContain('false');
+        });
+        it('should handle boolean literals in conditions', async () => {
+            const trueGate = {
+                type: 'gate',
+                condition: 'true',
+                truePath: [],
+                falsePath: [],
+            };
+            const falseGate = {
+                type: 'gate',
+                condition: 'false',
+                truePath: [],
+                falsePath: [],
+            };
+            const result1 = await runtime.executeNode(trueGate);
+            expect(result1.output).toContain('true');
+            const result2 = await runtime.executeNode(falseGate);
+            expect(result2.output).toContain('false');
+        });
+        it('should handle comparison operators', async () => {
+            runtime.setVariable('a', 5);
+            runtime.setVariable('b', 5);
+            const tests = [
+                { condition: 'a == b', expected: true },
+                { condition: 'a != b', expected: false },
+                { condition: 'a >= b', expected: true },
+                { condition: 'a <= b', expected: true },
+                { condition: 'a > b', expected: false },
+                { condition: 'a < b', expected: false },
+            ];
+            for (const { condition, expected } of tests) {
+                const gate = { type: 'gate', condition, truePath: [], falsePath: [] };
+                const result = await runtime.executeNode(gate);
+                expect(result.output).toContain(expected ? 'true' : 'false');
+            }
+        });
+    });
+    describe('Stream Execution', () => {
+        it('should process stream with transformations', async () => {
+            runtime.setVariable('numbers', [1, 2, 3, 4, 5]);
+            const streamNode = {
+                type: 'stream',
+                name: 'testStream',
+                source: 'numbers',
+                transformations: [
+                    { type: 'transformation', operation: 'sum', parameters: {} },
+                ],
+                position: { x: 0, y: 0, z: 0 },
+            };
+            const result = await runtime.executeNode(streamNode);
+            expect(result.success).toBe(true);
+            expect(runtime.getVariable('testStream_result')).toBe(15);
+        });
+        it('should handle multiple transformations', async () => {
+            runtime.setVariable('data', [5, 3, 8, 1, 9]);
+            const streamNode = {
+                type: 'stream',
+                name: 'multiStream',
+                source: 'data',
+                transformations: [
+                    { type: 'transformation', operation: 'sort', parameters: {} },
+                    { type: 'transformation', operation: 'take', parameters: { count: 3 } },
+                ],
+                position: { x: 0, y: 0, z: 0 },
+            };
+            const result = await runtime.executeNode(streamNode);
+            expect(result.success).toBe(true);
+            expect(runtime.getVariable('multiStream_result')).toEqual([1, 3, 5]);
+        });
+    });
+    describe('Event System', () => {
+        it('should register and emit events', async () => {
+            let eventFired = false;
+            let eventData = null;
+            runtime.on('test.event', (data) => {
+                eventFired = true;
+                eventData = data;
+            });
+            await runtime.emit('test.event', { value: 42 });
+            expect(eventFired).toBe(true);
+            expect(eventData).toEqual({ value: 42 });
+        });
+        it('should remove event handlers', async () => {
+            let count = 0;
+            const handler = () => { count++; };
+            runtime.on('counter', handler);
+            await runtime.emit('counter');
+            expect(count).toBe(1);
+            runtime.off('counter', handler);
+            await runtime.emit('counter');
+            expect(count).toBe(1); // Should not increment
+        });
+    });
+    describe('Code Parser Integration', () => {
+        it('should parse and execute orb declaration', async () => {
+            const code = `
+        orb greeting {
+          message: "Hello"
+          color: "#ff0000"
+        }
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            expect(parseResult.ast.length).toBe(1);
+            const results = await runtime.executeProgram(parseResult.ast);
+            expect(results[0].success).toBe(true);
+        });
+        it('should parse and execute function declaration', async () => {
+            const code = `
+        function greet(name: string): string {
+          return name
+        }
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            const results = await runtime.executeProgram(parseResult.ast);
+            expect(results[0].success).toBe(true);
+            const context = runtime.getContext();
+            expect(context.functions.has('greet')).toBe(true);
+        });
+        it('should parse and execute connection', async () => {
+            const code = `
+        orb source { value: 10 }
+        orb target { value: 0 }
+        connect source to target as "number"
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            expect(parseResult.ast.length).toBe(3);
+            const results = await runtime.executeProgram(parseResult.ast);
+            expect(results.every(r => r.success)).toBe(true);
+            const context = runtime.getContext();
+            expect(context.connections.length).toBe(1);
+        });
+    });
+    describe('Security', () => {
+        it('should block suspicious keywords in expressions', () => {
+            expect(runtime.evaluateExpression('eval("1+1")')).toBeUndefined();
+            expect(runtime.evaluateExpression('process.exit()')).toBeUndefined();
+            expect(runtime.evaluateExpression('require("fs")')).toBeUndefined();
+        });
+        it('should respect execution limits', async () => {
+            // Create a very deep recursion scenario
+            const nodes = Array(2000).fill(null).map((_, i) => ({
+                type: 'orb',
+                name: `orb${i}`,
+                properties: {},
+                methods: [],
+            }));
+            const results = await runtime.executeProgram(nodes);
+            // Should have stopped before completing all
+            const lastResult = results[results.length - 1];
+            expect(lastResult.error).toContain('Max total nodes exceeded');
+        });
+    });
+    describe('Reset', () => {
+        it('should clear all state on reset', async () => {
+            // Set up some state
+            runtime.setVariable('x', 100);
+            await runtime.executeNode({
+                type: 'orb',
+                name: 'testOrb',
+                properties: {},
+                methods: [],
+            });
+            runtime.on('test', () => { });
+            // Reset
+            runtime.reset();
+            // Verify state is cleared
+            expect(runtime.getVariable('x')).toBeUndefined();
+            expect(runtime.getContext().variables.size).toBe(0);
+            expect(runtime.getContext().functions.size).toBe(0);
+            expect(runtime.getExecutionHistory()).toHaveLength(0);
+        });
+    });
+});

package/src/HoloScriptRuntime.ts

@@ -31,6 +31,7 @@ import type {
   TransformationNode,
   UI2DNode,
 } from './types';
+import type { ImportLoader } from './types';
 
 const RUNTIME_SECURITY_LIMITS = {
   maxExecutionDepth: 50,
@@ -96,7 +97,7 @@ export class HoloScriptRuntime {
   private uiElements: Map<string, UIElementState> = new Map();
   private builtinFunctions: Map<string, (args: unknown[]) => unknown>;
 
-  constructor() {
+  constructor(_importLoader?: ImportLoader) {
     this.context = this.createEmptyContext();
     this.currentScope = { variables: this.context.variables };
     this.builtinFunctions = this.initBuiltins();
@@ -320,6 +321,9 @@ export class HoloScriptRuntime {
         case 'generic':
           result = await this.executeGeneric(node);
           break;
+        case 'expression-statement':
+          result = await this.executeCall(node);
+          break;
         default:
           result = {
             success: false,
@@ -543,7 +547,16 @@ export class HoloScriptRuntime {
     }
 
     // Check context variables
-    return this.context.variables.get(name);
+    if (this.context.variables.has(name)) {
+      return this.context.variables.get(name);
+    }
+
+    // Fallback to functions map (for imported functions)
+    if (this.context.functions.has(name)) {
+      return this.context.functions.get(name);
+    }
+
+    return undefined;
   }
 
   /**
@@ -625,7 +638,7 @@ export class HoloScriptRuntime {
 
     // Binary operations: a + b, a - b, etc.
     const binaryOps = [
-      { pattern: /(.+)\s*\+\s*(.+)/, op: (a: unknown, b: unknown) => Number(a) + Number(b) },
+      { pattern: /(.+)\s*\+\s*(.+)/, op: (a: unknown, b: unknown) => (typeof a === 'string' || typeof b === 'string') ? String(a) + String(b) : Number(a) + Number(b) },
       { pattern: /(.+)\s*-\s*(.+)/, op: (a: unknown, b: unknown) => Number(a) - Number(b) },
       { pattern: /(.+)\s*\*\s*(.+)/, op: (a: unknown, b: unknown) => Number(a) * Number(b) },
       { pattern: /(.+)\s*\/\s*(.+)/, op: (a: unknown, b: unknown) => Number(b) !== 0 ? Number(a) / Number(b) : 0 },
@@ -1618,6 +1631,7 @@ export class HoloScriptRuntime {
     return {
       variables: new Map(),
       functions: new Map(),
+      exports: new Map(),
       connections: [],
       spatialMemory: new Map(),
       hologramState: new Map(),