unreal-engine-mcp-server 0.5.21 → 0.6.0-a

package/dist/tools/level.js

@@ -1,783 +0,0 @@
-import { BaseTool } from './base-tool.js';
-import { sanitizePath } from '../utils/path-security.js';
-import { sanitizeCommandArgument } from '../utils/validation.js';
-import { DEFAULT_OPERATION_TIMEOUT_MS, DEFAULT_ASSET_OP_TIMEOUT_MS, LONG_RUNNING_OP_TIMEOUT_MS } from '../constants.js';
-export class LevelTools extends BaseTool {
-    managedLevels = new Map();
-    listCache;
-    LIST_CACHE_TTL_MS = 750;
-    currentLevelPath;
-    invalidateListCache() {
-        this.listCache = undefined;
-    }
-    normalizeLevelPath(rawPath) {
-        if (!rawPath) {
-            return { path: '/Game/Maps/Untitled', name: 'Untitled' };
-        }
-        let formatted = rawPath.replace(/\\/g, '/').trim();
-        if (!formatted.startsWith('/')) {
-            formatted = formatted.startsWith('Game/') ? `/${formatted}` : `/Game/${formatted.replace(/^\/?Game\//i, '')}`;
-        }
-        if (!formatted.startsWith('/Game/')) {
-            formatted = `/Game/${formatted.replace(/^\/+/, '')}`;
-        }
-        try {
-            formatted = sanitizePath(formatted);
-        }
-        catch (e) {
-            throw new Error(`Security validation failed for level path: ${e instanceof Error ? e.message : String(e)}`);
-        }
-        formatted = formatted.replace(/\.umap$/i, '');
-        if (formatted.endsWith('/')) {
-            formatted = formatted.slice(0, -1);
-        }
-        const segments = formatted.split('/').filter(Boolean);
-        const lastSegment = segments[segments.length - 1] ?? 'Untitled';
-        const name = lastSegment.includes('.') ? lastSegment.split('.').pop() ?? lastSegment : lastSegment;
-        return { path: formatted, name: name || 'Untitled' };
-    }
-    ensureRecord(path, seed) {
-        const normalized = this.normalizeLevelPath(path);
-        let record = this.managedLevels.get(normalized.path);
-        if (!record) {
-            record = {
-                path: normalized.path,
-                name: seed?.name ?? normalized.name,
-                partitioned: seed?.partitioned ?? false,
-                streaming: seed?.streaming ?? false,
-                loaded: seed?.loaded ?? false,
-                visible: seed?.visible ?? false,
-                createdAt: seed?.createdAt ?? Date.now(),
-                lastSavedAt: seed?.lastSavedAt,
-                metadata: seed?.metadata ? { ...seed.metadata } : undefined,
-                exports: seed?.exports ? [...seed.exports] : [],
-                lights: seed?.lights ? [...seed.lights] : []
-            };
-            this.managedLevels.set(normalized.path, record);
-            this.invalidateListCache();
-        }
-        return record;
-    }
-    mutateRecord(path, updates) {
-        if (!path || !path.trim()) {
-            return undefined;
-        }
-        const record = this.ensureRecord(path, updates);
-        let changed = false;
-        if (updates.name !== undefined && updates.name !== record.name) {
-            record.name = updates.name;
-            changed = true;
-        }
-        if (updates.partitioned !== undefined && updates.partitioned !== record.partitioned) {
-            record.partitioned = updates.partitioned;
-            changed = true;
-        }
-        if (updates.streaming !== undefined && updates.streaming !== record.streaming) {
-            record.streaming = updates.streaming;
-            changed = true;
-        }
-        if (updates.loaded !== undefined && updates.loaded !== record.loaded) {
-            record.loaded = updates.loaded;
-            changed = true;
-        }
-        if (updates.visible !== undefined && updates.visible !== record.visible) {
-            record.visible = updates.visible;
-            changed = true;
-        }
-        if (updates.createdAt !== undefined && updates.createdAt !== record.createdAt) {
-            record.createdAt = updates.createdAt;
-            changed = true;
-        }
-        if (updates.lastSavedAt !== undefined && updates.lastSavedAt !== record.lastSavedAt) {
-            record.lastSavedAt = updates.lastSavedAt;
-            changed = true;
-        }
-        if (updates.metadata) {
-            record.metadata = { ...(record.metadata ?? {}), ...updates.metadata };
-            changed = true;
-        }
-        if (updates.exports && updates.exports.length > 0) {
-            record.exports = [...record.exports, ...updates.exports];
-            changed = true;
-        }
-        if (updates.lights && updates.lights.length > 0) {
-            record.lights = [...record.lights, ...updates.lights];
-            changed = true;
-        }
-        if (changed) {
-            this.invalidateListCache();
-        }
-        return record;
-    }
-    getRecord(path) {
-        if (!path || !path.trim()) {
-            return undefined;
-        }
-        const normalized = this.normalizeLevelPath(path);
-        return this.managedLevels.get(normalized.path);
-    }
-    resolveLevelPath(explicit) {
-        if (explicit && explicit.trim()) {
-            return this.normalizeLevelPath(explicit).path;
-        }
-        return this.currentLevelPath;
-    }
-    removeRecord(path) {
-        const normalized = this.normalizeLevelPath(path);
-        if (this.managedLevels.delete(normalized.path)) {
-            if (this.currentLevelPath === normalized.path) {
-                this.currentLevelPath = undefined;
-            }
-            this.invalidateListCache();
-        }
-    }
-    listManagedLevels() {
-        const now = Date.now();
-        if (this.listCache && now - this.listCache.timestamp < this.LIST_CACHE_TTL_MS) {
-            return this.listCache.result;
-        }
-        const levels = Array.from(this.managedLevels.values()).map((record) => ({
-            path: record.path,
-            name: record.name,
-            partitioned: record.partitioned,
-            streaming: record.streaming,
-            loaded: record.loaded,
-            visible: record.visible,
-            createdAt: record.createdAt,
-            lastSavedAt: record.lastSavedAt,
-            exports: record.exports,
-            lightCount: record.lights.length
-        }));
-        const result = { success: true, message: 'Managed levels listed', count: levels.length, levels };
-        this.listCache = { result, timestamp: now };
-        return result;
-    }
-    summarizeLevel(path) {
-        const record = this.getRecord(path);
-        if (!record) {
-            return { success: false, error: `Level not tracked: ${path}` };
-        }
-        return {
-            success: true,
-            message: 'Level summary ready',
-            path: record.path,
-            name: record.name,
-            partitioned: record.partitioned,
-            streaming: record.streaming,
-            loaded: record.loaded,
-            visible: record.visible,
-            createdAt: record.createdAt,
-            lastSavedAt: record.lastSavedAt,
-            exports: record.exports,
-            lights: record.lights,
-            metadata: record.metadata
-        };
-    }
-    setCurrentLevel(path) {
-        const normalized = this.normalizeLevelPath(path);
-        this.currentLevelPath = normalized.path;
-        this.ensureRecord(normalized.path, { loaded: true, visible: true });
-    }
-    async listLevels() {
-        try {
-            const response = await this.sendAutomationRequest('list_levels', {}, {
-                timeoutMs: 10000
-            });
-            if (response && response.success !== false) {
-                const managed = this.listManagedLevels();
-                const ueLevels = (response.allMaps || []);
-                const managedOnly = managed.levels.filter(m => !ueLevels.some(u => u.path === m.path));
-                const finalLevels = [...ueLevels, ...managedOnly];
-                const result = {
-                    ...response,
-                    success: true,
-                    message: 'Levels listed from Unreal Engine',
-                    levels: finalLevels,
-                    currentMap: response.currentMap,
-                    currentMapPath: response.currentMapPath,
-                    currentWorldLevels: response.currentWorldLevels || [],
-                    data: {
-                        levels: finalLevels,
-                        count: finalLevels.length
-                    },
-                    managedLevels: managed.levels,
-                    managedLevelCount: managed.count
-                };
-                return result;
-            }
-        }
-        catch {
-        }
-        return this.listManagedLevels();
-    }
-    async getLevelSummary(levelPath) {
-        const resolved = this.resolveLevelPath(levelPath);
-        if (!resolved) {
-            return { success: false, error: 'No level specified' };
-        }
-        return this.summarizeLevel(resolved);
-    }
-    registerLight(levelPath, info) {
-        const resolved = this.resolveLevelPath(levelPath);
-        if (!resolved) {
-            return;
-        }
-        this.mutateRecord(resolved, {
-            lights: [
-                {
-                    name: info.name,
-                    type: info.type,
-                    createdAt: Date.now(),
-                    details: info.details
-                }
-            ]
-        });
-    }
-    async exportLevel(params) {
-        const resolved = this.resolveLevelPath(params.levelPath);
-        if (!resolved) {
-            return { success: false, error: 'No level specified for export' };
-        }
-        try {
-            const res = await this.sendAutomationRequest('manage_level', {
-                action: 'export_level',
-                levelPath: resolved,
-                exportPath: params.exportPath
-            }, { timeoutMs: params.timeoutMs ?? LONG_RUNNING_OP_TIMEOUT_MS });
-            if (res?.success === false) {
-                return {
-                    success: false,
-                    error: res.error || res.message || 'Export failed',
-                    levelPath: resolved,
-                    exportPath: params.exportPath,
-                    details: res
-                };
-            }
-            return {
-                success: true,
-                message: `Level exported to ${params.exportPath}`,
-                levelPath: resolved,
-                exportPath: params.exportPath,
-                details: res
-            };
-        }
-        catch (e) {
-            return { success: false, error: `Export failed: ${e instanceof Error ? e.message : String(e)}` };
-        }
-    }
-    async importLevel(params) {
-        const destination = params.destinationPath
-            ? this.normalizeLevelPath(params.destinationPath)
-            : this.normalizeLevelPath(`/Game/Maps/Imported_${Math.floor(Date.now() / 1000)}`);
-        try {
-            const res = await this.sendAutomationRequest('manage_level', {
-                action: 'import_level',
-                packagePath: params.packagePath,
-                destinationPath: destination.path
-            }, { timeoutMs: params.timeoutMs ?? LONG_RUNNING_OP_TIMEOUT_MS });
-            if (res?.success === false) {
-                const resObj = res;
-                return {
-                    success: false,
-                    error: resObj.error || resObj.message || 'Import failed',
-                    levelPath: destination.path,
-                    details: res
-                };
-            }
-            return {
-                success: true,
-                message: `Level imported to ${destination.path}`,
-                levelPath: destination.path,
-                partitioned: true,
-                streaming: Boolean(params.streaming),
-                details: res
-            };
-        }
-        catch (e) {
-            return { success: false, error: `Import failed: ${e instanceof Error ? e.message : String(e)}` };
-        }
-    }
-    async saveLevelAs(params) {
-        const source = this.resolveLevelPath(params.sourcePath);
-        const target = this.normalizeLevelPath(params.targetPath);
-        try {
-            const response = await this.sendAutomationRequest('manage_level', {
-                action: 'save_level_as',
-                savePath: target.path
-            }, {
-                timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
-            });
-            if (response.success === false) {
-                return { success: false, error: response.error || response.message || 'Failed to save level as' };
-            }
-            if (!source) {
-                this.ensureRecord(target.path, {
-                    name: target.name,
-                    loaded: true,
-                    visible: true,
-                    createdAt: Date.now(),
-                    lastSavedAt: Date.now()
-                });
-            }
-            else {
-                const sourceRecord = this.getRecord(source);
-                const now = Date.now();
-                this.ensureRecord(target.path, {
-                    name: target.name,
-                    partitioned: sourceRecord?.partitioned ?? true,
-                    streaming: sourceRecord?.streaming ?? false,
-                    loaded: true,
-                    visible: true,
-                    metadata: { ...(sourceRecord?.metadata ?? {}), savedFrom: source },
-                    exports: sourceRecord?.exports ?? [],
-                    lights: sourceRecord?.lights ?? [],
-                    createdAt: sourceRecord?.createdAt ?? now,
-                    lastSavedAt: now
-                });
-            }
-            this.setCurrentLevel(target.path);
-            return {
-                success: true,
-                message: response.message || `Level saved as ${target.path}`,
-                levelPath: target.path
-            };
-        }
-        catch (error) {
-            return { success: false, error: `Failed to save level as: ${error instanceof Error ? error.message : String(error)}` };
-        }
-    }
-    async deleteLevels(params) {
-        const removed = [];
-        for (const path of params.levelPaths) {
-            const normalized = this.normalizeLevelPath(path).path;
-            if (this.managedLevels.has(normalized)) {
-                this.removeRecord(normalized);
-                removed.push(normalized);
-            }
-        }
-        return {
-            success: true,
-            message: removed.length ? `Deleted ${removed.length} managed level(s)` : 'No managed levels removed',
-            removed
-        };
-    }
-    async loadLevel(params) {
-        const normalizedPath = this.normalizeLevelPath(params.levelPath).path;
-        if (params.streaming) {
-            try {
-                const simpleName = (params.levelPath || '').split('/').filter(Boolean).pop() || params.levelPath;
-                await this.bridge.executeConsoleCommand(`StreamLevel ${simpleName} Load Show`);
-                this.mutateRecord(normalizedPath, {
-                    streaming: true,
-                    loaded: true,
-                    visible: true
-                });
-                return {
-                    success: true,
-                    message: `Streaming level loaded: ${params.levelPath}`,
-                    levelPath: normalizedPath,
-                    streaming: true
-                };
-            }
-            catch (err) {
-                return {
-                    success: false,
-                    error: `Failed to load streaming level: ${err}`,
-                    levelPath: normalizedPath
-                };
-            }
-        }
-        else {
-            try {
-                const response = await this.sendAutomationRequest('manage_level', {
-                    action: 'load',
-                    levelPath: params.levelPath
-                }, { timeoutMs: DEFAULT_OPERATION_TIMEOUT_MS });
-                if (response.success) {
-                    this.setCurrentLevel(normalizedPath);
-                    this.mutateRecord(normalizedPath, {
-                        streaming: false,
-                        loaded: true,
-                        visible: true
-                    });
-                    return {
-                        ...response,
-                        success: true,
-                        message: `Level loaded: ${params.levelPath}`,
-                        level: normalizedPath,
-                        streaming: false
-                    };
-                }
-                else {
-                    return {
-                        ...response,
-                        success: false,
-                        error: response.error || 'LOAD_FAILED',
-                        message: response.message || `Failed to load level: ${params.levelPath}`,
-                        level: normalizedPath
-                    };
-                }
-            }
-            catch (bridgeError) {
-                let isBridgeConnected = false;
-                try {
-                    const automation = this.getAutomationBridge();
-                    isBridgeConnected = automation && typeof automation.sendAutomationRequest === 'function' && automation.isConnected();
-                }
-                catch {
-                    isBridgeConnected = false;
-                }
-                if (isBridgeConnected) {
-                    return {
-                        success: false,
-                        error: `Bridge error: ${bridgeError instanceof Error ? bridgeError.message : String(bridgeError)}`,
-                        level: normalizedPath
-                    };
-                }
-                try {
-                    const existsResp = await this.bridge.executeConsoleCommand(`GetLevelPath ${normalizedPath}`);
-                    if (!existsResp || (typeof existsResp.message === 'string' && existsResp.message.includes('not found'))) {
-                        return {
-                            success: false,
-                            error: 'LEVEL_NOT_FOUND',
-                            message: `Level not found: ${params.levelPath}`,
-                            level: normalizedPath
-                        };
-                    }
-                    await this.bridge.executeConsoleCommand(`Open ${normalizedPath}`);
-                    this.setCurrentLevel(normalizedPath);
-                    this.mutateRecord(normalizedPath, {
-                        streaming: false,
-                        loaded: true,
-                        visible: true
-                    });
-                    return {
-                        success: true,
-                        message: `Level loaded: ${params.levelPath}`,
-                        level: normalizedPath,
-                        streaming: false
-                    };
-                }
-                catch (err) {
-                    return {
-                        success: false,
-                        error: `Failed to load level: ${err}`,
-                        level: normalizedPath
-                    };
-                }
-            }
-        }
-    }
-    async saveLevel(params) {
-        try {
-            if (params.savePath && !params.savePath.startsWith('/Game/')) {
-                throw new Error(`Invalid save path: ${params.savePath}`);
-            }
-            const action = params.savePath ? 'save_level_as' : 'save';
-            const payload = { action };
-            if (params.savePath) {
-                payload.savePath = params.savePath;
-            }
-            const response = await this.sendAutomationRequest('manage_level', payload, {
-                timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
-            });
-            if (response.success === false) {
-                return { success: false, error: response.error || response.message || 'Failed to save level' };
-            }
-            const result = {
-                ...response,
-                success: true,
-                message: response.message || 'Level saved'
-            };
-            if (response.skipped) {
-                result.skipped = response.skipped;
-            }
-            if (response.reason) {
-                result.reason = response.reason;
-            }
-            if (response.warnings) {
-                result.warnings = response.warnings;
-            }
-            if (response.details) {
-                result.details = response.details;
-            }
-            return result;
-        }
-        catch (error) {
-            return { success: false, error: `Failed to save level: ${error instanceof Error ? error.message : String(error)}` };
-        }
-    }
-    async createLevel(params) {
-        const sanitizedName = sanitizeCommandArgument(params.levelName);
-        const isPartitioned = params.useWorldPartition ?? false;
-        let fullPath;
-        if (params.savePath) {
-            const normalizedPath = this.normalizeLevelPath(params.savePath).path;
-            const pathSegments = normalizedPath.split('/').filter(s => s.length > 0);
-            const lastSegment = pathSegments[pathSegments.length - 1];
-            if (lastSegment && lastSegment.toLowerCase() === sanitizedName.toLowerCase()) {
-                fullPath = normalizedPath;
-            }
-            else {
-                fullPath = `${normalizedPath}/${sanitizedName}`;
-            }
-        }
-        else {
-            fullPath = `/Game/Maps/${sanitizedName}`;
-        }
-        try {
-            const response = await this.sendAutomationRequest('create_new_level', {
-                levelPath: fullPath,
-                useWorldPartition: isPartitioned
-            }, {
-                timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
-            });
-            if (response.success === false) {
-                return {
-                    success: false,
-                    error: response.error || response.message || 'Failed to create level',
-                    path: fullPath,
-                    partitioned: isPartitioned
-                };
-            }
-            const result = {
-                ...response,
-                success: true,
-                message: response.message || 'Level created',
-                path: response.levelPath || fullPath,
-                packagePath: response.packagePath ?? fullPath,
-                objectPath: response.objectPath,
-                partitioned: isPartitioned
-            };
-            if (response.warnings) {
-                result.warnings = response.warnings;
-            }
-            if (response.details) {
-                result.details = response.details;
-            }
-            this.ensureRecord(fullPath, {
-                name: params.levelName,
-                partitioned: isPartitioned,
-                loaded: true,
-                visible: true,
-                createdAt: Date.now()
-            });
-            return result;
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Failed to create level: ${error instanceof Error ? error.message : String(error)}`,
-                path: fullPath,
-                partitioned: isPartitioned
-            };
-        }
-    }
-    async addSubLevel(params) {
-        const parent = params.parentLevel ? this.resolveLevelPath(params.parentLevel) : this.currentLevelPath;
-        const sub = this.normalizeLevelPath(params.subLevelPath).path;
-        try {
-            const response = await this.sendAutomationRequest('manage_level', {
-                action: 'add_sublevel',
-                levelPath: sub,
-                subLevelPath: sub,
-                parentPath: parent,
-                streamingMethod: params.streamingMethod
-            }, { timeoutMs: DEFAULT_OPERATION_TIMEOUT_MS });
-            if (response.success) {
-                this.ensureRecord(sub, { loaded: true, visible: true, streaming: true });
-                return response;
-            }
-            else if (response.error === 'UNKNOWN_ACTION') {
-            }
-            else {
-                return response;
-            }
-        }
-        catch (_e) {
-        }
-        const consoleResponse = await this.sendAutomationRequest('console_command', {
-            command: `LevelEditor.AddLevel ${sub}`
-        });
-        if (consoleResponse.success) {
-            this.ensureRecord(sub, { loaded: true, visible: true, streaming: true });
-            return {
-                success: true,
-                message: `Sublevel added via console: ${sub}`,
-                data: { method: 'console' }
-            };
-        }
-        return {
-            success: false,
-            error: 'Fallbacks failed',
-            message: 'Failed to add sublevel via automation or console.',
-            details: { consoleError: consoleResponse }
-        };
-    }
-    async streamLevel(params) {
-        const rawPath = typeof params.levelPath === 'string' ? params.levelPath.trim() : '';
-        const levelPath = rawPath.length > 0 ? rawPath : undefined;
-        const providedName = typeof params.levelName === 'string' ? params.levelName.trim() : '';
-        const derivedName = providedName.length > 0
-            ? providedName
-            : (levelPath ? levelPath.split('/').filter(Boolean).pop() ?? '' : '');
-        const levelName = derivedName.length > 0 ? derivedName : undefined;
-        const shouldBeVisible = params.shouldBeVisible ?? params.shouldBeLoaded;
-        try {
-            const response = await this.sendAutomationRequest('stream_level', {
-                levelPath: levelPath || '',
-                levelName: levelName || '',
-                shouldBeLoaded: params.shouldBeLoaded,
-                shouldBeVisible
-            }, {
-                timeoutMs: DEFAULT_ASSET_OP_TIMEOUT_MS
-            });
-            if (response.success === false) {
-                return {
-                    success: false,
-                    error: response.error || response.message || 'Streaming level update failed',
-                    message: response.message,
-                    level: levelName || '',
-                    levelPath: levelPath,
-                    loaded: params.shouldBeLoaded,
-                    visible: shouldBeVisible
-                };
-            }
-            const result = {
-                success: true,
-                message: response.message || 'Streaming level updated',
-                level: levelName || '',
-                levelPath,
-                loaded: params.shouldBeLoaded,
-                visible: shouldBeVisible
-            };
-            if (response.warnings) {
-                result.warnings = response.warnings;
-            }
-            if (response.details) {
-                result.details = response.details;
-            }
-            return result;
-        }
-        catch (_error) {
-            const levelIdentifier = levelName ?? levelPath ?? '';
-            const rawSimpleName = levelIdentifier.split('/').filter(Boolean).pop() || levelIdentifier;
-            const simpleName = sanitizeCommandArgument(rawSimpleName);
-            const loadCmd = params.shouldBeLoaded ? 'Load' : 'Unload';
-            const visCmd = shouldBeVisible ? 'Show' : 'Hide';
-            const command = `StreamLevel ${simpleName} ${loadCmd} ${visCmd}`;
-            return this.bridge.executeConsoleCommand(command);
-        }
-    }
-    async setupWorldComposition(params) {
-        const commands = [];
-        if (params.enableComposition) {
-            commands.push('EnableWorldComposition');
-            if (params.tileSize) {
-                commands.push(`SetWorldTileSize ${params.tileSize}`);
-            }
-            if (params.distanceStreaming) {
-                commands.push(`EnableDistanceStreaming ${params.streamingDistance || 5000}`);
-            }
-        }
-        else {
-            commands.push('DisableWorldComposition');
-        }
-        await this.bridge.executeConsoleCommands(commands);
-        return { success: true, message: 'World composition configured' };
-    }
-    async editLevelBlueprint(params) {
-        const command = `OpenLevelBlueprint ${sanitizeCommandArgument(params.eventType)}`;
-        return this.bridge.executeConsoleCommand(command);
-    }
-    async createSubLevel(params) {
-        const sanitizedName = sanitizeCommandArgument(params.name);
-        const sanitizedType = sanitizeCommandArgument(params.type);
-        const sanitizedParent = params.parent ? sanitizeCommandArgument(params.parent) : 'None';
-        const command = `CreateSubLevel ${sanitizedName} ${sanitizedType} ${sanitizedParent}`;
-        return this.bridge.executeConsoleCommand(command);
-    }
-    async setWorldSettings(params) {
-        const commands = [];
-        if (params.gravity !== undefined) {
-            commands.push(`SetWorldGravity ${params.gravity}`);
-        }
-        if (params.worldScale !== undefined) {
-            commands.push(`SetWorldToMeters ${params.worldScale}`);
-        }
-        if (params.gameMode) {
-            commands.push(`SetGameMode ${sanitizeCommandArgument(params.gameMode)}`);
-        }
-        if (params.defaultPawn) {
-            commands.push(`SetDefaultPawn ${sanitizeCommandArgument(params.defaultPawn)}`);
-        }
-        if (params.killZ !== undefined) {
-            commands.push(`SetKillZ ${params.killZ}`);
-        }
-        await this.bridge.executeConsoleCommands(commands);
-        return { success: true, message: 'World settings updated' };
-    }
-    async setLevelBounds(params) {
-        const command = `SetLevelBounds ${params.min.join(',')} ${params.max.join(',')}`;
-        return this.bridge.executeConsoleCommand(command);
-    }
-    async buildNavMesh(params) {
-        try {
-            const response = await this.sendAutomationRequest('build_navigation_mesh', {
-                rebuildAll: params.rebuildAll ?? false,
-                selectedOnly: params.selectedOnly ?? false
-            }, {
-                timeoutMs: 120000
-            });
-            if (response.success === false) {
-                return {
-                    success: false,
-                    error: response.error || response.message || 'Failed to build navigation'
-                };
-            }
-            const result = {
-                success: true,
-                message: response.message || (params.rebuildAll ? 'Navigation rebuild started' : 'Navigation update started')
-            };
-            if (params.rebuildAll !== undefined) {
-                result.rebuildAll = params.rebuildAll;
-            }
-            if (params.selectedOnly !== undefined) {
-                result.selectedOnly = params.selectedOnly;
-            }
-            if (response.selectionCount !== undefined) {
-                result.selectionCount = response.selectionCount;
-            }
-            if (response.warnings) {
-                result.warnings = response.warnings;
-            }
-            if (response.details) {
-                result.details = response.details;
-            }
-            return result;
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: `Navigation build not available: ${error instanceof Error ? error.message : String(error)}. Please ensure a NavMeshBoundsVolume exists in the level.`
-            };
-        }
-    }
-    async setLevelVisibility(params) {
-        const command = `SetLevelVisibility ${sanitizeCommandArgument(params.levelName)} ${params.visible}`;
-        return this.bridge.executeConsoleCommand(command);
-    }
-    async setWorldOrigin(params) {
-        const command = `SetWorldOriginLocation ${params.location.join(' ')}`;
-        return this.bridge.executeConsoleCommand(command);
-    }
-    async createStreamingVolume(params) {
-        const command = `CreateStreamingVolume ${sanitizeCommandArgument(params.levelName)} ${params.position.join(' ')} ${params.size.join(' ')} ${params.streamingDistance || 0}`;
-        return this.bridge.executeConsoleCommand(command);
-    }
-    async setLevelLOD(params) {
-        const command = `SetLevelLOD ${sanitizeCommandArgument(params.levelName)} ${params.lodLevel} ${params.distance}`;
-        return this.bridge.executeConsoleCommand(command);
-    }
-}
-//# sourceMappingURL=level.js.map