unreal-engine-mcp-server 0.6.0-beta-e → 0.6.0

package/dist/tools/catalog/capabilities/records/control-editor/command.js

@@ -1,251 +0,0 @@
-import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-const F = 'command';
-const D = 'editor';
-export const COMMAND_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'invoke_reflected_function', dispatchAction: 'control_editor',
-        domain: D, family: F,
-        summary: 'Call one reflected UFunction on a plugin\'s live object, marshalling arguments through the function\'s own property chain. No signature is hardcoded: whatever describe_reflected_api reports for the installed build is what this accepts, so an integration stays correct across plugin updates instead of silently passing a stale parameter list. Return and out parameters come back in `outputs`. Refuses when only the class default object exists, because invoking on the CDO mutates shared defaults and never reaches the running instance. This is arbitrary in-process invocation — it can reach any reflected function on any resolvable object — so it demands elevated consent.',
-        whenToUse: [
-            'A plugin exposes the needed operation only as a UFUNCTION and no native capability covers it.',
-            'describe_reflected_api confirmed the function and its current parameters.',
-        ],
-        whenNotToUse: [
-            'A native capability already covers the operation — prefer it; a reflected call carries none of the safety wrappers, undo transactions, or path validation the domain handlers apply.',
-            'The signature has not been confirmed against the installed build.',
-        ],
-        inputProps: {
-            className: { type: 'string', description: 'Reflected class name, for example "FabBrowserApi".' },
-            functionName: { type: 'string', description: 'Function name exactly as reported by describe_reflected_api.' },
-            arguments: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Argument values keyed by parameter name. Converted per-property, so structs and arrays are accepted in their JSON form. Omitted parameters keep their zero-initialised default and are listed in unsetParameters.' },
-        },
-        outputProps: {
-            className: { type: 'string', description: 'Class acted on.' },
-            functionName: { type: 'string', description: 'Function invoked.' },
-            resolvedObject: { type: 'string', description: 'Path name of the object the call was made on.' },
-            outputs: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Return value and out parameters, keyed by parameter name.' },
-            unsetParameters: { type: 'array', items: { type: 'string' }, description: 'Parameters left at their default because no argument was supplied.' },
-        },
-        required: ['className', 'functionName'],
-        effect: 'destructive',
-        policyOverride: { consent: 'elevated' },
-        costLatency: 'interactive',
-        exampleInput: { action: 'invoke_reflected_function', className: 'FabBrowserApi', functionName: 'GetAuthToken' },
-        exampleOutput: { success: true, functionName: 'GetAuthToken' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'describe_reflected_api', dispatchAction: 'control_editor',
-        domain: D, family: F,
-        topics: ['class functions', 'function parameters', 'plugin surface'],
-        summary: 'List a class\'s reflected functions (a plugin\'s live bridge object such as FabBrowserApi, or any engine class): each with its parameters, C++ types and return or out flags, read from the installed build; filter narrows by function name.',
-        whenToUse: [
-            'An integration must discover what a plugin currently exposes, rather than assume a signature recorded earlier.',
-            'A plugin API appears to have changed and the live surface needs checking.',
-        ],
-        whenNotToUse: [
-            'The class is a plain C++ type with no UCLASS reflection — nothing is discoverable.',
-            'A native capability already covers the operation.',
-        ],
-        inputProps: {
-            className: { type: 'string', description: 'Reflected class, either bare ("FabBrowserApi", "DirectionalLightComponent") or as a full path ("/Script/Engine.DirectionalLightComponent"). The live instance is preferred; the class default object is the fallback when no instance exists yet.' },
-            classPath: { type: 'string', description: 'Alias for className, the spelling the rest of the catalog uses.' },
-            filter: { type: 'string', description: 'Case-sensitive substring matched against function names.' },
-        },
-        outputProps: {
-            className: { type: 'string', description: 'Class that was resolved.' },
-            resolvedObject: { type: 'string', description: 'Path name of the object the surface was read from.' },
-            isDefaultObject: { type: 'boolean', description: 'True when only the CDO existed, which usually means the owning window has never been opened.' },
-            functions: {
-                type: 'array',
-                description: 'Reflected functions, name-sorted.',
-                items: {
-                    type: 'object',
-                    additionalProperties: false,
-                    properties: {
-                        name: { type: 'string', description: 'Function name as reflected.' },
-                        parameterCount: { type: 'number', description: 'Declared parameters, including the return value.' },
-                        parameters: {
-                            type: 'array',
-                            description: 'Parameters in declaration order.',
-                            items: {
-                                type: 'object',
-                                additionalProperties: false,
-                                properties: {
-                                    name: { type: 'string', description: 'Parameter name.' },
-                                    cppType: { type: 'string', description: 'Reflected C++ type, for example FString.' },
-                                    isReturn: { type: 'boolean', description: 'True for the return value.' },
-                                    isOut: { type: 'boolean', description: 'True for an out parameter that is not the return value.' },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-            functionCount: { type: 'number', description: 'Functions returned.' },
-        },
-        required: [],
-        requiredOneOf: ['className', 'classPath'],
-        effect: 'read',
-        costLatency: 'interactive',
-        exampleInput: { action: 'describe_reflected_api', className: 'FabBrowserApi' },
-        exampleOutput: { success: true, functionCount: 14 },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'list_editor_toolsets', dispatchAction: 'control_editor',
-        domain: D, family: F,
-        topics: ['epic toolsets', 'toolset registry', 'epic mcp tools', 'state tree', 'control rig', 'pcg', 'gameplay abilities', 'niagara toolset', 'mvvm'],
-        summary: 'List the tools of Epic\'s editor toolsets (the Toolset Registry that ships with Unreal Engine 5.8: StateTree, PCG, GAS, Niagara, UMG, MVVM, physics and more, as their plugins are enabled), each with a description and an effect (read, write, destructive) judged from its name; query narrows them, and toolName returns one tool\'s input schema for call_editor_tool.',
-        whenToUse: [
-            'No native capability covers the work and Epic ships a toolset for it on Unreal Engine 5.8.',
-            'The input schema of an Epic toolset tool is needed before call_editor_tool.',
-        ],
-        whenNotToUse: [
-            'A native capability already covers the operation: prefer it, it carries this plugin\'s path checks, undo steps and receipts.',
-            'The editor runs an engine before 5.8 (the registry does not exist there; the call answers EDITOR_TOOLSETS_UNAVAILABLE).',
-        ],
-        inputProps: {
-            query: { type: 'string', description: 'Words that must all appear in a tool\'s name or description (any case), e.g. "state tree add".' },
-            toolset: { type: 'string', description: 'List only the tools of this toolset, by the name the toolsets list shows.' },
-            toolName: { type: 'string', description: 'Full name of one tool, Toolset.Tool: returns its schema (description, inputSchema) and effect instead of the list.' },
-            limit: { type: 'integer', minimum: 1, maximum: 200, description: 'Most tools listed (default 50); matchedTools and hasMore tell what was left out.' },
-        },
-        outputProps: {
-            toolsets: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, 'x-unreal-reflection-boundary': true, description: 'Every registered toolset: name, description, toolCount.' },
-            tools: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, 'x-unreal-reflection-boundary': true, description: 'Matching tools: name (Toolset.Tool), description, effect (read, write or destructive; blocked for a tool that would run scripts or console code, which is never called).' },
-            matchedTools: { type: 'integer', description: 'Tools that matched, before limit.' },
-            hasMore: { type: 'boolean', description: 'True when more tools matched than were listed.' },
-            tool: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'With toolName: that tool\'s schema as Epic publishes it (name, description, inputSchema) plus effect.' },
-        },
-        required: [],
-        effect: 'read',
-        plugins: ['ToolsetRegistry'],
-        costLatency: 'interactive',
-        exampleInput: { action: 'list_editor_toolsets', query: 'selected actors' },
-        exampleOutput: { success: true, matchedTools: 1 },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'call_editor_tool', dispatchAction: 'control_editor',
-        domain: D, family: F,
-        topics: ['run epic tool', 'epic toolset call', 'toolset registry'],
-        summary: 'Run one tool of Epic\'s editor toolsets (Unreal Engine 5.8 Toolset Registry) with a JSON input matching the inputSchema list_editor_toolsets returned, and answer with its output once it finishes. A tool whose name starts with a destructive verb (Delete, Remove, Destroy, Clear, Reset ...) is refused with DESTRUCTIVE_EDITOR_TOOL: run it with call_editor_tool_destructive. A tool that would run scripts or console code, and every ConfigSettingsToolset tool (it reaches this plugin\'s own settings; use system_control project settings), is never called (EDITOR_TOOL_BLOCKED).',
-        whenToUse: ['list_editor_toolsets found an Epic tool for work no native capability covers.'],
-        whenNotToUse: [
-            'A native capability covers the operation: prefer it.',
-            'The tool deletes or resets something: use call_editor_tool_destructive.',
-        ],
-        inputProps: {
-            toolName: { type: 'string', description: 'Full tool name exactly as list_editor_toolsets lists it: the toolset, then the tool, e.g. EditorToolset.EditorAppToolset.GetSelectedActors.' },
-            input: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'The tool\'s arguments, shaped by the inputSchema list_editor_toolsets returned for toolName. Omit for a tool without arguments.' },
-        },
-        outputProps: {
-            toolName: { type: 'string', description: 'Tool that ran.' },
-            effect: { type: 'string', description: 'read or write, as judged from the tool\'s name.' },
-            output: { 'x-unreal-reflection-boundary': true, description: 'The tool\'s own result: its JSON output parsed, or the raw text when it is not JSON.' },
-        },
-        required: ['toolName'],
-        effect: 'write',
-        plugins: ['ToolsetRegistry'],
-        costLatency: 'interactive',
-        exampleInput: { action: 'call_editor_tool', toolName: 'EditorToolset.EditorAppToolset.GetSelectedActors' },
-        exampleOutput: { success: true, toolName: 'EditorToolset.EditorAppToolset.GetSelectedActors' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'call_editor_tool_destructive', dispatchAction: 'control_editor',
-        domain: D, family: F,
-        topics: ['delete with epic tool', 'remove with epic toolset'],
-        summary: 'Run one tool of Epic\'s editor toolsets that deletes or resets editor state (its name starts with Delete, Remove, Destroy, Clear, Reset or a similar verb), under the destructive scope and elevated consent; any other tool runs here too. A tool that would run scripts or console code is never called.',
-        whenToUse: ['call_editor_tool refused a tool with DESTRUCTIVE_EDITOR_TOOL and the deletion is intended.'],
-        whenNotToUse: ['The tool only reads or adds: use call_editor_tool, which needs no consent.'],
-        inputProps: {
-            toolName: { type: 'string', description: 'Full tool name exactly as list_editor_toolsets lists it: the toolset, then the tool, e.g. EditorToolset.EditorAppToolset.GetSelectedActors.' },
-            input: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'The tool\'s arguments, shaped by the inputSchema list_editor_toolsets returned for toolName.' },
-        },
-        outputProps: {
-            toolName: { type: 'string', description: 'Tool that ran.' },
-            effect: { type: 'string', description: 'destructive, read or write, as judged from the tool\'s name.' },
-            output: { 'x-unreal-reflection-boundary': true, description: 'The tool\'s own result: its JSON output parsed, or the raw text when it is not JSON.' },
-        },
-        required: ['toolName'],
-        effect: 'destructive',
-        policyOverride: { consent: 'elevated' },
-        plugins: ['ToolsetRegistry'],
-        costLatency: 'interactive',
-        exampleInput: { action: 'call_editor_tool_destructive', toolName: 'GameplayTagsToolset.GameplayTagsToolset.RemoveTag', input: { TagName: 'Character.State.Dead' } },
-        exampleOutput: { success: true, toolName: 'GameplayTagsToolset.GameplayTagsToolset.RemoveTag' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'open_editor_tab', dispatchAction: 'control_editor',
-        editorStates: ANY_EDITOR_STATE,
-        domain: D, family: F,
-        summary: 'Open a registered editor tab by id via FGlobalTabmanager, the same path the Window menu uses. Content-source plugins register their windows globally — Bridge as "BridgeTab" — so this reaches them without depending on either plugin. Fab registers no fixed id (it numbers each tab Fab1, Fab2, ...), so tabId "Fab" opens a new Fab tab through the Fab browser API (UE 5.8+). This is also the correct way to authenticate against those services: each owns its own sign-in and persists its own session, so opening its window lets it log in on its own terms rather than reimplementing a login.',
-        whenToUse: [
-            'A Quixel/Fab capability reported NOT_AUTHENTICATED and the owning window must be opened so the user can sign in.',
-            'An editor panel registered by a plugin needs to be brought up.',
-        ],
-        whenNotToUse: ['An asset editor should be opened for a specific asset (use open_asset).'],
-        inputProps: {
-            tabId: { type: 'string', description: 'Registered nomad tab id, for example "BridgeTab" (Quixel Bridge); "Fab" opens a new Fab tab.' },
-        },
-        outputProps: {
-            tabId: { type: 'string', description: 'Tab id acted on.' },
-            opened: { type: 'boolean', description: 'True when the tab manager returned a live tab.' },
-        },
-        required: ['tabId'],
-        effect: 'write',
-        costLatency: 'interactive',
-        exampleInput: { action: 'open_editor_tab', tabId: 'BridgeTab' },
-        exampleOutput: { success: true, opened: true },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'console_command', dispatchAction: 'console_command',
-        editorStates: ANY_EDITOR_STATE,
-        domain: D, family: F,
-        topics: ['console command', 'exec command', 'run command', 'stat fps', 'cheat command', 'type a cheat code'],
-        summary: 'Execute an Unreal console command via cross-parent dispatch to the console_command bridge action.',
-        whenToUse: ['A console command must be run from the editor context.'],
-        whenNotToUse: ['A dedicated action exists for the operation.'],
-        inputProps: { command: P.command },
-        required: ['command'],
-        effect: 'write',
-        exampleInput: { action: 'console_command', command: 'r.SetRes 1920x1080' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'restore_editor_window', domain: D, family: F,
-        editorStates: ANY_EDITOR_STATE,
-        summary: 'Restore or minimize the main editor window without giving it focus. Restoring also stops the editor throttling itself '
-            + 'while in the background (a minimized editor runs Play In Editor at about 3 fps, which makes every timed test lie); '
-            + 'minimize puts the window away and turns the throttle back on, so an editor kept out of the way costs the machine next to nothing.',
-        whenToUse: [
-            'Play In Editor crawls (about 3 fps) because the editor window is minimized or in the background.',
-            'The editor should stay out of the way while automation runs that needs no frames on screen: minimize it, and restore it for a timed run.',
-        ],
-        whenNotToUse: ['A screenshot or a sample_motion run is all that needs the window on screen (each restores a minimized editor by itself and minimizes it again afterwards).'],
-        inputProps: {
-            minimize: { type: 'boolean', description: 'Minimize the main editor window instead of restoring it, without taking focus, and turn Use Less CPU when in Background back on (saved). unthrottle is ignored. Default false.' },
-            unthrottle: { type: 'boolean', description: 'Also turn off Use Less CPU when in Background (EditorPerformanceSettings.bThrottleCPUWhenNotForeground) for this editor session; it is not saved, so the next launch throttles again. Default true; ignored with minimize.' },
-        },
-        outputProps: {
-            wasMinimized: { type: 'boolean', description: 'Whether the main window was minimized before the call.' },
-            minimized: { type: 'boolean', description: 'Whether the window is minimized after the call, read back from the native window.' },
-            restored: { type: 'boolean', description: 'Whether the window is on screen after the call.' },
-            throttleOff: { type: 'boolean', description: 'Whether background CPU throttling is off after the call.' },
-        },
-        required: [],
-        effect: 'write', behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'restore_editor_window', unthrottle: true },
-        exampleOutput: { success: true, wasMinimized: true, restored: true, throttleOff: true },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'set_preferences', domain: D, family: F,
-        editorStates: ANY_EDITOR_STATE,
-        summary: 'Set editor preferences for a category. Distinct from system_control set_project_setting.',
-        whenToUse: ['Editor preferences must be configured for a category.'],
-        whenNotToUse: ['Project settings are needed (use system_control set_project_setting).'],
-        inputProps: { category: P.category, preferences: P.preferences },
-        required: ['category', 'preferences'],
-        effect: 'write', behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'set_preferences', category: 'Editor', preferences: { bUseSmallToolBarIcons: true } },
-    }),
-];
-//# sourceMappingURL=command.js.map

