@viewscript/renderer 0.1.0-20260515014709 → 0.1.0-20260515015849

package/dist/runtime/__tests__/wasm-solver-bridge.test.js

@@ -1,214 +0,0 @@
-/**
- * Tests for WASM Solver Bridge
- *
- * Validates:
- * 1. QSnapshot construction from mutations + FFI results
- * 2. WASM tick() delegation and result parsing
- * 3. FFI result injection lifecycle
- */
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { WasmSolverBridge, createWasmSolverBridge, } from '../wasm-solver-bridge.js';
-// =============================================================================
-// Mock WASM Engine
-// =============================================================================
-function createMockEngine() {
-    return {
-        lastInput: null,
-        tick(inputJson) {
-            this.lastInput = inputJson;
-            return JSON.stringify({ pending_ffi_calls: [] });
-        },
-    };
-}
-function createMockEngineWithCalls(calls) {
-    return {
-        tick() {
-            return JSON.stringify({ pending_ffi_calls: calls });
-        },
-    };
-}
-// =============================================================================
-// Tests
-// =============================================================================
-describe('WasmSolverBridge', () => {
-    let bridge;
-    let mockEngine;
-    beforeEach(() => {
-        mockEngine = createMockEngine();
-        bridge = createWasmSolverBridge(mockEngine);
-    });
-    // ===========================================================================
-    // Basic Evaluation
-    // ===========================================================================
-    describe('evaluate', () => {
-        it('calls engine.tick() with QSnapshot JSON', () => {
-            const mutations = [];
-            bridge.evaluate(mutations);
-            expect(mockEngine.lastInput).not.toBeNull();
-            const snapshot = JSON.parse(mockEngine.lastInput);
-            expect(snapshot).toHaveProperty('values');
-            expect(snapshot).toHaveProperty('mutations');
-        });
-        it('returns empty bounds and pendingFfiCalls by default', () => {
-            const result = bridge.evaluate([]);
-            expect(result.bounds.size).toBe(0);
-            expect(result.pendingFfiCalls).toEqual([]);
-        });
-        it('extracts pendingFfiCalls from tick result', () => {
-            const calls = [{ ffi_id: 1, args: [1, 2, 3] }];
-            bridge = createWasmSolverBridge(createMockEngineWithCalls(calls));
-            const result = bridge.evaluate([]);
-            expect(result.pendingFfiCalls).toEqual(calls);
-        });
-    });
-    // ===========================================================================
-    // Mutation Conversion
-    // ===========================================================================
-    describe('mutation conversion', () => {
-        it('converts TStateMutation to QSnapshot values', () => {
-            const mutations = [
-                { entityId: 1, state: 'hover', value: 1, timestamp: 100 },
-                { entityId: 2, state: 'scroll_y', value: 0.5, timestamp: 100 },
-            ];
-            bridge.evaluate(mutations);
-            const snapshot = JSON.parse(mockEngine.lastInput);
-            expect(snapshot.values['1_hover']).toEqual({ type: 'float', value: 1 });
-            expect(snapshot.values['2_scroll_y']).toEqual({ type: 'float', value: 0.5 });
-        });
-        it('includes mutations array for legacy format', () => {
-            const mutations = [
-                { entityId: 1, state: 'pressed', value: 1, timestamp: 100 },
-            ];
-            bridge.evaluate(mutations);
-            const snapshot = JSON.parse(mockEngine.lastInput);
-            expect(snapshot.mutations).toHaveLength(1);
-            expect(snapshot.mutations[0]).toMatchObject({
-                entity_id: 1,
-                state: 'pressed',
-                value: 1,
-            });
-        });
-    });
-    // ===========================================================================
-    // FFI Result Injection
-    // ===========================================================================
-    describe('injectFfiResults', () => {
-        it('includes injected FFI results in QSnapshot values', () => {
-            const ffiResults = [
-                { name: 'clamped_opacity', value: 0.75, timestamp: 100 },
-                { name: 'distance', value: 42, timestamp: 100 },
-            ];
-            bridge.injectFfiResults(ffiResults);
-            bridge.evaluate([]);
-            const snapshot = JSON.parse(mockEngine.lastInput);
-            expect(snapshot.values['clamped_opacity']).toEqual({ type: 'float', value: 0.75 });
-            expect(snapshot.values['distance']).toEqual({ type: 'float', value: 42 });
-        });
-        it('clears FFI results after evaluate()', () => {
-            bridge.injectFfiResults([{ name: 'test', value: 1, timestamp: 100 }]);
-            // First evaluate includes FFI result
-            bridge.evaluate([]);
-            let snapshot = JSON.parse(mockEngine.lastInput);
-            expect(snapshot.values['test']).toBeDefined();
-            // Second evaluate should NOT include FFI result
-            bridge.evaluate([]);
-            snapshot = JSON.parse(mockEngine.lastInput);
-            expect(snapshot.values['test']).toBeUndefined();
-        });
-        it('FFI results override mutation values with same name', () => {
-            // This tests the merge order: FFI results come first, then mutations
-            // If there's a naming collision, the mutation should win
-            const ffiResults = [
-                { name: '1_hover', value: 0.5, timestamp: 100 },
-            ];
-            const mutations = [
-                { entityId: 1, state: 'hover', value: 1, timestamp: 100 },
-            ];
-            bridge.injectFfiResults(ffiResults);
-            bridge.evaluate(mutations);
-            const snapshot = JSON.parse(mockEngine.lastInput);
-            // Mutation overwrites FFI result (processed later)
-            expect(snapshot.values['1_hover'].value).toBe(1);
-        });
-    });
-    // ===========================================================================
-    // Error Handling
-    // ===========================================================================
-    describe('error handling', () => {
-        it('handles engine.tick() throwing', () => {
-            const errorEngine = {
-                tick() {
-                    throw new Error('WASM panic');
-                },
-            };
-            bridge = createWasmSolverBridge(errorEngine);
-            const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-            const result = bridge.evaluate([]);
-            expect(result.bounds.size).toBe(0);
-            expect(result.pendingFfiCalls).toEqual([]);
-            expect(errorSpy).toHaveBeenCalled();
-            errorSpy.mockRestore();
-        });
-        it('preserves FFI results when tick() throws for next frame retry', () => {
-            let callCount = 0;
-            const flakyEngine = {
-                lastInput: null,
-                tick(inputJson) {
-                    callCount++;
-                    if (callCount === 1) {
-                        throw new Error('Transient WASM error');
-                    }
-                    this.lastInput = inputJson;
-                    return JSON.stringify({ pending_ffi_calls: [] });
-                },
-            };
-            bridge = createWasmSolverBridge(flakyEngine);
-            const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-            // Inject FFI results
-            bridge.injectFfiResults([{ name: 'important_value', value: 42, timestamp: 100 }]);
-            // First evaluate fails - FFI results should be preserved
-            bridge.evaluate([]);
-            expect(errorSpy).toHaveBeenCalled();
-            // Second evaluate succeeds - FFI results should still be included
-            bridge.evaluate([]);
-            const snapshot = JSON.parse(flakyEngine.lastInput);
-            expect(snapshot.values['important_value']).toEqual({ type: 'float', value: 42 });
-            errorSpy.mockRestore();
-        });
-        it('handles invalid JSON from tick()', () => {
-            const badEngine = {
-                tick() {
-                    return 'not valid json';
-                },
-            };
-            bridge = createWasmSolverBridge(badEngine);
-            const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-            const result = bridge.evaluate([]);
-            expect(result.pendingFfiCalls).toEqual([]);
-            expect(errorSpy).toHaveBeenCalled();
-            errorSpy.mockRestore();
-        });
-        it('handles missing pending_ffi_calls in result', () => {
-            const partialEngine = {
-                tick() {
-                    return JSON.stringify({}); // No pending_ffi_calls field
-                },
-            };
-            bridge = createWasmSolverBridge(partialEngine);
-            const result = bridge.evaluate([]);
-            expect(result.pendingFfiCalls).toEqual([]);
-        });
-    });
-    // ===========================================================================
-    // Factory Function
-    // ===========================================================================
-    describe('createWasmSolverBridge', () => {
-        it('creates a new instance', () => {
-            const engine = createMockEngine();
-            const b1 = createWasmSolverBridge(engine);
-            const b2 = createWasmSolverBridge(engine);
-            expect(b1).not.toBe(b2);
-            expect(b1).toBeInstanceOf(WasmSolverBridge);
-        });
-    });
-});

