unreal-engine-mcp-server 0.4.7 → 0.5.1

package/dist/utils/validation.d.ts

@@ -1,32 +1,9 @@
-/**
- * Validation and sanitization utilities for Unreal Engine assets
- */
-/**
- * Sanitize an asset name for Unreal Engine
- * @param name The name to sanitize
- * @returns Sanitized name
- */
 export declare function sanitizeAssetName(name: string): string;
-/**
- * Sanitize a path for Unreal Engine
- * @param path The path to sanitize
- * @returns Sanitized path
- */
 export declare function sanitizePath(path: string): string;
-/**
- * Validate path length
- * @param path The full path to validate
- * @returns Object with validation result
- */
 export declare function validatePathLength(path: string): {
     valid: boolean;
     error?: string;
 };
-/**
- * Validate and sanitize asset parameters
- * @param params Object containing name and optionally savePath
- * @returns Sanitized parameters with validation result
- */
 export declare function validateAssetParams(params: {
     name: string;
     savePath?: string;
@@ -36,30 +13,13 @@ export declare function validateAssetParams(params: {
     sanitized: typeof params;
     error?: string;
 };
-/**
- * Extract valid skeletal mesh path from various inputs
- * @param input The input path which might be a skeleton or mesh
- * @returns Corrected skeletal mesh path or null
- */
 export declare function resolveSkeletalMeshPath(input: string): string | null;
-/**
- * Concurrency delay to prevent race conditions
- * @param ms Milliseconds to delay
- */
 export declare function concurrencyDelay(ms?: number): Promise<void>;
-/**
- * Ensure the provided value is a finite number within optional bounds.
- * @throws if the value is not a finite number or violates bounds
- */
 export declare function validateNumber(value: unknown, label: string, { min, max, allowZero }?: {
     min?: number;
     max?: number;
     allowZero?: boolean;
 }): number;
-/**
- * Validate an array (tuple) of finite numbers, preserving the original shape.
- * @throws if the tuple has the wrong length or contains invalid values
- */
 export declare function ensureVector3(value: unknown, label: string): [number, number, number];
 export declare function ensureColorRGB(value: unknown, label: string): [number, number, number];
 export declare function ensureRotation(value: unknown, label: string): [number, number, number];

package/dist/utils/validation.js

@@ -1,101 +1,58 @@
-/**
- * Validation and sanitization utilities for Unreal Engine assets
- */
 import { toRotTuple, toVec3Tuple } from './normalize.js';
-/**
- * Maximum path length allowed in Unreal Engine
- */
 const MAX_PATH_LENGTH = 260;
-/**
- * Invalid characters for Unreal Engine asset names
- * Note: Dashes are allowed in Unreal asset names
- */
-// eslint-disable-next-line no-useless-escape
 const INVALID_CHARS = /[@#%$&*()+=\[\]{}<>?|\\;:'"`,~!\s]/g;
-/**
- * Reserved keywords that shouldn't be used as names
- */
 const RESERVED_KEYWORDS = [
     'None', 'null', 'undefined', 'true', 'false',
     'class', 'struct', 'enum', 'interface',
     'default', 'transient', 'native'
 ];
-/**
- * Sanitize an asset name for Unreal Engine
- * @param name The name to sanitize
- * @returns Sanitized name
- */
 export function sanitizeAssetName(name) {
     if (!name || typeof name !== 'string') {
         return 'Asset';
     }
-    // Remove leading/trailing whitespace
     let sanitized = name.trim();
-    // Replace invalid characters with underscores
     sanitized = sanitized.replace(INVALID_CHARS, '_');
-    // Remove consecutive underscores
     sanitized = sanitized.replace(/_+/g, '_');
-    // Remove leading/trailing underscores
     sanitized = sanitized.replace(/^_+|_+$/g, '');
-    // If name is empty after sanitization, use default
     if (!sanitized) {
         return 'Asset';
     }
-    // If name is a reserved keyword, append underscore
     if (RESERVED_KEYWORDS.includes(sanitized)) {
         sanitized = `${sanitized}_Asset`;
     }
-    // Ensure name starts with a letter
     if (!/^[A-Za-z]/.test(sanitized)) {
         sanitized = `Asset_${sanitized}`;
     }
-    // Truncate overly long names to reduce risk of hitting path length limits
     if (sanitized.length > 64) {
         sanitized = sanitized.slice(0, 64);
     }
     return sanitized;
 }
-/**
- * Sanitize a path for Unreal Engine
- * @param path The path to sanitize
- * @returns Sanitized path
- */
 export function sanitizePath(path) {
     if (!path || typeof path !== 'string') {
         return '/Game';
     }
-    // Normalize slashes
     path = path.replace(/\\/g, '/');
-    // Ensure path starts with /
     if (!path.startsWith('/')) {
         path = `/${path}`;
     }
-    // Split path into segments and sanitize each
     let segments = path.split('/').filter(s => s.length > 0);
     if (segments.length === 0) {
         return '/Game';
     }
-    // Ensure the first segment is a valid root (Game, Engine, Script, Temp)
     const ROOTS = new Set(['Game', 'Engine', 'Script', 'Temp']);
     if (!ROOTS.has(segments[0])) {
         segments = ['Game', ...segments];
     }
     const sanitizedSegments = segments.map(segment => {
-        // Don't sanitize Game, Engine, or other root folders
         if (['Game', 'Engine', 'Script', 'Temp'].includes(segment)) {
             return segment;
         }
         return sanitizeAssetName(segment);
     });
-    // Reconstruct path
     const sanitizedPath = '/' + sanitizedSegments.join('/');
     return sanitizedPath;
 }
-/**
- * Validate path length
- * @param path The full path to validate
- * @returns Object with validation result
- */
 export function validatePathLength(path) {
     if (path.length > MAX_PATH_LENGTH) {
         return {
@@ -105,23 +62,14 @@ export function validatePathLength(path) {
     }
     return { valid: true };
 }
-/**
- * Validate and sanitize asset parameters
- * @param params Object containing name and optionally savePath
- * @returns Sanitized parameters with validation result
- */
 export function validateAssetParams(params) {
-    // Sanitize name
     const sanitizedName = sanitizeAssetName(params.name);
-    // Sanitize path if provided
     const sanitizedPath = params.savePath
         ? sanitizePath(params.savePath)
         : params.savePath;
-    // Construct full path for validation
     const fullPath = sanitizedPath
         ? `${sanitizedPath}/${sanitizedName}`
         : `/Game/${sanitizedName}`;
-    // Validate path length
     const pathValidation = validatePathLength(fullPath);
     if (!pathValidation.valid) {
         return {
@@ -139,16 +87,10 @@ export function validateAssetParams(params) {
         }
     };
 }
-/**
- * Extract valid skeletal mesh path from various inputs
- * @param input The input path which might be a skeleton or mesh
- * @returns Corrected skeletal mesh path or null
- */
 export function resolveSkeletalMeshPath(input) {
     if (!input || typeof input !== 'string') {
         return null;
     }
-    // Common skeleton to mesh mappings
     const skeletonToMeshMap = {
         '/Game/Mannequin/Character/Mesh/UE4_Mannequin_Skeleton': '/Game/Characters/Mannequins/Meshes/SKM_Manny_Simple',
         '/Game/Characters/Mannequins/Meshes/SK_Mannequin': '/Game/Characters/Mannequins/Meshes/SKM_Manny_Simple',
@@ -159,15 +101,11 @@ export function resolveSkeletalMeshPath(input) {
         '/Game/Characters/Mannequins/Skeletons/UE5_Manny_Skeleton': '/Game/Characters/Mannequins/Meshes/SKM_Manny_Simple',
         '/Game/Characters/Mannequins/Skeletons/UE5_Quinn_Skeleton': '/Game/Characters/Mannequins/Meshes/SKM_Quinn_Simple'
     };
-    // Check if this is a known skeleton path
     if (skeletonToMeshMap[input]) {
         return skeletonToMeshMap[input];
     }
-    // If it contains _Skeleton, try to convert to mesh name
     if (input.includes('_Skeleton')) {
-        // Try common replacements
         let meshPath = input.replace('_Skeleton', '');
-        // Mapping for replacements
         const replacements = {
             '/SK_': '/SKM_',
             'UE4_Mannequin': 'SKM_Manny',
@@ -175,28 +113,17 @@ export function resolveSkeletalMeshPath(input) {
             'UE5_Manny': 'SKM_Manny',
             'UE5_Quinn': 'SKM_Quinn'
         };
-        // Apply all replacements using regex
         meshPath = meshPath.replace(new RegExp(Object.keys(replacements).join('|'), 'g'), match => replacements[match]);
         return meshPath;
     }
-    // If it starts with SK_ (skeleton prefix), try SKM_ (skeletal mesh prefix)
     if (input.includes('/SK_')) {
         return input.replace('/SK_', '/SKM_');
     }
-    // Return as-is if no conversion needed
     return input;
 }
-/**
- * Concurrency delay to prevent race conditions
- * @param ms Milliseconds to delay
- */
-export async function concurrencyDelay(ms = 100) {
+export async function concurrencyDelay(ms = 20) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
-/**
- * Ensure the provided value is a finite number within optional bounds.
- * @throws if the value is not a finite number or violates bounds
- */
 export function validateNumber(value, label, { min, max, allowZero = true } = {}) {
     if (typeof value !== 'number' || !Number.isFinite(value)) {
         throw new Error(`Invalid ${label}: expected a finite number`);
@@ -212,10 +139,6 @@ export function validateNumber(value, label, { min, max, allowZero = true } = {}
     }
     return value;
 }
-/**
- * Validate an array (tuple) of finite numbers, preserving the original shape.
- * @throws if the tuple has the wrong length or contains invalid values
- */
 export function ensureVector3(value, label) {
     const tuple = toVec3Tuple(value);
     if (!tuple) {

package/dist/wasm/index.d.ts

@@ -0,0 +1,70 @@
+interface WASMConfig {
+    enabled?: boolean;
+    wasmPath?: string;
+    fallbackEnabled?: boolean;
+    performanceMonitoring?: boolean;
+}
+interface PerformanceMetrics {
+    operation: string;
+    duration: number;
+    timestamp: number;
+    useWASM: boolean;
+}
+export declare class WASMIntegration {
+    private log;
+    private module;
+    private config;
+    private metrics;
+    private maxMetrics;
+    private initialized;
+    private moduleUnavailable;
+    constructor(config?: WASMConfig);
+    initialize(): Promise<void>;
+    isReady(): boolean;
+    static isSupported(): boolean;
+    parseProperties(jsonStr: string, options?: {
+        maxDepth?: number;
+    }): Promise<any>;
+    composeTransform(location: [number, number, number], rotation: [number, number, number], scale: [number, number, number]): Float32Array;
+    decomposeMatrix(matrix: Float32Array): number[];
+    vectorAdd(v1: [number, number, number], v2: [number, number, number]): [number, number, number];
+    resolveDependencies(assetPath: string, dependencies: Record<string, string[]>, options?: {
+        maxDepth?: number;
+    }): Promise<any>;
+    calculateDependencyDepth(assetPath: string, dependencies: Record<string, string[]>, options?: {
+        maxDepth?: number;
+    }): Promise<number>;
+    findCircularDependencies(dependencies: Record<string, string[]>, options?: {
+        maxDepth?: number;
+    }): Promise<string[][]>;
+    topologicalSort(dependencies: Record<string, string[]>): Promise<string[]>;
+    getMetrics(): {
+        totalOperations: number;
+        wasmOperations: number;
+        tsOperations: number;
+        averageTime: number;
+        operations: PerformanceMetrics[];
+    };
+    getStatus(): {
+        enabled: boolean;
+        ready: boolean;
+        moduleUnavailable: boolean;
+    };
+    clearMetrics(): void;
+    reportPerformance(): string;
+    private recordMetrics;
+    private fallbackParseProperties;
+    private fallbackComposeTransform;
+    private fallbackDecomposeMatrix;
+    private fallbackVectorAdd;
+    private fallbackResolveDependencies;
+    private fallbackCalculateDependencyDepth;
+    private fallbackFindCircularDependencies;
+    private fallbackTopologicalSort;
+}
+export declare const wasmIntegration: WASMIntegration;
+export declare function initializeWASM(config?: WASMConfig): Promise<void>;
+export declare function isWASMReady(): boolean;
+export declare function getWASMPerformanceReport(): string;
+export {};
+//# sourceMappingURL=index.d.ts.map