package/dist/tools/catalog/capabilities/records/control-editor/history.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const HISTORY_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=history.d.ts.map

package/dist/tools/catalog/capabilities/records/control-editor/history.js

@@ -1,27 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-const F = 'history';
-const D = 'editor';
-export const HISTORY_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'undo', domain: D, family: F,
-        topics: ['undo last change', 'revert last action', 'ctrl z'],
-        summary: 'Undo the last editor transaction; the reply names it, and NOTHING_TO_UNDO means there was none.',
-        whenToUse: ['The most recent editor action must be reversed.'],
-        whenNotToUse: ['There is nothing to undo.'],
-        inputProps: {},
-        required: [],
-        effect: 'write',
-        exampleInput: { action: 'undo' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'redo', domain: D, family: F,
-        summary: 'Redo the last undone editor transaction; the reply names it, and NOTHING_TO_REDO means there was none.',
-        whenToUse: ['A previously undone action must be re-applied.'],
-        whenNotToUse: ['There is nothing to redo.'],
-        inputProps: {},
-        required: [],
-        effect: 'write',
-        exampleInput: { action: 'redo' },
-    }),
-];
-//# sourceMappingURL=history.js.map

package/dist/tools/catalog/capabilities/records/control-editor/index.d.ts

@@ -1,4 +0,0 @@
-import { type CapabilityRecordSource } from '../../model.js';
-export declare const CONTROL_EDITOR_UNFOLDED_SOURCES: readonly CapabilityRecordSource[];
-export declare const CONTROL_EDITOR_SOURCES: readonly CapabilityRecordSource[];
-//# sourceMappingURL=index.d.ts.map

