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

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

@@ -1,76 +0,0 @@
-import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-const F = 'screenshot';
-const D = 'editor';
-const SCREENSHOT_PROPS = {
-    filename: P.filename,
-    path: { type: 'string', description: 'Directory to save the PNG in, inside the project (relative to it, or absolute under it). Default Saved/Screenshots (game_viewport: Saved/Screenshots/WindowsEditor). A path outside the project is refused.' },
-    resolution: {
-        type: 'string',
-        description: 'Maximum WxH for the returned PNG (e.g. "1280x720"). The capture is downscaled to fit inside this box with its aspect ratio preserved; a box at least as large as the viewport leaves the image untouched. Without it an image returned inline fits 1600x900, and a file-only capture (returnBase64 false) keeps the viewport size.'
-    },
-    mode: {
-        type: 'string',
-        enum: ['editor_viewport', 'game_viewport', 'full_editor_window'],
-        description: 'Screenshot source: editor_viewport (default, the level viewport), game_viewport (the running game frame WITHOUT any UMG widgets) or full_editor_window (the editor window as displayed: the only mode that shows game UI and asset editors). While Play In Editor runs with the player ejected (control_editor play control=eject), the game is drawn by the editor viewport, so editor_viewport and game_viewport are then the same picture: the ejected view.'
-    },
-    window: {
-        type: ['integer', 'string'],
-        description: 'With mode full_editor_window, which window to capture: a list index (2, or "2") or a case-insensitive substring of its title ("WBP_HubUI"). Omit for the main editor frame, which is then always what is captured: a minimized main frame is restored without taking focus, and when that is not possible the call fails with EDITOR_WINDOW_MINIMIZED instead of capturing another window. A window restored for the capture is minimized again right after it. Every response lists the open windows under windows[], so read that to pick one.'
-    },
-    location: { ...P.location, description: 'editor_viewport (and game_viewport while the player is ejected): put the camera here first, in the same call ({x, y, z}); it stays there. That is the level viewport camera, or, while Play In Editor runs with the player ejected, the ejected view. While Play In Editor runs and the player is not ejected there is no free camera to move and the call is refused with PIE_VIEW_NOT_EJECTED (eject first, or point the game camera with set_camera cameraOp=view_target), exactly as set_camera is.' },
-    rotation: { ...P.rotation, description: 'editor_viewport (and game_viewport while the player is ejected): turn that camera to this first ({pitch, yaw, roll}), in the same call. Refused like location while Play In Editor runs and the player is not ejected.' },
-    returnBase64: P.returnBase64,
-    keepFile: {
-        type: 'boolean',
-        description: 'false: hand the image back without leaving a file in Saved/Screenshots (refused with returnBase64 false, which would leave no output at all). Default true. Files already written are listed by system_control list_output_files and removed by delete_output_file.'
-    },
-    waitForShaders: {
-        type: 'boolean',
-        description: 'true: when shaders are still compiling (after a scalability or material change), wait for the queue to drain before capturing, polling without blocking the game thread, for at most 25 seconds; shaderWait in the reply says how long it waited and how many jobs were left. Default false: capture now and report shadersCompiling.'
-    },
-    includeMetadata: P.includeMetadata,
-    metadata: P.metadata,
-};
-const SCREENSHOT_OUTPUT = {
-    shadersCompiling: { type: 'number', description: 'Shader compile jobs still outstanding when the picture was taken. Above 0, the surfaces they cover are drawn with the engine default material (black foliage, grey ground) and a warning says so; pass waitForShaders to capture after they finish.' },
-    shaderWait: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'With waitForShaders while shaders compiled: waitedSeconds, jobsLeft (still outstanding when the wait ended) and timedOut (true when jobs were left after the 25 second cap).' },
-    imageBase64: { type: 'string', description: 'Base64-encoded PNG image data.' },
-    mimeType: { type: 'string', description: 'Image MIME type.' },
-    width: { type: 'number', description: 'Width in pixels of the PNG actually returned.' },
-    height: { type: 'number', description: 'Height in pixels of the PNG actually returned.' },
-    viewportWidth: { type: 'number', description: 'Width in pixels of the viewport (or, for full_editor_window, the window) the picture was taken at. Present only when the image was downscaled (a resolution, or the 1600x900 inline default), so width/height differ from it.' },
-    viewportHeight: { type: 'number', description: 'Height in pixels of the viewport or window the picture was taken at. Present only when the image was downscaled.' },
-    sizeBytes: { type: 'integer', description: 'Image size in bytes.' },
-    screenshotPath: { type: 'string', description: 'Saved screenshot file path.' },
-    mode: { type: 'string', description: 'Screenshot source that was captured.' },
-    window: { type: 'string', description: 'Title of the editor window that was actually captured.' },
-    mainWindow: { type: 'boolean', description: 'full_editor_window: true when the captured window is the main editor frame.' },
-    windowRestored: { type: 'boolean', description: 'full_editor_window: true when the window was minimized and was put back on screen, without taking focus, for the capture. It is minimized again right after the capture, so windows[] shows it minimized.' },
-    windows: {
-        type: 'array',
-        items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-        description: 'Every visible editor window: index, title, x, y, width, height, isActive, isMinimized, isModal. Pass an index or a title substring back as the window parameter to capture a different one; x/y are screen coordinates for simulate_input.'
-    },
-    windowCount: { type: 'number', description: 'Number of visible editor windows.' },
-    cameraLocation: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'editor_viewport and an ejected game view: where the camera was for this picture.' },
-    cameraRotation: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'editor_viewport and an ejected game view: how the camera was turned for this picture.' },
-    view: { type: 'string', description: 'Which view the picture is of: editor_viewport (the level viewport), pie_game (the running game as its possessed pawn sees it) or pie_ejected (the free camera of an ejected player). Absent for full_editor_window and for the game_viewport capture of a possessed game.' },
-};
-export const SCREENSHOT_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'screenshot', domain: D, family: F,
-        editorStates: ANY_EDITOR_STATE,
-        summary: 'Capture a screenshot from the editor viewport, game viewport, or full editor window.',
-        whenToUse: ['A visual snapshot of the editor or game viewport is needed.'],
-        whenNotToUse: ['A real-time capture stream is needed.'],
-        inputProps: SCREENSHOT_PROPS,
-        required: [],
-        outputProps: SCREENSHOT_OUTPUT,
-        effect: 'read',
-        costLatency: 'interactive',
-        exampleInput: { action: 'screenshot', mode: 'editor_viewport', filename: 'viewport' },
-        exampleOutput: { success: true, screenshotPath: '/Game/Screenshots/viewport.png', mode: 'editor_viewport' },
-    }),
-];
-//# sourceMappingURL=screenshot.js.map

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

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

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

