unreal-engine-mcp-server 0.5.4 → 0.5.5

package/tests/test-sequence.mjs

@@ -1,104 +0,0 @@
-#!/usr/bin/env node
-/**
- * Comprehensive Sequencer Test Suite
- * Tool: manage_sequence
- * Coverage: All 31 actions with success, error, and edge cases
- */
-
-import { runToolTests } from './test-runner.mjs';
-
-const seqPath = '/Game/Cinematics/TC_Seq';
-const copyDir = '/Game/Cinematics/Copies';
-
-const testCases = [
-  // === PRE-CLEANUP ===
-  {
-    scenario: 'Pre-cleanup: Delete existing test sequences',
-    toolName: 'manage_asset',
-    arguments: { action: 'delete', assetPaths: [seqPath, `${copyDir}/TC_Seq_Copy`, `${copyDir}/TC_Seq_Renamed`, '/Game/Cinematics/TC_Cinematic'] },
-    expected: 'success|not_found'
-  },
-
-  // === LIFECYCLE (create, open, duplicate, rename, delete, list) ===
-  { scenario: 'Create sequence', toolName: 'manage_sequence', arguments: { action: 'create', name: 'TC_Seq', path: '/Game/Cinematics' }, expected: 'success|Sequence already exists' },
-  { scenario: 'Open sequence', toolName: 'manage_sequence', arguments: { action: 'open', path: seqPath }, expected: 'success' },
-  { scenario: 'List sequences', toolName: 'manage_sequence', arguments: { action: 'list', path: '/Game/Cinematics' }, expected: 'success' },
-  { scenario: 'Get sequence properties', toolName: 'manage_sequence', arguments: { action: 'get_properties', path: seqPath }, expected: 'success' },
-  { scenario: 'Set sequence properties', toolName: 'manage_sequence', arguments: { action: 'set_properties', path: seqPath, playbackStart: 0, playbackEnd: 120 }, expected: 'success' },
-  { scenario: 'Duplicate sequence', toolName: 'manage_sequence', arguments: { action: 'duplicate', path: seqPath, destinationPath: copyDir, newName: 'TC_Seq_Copy', overwrite: true }, expected: 'success - duplicated' },
-  { scenario: 'Rename sequence copy', toolName: 'manage_sequence', arguments: { action: 'rename', path: `${copyDir}/TC_Seq_Copy`, newName: 'TC_Seq_Renamed' }, expected: 'success|Failed to rename' },
-
-  // === METADATA ===
-  { scenario: 'Get sequence metadata', toolName: 'manage_sequence', arguments: { action: 'get_metadata', path: seqPath }, expected: 'success' },
-  { scenario: 'Set sequence metadata', toolName: 'manage_sequence', arguments: { action: 'set_metadata', path: seqPath, metadata: { author: 'Test', version: '1.0' } }, expected: 'success' },
-
-  // === BINDINGS (add_camera, add_actor, add_actors, remove_actors, get_bindings, add_spawnable_from_class) ===
-  { scenario: 'Add camera (spawn-only fallback ok)', toolName: 'manage_sequence', arguments: { action: 'add_camera', path: seqPath, spawnable: true }, expected: 'success' },
-  { scenario: 'Get bindings', toolName: 'manage_sequence', arguments: { action: 'get_bindings', path: seqPath }, expected: 'success - bindings listed' },
-
-  // Setup actor for binding tests
-  { scenario: 'Setup - Spawn Cube for Cinematic', toolName: 'control_actor', arguments: { action: 'spawn', classPath: '/Engine/BasicShapes/Cube', actorName: 'TC_SeqCube', location: { x: 0, y: 0, z: 0 } }, expected: 'success' },
-  { scenario: 'Add actor binding', toolName: 'manage_sequence', arguments: { action: 'add_actor', path: seqPath, actorName: 'TC_SeqCube' }, expected: 'success' },
-  { scenario: 'Add spawnable from class', toolName: 'manage_sequence', arguments: { action: 'add_spawnable_from_class', path: seqPath, className: 'PointLight' }, expected: 'success' },
-  { scenario: 'Remove actors', toolName: 'manage_sequence', arguments: { action: 'remove_actors', path: seqPath, actorNames: ['TC_SeqCube'] }, expected: 'success' },
-
-  // === PLAYBACK (play, pause, stop, set_playback_speed) ===
-  { scenario: 'Play sequence', toolName: 'manage_sequence', arguments: { action: 'play', path: seqPath }, expected: 'success' },
-  { scenario: 'Pause sequence', toolName: 'manage_sequence', arguments: { action: 'pause', path: seqPath }, expected: 'success' },
-  { scenario: 'Stop sequence', toolName: 'manage_sequence', arguments: { action: 'stop', path: seqPath }, expected: 'success' },
-  { scenario: 'Set playback speed 1.5x', toolName: 'manage_sequence', arguments: { action: 'set_playback_speed', path: seqPath, speed: 1.5 }, expected: 'success' },
-  { scenario: 'Set playback speed 0.5x', toolName: 'manage_sequence', arguments: { action: 'set_playback_speed', path: seqPath, speed: 0.5 }, expected: 'success' },
-
-  // === KEYFRAMES (add_keyframe) ===
-  { scenario: 'Re-add actor for keyframes', toolName: 'manage_sequence', arguments: { action: 'add_actor', path: seqPath, actorName: 'TC_SeqCube' }, expected: 'success' },
-  { scenario: 'Add keyframe at frame 0', toolName: 'manage_sequence', arguments: { action: 'add_keyframe', path: seqPath, actorName: 'TC_SeqCube', property: 'Transform', frame: 0, value: { location: { x: 0, y: 0, z: 0 } } }, expected: 'success' },
-  { scenario: 'Add keyframe at frame 60', toolName: 'manage_sequence', arguments: { action: 'add_keyframe', path: seqPath, actorName: 'TC_SeqCube', property: 'Transform', frame: 60, value: { location: { x: 200, y: 0, z: 0 } } }, expected: 'success' },
-  { scenario: 'Add keyframe at frame 120', toolName: 'manage_sequence', arguments: { action: 'add_keyframe', path: seqPath, actorName: 'TC_SeqCube', property: 'Transform', frame: 120, value: { location: { x: 0, y: 200, z: 0 } } }, expected: 'success' },
-
-  // === TRACKS (add_track, add_section, list_tracks, remove_track, set_track_muted, set_track_solo, set_track_locked) ===
-  { scenario: 'Add Transform track', toolName: 'manage_sequence', arguments: { action: 'add_track', path: seqPath, actorName: 'TC_SeqCube', trackType: 'Transform' }, expected: 'success' },
-  { scenario: 'Add Event track', toolName: 'manage_sequence', arguments: { action: 'add_track', path: seqPath, actorName: 'TC_SeqCube', trackType: 'Event' }, expected: 'success' },
-  { scenario: 'List tracks', toolName: 'manage_sequence', arguments: { action: 'list_tracks', path: seqPath }, expected: 'success' },
-  { scenario: 'Add section to track', toolName: 'manage_sequence', arguments: { action: 'add_section', path: seqPath, trackName: 'Transform', startFrame: 0, endFrame: 120 }, expected: 'success' },
-  { scenario: 'Set track muted', toolName: 'manage_sequence', arguments: { action: 'set_track_muted', path: seqPath, trackName: 'Transform', muted: true }, expected: 'success' },
-  { scenario: 'Set track unmuted', toolName: 'manage_sequence', arguments: { action: 'set_track_muted', path: seqPath, trackName: 'Transform', muted: false }, expected: 'success' },
-  { scenario: 'Set track solo', toolName: 'manage_sequence', arguments: { action: 'set_track_solo', path: seqPath, trackName: 'Transform', solo: true }, expected: 'success' },
-  { scenario: 'Set track locked', toolName: 'manage_sequence', arguments: { action: 'set_track_locked', path: seqPath, trackName: 'Transform', locked: true }, expected: 'success' },
-  { scenario: 'Set track unlocked', toolName: 'manage_sequence', arguments: { action: 'set_track_locked', path: seqPath, trackName: 'Transform', locked: false }, expected: 'success' },
-
-  // === DISPLAY/TIMING SETTINGS ===
-  { scenario: 'Set display rate 30fps', toolName: 'manage_sequence', arguments: { action: 'set_display_rate', path: seqPath, frameRate: '30fps' }, expected: 'success' },
-  { scenario: 'Set display rate 60fps', toolName: 'manage_sequence', arguments: { action: 'set_display_rate', path: seqPath, frameRate: '60fps' }, expected: 'success' },
-  { scenario: 'Set tick resolution', toolName: 'manage_sequence', arguments: { action: 'set_tick_resolution', path: seqPath, resolution: '24000fps' }, expected: 'success' },
-  { scenario: 'Set work range', toolName: 'manage_sequence', arguments: { action: 'set_work_range', path: seqPath, start: 0, end: 150 }, expected: 'success' },
-  { scenario: 'Set view range', toolName: 'manage_sequence', arguments: { action: 'set_view_range', path: seqPath, start: 0, end: 120 }, expected: 'success' },
-
-  // === REAL-WORLD SCENARIO ===
-  { scenario: 'Cinematic - Create Sequence', toolName: 'manage_sequence', arguments: { action: 'create', name: 'TC_Cinematic', path: '/Game/Cinematics' }, expected: 'success|Sequence already exists' },
-  { scenario: 'Cinematic - Add Actor', toolName: 'manage_sequence', arguments: { action: 'add_actor', path: '/Game/Cinematics/TC_Cinematic', actorName: 'TC_SeqCube' }, expected: 'success' },
-  { scenario: 'Cinematic - Keyframe Start', toolName: 'manage_sequence', arguments: { action: 'add_keyframe', path: '/Game/Cinematics/TC_Cinematic', actorName: 'TC_SeqCube', property: 'Transform', frame: 0, value: { location: { x: 0, y: 0, z: 0 } } }, expected: 'success' },
-  { scenario: 'Cinematic - Keyframe End', toolName: 'manage_sequence', arguments: { action: 'add_keyframe', path: '/Game/Cinematics/TC_Cinematic', actorName: 'TC_SeqCube', property: 'Transform', frame: 60, value: { location: { x: 200, y: 0, z: 0 } } }, expected: 'success' },
-
-  // === ERROR CASES ===
-  { scenario: 'Error: Invalid actor name', toolName: 'manage_sequence', arguments: { action: 'add_actor', path: seqPath, actorName: 'NonExistentActor' }, expected: 'not_found|error|ASSET_NOT_FOUND|LOAD_FAILED' },
-  { scenario: 'Error: Invalid class spawnable', toolName: 'manage_sequence', arguments: { action: 'add_spawnable_from_class', path: seqPath, className: 'InvalidClass' }, expected: 'error' },
-  { scenario: 'Error: Invalid sequence path', toolName: 'manage_sequence', arguments: { action: 'open', path: '/Game/NonExistent/Sequence' }, expected: 'error|not_found' },
-  { scenario: 'Error: Remove track non-existent', toolName: 'manage_sequence', arguments: { action: 'remove_track', path: seqPath, trackName: 'NonExistentTrack' }, expected: 'error|not_found' },
-
-  // === EDGE CASES ===
-  { scenario: 'Edge: Playback speed 0', toolName: 'manage_sequence', arguments: { action: 'set_playback_speed', speed: 0 }, expected: 'error' },
-  { scenario: 'Edge: Negative frame keyframe', toolName: 'manage_sequence', arguments: { action: 'add_keyframe', path: seqPath, actorName: 'TC_SeqCube', property: 'Transform', frame: -10, value: {} }, expected: 'success|error' },
-  { scenario: 'Edge: Empty actors array', toolName: 'manage_sequence', arguments: { action: 'add_actors', path: seqPath, actorNames: [] }, expected: 'actorNames required|INVALID_ARGUMENT' },
-  { scenario: 'Edge: Very high work range', toolName: 'manage_sequence', arguments: { action: 'set_work_range', path: seqPath, start: 0, end: 100000 }, expected: 'success' },
-
-  // === CLEANUP ===
-  { scenario: 'Cleanup - Delete Cinematic', toolName: 'manage_sequence', arguments: { action: 'delete', path: '/Game/Cinematics/TC_Cinematic' }, expected: 'success|Failed to delete' },
-  { scenario: 'Cleanup - Delete Cube', toolName: 'control_actor', arguments: { action: 'delete', actorName: 'TC_SeqCube' }, expected: 'success' },
-  { scenario: 'Cleanup - Remove track', toolName: 'manage_sequence', arguments: { action: 'remove_track', path: seqPath, trackName: 'Event' }, expected: 'success|not_found' },
-  { scenario: 'Delete original sequence', toolName: 'manage_sequence', arguments: { action: 'delete', path: seqPath }, expected: 'success|Failed to delete' },
-  { scenario: 'Delete renamed copy', toolName: 'manage_sequence', arguments: { action: 'delete', path: `${copyDir}/TC_Seq_Renamed` }, expected: 'success|Failed to delete' },
-  { scenario: 'Verify sequences removed', toolName: 'manage_sequence', arguments: { action: 'get_bindings', path: seqPath }, expected: 'success|not found|error|ASSET_NOT_FOUND|LOAD_FAILED' },
-  { scenario: 'Final cleanup via manage_asset', toolName: 'manage_asset', arguments: { action: 'delete', assetPaths: [seqPath, copyDir] }, expected: 'success|ASSET_NOT_FOUND|LOAD_FAILED' }
-];
-
-await runToolTests('Sequences', testCases);