package/dist/tools/catalog/capabilities/records/control-editor/index.js

@@ -1,28 +0,0 @@
-import { ASSET_RECORDS } from './asset.js';
-import { BOOKMARK_RECORDS } from './bookmark.js';
-import { CAMERA_RECORDS } from './camera.js';
-import { COMMAND_RECORDS } from './command.js';
-import { HISTORY_RECORDS } from './history.js';
-import { INPUT_RECORDS } from './input.js';
-import { RECORDING_RECORDS } from './recording.js';
-import { SCREENSHOT_RECORDS } from './screenshot.js';
-import { SESSION_RECORDS } from './session.js';
-import { TIMING_RECORDS } from './timing.js';
-import { VIEWPORT_RECORDS } from './viewport.js';
-import { applyFolds } from '../shared/fold.js';
-import { CONTROL_EDITOR_FOLDS } from '../folds/control-editor.folds.js';
-export const CONTROL_EDITOR_UNFOLDED_SOURCES = [
-    ...SESSION_RECORDS,
-    ...TIMING_RECORDS,
-    ...RECORDING_RECORDS,
-    ...CAMERA_RECORDS,
-    ...VIEWPORT_RECORDS,
-    ...COMMAND_RECORDS,
-    ...SCREENSHOT_RECORDS,
-    ...BOOKMARK_RECORDS,
-    ...ASSET_RECORDS,
-    ...INPUT_RECORDS,
-    ...HISTORY_RECORDS,
-];
-export const CONTROL_EDITOR_SOURCES = applyFolds(CONTROL_EDITOR_UNFOLDED_SOURCES, CONTROL_EDITOR_FOLDS, 'control_editor');
-//# sourceMappingURL=index.js.map