@@ -1,137 +0,0 @@
-import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-const F = 'session';
-const D = 'editor';
-export const SESSION_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'play', domain: D, family: F,
-        editorStates: ANY_EDITOR_STATE,
-        topics: ['play in editor', 'pie', 'start pie', 'start game', 'run game', 'press play', 'simulate'],
-        aliases: ['control_editor.start_pie'],
-        summary: 'Start Play-In-Editor (PIE) session; answers once the play world has begun play.',
-        whenToUse: ['A PIE session must be started to test gameplay.'],
-        whenNotToUse: ['PIE is already running.'],
-        inputProps: {},
-        required: [],
-        effect: 'write',
-        costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'play' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'stop', domain: D, family: F,
-        editorStates: ANY_EDITOR_STATE,
-        topics: ['stop pie', 'stop game', 'end play', 'exit pie'],
-        summary: 'Stop the running PIE session.',
-        whenToUse: ['The PIE session must be terminated.'],
-        whenNotToUse: ['PIE should only be paused.'],
-        inputProps: {},
-        required: [],
-        effect: 'write', behavior: { idempotency: 'idempotent' },
-        costLatency: 'interactive',
-        exampleInput: { action: 'stop' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'stop_pie', dispatchAction: 'stop',
-        editorStates: ANY_EDITOR_STATE,
-        domain: D, family: F,
-        summary: 'Stop the running PIE session (alias for stop).',
-        whenToUse: ['The PIE session must be terminated using the stop_pie alias.'],
-        whenNotToUse: ['PIE should only be paused.'],
-        inputProps: {},
-        required: [],
-        effect: 'write', behavior: { idempotency: 'idempotent' },
-        costLatency: 'interactive',
-        exampleInput: { action: 'stop_pie' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'pause', domain: D, family: F,
-        editorStates: ANY_EDITOR_STATE,
-        summary: 'Pause the running PIE session.',
-        whenToUse: ['PIE must be paused without stopping.'],
-        whenNotToUse: ['PIE is not running or already paused.'],
-        inputProps: {},
-        required: [],
-        effect: 'write', behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'pause' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'resume', domain: D, family: F,
-        editorStates: ANY_EDITOR_STATE,
-        summary: 'Resume a paused PIE session.',
-        whenToUse: ['A paused PIE session must resume.'],
-        whenNotToUse: ['PIE is not paused.'],
-        inputProps: {},
-        required: [],
-        effect: 'write', behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'resume' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'eject', domain: D, family: F,
-        editorStates: ANY_EDITOR_STATE,
-        summary: 'Eject the player from its pawn in PIE, as the editor\'s Eject button does: the session switches to Simulate in Editor and the view becomes a free camera that set_camera moves and screenshot photographs. Answers once the view has switched.',
-        whenToUse: ['The player must detach from the possessed pawn.', 'The view of a running game must be placed for a screenshot: eject, then set_camera.'],
-        whenNotToUse: ['PIE is not running (NO_ACTIVE_SESSION).', 'The game must keep playing from the pawn: an ejected player no longer drives it.'],
-        inputProps: {},
-        required: [],
-        effect: 'write',
-        outputProps: {
-            ejected: { type: 'boolean', description: 'True once the player has left its pawn and the view is a free camera; false (with EJECT_FAILED) when the session did not switch within 5 seconds, which happens when Play In Editor runs in a window of its own instead of a level viewport.' },
-            alreadyEjected: { type: 'boolean', description: 'True when the player was already ejected, so nothing changed.' },
-            view: { type: 'string', description: 'pie_ejected: the view that set_camera moves and screenshot photographs.' },
-            cameraLocation: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Where the free camera starts, {x, y, z}: where the pawn\'s camera was.' },
-            cameraRotation: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'How the free camera starts out turned, {pitch, yaw, roll}.' },
-        },
-        costLatency: 'interactive',
-        exampleInput: { action: 'eject' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'possess', domain: D, family: F,
-        editorStates: ANY_EDITOR_STATE,
-        summary: 'Possess a pawn in PIE: the player controller takes the pawn named by actorName. Without actorName it brings an ejected player back to its own pawn, as the editor\'s Possess button does (the way back from eject). Answers once the player is back in the game.',
-        whenToUse: ['The player must take control of a specific pawn.', 'An ejected player must return to the game (no actorName).'],
-        whenNotToUse: ['PIE is not running (NOT_IN_PIE).', 'The actor is not a pawn (INVALID_TARGET).'],
-        inputProps: { actorName: { type: 'string', description: 'Pawn to possess, in the running game. Omit it to bring an ejected player back to its own pawn.' } },
-        required: [],
-        effect: 'write',
-        outputProps: {
-            possessed: { type: 'string', description: 'The pawn the player controller holds after the call, by object name.' },
-            returnedFromEject: { type: 'boolean', description: 'True when the player was ejected and is now back in the game.' },
-            view: { type: 'string', description: 'pie_game: the game draws through the possessed pawn\'s camera again.' },
-        },
-        costLatency: 'interactive',
-        exampleInput: { action: 'possess', actorName: 'BP_PlayerCharacter' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'restart_editor', domain: D, family: F,
-        topics: ['restart editor', 'reload editor', 'apply plugin change', 'relaunch editor', 'quit editor', 'close editor', 'exit editor', 'unsaved packages', 'list unsaved changes', 'list unsaved assets', 'list dirty packages', 'what is unsaved'],
-        summary: 'Restart the editor process, relaunching the same project, or close it (relaunch false). validateOnly lists the unsaved packages without doing either.',
-        whenToUse: ['A plugin was enabled or disabled and the change needs a restart to take effect.',
-            'A pipeline needs to know whether a restart is safe right now; pass validateOnly.',
-            'A project setting that only applies at startup must be picked up.',
-            'The editor is no longer needed and should close (relaunch false).',
-            'Which packages have unsaved changes must be known (validateOnly).'],
-        whenNotToUse: ['Only a level needs reloading; use open_level.',
-            'A PIE session should end; use stop.'],
-        inputProps: {
-            validateOnly: P.validateOnly, discardUnsaved: P.discardUnsaved, delaySeconds: P.delaySeconds,
-            relaunch: { type: 'boolean', description: 'false closes the editor instead of relaunching it (default true). Unsaved packages are refused the same way.' },
-        },
-        outputProps: {
-            restarting: { type: 'boolean', description: 'True once the restart has been scheduled; false under validateOnly or when closing.' },
-            closing: { type: 'boolean', description: 'True once closing the editor (relaunch false) has been scheduled.' },
-            validateOnly: { type: 'boolean', description: 'True when this call only reported what a restart would do.' },
-            wouldRestart: { type: 'boolean', description: 'Under validateOnly, whether a real restart would proceed.' },
-            unsavedPackages: { type: 'array', items: { type: 'string', description: 'Package path.' }, description: 'Packages with unsaved changes a restart would discard.' },
-            unsavedCount: { type: 'integer', description: 'How many packages have unsaved changes.' },
-            delaySeconds: { type: 'number', description: 'Seconds the editor waits before relaunching.' },
-            discardedPackageCount: { type: 'integer', description: 'Unsaved packages discarded by this restart.' },
-            projectPath: { type: 'string', description: 'Project the editor relaunches with.' },
-        },
-        outputRequired: ['restarting'],
-        effect: 'destructive', behavior: { idempotency: 'non-idempotent', longRunning: true },
-        costLatency: 'long-running', costResources: 'high',
-        exampleInput: { action: 'restart_editor', validateOnly: true },
-        exampleOutput: { success: true, message: 'Restart would proceed.', restarting: false, validateOnly: true, wouldRestart: true, unsavedCount: 0, delaySeconds: 1 },
-    }),
-];
-//# sourceMappingURL=session.js.map

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

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

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