package/dist/semantic/__tests__/semantic-translator.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Tests for SemanticTranslator (Phase 7: Task 20)
- */
-export {};

package/dist/semantic/__tests__/semantic-translator.test.js

@@ -1,203 +0,0 @@
-/**
- * Tests for SemanticTranslator (Phase 7: Task 20)
- */
-import { describe, it, expect } from 'vitest';
-import { SemanticTranslator, createEntityRegistry, createEmptyRegistry, } from '../semantic-translator';
-describe('SemanticTranslator', () => {
-    describe('parseVarId', () => {
-        it('should parse valid VarId keys', () => {
-            const translator = new SemanticTranslator(createEmptyRegistry());
-            expect(translator.parseVarId('1:x')).toEqual({ entityId: 1, component: 'x' });
-            expect(translator.parseVarId('42:y')).toEqual({ entityId: 42, component: 'y' });
-            expect(translator.parseVarId('100:value')).toEqual({ entityId: 100, component: 'value' });
-            expect(translator.parseVarId('5:r')).toEqual({ entityId: 5, component: 'r' });
-            expect(translator.parseVarId('5:alpha')).toEqual({ entityId: 5, component: 'alpha' });
-        });
-        it('should return null for invalid keys', () => {
-            const translator = new SemanticTranslator(createEmptyRegistry());
-            expect(translator.parseVarId('')).toBeNull();
-            expect(translator.parseVarId('invalid')).toBeNull();
-            expect(translator.parseVarId(':x')).toBeNull();
-            expect(translator.parseVarId('1:')).toBeNull();
-            expect(translator.parseVarId('1:unknown_component')).toBeNull();
-            expect(translator.parseVarId('abc:x')).toBeNull();
-        });
-    });
-    describe('parseRationalToFloat', () => {
-        it('should parse rational strings', () => {
-            const translator = new SemanticTranslator(createEmptyRegistry());
-            expect(translator.parseRationalToFloat('100/1')).toBe(100);
-            expect(translator.parseRationalToFloat('1/2')).toBe(0.5);
-            expect(translator.parseRationalToFloat('100')).toBe(100);
-            expect(translator.parseRationalToFloat('-50/1')).toBe(-50);
-            expect(translator.parseRationalToFloat('1/3')).toBeCloseTo(0.333, 2);
-        });
-        it('should handle zero denominator', () => {
-            const translator = new SemanticTranslator(createEmptyRegistry());
-            expect(translator.parseRationalToFloat('1/0')).toBeNaN();
-        });
-    });
-    describe('translateSolution', () => {
-        it('should translate a simple point solution', () => {
-            const registry = createEntityRegistry([
-                { entityId: 1, type: 'point', name: 'P1' },
-            ]);
-            const translator = new SemanticTranslator(registry);
-            const rawSolution = new Map([
-                ['1:x', '100/1'],
-                ['1:y', '200/1'],
-            ]);
-            const result = translator.translateSolution(rawSolution, 0);
-            expect(result.solutionIndex).toBe(0);
-            expect(result.entities).toHaveLength(1);
-            expect(result.entities[0].entityId).toBe(1);
-            expect(result.entities[0].type).toBe('point');
-            expect(result.entities[0].coordinates?.x).toBe(100);
-            expect(result.entities[0].coordinates?.y).toBe(200);
-            expect(result.entities[0].description).toContain('P1');
-            expect(result.entities[0].description).toContain('100');
-            expect(result.entities[0].description).toContain('200');
-        });
-        it('should translate multiple entities', () => {
-            const registry = createEntityRegistry([
-                { entityId: 1, type: 'point', name: 'Start' },
-                { entityId: 2, type: 'point', name: 'End' },
-                { entityId: 3, type: 'control_point', name: 'CP1' },
-            ]);
-            const translator = new SemanticTranslator(registry);
-            const rawSolution = new Map([
-                ['1:x', '0/1'],
-                ['1:y', '0/1'],
-                ['2:x', '100/1'],
-                ['2:y', '0/1'],
-                ['3:x', '50/1'],
-                ['3:y', '50/1'],
-            ]);
-            const result = translator.translateSolution(rawSolution, 0);
-            expect(result.entities).toHaveLength(3);
-            expect(result.summary).toContain('3 entities');
-        });
-        it('should translate color stop entities', () => {
-            const registry = createEntityRegistry([
-                { entityId: 10, type: 'color_stop', name: 'Stop1' },
-            ]);
-            const translator = new SemanticTranslator(registry);
-            const rawSolution = new Map([
-                ['10:r', '255/1'],
-                ['10:g', '128/1'],
-                ['10:b', '0/1'],
-                ['10:alpha', '1/1'],
-                ['10:position', '1/2'],
-            ]);
-            const result = translator.translateSolution(rawSolution, 0);
-            expect(result.entities).toHaveLength(1);
-            expect(result.entities[0].type).toBe('color_stop');
-            expect(result.entities[0].color?.r).toBe(255);
-            expect(result.entities[0].color?.g).toBe(128);
-            expect(result.entities[0].color?.b).toBe(0);
-            expect(result.entities[0].color?.position).toBe(0.5);
-            expect(result.entities[0].description).toContain('50%');
-            expect(result.entities[0].description).toContain('rgb(255, 128, 0)');
-        });
-        it('should handle unknown entity types', () => {
-            const translator = new SemanticTranslator(createEmptyRegistry());
-            const rawSolution = new Map([
-                ['99:x', '50/1'],
-                ['99:y', '75/1'],
-            ]);
-            const result = translator.translateSolution(rawSolution, 0);
-            expect(result.entities).toHaveLength(1);
-            expect(result.entities[0].type).toBe('unknown');
-            expect(result.entities[0].coordinates?.x).toBe(50);
-        });
-        it('should detect horizontal alignment relationships', () => {
-            const registry = createEntityRegistry([
-                { entityId: 1, type: 'point' },
-                { entityId: 2, type: 'point' },
-                { entityId: 3, type: 'point' },
-            ]);
-            const translator = new SemanticTranslator(registry);
-            // Three points on the same horizontal line (y=100)
-            const rawSolution = new Map([
-                ['1:x', '0/1'],
-                ['1:y', '100/1'],
-                ['2:x', '50/1'],
-                ['2:y', '100/1'],
-                ['3:x', '100/1'],
-                ['3:y', '100/1'],
-            ]);
-            const result = translator.translateSolution(rawSolution, 0);
-            expect(result.relationships.length).toBeGreaterThan(0);
-            const alignment = result.relationships.find(r => r.type === 'alignment');
-            expect(alignment).toBeDefined();
-            expect(alignment?.description).toContain('horizontally aligned');
-        });
-    });
-    describe('compareSolutions', () => {
-        it('should detect identical solutions', () => {
-            const registry = createEntityRegistry([
-                { entityId: 1, type: 'point', name: 'P1' },
-            ]);
-            const translator = new SemanticTranslator(registry);
-            const rawSolution = new Map([
-                ['1:x', '100/1'],
-                ['1:y', '200/1'],
-            ]);
-            const solution1 = translator.translateSolution(rawSolution, 0);
-            const solution2 = translator.translateSolution(rawSolution, 1);
-            const diff = translator.compareSolutions(solution1, solution2);
-            expect(diff.differingEntities).toHaveLength(0);
-            expect(diff.summary).toContain('identical');
-        });
-        it('should detect differing solutions', () => {
-            const registry = createEntityRegistry([
-                { entityId: 1, type: 'point', name: 'P1' },
-            ]);
-            const translator = new SemanticTranslator(registry);
-            const solution1 = translator.translateSolution(new Map([['1:x', '100/1'], ['1:y', '200/1']]), 0);
-            const solution2 = translator.translateSolution(new Map([['1:x', '150/1'], ['1:y', '250/1']]), 1);
-            const diff = translator.compareSolutions(solution1, solution2);
-            expect(diff.differingEntities).toHaveLength(1);
-            expect(diff.differingEntities[0].entityId).toBe(1);
-            expect(diff.summary).toContain('1 entities differ');
-        });
-    });
-    describe('translateMultipleSolutions', () => {
-        it('should translate and compare multiple solutions', () => {
-            const registry = createEntityRegistry([
-                { entityId: 1, type: 'point', name: 'P1' },
-            ]);
-            const translator = new SemanticTranslator(registry);
-            const rawSolutions = [
-                new Map([['1:x', '100/1'], ['1:y', '0/1']]),
-                new Map([['1:x', '-100/1'], ['1:y', '0/1']]),
-            ];
-            const result = translator.translateMultipleSolutions(rawSolutions);
-            expect(result.solutions).toHaveLength(2);
-            expect(result.comparison).toContain('2 solutions found');
-            expect(result.comparison).toContain('differ');
-        });
-        it('should handle single solution', () => {
-            const translator = new SemanticTranslator(createEmptyRegistry());
-            const rawSolutions = [
-                new Map([['1:x', '100/1']]),
-            ];
-            const result = translator.translateMultipleSolutions(rawSolutions);
-            expect(result.solutions).toHaveLength(1);
-            expect(result.comparison).toContain('Only one solution');
-        });
-    });
-});
-describe('createEntityRegistry', () => {
-    it('should create a working registry', () => {
-        const entities = [
-            { entityId: 1, type: 'point', name: 'P1' },
-            { entityId: 2, type: 'rect', name: 'R1' },
-        ];
-        const registry = createEntityRegistry(entities);
-        expect(registry.get(1)?.type).toBe('point');
-        expect(registry.get(2)?.name).toBe('R1');
-        expect(registry.get(999)).toBeUndefined();
-        expect(registry.getAll()).toHaveLength(2);
-    });
-});