package/dist/tools/catalog/capabilities/records/control-editor/input.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const INPUT_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=input.d.ts.map

package/dist/tools/catalog/capabilities/records/control-editor/input.js

@@ -1,50 +0,0 @@
-import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-const F = 'input';
-const D = 'editor';
-export const INPUT_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'simulate_input', domain: D, family: F,
-        editorStates: ANY_EDITOR_STATE,
-        aliases: ['control_editor.click_widget', 'control_editor.widget_click', 'control_editor.press_ui_button'],
-        topics: ['click button', 'click ui button', 'click button in running game', 'check or toggle a checkbox in running game', 'press key', 'press jump key', 'simulate key press', 'drive game ui', 'test running game', 'list live widgets', 'list widgets in running game', 'widgets on screen', 'list buttons on screen', 'press space', 'press spacebar', 'hold key down', 'list open widgets in game'],
-        summary: 'Simulate a keyboard or mouse input event (key_down, key_up, key_tap, mouse_click, mouse_move), or list and press the live UMG widgets of a PIE session (widget_list, widget_click).',
-        whenToUse: [
-            'Synthetic input must be injected into the editor or PIE.',
-            'A game has to be played: key_tap taps a key, key_down with holdSeconds holds it for that many game seconds, and inputAction injects an Enhanced Input action directly when no key is mapped to it.',
-            'A game UI must be operated in PIE: widget_list names every live widget, and widget_click presses a Button, toggles a CheckBox or sets a Slider (value) by name without touching the OS cursor, so it works while the editor window is in the background.',
-        ],
-        whenNotToUse: ['Real hardware input is available.'],
-        inputProps: {
-            key: P.key,
-            type: P.type,
-            inputType: P.inputType,
-            inputAction: P.inputAction,
-            value: P.value,
-            holdSeconds: P.holdSeconds,
-            x: P.x,
-            y: P.y,
-            z: P.z,
-            button: P.button,
-            widget: P.widget,
-        },
-        required: [],
-        outputProps: {
-            routedToPIE: { type: 'boolean', description: 'The event was routed to the PIE viewport rather than the editor.' },
-            handledByPIE: { type: 'boolean', description: 'PIE actually consumed the event. False here with routedToPIE true means the key reached the game and nothing bound it: no active input mapping context maps that key (inject the action with inputAction instead).' },
-            handledBySlate: { type: 'boolean', description: 'Slate consumed the event (editor-level input).' },
-            injectedAction: { type: 'string', description: 'The Enhanced Input action that was injected, when inputAction resolved to one. Absent means the call went down the raw-key path, which reaches the game only through a mapping context that maps the key.' },
-            widgets: {
-                type: 'array',
-                items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-                description: 'widget_list: each live user widget (userWidget, object, inViewport) with its Button/CheckBox/Slider children (name, type, enabled, visible, focused, and text, value or checked).',
-            },
-            widget: { type: 'string', description: 'widget_click: the widget that was driven, as Owner.Name.' },
-            widgetType: { type: 'string', description: 'widget_click: the driven widget\'s class (Button, CheckBox, Slider).' },
-        },
-        effect: 'write',
-        exampleInput: { action: 'simulate_input', type: 'key_down', key: 'SpaceBar' },
-        exampleOutput: { success: true, message: 'Input simulated', routedToPIE: true, handledByPIE: true, handledBySlate: false },
-    }),
-];
-//# sourceMappingURL=input.js.map