@@ -1,59 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-const F = 'timing';
-const D = 'editor';
-const RUNNING = ['pie', 'simulate'];
-const STEP_GAME_SECONDS = { type: 'number', description: 'Game seconds the steps advanced, when a fixed delta time is set (set_game_speed fixed_delta_time): steps x deltaTime x game speed.' };
-const STEP_DILATION = { type: 'number', description: 'The game speed the steps ran at, present when it is not 1: a step keeps the slow motion that was set, so at speed 0.1 each step advances a tenth of its frame of game time.' };
-export const TIMING_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'set_game_speed', domain: D, family: F,
-        summary: 'Set the speed of the running game (PIE time dilation), for slow motion while testing.',
-        whenToUse: ['Game speed must be changed for testing, e.g. slowed down to observe a short-lived actor.'],
-        whenNotToUse: ['PIE is not running (start it with control_editor play first).'],
-        inputProps: { speed: P.speed },
-        required: ['speed'],
-        effect: 'write', behavior: { idempotency: 'idempotent' },
-        editorStates: RUNNING,
-        exampleInput: { action: 'set_game_speed', speed: 0.5 },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'set_fixed_delta_time', domain: D, family: F,
-        summary: 'Make every frame of the running game advance by a fixed delta time, or 0 to follow real time again.',
-        whenToUse: ['A fixed delta time is needed for deterministic stepping.'],
-        whenNotToUse: ['Variable delta time is preferred.', 'PIE is not running.'],
-        inputProps: { deltaTime: P.deltaTime },
-        required: ['deltaTime'],
-        effect: 'write', behavior: { idempotency: 'idempotent' },
-        editorStates: RUNNING,
-        exampleInput: { action: 'set_fixed_delta_time', deltaTime: 0.01667 },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'step_frame', domain: D, family: F,
-        summary: 'Advance the PIE simulation by one or more frames, each at the current game speed (slow motion makes each step shorter; timeDilation says so).',
-        whenToUse: ['The simulation must advance a fixed number of frames.'],
-        whenNotToUse: ['Real-time simulation is preferred.'],
-        inputProps: { steps: P.steps },
-        required: [],
-        effect: 'write', editorStates: RUNNING,
-        exampleInput: { action: 'step_frame', steps: 1 },
-        exampleOutput: { success: true, message: 'Stepped 1 frame(s)', steps: 1 },
-        outputProps: { steps: P.steps, gameSeconds: STEP_GAME_SECONDS, timeDilation: STEP_DILATION },
-        outputRequired: ['steps'],
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'single_frame_step', dispatchAction: 'step_frame',
-        domain: D, family: F,
-        summary: 'Advance the PIE simulation by one frame (alias for step_frame).',
-        whenToUse: ['The simulation must advance exactly one frame.'],
-        whenNotToUse: ['Multiple frames are needed (use step_frame with steps).'],
-        inputProps: { steps: P.steps },
-        required: [],
-        effect: 'write', editorStates: RUNNING,
-        exampleInput: { action: 'single_frame_step', steps: 1 },
-        exampleOutput: { success: true, message: 'Stepped 1 frame(s)', steps: 1 },
-        outputProps: { steps: P.steps, gameSeconds: STEP_GAME_SECONDS, timeDilation: STEP_DILATION },
-        outputRequired: ['steps'],
-    }),
-];
-//# sourceMappingURL=timing.js.map

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

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

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

