unreal-engine-mcp-server 0.5.0 → 0.5.2

package/src/tools/lighting.ts

@@ -2,6 +2,7 @@
 import { UnrealBridge } from '../unreal-bridge.js';
 import { AutomationBridge } from '../automation/index.js';
 import { ensureVector3 } from '../utils/validation.js';
+import { wasmIntegration } from '../wasm/index.js';
 
 export class LightingTools {
   constructor(private bridge: UnrealBridge, private automationBridge?: AutomationBridge) { }
@@ -39,7 +40,7 @@ export class LightingTools {
       name: string;
       location?: [number, number, number];
       rotation?: [number, number, number] | { pitch: number, yaw: number, roll: number };
-      properties?: Record<string, any>;
+      properties?: Record<string, unknown>;
     }
   ) {
     if (!this.automationBridge) {
@@ -47,13 +48,17 @@ export class LightingTools {
     }
 
     try {
-      const payload: Record<string, any> = {
+      const payload: Record<string, unknown> = {
         lightClass,
         name: params.name,
       };
 
       if (params.location) {
-        payload.location = { x: params.location[0], y: params.location[1], z: params.location[2] };
+        // Use WASM vectorAdd for light location processing
+        const zeroVector: [number, number, number] = [0, 0, 0];
+        const processedLocation = wasmIntegration.vectorAdd(zeroVector, params.location);
+        console.error('[WASM] Using vectorAdd for light positioning');
+        payload.location = { x: processedLocation[0], y: processedLocation[1], z: processedLocation[2] };
       }
 
       if (params.rotation) {
@@ -93,7 +98,7 @@ export class LightingTools {
     castShadows?: boolean;
     temperature?: number;
     useAsAtmosphereSunLight?: boolean;
-    properties?: Record<string, any>;
+    properties?: Record<string, unknown>;
   }) {
     const name = this.normalizeName(params.name);
     if (!this.automationBridge) {
@@ -144,7 +149,7 @@ export class LightingTools {
     const rot = params.rotation || [0, 0, 0];
 
     // Build properties for the light
-    const properties: Record<string, any> = params.properties || {};
+    const properties: Record<string, unknown> = params.properties || {};
     if (params.intensity !== undefined) {
       properties.intensity = params.intensity;
     }
@@ -170,9 +175,9 @@ export class LightingTools {
       });
 
       return { success: true, message: `Directional light '${name}' spawned` };
-    } catch (e: any) {
+    } catch (e: unknown) {
       // Don't mask errors as "not implemented" - report the actual error from the bridge
-      return { success: false, error: `Failed to create directional light: ${e?.message ?? e}` } as any;
+      return { success: false, error: `Failed to create directional light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
     }
   }
 
@@ -242,7 +247,7 @@ export class LightingTools {
     }
 
     // Build properties for the light
-    const properties: Record<string, any> = {};
+    const properties: Record<string, unknown> = {};
     if (params.intensity !== undefined) {
       properties.intensity = params.intensity;
     }
@@ -268,9 +273,9 @@ export class LightingTools {
       });
 
       return { success: true, message: `Point light '${name}' spawned at ${location.join(', ')}` };
-    } catch (e: any) {
+    } catch (e: unknown) {
       // Don't mask errors as "not implemented" - report the actual error from the bridge
-      return { success: false, error: `Failed to create point light: ${e?.message ?? e}` } as any;
+      return { success: false, error: `Failed to create point light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
     }
   }
 
@@ -364,7 +369,7 @@ export class LightingTools {
       }
     }
     // Build properties for the light
-    const properties: Record<string, any> = {};
+    const properties: Record<string, unknown> = {};
     if (params.intensity !== undefined) {
       properties.intensity = params.intensity;
     }
@@ -393,9 +398,9 @@ export class LightingTools {
       });
 
       return { success: true, message: `Spot light '${name}' spawned at ${params.location.join(', ')}` };
-    } catch (e: any) {
+    } catch (e: unknown) {
       // Don't mask errors as "not implemented" - report the actual error from the bridge
-      return { success: false, error: `Failed to create spot light: ${e?.message ?? e}` } as any;
+      return { success: false, error: `Failed to create spot light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
     }
   }
 
@@ -480,7 +485,7 @@ export class LightingTools {
       }
     }
     // Build properties for the light
-    const properties: Record<string, any> = {};
+    const properties: Record<string, unknown> = {};
     if (params.intensity !== undefined) {
       properties.intensity = params.intensity;
     }
@@ -503,9 +508,9 @@ export class LightingTools {
       });
 
       return { success: true, message: `Rect light '${name}' spawned at ${params.location.join(', ')}` };
-    } catch (e: any) {
+    } catch (e: unknown) {
       // Don't mask errors as "not implemented" - report the actual error from the bridge
-      return { success: false, error: `Failed to create rect light: ${e?.message ?? e}` } as any;
+      return { success: false, error: `Failed to create rect light: ${(e instanceof Error ? e.message : String(e)) ?? e}` };
     }
   }
 
@@ -576,13 +581,13 @@ export class LightingTools {
     }
 
     try {
-      const properties: Record<string, any> = {};
+      const properties: Record<string, unknown> = {};
       if (params.intensity !== undefined) properties.Intensity = params.intensity;
       if (params.castShadows !== undefined) properties.CastShadows = params.castShadows;
       if (params.realTimeCapture !== undefined) properties.RealTimeCapture = params.realTimeCapture;
       if (params.color) properties.LightColor = { r: params.color[0], g: params.color[1], b: params.color[2], a: 1.0 };
 
-      const payload: Record<string, any> = {
+      const payload: Record<string, unknown> = {
         name,
         sourceType: params.sourceType || 'CapturedScene',
         location: params.location,
@@ -806,12 +811,12 @@ export class LightingTools {
         success: true,
         message: response.message || 'Lighting build started',
         ...(response.result || {})
-      } as any;
+      };
     } catch (error) {
       return {
         success: false,
         error: `Failed to build lighting: ${error instanceof Error ? error.message : String(error)}`
-      } as any;
+      };
     }
   }
 

package/src/tools/materials.ts

@@ -120,7 +120,7 @@ export class MaterialTools {
     }
   }
 
-  async createMaterialInstance(name: string, path: string, parentMaterial: string, parameters?: Record<string, any>) {
+  async createMaterialInstance(name: string, path: string, parentMaterial: string, parameters?: Record<string, unknown>) {
     try {
       if (!name || name.trim() === '') {
         return { success: false, error: 'Material instance name cannot be empty' };
@@ -146,8 +146,14 @@ export class MaterialTools {
           if (!(errTxt.toLowerCase().includes('unknown') || errTxt.includes('UNKNOWN_PLUGIN_ACTION'))) {
             return { success: false, error: resp?.error ?? resp?.message ?? 'CREATE_MATERIAL_INSTANCE_FAILED' } as any;
           }
-        } catch (_e) {
-          // fall back to python path below
+        } catch (e) {
+          // If the error is simply generic or unknown action, we fall back.
+          // But if it's a specific error, we might log it.
+          // For now, let's at least not silence everything.
+          const msg = e instanceof Error ? e.message : String(e);
+          if (!msg.includes('unknown') && !msg.includes('UNKNOWN_PLUGIN_ACTION')) {
+            console.warn(`[MaterialTools] Plugin create_material_instance failed with specific error (falling back to python): ${msg}`);
+          }
         }
       }
 

package/src/tools/niagara.ts

@@ -1,6 +1,7 @@
 import { UnrealBridge } from '../unreal-bridge.js';
 import { AutomationBridge } from '../automation/index.js';
 import { sanitizeAssetName, validateAssetParams } from '../utils/validation.js';
+import { wasmIntegration } from '../wasm/index.js';
 
 type Vector3 = [number, number, number];
 
@@ -30,6 +31,18 @@ export class NiagaraTools {
         throw new Error('Automation Bridge not available. Niagara system creation requires plugin support.');
       }
 
+      // Process emitter params with WASM
+      if (params.emitters) {
+        for (const emitter of params.emitters) {
+          if (emitter.shapeSize) {
+            const zeroVector: [number, number, number] = [0, 0, 0];
+            const processedSize = wasmIntegration.vectorAdd(zeroVector, emitter.shapeSize);
+            console.error('[WASM] Using vectorAdd for Niagara emitter shape size');
+            emitter.shapeSize = [processedSize[0], processedSize[1], processedSize[2]];
+          }
+        }
+      }
+
       const path = params.savePath || '/Game/Effects/Niagara';
       const response: any = await this.automationBridge.sendAutomationRequest(
         'create_niagara_system',
@@ -118,8 +131,22 @@ export class NiagaraTools {
     };
 
     const requestPayload: Record<string, unknown> = { systemPath: params.systemPath };
-    const start = toVector(params.start);
-    const end = toVector(params.end);
+    let start = toVector(params.start);
+    let end = toVector(params.end);
+
+    // Use WASM for vector processing if available
+    const zeroVector: [number, number, number] = [0, 0, 0];
+    if (start) {
+      const processed = wasmIntegration.vectorAdd(zeroVector, start);
+      console.error('[WASM] Using vectorAdd for Niagara ribbon start');
+      start = [processed[0], processed[1], processed[2]];
+    }
+    if (end) {
+      const processed = wasmIntegration.vectorAdd(zeroVector, end);
+      console.error('[WASM] Using vectorAdd for Niagara ribbon end');
+      end = [processed[0], processed[1], processed[2]];
+    }
+
     if (start) requestPayload.start = start;
     if (end) requestPayload.end = end;
     if (params.color) requestPayload.color = params.color;
@@ -202,6 +229,21 @@ export class NiagaraTools {
       return { success: false, error: 'AUTOMATION_BRIDGE_UNAVAILABLE', message: 'addEmitter requires automation bridge' } as const;
     }
 
+    // Use WASM for velocity processing
+    if (params.properties) {
+      const zeroVector: [number, number, number] = [0, 0, 0];
+      if (params.properties.velocityMin) {
+        const processed = wasmIntegration.vectorAdd(zeroVector, params.properties.velocityMin);
+        console.error('[WASM] Using vectorAdd for Niagara velocity min');
+        params.properties.velocityMin = [processed[0], processed[1], processed[2]];
+      }
+      if (params.properties.velocityMax) {
+        const processed = wasmIntegration.vectorAdd(zeroVector, params.properties.velocityMax);
+        console.error('[WASM] Using vectorAdd for Niagara velocity max');
+        params.properties.velocityMax = [processed[0], processed[1], processed[2]];
+      }
+    }
+
     try {
       const resp: any = await this.automationBridge.sendAutomationRequest('manage_niagara_graph', {
         subAction: 'add_emitter',

package/src/tools/performance.ts

@@ -474,7 +474,7 @@ export class PerformanceTools {
   // Draw call optimization
   async optimizeDrawCalls(params: {
     enableInstancing?: boolean;
-    enableBatching?: boolean; // no-op (deprecated internal toggle)
+
     mergeActors?: boolean;
     actors?: string[];
   }) {
@@ -495,7 +495,6 @@ export class PerformanceTools {
 
           const payload: any = {
             enableInstancing: params.enableInstancing,
-            enableBatching: params.enableBatching,
             mergeActors: params.mergeActors,
             actors: actors
           };

package/src/tools/physics.ts

@@ -3,6 +3,7 @@ import { UnrealBridge } from '../unreal-bridge.js';
 import { AutomationBridge } from '../automation/index.js';
 import { validateAssetParams, resolveSkeletalMeshPath, concurrencyDelay } from '../utils/validation.js';
 import { coerceString, coerceStringArray } from '../utils/result-helpers.js';
+import { wasmIntegration } from '../wasm/index.js';
 
 export class PhysicsTools {
   constructor(private bridge: UnrealBridge, private automationBridge?: AutomationBridge) { }
@@ -485,10 +486,15 @@ export class PhysicsTools {
     }
 
     try {
+      // Use WASM for vector normalization/validation
+      const zeroVector: [number, number, number] = [0, 0, 0];
+      const normalizedVector = wasmIntegration.vectorAdd(zeroVector, params.vector);
+      console.error('[WASM] Using vectorAdd for physics force vector processing');
+
       const response = await this.automationBridge.sendAutomationRequest('apply_force', {
         actorName: params.actorName,
         forceType: params.forceType,
-        vector: params.vector,
+        vector: normalizedVector,
         boneName: params.boneName,
         isLocal: params.isLocal
       }, {

package/src/tools/sequence.ts

@@ -1,5 +1,7 @@
 import { BaseTool } from './base-tool.js';
-import { ISequenceTools } from '../types/tool-interfaces.js';
+import { ISequenceTools, StandardActionResponse } from '../types/tool-interfaces.js';
+import { SequenceResponse } from '../types/automation-responses.js';
+import { wasmIntegration } from '../wasm/index.js';
 
 export interface LevelSequence {
   path: string;
@@ -39,7 +41,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     const finalTimeout = typeof timeoutMs === 'number' && timeoutMs > 0 ? timeoutMs : defaultTimeout;
 
     try {
-      const response = await this.sendAutomationRequest(
+      const response = await this.sendAutomationRequest<SequenceResponse>(
         action,
         payload,
         { timeoutMs: finalTimeout, waitForEvent: false }
@@ -49,7 +51,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
       const result = response.result ?? response;
 
       return { success, message: response.message ?? undefined, error: response.success === false ? (response.error ?? response.message) : undefined, result, requestId: response.requestId } as any;
-    } catch (err: any) {
+    } catch (err: unknown) {
       return { success: false, error: String(err), message: String(err) } as const;
     }
   }
@@ -61,7 +63,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return txt.includes('unknown_action') || txt.includes('unknown automation action') || txt.includes('not_implemented') || txt === 'unknown_plugin_action';
   }
 
-  async create(params: { name: string; path?: string; timeoutMs?: number }) {
+  async create(params: { name: string; path?: string; timeoutMs?: number }): Promise<StandardActionResponse> {
     const name = params.name?.trim();
     const base = (params.path || '/Game/Sequences').replace(/\/$/, '');
     if (!name) return { success: false, error: 'name is required' };
@@ -79,7 +81,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async open(params: { path: string }) {
+  async open(params: { path: string }): Promise<StandardActionResponse> {
     const path = params.path?.trim();
     const resp = await this.sendAction('sequence_open', { path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -91,7 +93,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async addCamera(params: { spawnable?: boolean; path?: string }) {
+  async addCamera(params: { spawnable?: boolean; path?: string }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params.path);
     const resp = await this.sendAction('sequence_add_camera', { path, spawnable: params.spawnable !== false });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -100,7 +102,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async addActor(params: { actorName: string; createBinding?: boolean; path?: string }) {
+  async addActor(params: { actorName: string; createBinding?: boolean; path?: string }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params.path);
     const resp = await this.sendAction('sequence_add_actor', { path, actorName: params.actorName, createBinding: params.createBinding });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -112,7 +114,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Play the current level sequence
    */
-  async play(params?: { path?: string; startTime?: number; loopMode?: 'once' | 'loop' | 'pingpong' }) {
+  async play(params?: { path?: string; startTime?: number; loopMode?: 'once' | 'loop' | 'pingpong' }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params?.path);
     const resp = await this.sendAction('sequence_play', { path, startTime: params?.startTime, loopMode: params?.loopMode });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -124,7 +126,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Pause the current level sequence
    */
-  async pause(params?: { path?: string }) {
+  async pause(params?: { path?: string }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params?.path);
     const resp = await this.sendAction('sequence_pause', { path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -136,7 +138,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Stop/close the current level sequence
    */
-  async stop(params?: { path?: string }) {
+  async stop(params?: { path?: string }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params?.path);
     const resp = await this.sendAction('sequence_stop', { path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -154,7 +156,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     lengthInFrames?: number;
     playbackStart?: number;
     playbackEnd?: number;
-  }) {
+  }): Promise<StandardActionResponse> {
     const payload: Record<string, unknown> = {
       path: params.path,
       frameRate: params.frameRate,
@@ -172,7 +174,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Set display rate (fps)
    */
-  async setDisplayRate(params: { path?: string; frameRate: string | number }) {
+  async setDisplayRate(params: { path?: string; frameRate: string | number }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_set_display_rate', { path: params.path, frameRate: params.frameRate });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_set_display_rate' } as const;
@@ -183,7 +185,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Get sequence properties
    */
-  async getSequenceProperties(params: { path?: string }) {
+  async getSequenceProperties(params: { path?: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_get_properties', { path: params.path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_get_properties' } as const;
@@ -194,7 +196,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Set playback speed/rate
    */
-  async setPlaybackSpeed(params: { speed: number; path?: string }) {
+  async setPlaybackSpeed(params: { speed: number; path?: string }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params.path);
     const resp = await this.sendAction('sequence_set_playback_speed', { path, speed: params.speed });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -206,7 +208,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Get all bindings in the current sequence
    */
-  async getBindings(params?: { path?: string }) {
+  async getBindings(params?: { path?: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_get_bindings', { path: params?.path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_get_bindings' } as const;
@@ -217,7 +219,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Add multiple actors to sequence at once
    */
-  async addActors(params: { actorNames: string[]; path?: string }) {
+  async addActors(params: { actorNames: string[]; path?: string }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params.path);
     const resp = await this.sendAction('sequence_add_actors', { path, actorNames: params.actorNames });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -229,7 +231,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Remove actors from binding
    */
-  async removeActors(params: { actorNames: string[]; path?: string }) {
+  async removeActors(params: { actorNames: string[]; path?: string }): Promise<StandardActionResponse> {
     const path = this.resolveSequencePath(params.path);
     const resp = await this.sendAction('sequence_remove_actors', { path, actorNames: params.actorNames });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
@@ -241,7 +243,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Create a spawnable from an actor class
    */
-  async addSpawnableFromClass(params: { className: string; path?: string }) {
+  async addSpawnableFromClass(params: { className: string; path?: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_add_spawnable_from_class', { className: params.className, path: params.path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_add_spawnable_from_class' } as const;
@@ -249,7 +251,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async list(params?: { path?: string }) {
+  async list(params?: { path?: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_list', { path: params?.path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_list' } as const;
@@ -265,7 +267,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async duplicate(params: { path: string; destinationPath: string }) {
+  async duplicate(params: { path: string; destinationPath: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_duplicate', { path: params.path, destinationPath: params.destinationPath });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_duplicate' } as const;
@@ -273,7 +275,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async rename(params: { path: string; newName: string }) {
+  async rename(params: { path: string; newName: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_rename', { path: params.path, newName: params.newName });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_rename' } as const;
@@ -281,7 +283,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async deleteSequence(params: { path: string }) {
+  async deleteSequence(params: { path: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_delete', { path: params.path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_delete' } as const;
@@ -289,7 +291,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
     return resp;
   }
 
-  async getMetadata(params: { path?: string }) {
+  async getMetadata(params: { path?: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_get_metadata', { path: params.path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_get_metadata' } as const;
@@ -311,7 +313,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
       rotation?: { roll: number; pitch: number; yaw: number };
       scale?: { x: number; y: number; z: number };
     };
-  }) {
+  }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_add_keyframe', {
       path: params.path,
       bindingId: params.bindingId,
@@ -320,6 +322,20 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
       frame: params.frame,
       value: params.value
     });
+
+    // Use WASM for transform processing
+    if (params.property === 'Transform' && params.value) {
+      const loc = params.value.location;
+      const rot = params.value.rotation;
+      const scale = params.value.scale;
+      if (loc && rot && scale) {
+        const locArr: [number, number, number] = [loc.x, loc.y, loc.z];
+        const rotArr: [number, number, number] = [rot.pitch, rot.yaw, rot.roll];
+        const scaleArr: [number, number, number] = [scale.x, scale.y, scale.z];
+        wasmIntegration.composeTransform(locArr, rotArr, scaleArr);
+        console.error('[WASM] Using composeTransform for keyframe validation');
+      }
+    }
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_add_keyframe' } as const;
     }
@@ -329,7 +345,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * List tracks in a sequence
    */
-  async listTracks(params: { path: string }) {
+  async listTracks(params: { path: string }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_list_tracks', { path: params.path });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_list_tracks' } as const;
@@ -348,7 +364,7 @@ export class SequenceTools extends BaseTool implements ISequenceTools {
   /**
    * Set playback work range
    */
-  async setWorkRange(params: { path?: string; start: number; end: number }) {
+  async setWorkRange(params: { path?: string; start: number; end: number }): Promise<StandardActionResponse> {
     const resp = await this.sendAction('sequence_set_work_range', { path: params.path, start: params.start, end: params.end });
     if (!resp.success && this.isUnknownActionResponse(resp)) {
       return { success: false, error: 'UNKNOWN_PLUGIN_ACTION', message: 'Automation plugin does not implement sequence_set_work_range' } as const;

package/src/tools/ui.ts

@@ -59,7 +59,7 @@ export class UITools {
         package_path: path,
         factory_class: 'WidgetBlueprintFactory',
         asset_class: 'unreal.WidgetBlueprint'
-      } as Record<string, any>;
+      } as Record<string, unknown>;
 
       const resp = await this.bridge.executeEditorFunction('CREATE_ASSET', payload as any);
       const result = resp && typeof resp === 'object' ? (resp.result ?? resp) : resp;
@@ -123,7 +123,6 @@ export class UITools {
   async setWidgetText(_params: {
     key: string; // The widget name to find
     value: string; // The text to set
-    componentName?: string; // Legacy/Unused in new impl
   }) {
     if (!this.automationBridge) {
       throw new Error('Automation bridge required for setting widget text');
@@ -149,7 +148,6 @@ export class UITools {
   async setWidgetImage(_params: {
     key: string;
     texturePath: string;
-    componentName?: string; // Unused
   }) {
     if (!this.automationBridge) {
       throw new Error('Automation bridge required for setting widget images');