package/dist/tools/catalog/capabilities/records/control-editor/properties.d.ts

@@ -1,77 +0,0 @@
-import type { JsonObject } from '../../model.js';
-export declare const P: {
-    actorName: JsonObject;
-    name: JsonObject;
-    objectPath: JsonObject;
-    location: {
-        type: string;
-        properties: {
-            x: JsonObject;
-            y: JsonObject;
-            z: JsonObject;
-        };
-        description: string;
-        additionalProperties: boolean;
-    };
-    rotation: {
-        type: string;
-        properties: {
-            pitch: JsonObject;
-            yaw: JsonObject;
-            roll: JsonObject;
-        };
-        description: string;
-        additionalProperties: boolean;
-    };
-    blendTime: JsonObject;
-    speed: JsonObject;
-    deltaTime: JsonObject;
-    fov: JsonObject;
-    viewMode: JsonObject;
-    width: JsonObject;
-    height: JsonObject;
-    mode: JsonObject;
-    enabled: JsonObject;
-    realtime: JsonObject;
-    validateOnly: JsonObject;
-    discardUnsaved: JsonObject;
-    delaySeconds: JsonObject;
-    stat: JsonObject;
-    command: JsonObject;
-    filename: JsonObject;
-    path: JsonObject;
-    resolution: JsonObject;
-    returnBase64: JsonObject;
-    includeMetadata: JsonObject;
-    metadata: {
-        type: string;
-        description: string;
-        additionalProperties: boolean;
-        'x-unreal-reflection-boundary': boolean;
-    };
-    id: JsonObject;
-    assetPath: JsonObject;
-    levelPath: JsonObject;
-    category: JsonObject;
-    preferences: {
-        type: string;
-        description: string;
-        additionalProperties: boolean;
-        'x-unreal-reflection-boundary': boolean;
-    };
-    steps: JsonObject;
-    key: JsonObject;
-    type: JsonObject;
-    inputType: JsonObject;
-    inputAction: JsonObject;
-    value: JsonObject;
-    holdSeconds: JsonObject;
-    x: JsonObject;
-    y: JsonObject;
-    z: JsonObject;
-    button: JsonObject;
-    widget: JsonObject;
-    frameRate: JsonObject;
-    durationSeconds: JsonObject;
-};
-//# sourceMappingURL=properties.d.ts.map