@@ -1,91 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-const F = 'viewport';
-const D = 'editor';
-export const VIEWPORT_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'set_view_mode', domain: D, family: F,
-        summary: 'Set the rendering view mode (Lit, Unlit, Wireframe, etc.) of the view on screen: the level viewport, or while the player plays the running game\'s view (method game_viewport).',
-        whenToUse: ['The viewport render mode must be changed for debugging or visualization.'],
-        whenNotToUse: ['The default Lit mode is acceptable.'],
-        inputProps: { viewMode: P.viewMode },
-        required: ['viewMode'],
-        effect: 'read',
-        exampleInput: { action: 'set_view_mode', viewMode: 'Wireframe' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'set_viewport_resolution', dispatchAction: 'console_command',
-        domain: D, family: F,
-        summary: 'Set the viewport resolution via the r.SetRes console command.',
-        whenToUse: ['The viewport resolution must be changed.'],
-        whenNotToUse: ['The default resolution is acceptable.'],
-        inputProps: { width: P.width, height: P.height },
-        required: ['width', 'height'],
-        effect: 'read',
-        exampleInput: { action: 'set_viewport_resolution', width: 1920, height: 1080 },
-        exampleOutput: { success: true, message: 'Resolution set', width: 1920, height: 1080 },
-        outputProps: { width: P.width, height: P.height },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'set_viewport_realtime', domain: D, family: F,
-        summary: 'Toggle realtime rendering in the editor viewport.',
-        whenToUse: ['Realtime rendering must be enabled or disabled.'],
-        whenNotToUse: ['The current realtime state is acceptable.'],
-        inputProps: { enabled: P.enabled, realtime: P.realtime },
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'set_viewport_realtime', enabled: false },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'set_editor_mode', domain: D, family: F,
-        summary: 'Activate an editor mode by id (EM_Landscape, EM_Foliage, EM_MeshPaint, EM_Default) and confirm it is active.',
-        whenToUse: ['A specific editor mode must be activated.'],
-        whenNotToUse: ['The default mode is acceptable.'],
-        inputProps: { mode: P.mode },
-        required: ['mode'],
-        effect: 'read',
-        exampleInput: { action: 'set_editor_mode', mode: 'landscape' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'set_immersive_mode', domain: D, family: F,
-        summary: 'Turn immersive viewport mode on or off (fails with NO_VIEWPORT when no level viewport is open).',
-        whenToUse: ['The viewport must enter or exit immersive fullscreen.'],
-        whenNotToUse: ['The current immersive state is acceptable.'],
-        inputProps: { enabled: P.enabled },
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'set_immersive_mode', enabled: true },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'set_game_view', domain: D, family: F,
-        summary: 'Toggle game view (no editor icons) in the level viewport, or in the free view of an ejected player.',
-        whenToUse: ['The viewport must show or hide the game view.'],
-        whenNotToUse: ['The current game view state is acceptable.',
-            'Play In Editor runs and the player is not ejected: the game on screen draws no editor icons anyway, so this is refused with PIE_VIEW_NOT_EJECTED.'],
-        inputProps: { enabled: P.enabled },
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'set_game_view', enabled: true },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'show_stats', domain: D, family: F,
-        summary: 'Show a stat overlay in the viewport (FPS and Unit when no stat is named); a stat already shown stays shown.',
-        whenToUse: ['A debug stat must be displayed.'],
-        whenNotToUse: ['The stat is already shown.'],
-        inputProps: { stat: P.stat },
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'show_stats', stat: 'fps' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'hide_stats', domain: D, family: F,
-        summary: 'Hide one stat overlay, or every stat when none is named; a stat already hidden stays hidden.',
-        whenToUse: ['A debug stat must be hidden.'],
-        whenNotToUse: ['The stat is already hidden.'],
-        inputProps: { stat: P.stat },
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'hide_stats', stat: 'fps' },
-    }),
-];
-//# sourceMappingURL=viewport.js.map