package/tests/test-system.mjs

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-/**
- * Comprehensive System Control Test Suite
- * Tool: system_control
- * Coverage: All 22 actions with success, error, and edge cases
- */
-
-import { runToolTests } from './test-runner.mjs';
-
-const testCases = [
-  // === PROFILING (profile, show_fps, show_stats) ===
-  { scenario: 'Enable FPS display', toolName: 'system_control', arguments: { action: 'show_fps', enabled: true }, expected: 'success - FPS shown' },
-  { scenario: 'Disable FPS display', toolName: 'system_control', arguments: { action: 'show_fps', enabled: false }, expected: 'success - FPS hidden' },
-  { scenario: 'Show stats', toolName: 'system_control', arguments: { action: 'show_stats', category: 'Engine' }, expected: 'success' },
-  { scenario: 'Enable CPU profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'CPU', enabled: true }, expected: 'success - profiling enabled' },
-  { scenario: 'Disable CPU profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'CPU', enabled: false }, expected: 'success - profiling disabled' },
-  { scenario: 'Enable GPU profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'GPU', enabled: true }, expected: 'success' },
-  { scenario: 'Disable GPU profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'GPU', enabled: false }, expected: 'success' },
-  { scenario: 'Enable RenderThread profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'RenderThread', enabled: true }, expected: 'success' },
-  { scenario: 'Disable RenderThread profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'RenderThread', enabled: false }, expected: 'success' },
-  { scenario: 'Enable Memory profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'Memory', enabled: true }, expected: 'success' },
-  { scenario: 'Disable Memory profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'Memory', enabled: false }, expected: 'success' },
-  { scenario: 'Profile All', toolName: 'system_control', arguments: { action: 'profile', profileType: 'All', enabled: true }, expected: 'success' },
-  { scenario: 'Generate memory report', toolName: 'system_control', arguments: { action: 'profile', profileType: 'Memory', detailed: true, outputPath: './tests/reports' }, expected: 'success' },
-
-  // === QUALITY SETTINGS (set_quality, set_resolution_scale, set_vsync, set_frame_rate_limit) ===
-  { scenario: 'Set shadow quality to medium', toolName: 'system_control', arguments: { action: 'set_quality', category: 'Shadow', level: 1 }, expected: 'success - quality set' },
-  { scenario: 'Set texture quality to high', toolName: 'system_control', arguments: { action: 'set_quality', category: 'Texture', level: 2 }, expected: 'success - quality set' },
-  { scenario: 'Set quality level 0 (low)', toolName: 'system_control', arguments: { action: 'set_quality', category: 'ViewDistance', level: 0 }, expected: 'success' },
-  { scenario: 'Set quality level 3 (epic)', toolName: 'system_control', arguments: { action: 'set_quality', category: 'Effects', level: 3 }, expected: 'success' },
-
-  // === CONSOLE COMMANDS (execute_command, console_command) ===
-  { scenario: 'Execute console command (stat fps)', toolName: 'system_control', arguments: { action: 'execute_command', command: 'stat fps' }, expected: 'success - console command executed' },
-  { scenario: 'Console command (alias)', toolName: 'system_control', arguments: { action: 'console_command', command: 'stat unit' }, expected: 'success' },
-  { scenario: 'Console command - stat none', toolName: 'system_control', arguments: { action: 'console_command', command: 'stat none' }, expected: 'success' },
-  { scenario: 'Console command - gc', toolName: 'system_control', arguments: { action: 'console_command', command: 'obj gc' }, expected: 'success' },
-
-  // === SCREENSHOTS ===
-  { scenario: 'Take a screenshot', toolName: 'system_control', arguments: { action: 'screenshot', filename: 'tc_sys_screenshot' }, expected: 'success - screenshot taken' },
-  { scenario: 'Take screenshot with metadata', toolName: 'system_control', arguments: { action: 'screenshot', includeMetadata: true, metadata: { test: 'system_tc' } }, expected: 'success - metadata screenshot taken' },
-
-  // === RESOLUTION / DISPLAY ===
-  { scenario: 'Set resolution 1920x1080', toolName: 'system_control', arguments: { action: 'set_resolution', resolution: '1920x1080' }, expected: 'success' },
-  { scenario: 'Set fullscreen on', toolName: 'system_control', arguments: { action: 'set_fullscreen', enabled: true }, expected: 'success' },
-  { scenario: 'Set fullscreen off', toolName: 'system_control', arguments: { action: 'set_fullscreen', enabled: false }, expected: 'success' },
-
-  // === WIDGETS ===
-  { scenario: 'Create debug widget asset', toolName: 'system_control', arguments: { action: 'create_widget', name: 'TestWidget_Safe', savePath: '/Game/Tests' }, expected: 'success - widget created or handled' },
-  { scenario: 'Create console widget asset', toolName: 'system_control', arguments: { action: 'create_widget', name: 'TestWidget_Console', savePath: '/Game/Tests' }, expected: 'success - widget created or handled' },
-  { scenario: 'Show notification widget', toolName: 'system_control', arguments: { action: 'show_widget', widgetId: 'Notification', visible: true, message: 'TC: Notification', duration: 1.5 }, expected: 'success - notification shown' },
-  { scenario: 'Add child to widget', toolName: 'system_control', arguments: { action: 'add_widget_child', parentName: 'TestWidget_Safe', childClass: 'Button' }, expected: 'success|handled' },
-
-  // === CVARS ===
-  { scenario: 'Set VSync CVAR', toolName: 'system_control', arguments: { action: 'set_cvar', name: 'r.VSync', value: '0' }, expected: 'success - CVAR set' },
-  { scenario: 'Set max FPS CVAR', toolName: 'system_control', arguments: { action: 'set_cvar', name: 't.MaxFPS', value: '60' }, expected: 'success - CVAR set' },
-  { scenario: 'Set anti-aliasing CVAR', toolName: 'system_control', arguments: { action: 'set_cvar', name: 'r.PostProcessAAQuality', value: '4' }, expected: 'success' },
-  { scenario: 'Set LOD bias CVAR', toolName: 'system_control', arguments: { action: 'set_cvar', name: 'foliage.LODDistanceScale', value: '1.0' }, expected: 'success' },
-
-  // === SOUND ===
-  { scenario: 'Play UI sound', toolName: 'system_control', arguments: { action: 'play_sound', soundPath: '/Engine/EditorSounds/Notifications/CompileSuccess.CompileSuccess', volume: 0.5 }, expected: 'success - sound played or handled' },
-  { scenario: 'Play sound silent', toolName: 'system_control', arguments: { action: 'play_sound', soundPath: '/Engine/EditorSounds/Notifications/CompileSuccess.CompileSuccess', volume: 0 }, expected: 'success' },
-
-  // === PROJECT SETTINGS ===
-  { scenario: 'Get project settings', toolName: 'system_control', arguments: { action: 'get_project_settings', category: 'Project' }, expected: 'success' },
-  { scenario: 'Get project settings - Engine', toolName: 'system_control', arguments: { action: 'get_project_settings', section: '/Script/EngineSettings.GeneralProjectSettings' }, expected: 'success' },
-  { scenario: 'Set project setting', toolName: 'system_control', arguments: { action: 'set_project_setting', section: '/Script/Engine.Engine', key: 'bSmoothFrameRate', value: 'true', configName: 'Engine' }, expected: 'success|handled' },
-
-  // === VALIDATION ===
-  { scenario: 'Validate assets', toolName: 'system_control', arguments: { action: 'validate_assets', paths: ['/Game'] }, expected: 'success' },
-
-  // === LUMEN ===
-  { scenario: 'Lumen update scene', toolName: 'system_control', arguments: { action: 'lumen_update_scene' }, expected: 'success|handled' },
-
-  // === SUBSCRIPTIONS (subscribe, unsubscribe, spawn_category, start_session) ===
-  { scenario: 'Subscribe to events', toolName: 'system_control', arguments: { action: 'subscribe', channels: 'Assets' }, expected: 'success|handled' },
-  { scenario: 'Unsubscribe from events', toolName: 'system_control', arguments: { action: 'unsubscribe', channels: 'Assets' }, expected: 'success|handled' },
-  { scenario: 'Spawn category', toolName: 'system_control', arguments: { action: 'spawn_category', category: 'TestCategory' }, expected: 'success|handled' },
-  { scenario: 'Start session', toolName: 'system_control', arguments: { action: 'start_session' }, expected: 'success|handled' },
-
-  // === ERROR CASES ===
-  { scenario: 'Error: Invalid profile type', toolName: 'system_control', arguments: { action: 'profile', profileType: 'InvalidProfile' }, expected: 'error' },
-  { scenario: 'Error: Empty command', toolName: 'system_control', arguments: { action: 'console_command', command: '' }, expected: 'error|handled' },
-  { scenario: 'Error: Invalid resolution', toolName: 'system_control', arguments: { action: 'set_resolution', width: -1, height: -1 }, expected: 'error|validation' },
-  { scenario: 'Error: Invalid quality level', toolName: 'system_control', arguments: { action: 'set_quality', category: 'Shadow', level: 999 }, expected: 'error|clamped' },
-  { scenario: 'Error: Invalid sound path', toolName: 'system_control', arguments: { action: 'play_sound', soundPath: '/Game/Invalid/Sound' }, expected: 'error|not_found' },
-
-  // === CLEANUP ===
-  {
-    scenario: 'Cleanup widgets',
-    toolName: 'manage_asset',
-    arguments: { action: 'delete', assetPaths: ['/Game/Tests/TestWidget_Safe', '/Game/Tests/TestWidget_Console'] },
-    expected: 'success|handled'
-  }
-];
-
-await runToolTests('System Control', testCases);

package/tests/test-wasm.mjs

@@ -1,283 +0,0 @@
-#!/usr/bin/env node
-/**
- * WebAssembly Integration Test Suite
- *
- * Tests the WebAssembly integration and fallback mechanisms
- */
-
-import { wasmIntegration } from '../dist/wasm/index.js';
-import { pathToFileURL } from 'node:url';
-
-const log = {
-  info: (...args) => console.log('[INFO]', ...args),
-  warn: (...args) => console.warn('[WARN]', ...args),
-  error: (...args) => console.error('[ERROR]', ...args),
-  debug: (...args) => console.debug('[DEBUG]', ...args)
-};
-
-async function testWASMIntegration() {
-  log.info('Starting WebAssembly integration test...\n');
-
-  // Test 1: Environment Check
-  log.info('=== Test 1: Environment Check ===');
-  const isSupported = wasmIntegration.constructor.isSupported();
-  log.info(`WebAssembly supported: ${isSupported}`);
-
-  if (!isSupported) {
-    log.warn('WebAssembly not supported, testing TypeScript fallbacks only');
-  }
-
-  // Test 2: Initialization
-  log.info('\n=== Test 2: Initialization ===');
-  try {
-    await wasmIntegration.initialize();
-    log.info('✅ Initialization successful');
-
-    if (wasmIntegration.isReady()) {
-      log.info('✅ WASM module is ready');
-    } else {
-      log.warn('⚠️ WASM module not ready, using TypeScript fallbacks');
-    }
-  } catch (error) {
-    log.error('❌ Initialization failed:', error.message);
-    log.info('This is expected if WASM module is not built yet');
-  }
-
-  // Test 3: Property Parsing
-  log.info('\n=== Test 3: Property Parsing ===');
-  const testJson = JSON.stringify({
-    name: 'TestAsset',
-    value: 42,
-    location: { x: 100, y: 200, z: 300 },
-    tags: ['tag1', 'tag2'],
-    properties: {
-      material: { name: 'Mat1', intensity: 5000 }
-    }
-  });
-
-  try {
-    const start = performance.now();
-    const result = await wasmIntegration.parseProperties(testJson);
-    const duration = performance.now() - start;
-
-    log.info(`✅ Property parsing completed in ${duration.toFixed(2)}ms`);
-    log.info(`Result has ${Object.keys(result).length} properties`);
-
-    if (result && typeof result === 'object') {
-      log.info('Result structure is valid');
-    }
-  } catch (error) {
-    log.error('❌ Property parsing failed:', error.message);
-  }
-
-  // Test 4: Transform Calculations
-  log.info('\n=== Test 4: Transform Calculations ===');
-  try {
-    const location = [100, 200, 300];
-    const rotation = [0, 90, 0];
-    const scale = [1, 1, 1];
-
-    const matrix = wasmIntegration.composeTransform(location, rotation, scale);
-
-    log.info(`✅ Transform composition successful`);
-    log.info(`Matrix length: ${matrix.length} (expected: 9)`);
-
-    if (matrix.length === 9) {
-      log.info('✅ Matrix has correct length');
-    }
-
-    // Test matrix decomposition
-    const decomposed = wasmIntegration.decomposeMatrix(matrix);
-    log.info(`✅ Matrix decomposition successful`);
-    log.info(`Decomposed: [${decomposed.slice(0, 3).join(', ')}, ...]`);
-  } catch (error) {
-    log.error('❌ Transform calculation failed:', error.message);
-  }
-
-  // Test 5: Vector Operations
-  log.info('\n=== Test 5: Vector Operations ===');
-  try {
-    const v1 = [1, 2, 3];
-    const v2 = [4, 5, 6];
-    const result = wasmIntegration.vectorAdd(v1, v2);
-
-    log.info(`✅ Vector addition successful`);
-    log.info(`${v1.join(', ')} + ${v2.join(', ')} = [${result.join(', ')}]`);
-
-    // Verify result
-    const expected = [5, 7, 9];
-    const isCorrect = result.every((val, idx) => Math.abs(val - expected[idx]) < 0.001);
-
-    if (isCorrect) {
-      log.info('✅ Vector addition result is correct');
-    } else {
-      log.warn('⚠️ Vector addition result may be incorrect');
-    }
-  } catch (error) {
-    log.error('❌ Vector operation failed:', error.message);
-  }
-
-  // Test 6: Dependency Resolution
-  log.info('\n=== Test 6: Dependency Resolution ===');
-  const testDependencies = {
-    'AssetA': ['AssetB', 'AssetC'],
-    'AssetB': ['AssetC'],
-    'AssetC': []
-  };
-
-  try {
-    const result = await wasmIntegration.resolveDependencies('AssetA', testDependencies);
-
-    log.info(`✅ Dependency resolution successful`);
-    log.info(`Found ${result.dependencies?.length || 0} dependencies`);
-    log.info(`Asset path: ${result.asset}`);
-
-    if (result.dependencies && result.dependencies.length > 0) {
-      log.info('First dependency:', result.dependencies[0].path);
-    }
-  } catch (error) {
-    log.error('❌ Dependency resolution failed:', error.message);
-  }
-
-  // Test 7: Performance Metrics
-  log.info('\n=== Test 7: Performance Metrics ===');
-  const metrics = wasmIntegration.getMetrics();
-
-  log.info(`Total operations: ${metrics.totalOperations}`);
-  log.info(`WASM operations: ${metrics.wasmOperations}`);
-  log.info(`TypeScript operations: ${metrics.tsOperations}`);
-  log.info(`Average time: ${metrics.averageTime.toFixed(2)}ms`);
-
-  if (metrics.totalOperations > 0) {
-    log.info('✅ Performance metrics collected');
-  }
-
-  // Print detailed performance report
-  log.info('\n=== Performance Report ===');
-  log.info(wasmIntegration.reportPerformance());
-
-  // Test 9: Circular Dependency Detection
-  log.info('\n=== Test 9: Circular Dependency Detection ===');
-  const circularDeps = {
-    'AssetA': ['AssetB'],
-    'AssetB': ['AssetC'],
-    'AssetC': ['AssetA'] // Creates a cycle
-  };
-
-  try {
-    const circular = await wasmIntegration.findCircularDependencies(circularDeps);
-    log.info(`✅ Circular dependency detection completed`);
-    log.info(`Found ${circular.length} circular dependency chains`);
-    if (circular.length > 0) {
-      log.info(`Cycle: ${circular[0].join(' -> ')}`);
-    }
-  } catch (error) {
-    log.error('❌ Circular dependency detection failed:', error.message);
-  }
-
-  // Test 10: Topological Sort
-  log.info('\n=== Test 10: Topological Sort ===');
-  const sortDeps = {
-    'D': [],
-    'C': ['D'],
-    'B': ['C', 'D'],
-    'A': ['B', 'C']
-  };
-
-  try {
-    const sorted = await wasmIntegration.topologicalSort(sortDeps);
-    log.info(`✅ Topological sort completed`);
-    log.info(`Order: ${sorted.join(' -> ')}`);
-    // D should come before C, C before B, B before A
-    const dIdx = sorted.indexOf('D');
-    const cIdx = sorted.indexOf('C');
-    const bIdx = sorted.indexOf('B');
-    const aIdx = sorted.indexOf('A');
-    if (dIdx < cIdx && cIdx < bIdx && bIdx < aIdx) {
-      log.info('✅ Sort order is correct');
-    } else {
-      log.warn('⚠️ Sort order may be incorrect');
-    }
-  } catch (error) {
-    log.error('❌ Topological sort failed:', error.message);
-  }
-
-  // Test 11: Edge Cases
-  log.info('\n=== Test 11: Edge Cases ===');
-
-  // Empty JSON
-  try {
-    const emptyResult = await wasmIntegration.parseProperties('{}');
-    log.info(`✅ Empty JSON parsing: ${Object.keys(emptyResult).length === 0 ? 'passed' : 'result has keys'}`);
-  } catch (error) {
-    log.error('❌ Empty JSON parsing failed:', error.message);
-  }
-
-  // Invalid JSON (should fallback gracefully)
-  try {
-    await wasmIntegration.parseProperties('not valid json');
-    log.warn('⚠️ Invalid JSON did not throw - fallback handled');
-  } catch (error) {
-    log.info(`✅ Invalid JSON correctly rejected: ${error.message.substring(0, 50)}...`);
-  }
-
-  // Zero vectors
-  try {
-    const zeroAdd = wasmIntegration.vectorAdd([0, 0, 0], [0, 0, 0]);
-    const isZero = zeroAdd.every(v => v === 0);
-    log.info(`✅ Zero vector addition: ${isZero ? 'passed' : 'unexpected result'}`);
-  } catch (error) {
-    log.error('❌ Zero vector test failed:', error.message);
-  }
-
-  // Test 12: Performance Benchmark
-  log.info('\n=== Test 12: Performance Benchmark ===');
-  const iterations = 100;
-  const largeJson = JSON.stringify({
-    assets: Array.from({ length: 50 }, (_, i) => ({
-      name: `Asset${i}`,
-      path: `/Game/Assets/Asset${i}`,
-      properties: { value: i * 100, enabled: i % 2 === 0 }
-    }))
-  });
-
-  const benchStart = performance.now();
-  for (let i = 0; i < iterations; i++) {
-    await wasmIntegration.parseProperties(largeJson);
-  }
-  const benchDuration = performance.now() - benchStart;
-  log.info(`✅ Parsed ${iterations} large JSON objects in ${benchDuration.toFixed(2)}ms`);
-  log.info(`Average: ${(benchDuration / iterations).toFixed(3)}ms per parse`);
-
-  // Vector math benchmark
-  const vecStart = performance.now();
-  for (let i = 0; i < 1000; i++) {
-    wasmIntegration.vectorAdd([i, i + 1, i + 2], [i * 2, i * 3, i * 4]);
-  }
-  const vecDuration = performance.now() - vecStart;
-  log.info(`✅ 1000 vector additions in ${vecDuration.toFixed(2)}ms`);
-
-  // Final Summary
-  log.info('\n=== Test Summary ===');
-  log.info('All tests completed. Check the output above for details.');
-  log.info('');
-  log.info('Note: Some tests may use TypeScript fallbacks if WASM is not available.');
-  log.info('This is expected behavior and the integration will still work correctly.');
-  log.info('');
-  log.info('To use WebAssembly:');
-  log.info('1. Build the WASM module: cd wasm && wasm-pack build --target web');
-  log.info('2. Copy the pkg/ directory to src/wasm/');
-  log.info('3. Set environment variable: WASM_ENABLED=true');
-  log.info('4. Run tests again');
-
-  process.exit(0);
-}
-
-const mainScriptUrl = pathToFileURL(process.argv[1]).href;
-
-if (import.meta.url === mainScriptUrl) {
-  testWASMIntegration().catch(error => {
-    log.error('Test failed with error:', error);
-    process.exit(1);
-  });
-}