package/dist/tools/catalog/capabilities/records/control-editor/properties.js

@@ -1,70 +0,0 @@
-import { str, num, bool } from '../shared/schema-props.js';
-const int = (description) => ({ type: 'integer', description });
-export const P = {
-    actorName: str('Name of the actor to target.'),
-    name: str('Name identifier.'),
-    objectPath: str('Object path alias for actorName.'),
-    location: {
-        type: 'object',
-        properties: { x: num('x'), y: num('y'), z: num('z') },
-        description: '3D location (x, y, z).',
-        additionalProperties: false,
-    },
-    rotation: {
-        type: 'object',
-        properties: { pitch: num('pitch'), yaw: num('yaw'), roll: num('roll') },
-        description: '3D rotation (pitch, yaw, roll).',
-        additionalProperties: false,
-    },
-    blendTime: num('Blend time in seconds for set_view_target.'),
-    speed: num('Clock multiplier for the running game: 1 is normal, 0.05 runs it twenty times slower (above 0, up to 20).'),
-    deltaTime: num('Seconds every frame advances the running game, however long the frame really took (deterministic runs); 0 turns fixed stepping off. It also ends when PIE stops.'),
-    fov: num('Camera field of view in degrees.'),
-    viewMode: str('Viewport view mode (e.g. Lit, Unlit, Wireframe).'),
-    width: num('Viewport width in pixels.'),
-    height: num('Viewport height in pixels.'),
-    mode: str('Editor mode id to activate: EM_Default, EM_Landscape, EM_Foliage, EM_MeshPaint or any registered mode id; a bare name (landscape) is tried as EM_<name>. The call fails when the mode is not active afterwards.'),
-    enabled: bool('Whether the feature is enabled.'),
-    realtime: bool('Whether realtime rendering is enabled.'),
-    validateOnly: bool('Report whether a restart would proceed, and what it would discard, without restarting.'),
-    discardUnsaved: bool('Restart even though packages have unsaved changes, discarding them. Omitted, a restart with unsaved work is refused.'),
-    delaySeconds: num('Seconds to wait before restarting, so the response reaches the caller first. Clamped to 0.1-30.'),
-    stat: str('One stat to show or hide (FPS, Unit, Game, SceneRendering...). show_stats without it shows FPS and Unit; hide_stats without it hides every stat. A stat already in the wanted state is left alone, so repeating a call never toggles it back.'),
-    command: str('Console command string.'),
-    filename: str('Screenshot or recording filename.'),
-    path: str('Directory or file path.'),
-    resolution: str('Resolution setting (e.g. 1024x1024).'),
-    returnBase64: bool('Return the PNG inline as an image (default true); a capture also saves a file unless keepFile is false. With no resolution, an inline image is downscaled to fit 1600x900. false returns only the saved path and metadata, at the full viewport size.'),
-    includeMetadata: bool('Attach caller-provided metadata to the response.'),
-    metadata: {
-        type: 'object',
-        description: 'Caller-provided metadata.',
-        additionalProperties: true,
-        'x-unreal-reflection-boundary': true,
-    },
-    id: int('Bookmark slot number, 0 to 9 on a default level (the slots Ctrl+0..9 set). Unreal bookmarks are numbered slots, not names; a number outside the level\'s range is refused.'),
-    assetPath: str('Asset path (e.g. /Game/Path/Asset).'),
-    levelPath: str('Level asset path.'),
-    category: str('Preferences category.'),
-    preferences: {
-        type: 'object',
-        description: 'Editor preferences key-value pairs.',
-        additionalProperties: true,
-        'x-unreal-reflection-boundary': true,
-    },
-    steps: int('Number of frames to step.'),
-    key: str('Key name: SpaceBar, D, Left, Enter, P. Escape is the editor stop-play key: in Play In Editor it ends the session instead of reaching the game, so test an action bound to Escape through another key mapped to it.'),
-    type: str('Input event type (key_down, key_up, key_tap = press then release, mouse_click, mouse_move), or widget_list / widget_click to operate the live UMG of a PIE session.'),
-    inputType: str('Alias for type used by simulate_input.'),
-    inputAction: str('Enhanced Input action to inject directly, as an asset path such as /Game/Input/IA_Move. A raw key already reaches Enhanced Input through the active mapping contexts (key_down D moves a pawn whose context maps D); use inputAction when no key is mapped to the action, or to inject an analog value.'),
-    value: num('Scalar value to inject for inputAction (default 1; use a negative value for the opposite direction), or the value to set a Slider to with widget_click. Ignored for a raw key.'),
-    holdSeconds: num('Keep injecting inputAction, or keep a raw key_down/key_tap key pressed, for this many seconds of GAME time so the pawn actually travels (default 0: an action lasts one frame, a key_down stays down until key_up, a key_tap lets go after 0.1s). Game time, not wall time: under set_game_speed 0.05 a 2s hold still delivers 2s of in-game input, which takes 40s of real time. A key_up for the same action or key stops the hold early.'),
-    x: num('Mouse X coordinate for simulate_input, or the X value of an Axis2D or Axis3D inputAction.'),
-    y: num('Mouse Y coordinate for simulate_input, or the Y value of an Axis2D or Axis3D inputAction.'),
-    z: num('Z value of an Axis3D inputAction (x and y give the other two).'),
-    button: str('Mouse button for simulate_input.'),
-    widget: str('For type widget_click: the live UMG widget to drive, by name (PlayButton), or Owner.Name (WBP_MainMenu.PlayButton) when several share it. widget_list shows both.'),
-    frameRate: num('Replay frames recorded per second, 1 to 120 (sets demo.RecordHz; the engine default is 8).'),
-    durationSeconds: num('Stop the recording by itself after this many seconds of game time.'),
-};
-//# sourceMappingURL=properties.js.map