package/dist/tools/catalog/capabilities/records/core/builder.d.ts

@@ -1,35 +0,0 @@
-import type { CapabilityBehaviorSource, CapabilityPolicy, CapabilityRecordSource, JsonObject } from '../../model.js';
-type EffectType = 'read' | 'write' | 'destructive';
-type EditorState = 'edit' | 'pie' | 'simulate';
-export declare const ANY_EDITOR_STATE: readonly EditorState[];
-export type CoreRecordSpec = {
-    readonly parentTool: string;
-    readonly action: string;
-    readonly id?: string;
-    readonly bareInput?: boolean;
-    readonly dispatchAction?: string;
-    readonly domain: string;
-    readonly family: string;
-    readonly summary: string;
-    readonly whenToUse: readonly string[];
-    readonly whenNotToUse: readonly string[];
-    readonly inputProps: JsonObject;
-    readonly required?: readonly string[];
-    readonly requiredOneOf?: readonly string[];
-    readonly outputProps?: JsonObject;
-    readonly outputRequired?: readonly string[];
-    readonly effect: EffectType;
-    readonly behavior?: Partial<CapabilityBehaviorSource>;
-    readonly policyOverride?: Partial<CapabilityPolicy>;
-    readonly costLatency?: 'instant' | 'interactive' | 'long-running';
-    readonly costResources?: 'low' | 'medium' | 'high';
-    readonly plugins?: readonly string[];
-    readonly editorStates?: readonly EditorState[];
-    readonly aliases?: readonly string[];
-    readonly topics?: readonly string[];
-    readonly exampleInput: JsonObject;
-    readonly exampleOutput?: JsonObject;
-};
-export declare function buildCoreRecord(spec: CoreRecordSpec): CapabilityRecordSource;
-export {};
-//# sourceMappingURL=builder.d.ts.map

