@vib3code/sdk 2.0.1

package/src/testing/ParallelTestFramework.js

@@ -0,0 +1,519 @@
+/**
+ * VIB34D PARALLEL TEST FRAMEWORK
+ * Ultra-comprehensive testing system for identifying issues across all systems simultaneously
+ * Tests multiple different approaches in parallel to isolate problems
+ */
+
+export class ParallelTestFramework {
+    constructor() {
+        this.testSuites = new Map();
+        this.testResults = new Map();
+        this.isRunning = false;
+        this.systems = ['faceted', 'quantum', 'holographic']; // 3 active (polychora TBD)
+        this.parameters = ['geometry', 'gridDensity', 'morphFactor', 'speed', 'hue', 'intensity', 'saturation'];
+        this.interactions = ['mouse', 'click', 'scroll', 'touch', 'audio'];
+        
+        // Test configurations for different approaches
+        this.testConfigs = {
+            // Audio reactivity testing
+            audioReactivity: [
+                { name: 'mvep-style', approach: 'direct-render-loop' },
+                { name: 'central-coordinator', approach: 'distributed-system' },
+                { name: 'hybrid-approach', approach: 'selective-distribution' },
+                { name: 'isolated-processing', approach: 'per-system-audio' }
+            ],
+            
+            // Speed control testing  
+            speedControl: [
+                { name: 'base-multiplier', approach: 'baseSpeed * multiplier' },
+                { name: 'additive-boost', approach: 'baseSpeed + audioBoost' },
+                { name: 'controlled-addition', approach: '(baseSpeed * 0.2) + (audioBoost * 0.1)' },
+                { name: 'exponential-scaling', approach: 'baseSpeed * Math.pow(1 + audioBoost, 2)' }
+            ],
+            
+            // Mouse interaction testing
+            mouseInteraction: [
+                { name: 'full-intensity', approach: 'mouseIntensity * 0.5' },
+                { name: 'half-intensity', approach: 'mouseIntensity * 0.25' },
+                { name: 'quarter-intensity', approach: 'mouseIntensity * 0.125' },
+                { name: 'adaptive-intensity', approach: 'mouseIntensity * (0.1 + smoothness * 0.4)' }
+            ],
+            
+            // Parameter synchronization testing
+            parameterSync: [
+                { name: 'immediate-update', approach: 'direct-parameter-set' },
+                { name: 'smooth-transition', approach: 'lerped-parameter-update' },
+                { name: 'batch-update', approach: 'grouped-parameter-changes' },
+                { name: 'debounced-update', approach: 'delayed-parameter-application' }
+            ]
+        };
+        
+        console.log('🧪 Parallel Test Framework initialized with', Object.keys(this.testConfigs).length, 'test categories');
+    }
+    
+    /**
+     * Run parallel tests across all systems for a specific issue type
+     */
+    async runParallelTests(issueType, testDuration = 10000) {
+        if (this.isRunning) {
+            console.warn('🚨 Tests already running, please wait...');
+            return;
+        }
+        
+        this.isRunning = true;
+        const testConfig = this.testConfigs[issueType];
+        
+        if (!testConfig) {
+            console.error('❌ Unknown issue type:', issueType);
+            return;
+        }
+        
+        console.log(`🚀 Starting parallel tests for: ${issueType.toUpperCase()}`);
+        console.log(`📊 Testing ${testConfig.length} approaches across ${this.systems.length} systems`);
+        
+        const testPromises = [];
+        
+        // Create parallel test instances for each approach + system combination
+        for (const approach of testConfig) {
+            for (const system of this.systems) {
+                const testPromise = this.runSingleTest({
+                    issueType,
+                    approach: approach.name,
+                    system,
+                    config: approach,
+                    duration: testDuration
+                });
+                testPromises.push(testPromise);
+            }
+        }
+        
+        // Run all tests in parallel
+        console.log(`⚡ Running ${testPromises.length} parallel test instances...`);
+        const results = await Promise.allSettled(testPromises);
+        
+        // Analyze results
+        this.analyzeParallelResults(issueType, results);
+        this.isRunning = false;
+        
+        return this.generateTestReport(issueType);
+    }
+    
+    /**
+     * Run a single test instance
+     */
+    async runSingleTest(testSpec) {
+        const testId = `${testSpec.issueType}-${testSpec.approach}-${testSpec.system}`;
+        console.log(`🧪 Starting test: ${testId}`);
+        
+        try {
+            // Create isolated test environment
+            const testEnvironment = await this.createTestEnvironment(testSpec);
+            
+            // Apply test approach
+            await this.applyTestApproach(testEnvironment, testSpec);
+            
+            // Run test scenarios
+            const results = await this.runTestScenarios(testEnvironment, testSpec);
+            
+            // Cleanup
+            await this.cleanupTestEnvironment(testEnvironment);
+            
+            return {
+                testId,
+                success: true,
+                results,
+                timestamp: Date.now()
+            };
+        } catch (error) {
+            console.error(`❌ Test failed: ${testId}`, error);
+            return {
+                testId,
+                success: false,
+                error: error.message,
+                timestamp: Date.now()
+            };
+        }
+    }
+    
+    /**
+     * Create isolated test environment for a specific system
+     */
+    async createTestEnvironment(testSpec) {
+        const canvas = document.createElement('canvas');
+        canvas.width = 512;
+        canvas.height = 512;
+        canvas.id = `test-${testSpec.system}-${Date.now()}`;
+        canvas.style.display = 'none';
+        document.body.appendChild(canvas);
+        
+        let testSystem;
+        
+        // Create system instance based on type
+        switch (testSpec.system) {
+            case 'faceted':
+                const { VIB34DIntegratedEngine } = await import('../core/Engine.js');
+                testSystem = new VIB34DIntegratedEngine();
+                break;
+            case 'quantum':
+                const { QuantumEngine } = await import('../quantum/QuantumEngine.js');
+                testSystem = new QuantumEngine();
+                break;
+            case 'holographic':
+                const { RealHolographicSystem } = await import('../holograms/RealHolographicSystem.js');
+                testSystem = new RealHolographicSystem();
+                break;
+            // POLYCHORA: TBD placeholder - disabled
+            // case 'polychora':
+            //     const { PolychoraSystem } = await import('../core/PolychoraSystem.js');
+            //     testSystem = new PolychoraSystem();
+            //     break;
+            default:
+                throw new Error(`Unknown system type: ${testSpec.system}`);
+        }
+        
+        return {
+            canvas,
+            system: testSystem,
+            metrics: {
+                frameRate: 0,
+                responsiveness: 0,
+                smoothness: 0,
+                errors: []
+            }
+        };
+    }
+    
+    /**
+     * Apply specific test approach to system
+     */
+    async applyTestApproach(testEnvironment, testSpec) {
+        const { system } = testEnvironment;
+        
+        switch (testSpec.issueType) {
+            case 'audioReactivity':
+                await this.applyAudioReactivityApproach(system, testSpec.config);
+                break;
+            case 'speedControl':
+                await this.applySpeedControlApproach(system, testSpec.config);
+                break;
+            case 'mouseInteraction':
+                await this.applyMouseInteractionApproach(system, testSpec.config);
+                break;
+            case 'parameterSync':
+                await this.applyParameterSyncApproach(system, testSpec.config);
+                break;
+        }
+    }
+    
+    /**
+     * Run test scenarios and collect metrics
+     */
+    async runTestScenarios(testEnvironment, testSpec) {
+        const scenarios = [
+            { name: 'baseline', description: 'System at rest' },
+            { name: 'parameter-changes', description: 'Rapid parameter changes' },
+            { name: 'audio-reactivity', description: 'Audio input simulation' },
+            { name: 'mouse-interaction', description: 'Mouse movement simulation' },
+            { name: 'stress-test', description: 'High-frequency updates' }
+        ];
+        
+        const results = {};
+        
+        for (const scenario of scenarios) {
+            console.log(`  📋 Running scenario: ${scenario.name}`);
+            results[scenario.name] = await this.runScenario(testEnvironment, scenario, testSpec);
+        }
+        
+        return results;
+    }
+    
+    /**
+     * Run individual test scenario
+     */
+    async runScenario(testEnvironment, scenario, testSpec) {
+        const { system, metrics } = testEnvironment;
+        const startTime = performance.now();
+        let frameCount = 0;
+        const errors = [];
+        
+        // Reset metrics
+        metrics.frameRate = 0;
+        metrics.responsiveness = 0;
+        metrics.smoothness = 0;
+        metrics.errors = [];
+        
+        // Setup scenario-specific conditions
+        switch (scenario.name) {
+            case 'parameter-changes':
+                await this.simulateParameterChanges(system, 1000);
+                break;
+            case 'audio-reactivity':
+                await this.simulateAudioInput(system, 1000);
+                break;
+            case 'mouse-interaction':
+                await this.simulateMouseInteraction(system, 1000);
+                break;
+            case 'stress-test':
+                await this.simulateStressConditions(system, 1000);
+                break;
+        }
+        
+        const endTime = performance.now();
+        const duration = endTime - startTime;
+        
+        return {
+            duration,
+            frameRate: frameCount / (duration / 1000),
+            responsiveness: metrics.responsiveness,
+            smoothness: metrics.smoothness,
+            errorCount: errors.length,
+            errors
+        };
+    }
+    
+    /**
+     * Analyze results from all parallel tests
+     */
+    analyzeParallelResults(issueType, results) {
+        console.log(`📊 Analyzing results for: ${issueType.toUpperCase()}`);
+        
+        const successfulTests = results.filter(r => r.status === 'fulfilled' && r.value.success);
+        const failedTests = results.filter(r => r.status === 'rejected' || !r.value.success);
+        
+        console.log(`✅ Successful tests: ${successfulTests.length}`);
+        console.log(`❌ Failed tests: ${failedTests.length}`);
+        
+        // Group results by approach
+        const resultsByApproach = new Map();
+        
+        successfulTests.forEach(test => {
+            const result = test.value;
+            const approach = result.testId.split('-')[1];
+            
+            if (!resultsByApproach.has(approach)) {
+                resultsByApproach.set(approach, []);
+            }
+            resultsByApproach.get(approach).push(result);
+        });
+        
+        // Find best performing approaches
+        const performanceRankings = [];
+        
+        resultsByApproach.forEach((tests, approach) => {
+            const avgPerformance = this.calculateAveragePerformance(tests);
+            performanceRankings.push({ approach, ...avgPerformance });
+        });
+        
+        performanceRankings.sort((a, b) => b.overallScore - a.overallScore);
+        
+        console.log('🏆 Performance Rankings:');
+        performanceRankings.forEach((ranking, index) => {
+            console.log(`${index + 1}. ${ranking.approach}: ${(ranking.overallScore * 100).toFixed(1)}% overall score`);
+        });
+        
+        this.testResults.set(issueType, {
+            timestamp: Date.now(),
+            totalTests: results.length,
+            successfulTests: successfulTests.length,
+            failedTests: failedTests.length,
+            rankings: performanceRankings,
+            rawResults: results
+        });
+    }
+    
+    /**
+     * Calculate average performance metrics
+     */
+    calculateAveragePerformance(tests) {
+        let totalFrameRate = 0;
+        let totalResponsiveness = 0;
+        let totalSmoothness = 0;
+        let totalErrors = 0;
+        
+        tests.forEach(test => {
+            Object.values(test.results).forEach(scenario => {
+                totalFrameRate += scenario.frameRate || 0;
+                totalResponsiveness += scenario.responsiveness || 0;
+                totalSmoothness += scenario.smoothness || 0;
+                totalErrors += scenario.errorCount || 0;
+            });
+        });
+        
+        const totalScenarios = tests.length * 5; // 5 scenarios per test
+        
+        return {
+            avgFrameRate: totalFrameRate / totalScenarios,
+            avgResponsiveness: totalResponsiveness / totalScenarios,
+            avgSmoothness: totalSmoothness / totalScenarios,
+            avgErrors: totalErrors / totalScenarios,
+            overallScore: this.calculateOverallScore({
+                frameRate: totalFrameRate / totalScenarios,
+                responsiveness: totalResponsiveness / totalScenarios,
+                smoothness: totalSmoothness / totalScenarios,
+                errors: totalErrors / totalScenarios
+            })
+        };
+    }
+    
+    /**
+     * Calculate overall performance score (0-1)
+     */
+    calculateOverallScore(metrics) {
+        const frameRateScore = Math.min(metrics.frameRate / 60, 1); // 60fps = 1.0
+        const responsivenessScore = Math.min(metrics.responsiveness, 1);
+        const smoothnessScore = Math.min(metrics.smoothness, 1);
+        const errorPenalty = Math.max(0, 1 - (metrics.errors * 0.1)); // -0.1 per error
+        
+        return (frameRateScore * 0.3 + responsivenessScore * 0.3 + smoothnessScore * 0.3 + errorPenalty * 0.1);
+    }
+    
+    /**
+     * Generate comprehensive test report
+     */
+    generateTestReport(issueType) {
+        const results = this.testResults.get(issueType);
+        
+        if (!results) {
+            return null;
+        }
+        
+        const report = {
+            issueType,
+            timestamp: results.timestamp,
+            summary: {
+                totalTests: results.totalTests,
+                successRate: (results.successfulTests / results.totalTests * 100).toFixed(1) + '%',
+                bestApproach: results.rankings[0]?.approach || 'none',
+                bestScore: ((results.rankings[0]?.overallScore || 0) * 100).toFixed(1) + '%'
+            },
+            rankings: results.rankings,
+            recommendations: this.generateRecommendations(issueType, results.rankings)
+        };
+        
+        console.log('📋 Test Report Generated:');
+        console.log('Issue Type:', report.issueType);
+        console.log('Success Rate:', report.summary.successRate);
+        console.log('Best Approach:', report.summary.bestApproach);
+        console.log('Best Score:', report.summary.bestScore);
+        
+        return report;
+    }
+    
+    /**
+     * Generate recommendations based on test results
+     */
+    generateRecommendations(issueType, rankings) {
+        if (rankings.length === 0) {
+            return ['No successful tests - investigate fundamental issues'];
+        }
+        
+        const best = rankings[0];
+        const recommendations = [`Use ${best.approach} approach for best performance`];
+        
+        if (best.overallScore < 0.7) {
+            recommendations.push('Overall performance below 70% - consider additional optimizations');
+        }
+        
+        if (best.avgErrors > 0) {
+            recommendations.push(`Address ${best.avgErrors.toFixed(1)} average errors per test`);
+        }
+        
+        if (best.avgFrameRate < 30) {
+            recommendations.push('Frame rate below 30fps - optimize rendering performance');
+        }
+        
+        // Compare top approaches
+        if (rankings.length > 1) {
+            const second = rankings[1];
+            const scoreDiff = best.overallScore - second.overallScore;
+            
+            if (scoreDiff < 0.1) {
+                recommendations.push(`Consider ${second.approach} as alternative (${(scoreDiff * 100).toFixed(1)}% difference)`);
+            }
+        }
+        
+        return recommendations;
+    }
+    
+    /**
+     * Simulation methods for test scenarios
+     */
+    async simulateParameterChanges(system, duration) {
+        // Implementation for parameter change simulation
+        // Rapidly change parameters and measure response
+    }
+    
+    async simulateAudioInput(system, duration) {
+        // Implementation for audio simulation
+        // Simulate various audio patterns and frequencies
+    }
+    
+    async simulateMouseInteraction(system, duration) {
+        // Implementation for mouse simulation
+        // Simulate various mouse movement patterns
+    }
+    
+    async simulateStressConditions(system, duration) {
+        // Implementation for stress testing
+        // High-frequency updates, rapid changes, etc.
+    }
+    
+    /**
+     * Apply specific test approaches
+     */
+    async applyAudioReactivityApproach(system, config) {
+        // Implementation for audio reactivity approach testing
+    }
+    
+    async applySpeedControlApproach(system, config) {
+        // Implementation for speed control approach testing
+    }
+    
+    async applyMouseInteractionApproach(system, config) {
+        // Implementation for mouse interaction approach testing
+    }
+    
+    async applyParameterSyncApproach(system, config) {
+        // Implementation for parameter sync approach testing
+    }
+    
+    /**
+     * Cleanup test environment
+     */
+    async cleanupTestEnvironment(testEnvironment) {
+        if (testEnvironment.canvas) {
+            testEnvironment.canvas.remove();
+        }
+        
+        if (testEnvironment.system && typeof testEnvironment.system.destroy === 'function') {
+            testEnvironment.system.destroy();
+        }
+    }
+    
+    /**
+     * Quick test runner for specific issues
+     */
+    async quickTest(issueType, systems = null) {
+        const testSystems = systems || this.systems;
+        console.log(`🚀 Quick test for ${issueType} across ${testSystems.length} systems`);
+        
+        return await this.runParallelTests(issueType, 3000); // 3 second tests
+    }
+    
+    /**
+     * Get all available test types
+     */
+    getAvailableTests() {
+        return Object.keys(this.testConfigs);
+    }
+    
+    /**
+     * Get test results for specific issue type
+     */
+    getTestResults(issueType) {
+        return this.testResults.get(issueType);
+    }
+}
+
+// Global instance for easy access
+window.ParallelTestFramework = ParallelTestFramework;