package/dist/tools/catalog/capabilities/records/control-editor/recording.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const RECORDING_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=recording.d.ts.map

package/dist/tools/catalog/capabilities/records/control-editor/recording.js

@@ -1,31 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-const F = 'recording';
-const D = 'editor';
-export const RECORDING_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'start_recording', domain: D, family: F,
-        summary: 'Start a replay (demo) recording of the running game; Play In Editor must be running. Fails when no recorder started.',
-        whenToUse: ['A demo recording must be started for replay capture.'],
-        whenNotToUse: ['A recording is already in progress.'],
-        inputProps: { filename: P.filename, name: P.name, frameRate: P.frameRate, durationSeconds: P.durationSeconds },
-        required: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        exampleInput: { action: 'start_recording', filename: 'TestRecording' },
-        exampleOutput: { success: true, message: 'Started recording to TestRecording', filename: 'TestRecording' },
-        outputProps: { filename: P.filename },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'stop_recording', domain: D, family: F,
-        summary: 'Stop the active demo recording session.',
-        whenToUse: ['An in-progress demo recording must be stopped.'],
-        whenNotToUse: ['No recording is in progress.'],
-        inputProps: {},
-        required: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        exampleInput: { action: 'stop_recording' },
-    }),
-];
-//# sourceMappingURL=recording.js.map

package/dist/tools/catalog/capabilities/records/control-editor/screenshot.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const SCREENSHOT_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=screenshot.d.ts.map