package/dist/tools/catalog/capabilities/records/core/builder.js

@@ -1,46 +0,0 @@
-import { CapabilityAliasSchema, CapabilityIdSchema, LegacyActionNameSchema, LegacyToolNameSchema } from '../../identifiers.js';
-import { actionInputSchema, behavior, EMPTY_OUTPUT, outputSchema, policy, schema } from '../shared/record-presets.js';
-export const ANY_EDITOR_STATE = ['edit', 'pie', 'simulate'];
-function availability(requiredPlugins = [], editorStates = ['edit']) {
-    return {
-        requiredPlugins: [...requiredPlugins],
-        editorStates: [...editorStates],
-    };
-}
-function routing(parentTool, dispatchAction) {
-    return {
-        parentTool: LegacyToolNameSchema.parse(parentTool),
-        dispatchAction: LegacyActionNameSchema.parse(dispatchAction),
-    };
-}
-export function buildCoreRecord(spec) {
-    const input = spec.bareInput
-        ? schema(spec.inputProps, spec.required, spec.requiredOneOf)
-        : actionInputSchema(spec.inputProps, spec.required, spec.requiredOneOf);
-    const output = spec.outputProps
-        ? outputSchema(spec.outputProps, spec.outputRequired ?? [])
-        : EMPTY_OUTPUT;
-    return {
-        id: CapabilityIdSchema.parse(spec.id ?? `${spec.parentTool}.${spec.action}`),
-        aliases: (spec.aliases ?? []).map((alias) => CapabilityAliasSchema.parse(alias)),
-        legacyIds: [
-            { tool: LegacyToolNameSchema.parse(spec.parentTool), action: LegacyActionNameSchema.parse(spec.action) },
-        ],
-        discovery: {
-            domain: spec.domain,
-            family: spec.family,
-            topics: [spec.action, ...(spec.topics ?? [])],
-            summary: spec.summary,
-            whenToUse: [...spec.whenToUse],
-            whenNotToUse: [...spec.whenNotToUse],
-        },
-        schemas: { input, output },
-        examples: [{ title: spec.summary, input: spec.exampleInput, output: spec.exampleOutput ?? { success: true } }],
-        availability: availability(spec.plugins, spec.editorStates),
-        behavior: behavior(spec.effect, spec.behavior),
-        policy: { ...policy(spec.effect), ...(spec.policyOverride ?? {}) },
-        cost: { latency: spec.costLatency ?? 'instant', resources: spec.costResources ?? 'low' },
-        routing: routing(spec.parentTool, spec.dispatchAction ?? spec.action),
-    };
-}
-//# sourceMappingURL=builder.js.map

package/dist/tools/catalog/capabilities/records/folds/animation-physics.folds.d.ts

@@ -1,3 +0,0 @@
-import type { FoldSpec } from '../shared/fold-types.js';
-export declare const ANIMATION_PHYSICS_FOLDS: readonly FoldSpec[];
-//# sourceMappingURL=animation-physics.folds.d.ts.map

package/dist/tools/catalog/capabilities/records/folds/animation-physics.folds.js

