@holoscript/core 2.0.1 → 2.1.0

package/src/__tests__/integration.test.ts

@@ -1,416 +0,0 @@
-/**
- * HoloScript Integration Tests
- *
- * End-to-end tests that verify the complete pipeline:
- * Parser -> Runtime -> Type Checker -> Debugger
- */
-
-import { describe, it, expect, beforeEach } from 'vitest';
-import { HoloScriptCodeParser } from '../HoloScriptCodeParser';
-import { HoloScriptRuntime } from '../HoloScriptRuntime';
-import { HoloScriptTypeChecker } from '../HoloScriptTypeChecker';
-import { HoloScriptDebugger } from '../HoloScriptDebugger';
-
-describe('HoloScript Integration Tests', () => {
-  let parser: HoloScriptCodeParser;
-  let runtime: HoloScriptRuntime;
-  let typeChecker: HoloScriptTypeChecker;
-
-  beforeEach(() => {
-    parser = new HoloScriptCodeParser();
-    runtime = new HoloScriptRuntime();
-    typeChecker = new HoloScriptTypeChecker();
-  });
-
-  describe('Parser -> Runtime Pipeline', () => {
-    it('should parse and execute a simple orb declaration', async () => {
-      const code = `
-        orb myOrb {
-          name: "TestOrb"
-          color: "#ff0000"
-          glow: true
-        }
-      `;
-
-      const parseResult = parser.parse(code);
-      expect(parseResult.success).toBe(true);
-      expect(parseResult.ast.length).toBeGreaterThan(0);
-
-      const results = await runtime.executeProgram(parseResult.ast);
-      expect(results.length).toBeGreaterThan(0);
-      expect(results[0].success).toBe(true);
-    });
-
-    it('should parse and execute a function definition', async () => {
-      const code = `
-        function greet(name: string): string {
-          return "Hello, " + name
-        }
-      `;
-
-      const parseResult = parser.parse(code);
-      expect(parseResult.success).toBe(true);
-
-      const results = await runtime.executeProgram(parseResult.ast);
-      expect(results[0].success).toBe(true);
-
-      // Call the function
-      const callResult = await runtime.callFunction('greet', ['World']);
-      expect(callResult.success).toBe(true);
-    });
-
-    it('should parse and execute connections between orbs', async () => {
-      const code = `
-        orb source {
-          name: "Source"
-        }
-        orb target {
-          name: "Target"
-        }
-        connect source to target as "data"
-      `;
-
-      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);
-    });
-
-    it('should handle program with multiple orbs', async () => {
-      const code = `
-        orb dataOrb {
-          value: 42
-          name: "DataOrb"
-        }
-
-        orb outputOrb {
-          name: "OutputOrb"
-        }
-      `;
-
-      const parseResult = parser.parse(code);
-      expect(parseResult.success).toBe(true);
-      expect(parseResult.ast.length).toBeGreaterThanOrEqual(2);
-
-      const results = await runtime.executeProgram(parseResult.ast);
-      expect(results.length).toBeGreaterThanOrEqual(2);
-    });
-  });
-
-  describe('Parser -> Type Checker Pipeline', () => {
-    it('should type check orb declarations', () => {
-      const code = `
-        orb typedOrb {
-          count: 10
-          name: "TypedOrb"
-          active: true
-        }
-      `;
-
-      const parseResult = parser.parse(code);
-      expect(parseResult.success).toBe(true);
-
-      const typeResult = typeChecker.check(parseResult.ast);
-      expect(typeResult.valid).toBe(true);
-      expect(typeResult.diagnostics.length).toBe(0);
-    });
-
-    it('should type check function signatures', () => {
-      const code = `
-        function add(a: number, b: number): number {
-          return a + b
-        }
-      `;
-
-      const parseResult = parser.parse(code);
-      expect(parseResult.success).toBe(true);
-
-      const typeResult = typeChecker.check(parseResult.ast);
-      expect(typeResult.valid).toBe(true);
-    });
-
-    it('should detect type information', () => {
-      const code = `
-        const MAX_VALUE = 100
-        let counter = 0
-
-        orb configOrb {
-          limit: MAX_VALUE
-        }
-      `;
-
-      const parseResult = parser.parse(code);
-      expect(parseResult.success).toBe(true);
-
-      const typeResult = typeChecker.check(parseResult.ast);
-      expect(typeResult.typeMap.size).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Full Pipeline: Parse -> Type Check -> Execute', () => {
-    it('should process a complete program through all stages', async () => {
-      const code = `
-        orb sensorOrb {
-          reading: 75
-          name: "Sensor"
-        }
-
-        function checkReading(value: number): boolean {
-          return value > 50
-        }
-      `;
-
-      // Stage 1: Parse
-      const parseResult = parser.parse(code);
-      expect(parseResult.success).toBe(true);
-      expect(parseResult.errors.length).toBe(0);
-
-      // Stage 2: Type Check
-      const typeResult = typeChecker.check(parseResult.ast);
-      expect(typeResult.valid).toBe(true);
-
-      // Stage 3: Execute
-      const execResults = await runtime.executeProgram(parseResult.ast);
-      expect(execResults.every(r => r.success)).toBe(true);
-    });
-  });
-
-  describe('Debugger Integration', () => {
-    it('should load source and set breakpoints', () => {
-      const debugger_ = new HoloScriptDebugger(runtime);
-
-      const code = `
-        orb debugOrb {
-          name: "DebugOrb"
-        }
-
-        function test() {
-          show debugOrb
-        }
-      `;
-
-      const loadResult = debugger_.loadSource(code);
-      expect(loadResult.success).toBe(true);
-
-      const bp = debugger_.setBreakpoint(2);
-      expect(bp.id).toBeDefined();
-      expect(bp.line).toBe(2);
-      expect(bp.enabled).toBe(true);
-
-      const breakpoints = debugger_.getBreakpoints();
-      expect(breakpoints.length).toBe(1);
-    });
-
-    it('should step through execution', async () => {
-      const debugger_ = new HoloScriptDebugger(runtime);
-
-      const code = `
-        orb stepOrb {
-          name: "StepOrb"
-        }
-      `;
-
-      debugger_.loadSource(code);
-
-      // Start and immediately pause
-      await debugger_.start();
-
-      const state = debugger_.getState();
-      expect(state.status).toBeDefined();
-    });
-
-    it('should evaluate expressions in debug context', async () => {
-      const debugger_ = new HoloScriptDebugger(runtime);
-
-      const code = `
-        orb evalOrb {
-          value: 42
-        }
-      `;
-
-      debugger_.loadSource(code);
-      await debugger_.start();
-
-      // Wait for execution to complete
-      const result = await debugger_.evaluate('evalOrb');
-      expect(result).toBeDefined();
-    });
-
-    it('should handle breakpoint events', async () => {
-      const debugger_ = new HoloScriptDebugger(runtime);
-      const events: string[] = [];
-
-      debugger_.on('breakpoint-hit', () => events.push('breakpoint'));
-      debugger_.on('state-change', () => events.push('state'));
-
-      const code = `
-        orb eventOrb {
-          name: "EventOrb"
-        }
-      `;
-
-      debugger_.loadSource(code);
-      debugger_.setBreakpoint(2);
-
-      await debugger_.start();
-
-      // Events should have been captured
-      expect(events.length).toBeGreaterThanOrEqual(0);
-    });
-  });
-
-  describe('Error Handling', () => {
-    it('should handle parse errors gracefully', () => {
-      const code = `
-        orb { invalid syntax here
-      `;
-
-      const parseResult = parser.parse(code);
-      expect(parseResult.success).toBe(false);
-      expect(parseResult.errors.length).toBeGreaterThan(0);
-    });
-
-    it('should handle runtime errors gracefully', async () => {
-      const code = `
-        function errorFunc() {
-          throw "Error"
-        }
-      `;
-
-      const parseResult = parser.parse(code);
-      expect(parseResult.success).toBe(true);
-
-      const results = await runtime.executeProgram(parseResult.ast);
-      // Function definition should succeed
-      expect(results[0].success).toBe(true);
-    });
-
-    it('should handle debugger errors gracefully', async () => {
-      const debugger_ = new HoloScriptDebugger(runtime);
-
-      // Completely invalid syntax that parser will reject
-      const loadResult = debugger_.loadSource('{{{{{{');
-      // Parser may or may not reject this depending on implementation
-      // Just verify we get a result without crashing
-      expect(loadResult).toBeDefined();
-    });
-  });
-
-  describe('Loop Constructs', () => {
-    it('should parse for loops', () => {
-      const code = `
-        for (i = 0; i < 10; i++) {
-          show i
-        }
-      `;
-
-      const parseResult = parser.parse(code);
-      expect(parseResult.success).toBe(true);
-      expect(parseResult.ast[0].type).toBe('for-loop');
-    });
-
-    it.todo('should parse while loops - needs parser enhancement');
-
-    it.todo('should parse forEach loops - needs parser enhancement');
-  });
-
-  describe('Module System', () => {
-    it.todo('should parse import statements - needs parser enhancement');
-
-    it('should parse export statements', () => {
-      const code = `
-        export function helper() {
-          return 42
-        }
-      `;
-
-      const parseResult = parser.parse(code);
-      expect(parseResult.success).toBe(true);
-      expect(parseResult.ast[0].type).toBe('export');
-    });
-
-    it('should parse variable declarations', () => {
-      const code = `
-        const MAX = 100
-        let count = 0
-        var legacy = true
-      `;
-
-      const parseResult = parser.parse(code);
-      expect(parseResult.success).toBe(true);
-      expect(parseResult.ast.length).toBe(3);
-      expect(parseResult.ast[0].type).toBe('variable-declaration');
-    });
-  });
-
-  describe('Runtime Context', () => {
-    it('should maintain variable state across executions', async () => {
-      const code1 = `
-        orb stateOrb {
-          counter: 0
-        }
-      `;
-
-      const parseResult1 = parser.parse(code1);
-      await runtime.executeProgram(parseResult1.ast);
-
-      // Context should exist after execution
-      const context = runtime.getContext();
-      expect(context).toBeDefined();
-      expect(context.variables).toBeDefined();
-    });
-
-    it('should support function calls with arguments', async () => {
-      const code = `
-        function multiply(a: number, b: number): number {
-          return a * b
-        }
-      `;
-
-      const parseResult = parser.parse(code);
-      await runtime.executeProgram(parseResult.ast);
-
-      const result = await runtime.callFunction('multiply', [5, 3]);
-      expect(result.success).toBe(true);
-    });
-
-    it('should reset context on runtime reset', async () => {
-      const code = `
-        orb tempOrb {
-          name: "Temporary"
-        }
-      `;
-
-      const parseResult = parser.parse(code);
-      await runtime.executeProgram(parseResult.ast);
-
-      const contextBefore = runtime.getContext();
-      expect(contextBefore).toBeDefined();
-
-      runtime.reset();
-
-      const contextAfter = runtime.getContext();
-      // After reset, variables should be empty
-      expect(contextAfter.variables.size).toBe(0);
-    });
-  });
-});
-
-describe('HoloScript Bridge Integration', () => {
-  // These tests would require the Hololand bridge
-  // Stubbed for now - would need mock world interface
-
-  it.skip('should sync orbs to world objects', async () => {
-    // Would test HoloScriptBridge.loadScript -> world.createObject
-  });
-
-  it.skip('should handle world events', async () => {
-    // Would test world.emit -> bridge event handling
-  });
-
-  it.skip('should sync runtime state to world', async () => {
-    // Would test bridge.sync() updating world objects
-  });
-});

package/src/__tests__/performance.bench.js

@@ -1,218 +0,0 @@
-/**
- * HoloScript Performance Benchmarks
- *
- * Measures parsing, execution, and type checking performance.
- * Run with: npx vitest bench
- */
-import { describe, bench, beforeAll } from 'vitest';
-import { HoloScriptCodeParser } from '../HoloScriptCodeParser';
-import { HoloScriptRuntime } from '../HoloScriptRuntime';
-import { HoloScriptTypeChecker } from '../HoloScriptTypeChecker';
-// Test data
-const SIMPLE_ORB = `
-orb testOrb {
-  name: "TestOrb"
-  color: "#ff0000"
-  glow: true
-}
-`;
-const MULTIPLE_ORBS = Array.from({ length: 10 }, (_, i) => `
-orb orb${i} {
-  name: "Orb${i}"
-  color: "#${i.toString(16).padStart(6, '0')}"
-  value: ${i * 10}
-}
-`).join('\n');
-const COMPLEX_PROGRAM = `
-orb dataSource {
-  name: "DataSource"
-  rate: 100
-}
-
-orb processor {
-  name: "Processor"
-  capacity: 1000
-}
-
-orb output {
-  name: "Output"
-  format: "json"
-}
-
-function processData(input: number): number {
-  return input * 2
-}
-
-function validateInput(data: object): boolean {
-  return true
-}
-
-connect dataSource to processor as "raw"
-connect processor to output as "processed"
-`;
-const FUNCTIONS_PROGRAM = Array.from({ length: 20 }, (_, i) => `
-function func${i}(x: number): number {
-  return x + ${i}
-}
-`).join('\n');
-describe('Parser Performance', () => {
-    let parser;
-    beforeAll(() => {
-        parser = new HoloScriptCodeParser();
-    });
-    bench('parse simple orb', () => {
-        parser.parse(SIMPLE_ORB);
-    });
-    bench('parse 10 orbs', () => {
-        parser.parse(MULTIPLE_ORBS);
-    });
-    bench('parse complex program', () => {
-        parser.parse(COMPLEX_PROGRAM);
-    });
-    bench('parse 20 functions', () => {
-        parser.parse(FUNCTIONS_PROGRAM);
-    });
-    bench('tokenize simple orb', () => {
-        // @ts-expect-error - accessing private method for benchmark
-        parser.tokenize(SIMPLE_ORB);
-    });
-    bench('tokenize complex program', () => {
-        // @ts-expect-error - accessing private method for benchmark
-        parser.tokenize(COMPLEX_PROGRAM);
-    });
-});
-describe('Runtime Performance', () => {
-    let parser;
-    let runtime;
-    let simpleAST;
-    let complexAST;
-    beforeAll(() => {
-        parser = new HoloScriptCodeParser();
-        runtime = new HoloScriptRuntime();
-        const simpleResult = parser.parse(SIMPLE_ORB);
-        simpleAST = simpleResult.ast;
-        const complexResult = parser.parse(COMPLEX_PROGRAM);
-        complexAST = complexResult.ast;
-    });
-    bench('execute simple orb', async () => {
-        runtime.reset();
-        await runtime.executeProgram(simpleAST);
-    });
-    bench('execute complex program', async () => {
-        runtime.reset();
-        await runtime.executeProgram(complexAST);
-    });
-    bench('execute single node', async () => {
-        if (simpleAST.length > 0) {
-            await runtime.executeNode(simpleAST[0]);
-        }
-    });
-    bench('runtime reset', () => {
-        runtime.reset();
-    });
-    bench('get context', () => {
-        runtime.getContext();
-    });
-    bench('set/get variable', () => {
-        runtime.setVariable('benchVar', 42);
-        runtime.getVariable('benchVar');
-    });
-});
-describe('Type Checker Performance', () => {
-    let parser;
-    let typeChecker;
-    let simpleAST;
-    let complexAST;
-    let functionsAST;
-    beforeAll(() => {
-        parser = new HoloScriptCodeParser();
-        typeChecker = new HoloScriptTypeChecker();
-        const simpleResult = parser.parse(SIMPLE_ORB);
-        simpleAST = simpleResult.ast;
-        const complexResult = parser.parse(COMPLEX_PROGRAM);
-        complexAST = complexResult.ast;
-        const functionsResult = parser.parse(FUNCTIONS_PROGRAM);
-        functionsAST = functionsResult.ast;
-    });
-    bench('type check simple orb', () => {
-        typeChecker.check(simpleAST);
-    });
-    bench('type check complex program', () => {
-        typeChecker.check(complexAST);
-    });
-    bench('type check 20 functions', () => {
-        typeChecker.check(functionsAST);
-    });
-    bench('get all types', () => {
-        typeChecker.check(complexAST);
-        typeChecker.getAllTypes();
-    });
-});
-describe('Full Pipeline Performance', () => {
-    let parser;
-    let runtime;
-    let typeChecker;
-    beforeAll(() => {
-        parser = new HoloScriptCodeParser();
-        runtime = new HoloScriptRuntime();
-        typeChecker = new HoloScriptTypeChecker();
-    });
-    bench('full pipeline: parse -> type check -> execute (simple)', async () => {
-        const parseResult = parser.parse(SIMPLE_ORB);
-        typeChecker.check(parseResult.ast);
-        runtime.reset();
-        await runtime.executeProgram(parseResult.ast);
-    });
-    bench('full pipeline: parse -> type check -> execute (complex)', async () => {
-        const parseResult = parser.parse(COMPLEX_PROGRAM);
-        typeChecker.check(parseResult.ast);
-        runtime.reset();
-        await runtime.executeProgram(parseResult.ast);
-    });
-    bench('parse only (no execution)', () => {
-        parser.parse(COMPLEX_PROGRAM);
-    });
-});
-describe('Memory and Scalability', () => {
-    let parser;
-    let runtime;
-    beforeAll(() => {
-        parser = new HoloScriptCodeParser();
-        runtime = new HoloScriptRuntime();
-    });
-    bench('parse 100 orbs', () => {
-        const largeProgram = Array.from({ length: 100 }, (_, i) => `
-      orb orb${i} {
-        name: "Orb${i}"
-        value: ${i}
-      }
-    `).join('\n');
-        parser.parse(largeProgram);
-    });
-    bench('execute 50 orbs', async () => {
-        const program = Array.from({ length: 50 }, (_, i) => `
-      orb orb${i} {
-        name: "Orb${i}"
-      }
-    `).join('\n');
-        const result = parser.parse(program);
-        runtime.reset();
-        await runtime.executeProgram(result.ast);
-    });
-    bench('many connections', () => {
-        const program = `
-      orb source { name: "Source" }
-      orb a { name: "A" }
-      orb b { name: "B" }
-      orb c { name: "C" }
-      orb d { name: "D" }
-      orb target { name: "Target" }
-      connect source to a as "data"
-      connect a to b as "data"
-      connect b to c as "data"
-      connect c to d as "data"
-      connect d to target as "data"
-    `;
-        parser.parse(program);
-    });
-});