package/src/testing/__snapshots__/exportFormats.test.js.snap

@@ -0,0 +1,24 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`export formats > matches the export format snapshot 1`] = `
+[
+  {
+    "description": "Vector sprite sheet for web and design tooling.",
+    "extension": ".svg",
+    "id": "svg-sprite",
+    "name": "SVG Sprite Sheet",
+  },
+  {
+    "description": "Motion-ready JSON payload for Lottie renderers.",
+    "extension": ".json",
+    "id": "lottie-json",
+    "name": "Lottie JSON",
+  },
+  {
+    "description": "CSS custom properties for theming pipelines.",
+    "extension": ".css",
+    "id": "css-variables",
+    "name": "CSS Variables",
+  },
+]
+`;

package/src/testing/exportFormats.test.js

@@ -0,0 +1,8 @@
+import { describe, expect, it } from 'vitest';
+import { EXPORT_FORMATS } from '../../tools/export/formats.js';
+
+describe('export formats', () => {
+    it('matches the export format snapshot', () => {
+        expect(EXPORT_FORMATS).toMatchSnapshot();
+    });
+});

package/src/testing/projections.test.js

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import { perspectiveProject4D, stereographicProject4D } from '../math/projections.js';
+
+describe('4D projections', () => {
+    it('clamps stereographic denominators near singularities', () => {
+        const result = stereographicProject4D([1, 0, 0, 1 - 1e-12], { epsilon: 1e-4 });
+        expect(Math.abs(result.denom)).toBeGreaterThanOrEqual(1e-4);
+    });
+
+    it('projects with perspective distance parameter', () => {
+        const result = perspectiveProject4D([2, 0, 0, 1], { distance: 4 });
+        expect(result.x).toBeCloseTo(2 / 3, 6);
+    });
+});