@@ -1,113 +0,0 @@
-import { byName } from '../shared/fold-spec.js';
-export const ANIMATION_PHYSICS_FOLDS = [
-    { primary: 'play_montage', summary: 'Play an animation montage on an actor.', members: ['play_anim_montage'] },
-    {
-        primary: 'setup_ragdoll', topics: ['go limp', 'make body go limp', 'make character go limp'], selector: 'ragdoll',
-        summary: 'Set up ragdoll physics on an actor, or activate/deactivate an existing ragdoll.',
-        members: { setup: 'setup_ragdoll', activate: 'activate_ragdoll' },
-    },
-    {
-        primary: 'create_animation_asset', selector: 'kind',
-        summary: 'Create an animation asset: a sequence, montage, blend space (1D/2D), aim offset, pose asset from a sequence, or procedural animation.',
-        topics: ['create animation', 'create montage', 'create blend space', 'create aim offset', 'pose asset', 'procedural animation', 'new animation sequence'],
-        members: {
-            asset: 'create_animation_asset', sequence: 'create_animation_sequence', montage: 'create_montage',
-            blend_space: 'create_blend_space', blend_space_1d: 'create_blend_space_1d', blend_space_2d: 'create_blend_space_2d',
-            aim_offset: 'create_aim_offset', pose_library: 'create_pose_library', procedural: 'create_procedural_anim',
-        },
-    },
-    {
-        primary: 'edit_animation', selector: 'edit',
-        summary: 'Edit an animation sequence: bone tracks and keys, curve keys, notifies, sync markers, additive and root-motion settings, length, aim-offset samples.',
-        topics: ['add notify', 'add sync marker', 'set bone key', 'root motion', 'sequence length', 'edit animation sequence'],
-        members: byName(['add_bone_track', 'set_bone_key', 'set_curve_key', 'add_notify', 'add_notify_state', 'add_sync_marker',
-            'set_additive_settings', 'set_root_motion_settings', 'set_sequence_length', 'add_aim_offset_sample']),
-    },
-    {
-        primary: 'edit_montage', selector: 'edit',
-        summary: 'Edit an animation montage: notifies, sections, slots, section links, blend-in/out times and section timing.',
-        topics: ['montage section', 'montage slot', 'montage notify', 'blend in', 'blend out', 'link sections', 'blend in time'],
-        members: byName(['add_montage_notify', 'add_montage_section', 'add_montage_slot', 'link_sections', 'set_blend_in', 'set_blend_out', 'set_section_timing']),
-    },
-    {
-        primary: 'edit_anim_graph', selector: 'edit',
-        summary: 'Edit an Animation Blueprint graph: blend, cached-pose and slot nodes, state machines, states, transitions and transition rules, blend trees.',
-        topics: ['anim graph', 'state machine', 'add state', 'add transition', 'blend node', 'blend tree', 'cached pose', 'slot node', 'add walk state', 'locomotion states'],
-        members: byName(['add_blend_node', 'add_cached_pose', 'add_slot_node', 'create_state_machine', 'add_state_machine',
-            'add_state', 'add_transition', 'set_transition_rules', 'delete_transition', 'create_blend_tree']),
-    },
-    {
-        primary: 'edit_blend_space', selector: 'edit',
-        summary: 'Edit a blend space: add samples, set axis and interpolation settings, force a rebuild.',
-        topics: ['blend space sample', 'blend space axis', 'interpolation settings', 'rebuild blend space'],
-        members: { add_sample: 'add_blend_sample', set_axis_settings: 'set_axis_settings', set_interpolation_settings: 'set_interpolation_settings', rebuild: 'force_rebuild_blend_space' },
-    },
-    {
-        primary: 'configure_anim_graph_node', selector: 'edit',
-        summary: 'Configure an AnimGraph node: add a layered-blend-per-bone node or set a node property value.',
-        topics: ['layered blend per bone', 'anim graph node value', 'blend upper body only'],
-        members: { add_layered_blend_per_bone: 'add_layered_blend_per_bone', set_value: 'set_anim_graph_node_value' },
-    },
-    {
-        primary: 'edit_skeleton', selector: 'edit',
-        summary: 'Edit a skeleton: add, rename or reparent bones, set bone transforms, add virtual bones.',
-        topics: ['add bone', 'rename bone', 'bone parent', 'bone transform', 'virtual bone'],
-        members: byName(['add_bone', 'rename_bone', 'set_bone_parent', 'set_bone_transform', 'create_virtual_bone']),
-    },
-    {
-        primary: 'configure_socket', selector: 'socketOp',
-        summary: 'Configure a skeleton socket: upsert its attachment and offsets, or strictly add, create or modify one.',
-        topics: ['skeleton socket', 'add socket', 'modify socket', 'create socket'],
-        members: { configure: 'configure_socket', add: 'add_socket', create: 'create_socket', modify: 'modify_socket' },
-    },
-    {
-        primary: 'edit_physics_asset', selector: 'edit',
-        summary: 'Create a physics asset or edit its bodies and constraints, and assign it to a skeletal mesh.',
-        topics: ['physics asset', 'physics body', 'physics constraint', 'constraint limits', 'assign physics asset', 'skeleton physics', 'preview physics', 'add collision to bones', 'assign physics asset to mesh'],
-        members: {
-            create: 'create_physics_asset', add_body: 'add_physics_body', configure_body: 'configure_physics_body', modify_body: 'modify_physics_body',
-            add_constraint: 'add_physics_constraint', set_constraint: 'set_physics_constraint', configure_constraint_limits: 'configure_constraint_limits',
-            assign: 'set_physics_asset',
-        },
-    },
-    {
-        primary: 'edit_skin_weights', selector: 'edit',
-        summary: 'Edit skeletal-mesh skin weights: auto-skin, set vertex weights, copy them from another skinned mesh, mirror one side onto the other, or prune tiny influences. Weights are always normalized on write.',
-        topics: ['skin weights', 'vertex weights', 'auto skin', 'copy weights', 'mirror weights', 'prune weights'],
-        members: { auto: 'auto_skin_weights', set: 'set_vertex_weights', copy: 'copy_weights', mirror: 'mirror_weights', prune: 'prune_weights' },
-    },
-    {
-        primary: 'edit_morph_target', selector: 'edit',
-        summary: 'Create a morph target, set its deltas, import morph targets from another mesh, or set a morph target value on an actor.',
-        topics: ['morph target', 'morph target deltas', 'import morph targets', 'morph target value'],
-        members: { create: 'create_morph_target', set_deltas: 'set_morph_target_deltas', import: 'import_morph_targets', set_value: 'set_morph_target_value' },
-    },
-    {
-        primary: 'bind_cloth_to_skeletal_mesh', topics: ['add cloth simulation'], selector: 'clothOp',
-        summary: 'Bind or assign a cloth asset to a skeletal mesh section.',
-        members: { bind: 'bind_cloth_to_skeletal_mesh', assign: 'assign_cloth_asset_to_mesh' },
-    },
-    { primary: 'create_animation_blueprint', summary: 'Create an Animation Blueprint for a skeleton.', members: ['create_anim_blueprint', 'create_animation_bp'] },
-    {
-        primary: 'setup_ik', selector: 'kind',
-        summary: 'Set up IK: create an IK rig or IK retargeter, a Control Rig for IK solvers, or set which source chain drives each target chain of a retargeter.',
-        topics: ['ik rig', 'ik retargeter', 'inverse kinematics', 'retarget chain mapping', 'full body ik'],
-        members: { setup: 'setup_ik', rig: 'create_ik_rig', retargeter: 'create_ik_retargeter', chain_mapping: 'set_retarget_chain_mapping' },
-    },
-    {
-        primary: 'get_skeleton_info', selector: 'info',
-        summary: 'Read skeleton data: summary, bones, sockets, virtual bones, bone transforms, morph targets, physics asset and bodies.',
-        topics: ['skeleton info', 'list bones', 'list sockets', 'bone transform', 'morph targets', 'physics bodies', 'virtual bones', 'check skeleton bones'],
-        members: {
-            skeleton: 'get_skeleton_info', bones: 'list_bones', sockets: 'list_sockets', virtual_bones: 'list_virtual_bones',
-            bone_transform: 'get_bone_transform', morph_targets: 'list_morph_targets', physics_asset: 'get_physics_asset_info', physics_bodies: 'list_physics_bodies',
-        },
-    },
-    {
-        primary: 'remove_skeleton_element', selector: 'element',
-        summary: 'Remove a bone, socket or physics body from a skeleton or physics asset.',
-        topics: ['remove bone', 'remove socket', 'remove physics body'],
-        members: { bone: 'remove_bone', socket: 'remove_socket', physics_body: 'remove_physics_body' },
-    },
-];
-//# sourceMappingURL=animation-physics.folds.js.map

package/dist/tools/catalog/capabilities/records/folds/build-environment.folds.d.ts

@@ -1,3 +0,0 @@
-import type { FoldSpec } from '../shared/fold-types.js';
-export declare const BUILD_ENVIRONMENT_FOLDS: readonly FoldSpec[];
-//# sourceMappingURL=build-environment.folds.d.ts.map