unreal-engine-mcp-server 0.4.7 → 0.5.1

package/tests/test-sequence.mjs

@@ -0,0 +1,104 @@
+#!/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

@@ -0,0 +1,96 @@
+#!/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

@@ -0,0 +1,283 @@
+#!/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);
+  });
+}