package/src/testing/rotations.test.js

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+import {
+    applyMatrix4x4,
+    createRotationMatrix4D,
+    identityMatrix4x4,
+    multiplyMatrix4x4,
+    normalizeVector4D,
+    transposeMatrix4x4,
+    vectorLength4D,
+} from '../math/rotations.js';
+
+const EPSILON = 1e-6;
+
+describe('4D rotation matrices', () => {
+    it('keeps rotation matrices orthonormal', () => {
+        const matrix = createRotationMatrix4D('XW', Math.PI / 3);
+        const transpose = transposeMatrix4x4(matrix);
+        const product = multiplyMatrix4x4(matrix, transpose);
+        const identity = identityMatrix4x4();
+
+        product.forEach((value, index) => {
+            expect(Math.abs(value - identity[index])).toBeLessThan(1e-6);
+        });
+    });
+
+    it('preserves vector length across repeated rotations', () => {
+        const step = createRotationMatrix4D('YZ', Math.PI / 180);
+        let vector = normalizeVector4D([1, 0.2, -0.4, 0.7]);
+        const initialLength = vectorLength4D(vector);
+
+        for (let i = 0; i < 720; i += 1) {
+            vector = applyMatrix4x4(step, vector);
+        }
+
+        expect(Math.abs(vectorLength4D(vector) - initialLength)).toBeLessThan(EPSILON);
+    });
+});