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

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

@@ -1,165 +0,0 @@
-import { byName, byTarget } from '../shared/fold-spec.js';
-import { LIGHT_SUMMARY, LIGHT_WHEN_NOT_TO_USE, LIGHT_WHEN_TO_USE } from '../shared/light-text.js';
-export const BUILD_ENVIRONMENT_FOLDS = [
-    {
-        primary: 'create_landscape', selector: 'kind',
-        summary: 'Create a landscape actor, or a landscape grass type asset.',
-        members: { landscape: 'create_landscape', grass_type: 'create_landscape_grass_type' },
-    },
-    {
-        primary: 'sculpt', selector: 'sculptOp',
-        summary: 'Sculpt a landscape with a brush, modify its heightmap data directly, or set its material.',
-        topics: ['sculpt landscape', 'heightmap', 'landscape material', 'raise or flatten the terrain or ground'],
-        members: { sculpt: 'sculpt', heightmap: 'modify_heightmap', material: 'set_landscape_material' },
-        aliasMembers: ['sculpt_landscape'],
-    },
-    {
-        primary: 'edit_landscape', selector: 'edit',
-        summary: 'Edit a landscape: paint layers, import a heightmap, configure LOD, material or splines, generate LODs.',
-        topics: ['paint landscape', 'landscape layer', 'import heightmap', 'landscape lod', 'landscape splines'],
-        members: byName(['paint_landscape', 'paint_landscape_layer', 'import_heightmap', 'configure_landscape_lod', 'configure_landscape_material', 'configure_landscape_splines', 'generate_lods']),
-    },
-    {
-        primary: 'create_landscape_asset', selector: 'kind',
-        summary: 'Create a landscape layer info asset or a landscape streaming proxy.',
-        members: { layer_info: 'create_landscape_layer_info', streaming_proxy: 'create_landscape_streaming_proxy' },
-    },
-    {
-        primary: 'add_foliage', selector: 'foliageOp',
-        summary: 'Create or update a foliage type asset, place explicit instances/transforms, or paint instances over a brush disc or a box area, dropped onto the ground.',
-        topics: ['add foliage', 'paint foliage', 'foliage instances', 'scatter foliage', 'scatter grass', 'fill area with foliage', 'plant trees', 'place bushes', 'add trees, grass or flowers to the level', 'make a forest', 'scatter rocks'],
-        members: { scatter: 'add_foliage', instances: 'add_foliage_instances', paint: 'paint_foliage' },
-    },
-    {
-        primary: 'create_foliage_type', selector: 'kind',
-        summary: 'Create a foliage type asset or a procedural foliage spawner.',
-        members: { type: 'create_foliage_type', procedural: 'create_procedural_foliage' },
-    },
-    {
-        primary: 'configure_foliage', selector: 'setting',
-        summary: 'Configure a foliage type: mesh, placement, collision, culling, LOD.',
-        topics: ['foliage mesh', 'foliage placement', 'foliage collision', 'foliage culling', 'foliage lod'],
-        members: byTarget('configure_foliage_', ['configure_foliage_mesh', 'configure_foliage_placement', 'configure_foliage_collision', 'configure_foliage_culling', 'configure_foliage_lod']),
-    },
-    { primary: 'remove_foliage', topics: ['remove trees or grass'], summary: 'Remove foliage instances of a type, all foliage, or only those inside an area box (a pit or a path).', members: ['remove_foliage_instances'] },
-    {
-        primary: 'create_light', summary: LIGHT_SUMMARY, whenToUse: LIGHT_WHEN_TO_USE, whenNotToUse: LIGHT_WHEN_NOT_TO_USE,
-        topics: ['add point light', 'add spot light', 'add a light', 'place a light', 'rect light', 'spotlight', 'street lamp light', 'light intensity', 'light color'],
-        members: ['create_dynamic_light', 'spawn_light'],
-    },
-    {
-        primary: 'create_sky_light', selector: 'skyLightOp',
-        summary: 'Create a sky light, or ensure the level has exactly one.',
-        members: { create: 'create_sky_light', ensure_single: 'ensure_single_sky_light' },
-        aliasMembers: ['spawn_sky_light'],
-    },
-    {
-        primary: 'configure_lighting', selector: 'setting',
-        summary: 'Configure scene lighting: shadows, ambient occlusion, exposure, global illumination, volumetric fog.',
-        topics: ['shadows', 'ambient occlusion', 'exposure', 'global illumination', 'lumen', 'volumetric fog', 'turn on lumen'],
-        members: { shadows: 'configure_shadows', ambient_occlusion: 'set_ambient_occlusion', exposure: 'set_exposure', global_illumination: 'setup_global_illumination', volumetric_fog: 'setup_volumetric_fog' },
-    },
-    {
-        primary: 'create_lighting_setup', selector: 'kind',
-        summary: 'Create a lighting-enabled level or a Lightmass importance volume.',
-        members: { level: 'create_lighting_enabled_level', lightmass_volume: 'create_lightmass_volume' },
-    },
-    {
-        primary: 'configure_ray_tracing', selector: 'feature',
-        summary: 'Configure a ray-tracing feature: ambient occlusion, global illumination, reflections, shadows, path tracing.',
-        topics: ['ray tracing', 'ray traced shadows', 'ray traced reflections', 'path tracing', 'ray traced gi'],
-        members: { ao: 'configure_ray_traced_ao', gi: 'configure_ray_traced_gi', reflections: 'configure_ray_traced_reflections', shadows: 'configure_ray_traced_shadows', path_tracing: 'configure_path_tracing' },
-    },
-    {
-        primary: 'configure_post_process', selector: 'setting',
-        summary: 'Configure a post-process setting on a volume or camera: bloom, exposure, depth of field, motion blur, tonemapper, color grading, LUT, white balance, vignette, grain, chromatic aberration, lens flare, SSAO/GTAO, SSR, screen percentage, blend.',
-        topics: ['post process', 'bloom', 'exposure', 'depth of field', 'motion blur', 'tonemapper', 'color grading', 'vignette', 'add bloom', 'screen tint', 'change screen tint', 'add bloom or depth of field'],
-        members: byName(['configure_bloom', 'set_bloom_intensity', 'set_bloom_threshold', 'configure_exposure', 'set_exposure_compensation', 'set_exposure_method',
-            'set_exposure_min_max', 'configure_dof', 'set_dof_method', 'set_focal_distance', 'set_aperture', 'configure_bokeh', 'configure_motion_blur',
-            'set_motion_blur_amount', 'set_motion_blur_max', 'configure_tonemapper', 'set_tonemapper_type', 'set_pp_color_grading', 'set_pp_lut',
-            'set_pp_white_balance', 'configure_vignette', 'configure_grain', 'configure_chromatic_aberration', 'configure_lens_flare', 'configure_ssao',
-            'configure_gtao', 'configure_ssr_settings', 'configure_lumen_reflection_settings', 'configure_screen_percentage', 'configure_pp_blend']),
-    },
-    {
-        primary: 'create_capture_actor', selector: 'kind',
-        summary: 'Create a scene capture (2D or cube) or a reflection capture (sphere, box or planar).',
-        topics: ['scene capture', 'reflection capture', 'planar reflection', 'render target capture', 'place a reflection capture', 'add a reflection capture'],
-        members: { scene_capture_2d: 'create_scene_capture_2d', scene_capture_cube: 'create_scene_capture_cube', sphere_reflection: 'create_sphere_reflection_capture', box_reflection: 'create_box_reflection_capture', planar_reflection: 'create_planar_reflection' },
-    },
-    {
-        primary: 'configure_scene_capture', selector: 'setting',
-        summary: 'Configure a capture actor: render target, capture source, resolution, offset, planar-reflection settings, reflection capture resolution, or trigger a (re)capture.',
-        topics: ['render target', 'capture source', 'capture resolution', 'recapture scene', 'reflection capture resolution'],
-        members: {
-            render_target: 'assign_render_target', source: 'configure_capture_source', resolution: 'configure_capture_resolution', offset: 'configure_capture_offset',
-            planar_reflection: 'configure_planar_reflection', reflection_resolution: 'configure_reflection_capture_resolution', capture: 'capture_scene', recapture: 'recapture_scene',
-        },
-    },
-    {
-        primary: 'configure_lightmass', selector: 'setting',
-        summary: 'Configure static lighting builds: Lightmass settings, build quality, indirect lighting cache.',
-        topics: ['lightmass', 'lighting quality', 'indirect lighting cache', 'static lighting'],
-        members: { settings: 'configure_lightmass_settings', build_quality: 'build_lighting_quality', indirect_lighting_cache: 'configure_indirect_lighting_cache' },
-    },
-    {
-        primary: 'set_light_channel', selector: 'channelTarget',
-        summary: 'Set lighting channels on a light or on an actor\'s primitives.',
-        members: { light: 'set_light_channel', actor: 'set_actor_light_channel' },
-    },
-    {
-        primary: 'create_spline', selector: 'kind',
-        summary: 'Create a spline actor, a spline mesh component, or a typed spline (road, wall, fence, pipe, cable, river).',
-        topics: ['spline actor', 'spline mesh', 'road spline', 'wall spline', 'fence', 'pipe', 'cable', 'river spline', 'make a spline', 'add a cable', 'add a fence along a path'],
-        members: {
-            actor: 'create_spline_actor', mesh_component: 'create_spline_mesh_component', road: 'create_road_spline', wall: 'create_wall_spline',
-            fence: 'create_fence_spline', pipe: 'create_pipe_spline', cable: 'create_cable_spline', river: 'create_river_spline',
-        },
-    },
-    {
-        primary: 'edit_spline', selector: 'edit',
-        summary: 'Edit spline points: add a point, set a point\'s position, rotation, scale or tangents, set the spline type.',
-        topics: ['spline point', 'spline tangent', 'spline type'],
-        members: { add_point: 'add_spline_point', set_point_position: 'set_spline_point_position', set_point_rotation: 'set_spline_point_rotation', set_point_scale: 'set_spline_point_scale', set_point_tangents: 'set_spline_point_tangents', set_type: 'set_spline_type' },
-    },
-    {
-        primary: 'configure_spline_meshes', selector: 'setting',
-        summary: 'Configure meshes along a spline: mesh asset, material, forward axis, spacing, randomization, or scatter meshes along it.',
-        topics: ['spline mesh asset', 'spline mesh material', 'mesh spacing', 'scatter along spline', 'mesh randomization', 'space fence posts'],
-        members: { mesh_asset: 'set_spline_mesh_asset', material: 'set_spline_mesh_material', axis: 'configure_spline_mesh_axis', spacing: 'configure_mesh_spacing', randomization: 'configure_mesh_randomization', scatter: 'scatter_meshes_along_spline' },
-    },
-    {
-        primary: 'configure_atmosphere', selector: 'setting',
-        summary: 'Configure the sky and atmosphere: sky atmosphere, sky light, sun position, directional light, height fog, volumetric clouds, time of day, sky/light color curves.',
-        topics: ['sky atmosphere', 'sun position', 'height fog', 'volumetric cloud', 'time of day', 'sky light', 'directional light', 'add fog', 'add sky', 'make it night', 'make it foggy', 'make it sunset or sunrise', 'add fog to the scene'],
-        members: {
-            sky_atmosphere: 'configure_sky_atmosphere', sky_light: 'configure_sky_light', sun_position: 'configure_sun_position', directional_light: 'configure_directional_light_atmosphere',
-            height_fog: 'configure_exponential_height_fog', volumetric_cloud: 'configure_volumetric_cloud', time_of_day: 'set_time_of_day',
-            sky_color_curve: 'configure_sky_color_curve', light_color_curve: 'configure_light_color_curve',
-        },
-    },
-    {
-        primary: 'create_atmosphere_actor', selector: 'kind',
-        summary: 'Create a sky sphere, a fog volume, or a time-of-day system.',
-        topics: ['sky sphere', 'fog volume', 'time of day system'],
-        members: { sky_sphere: 'create_sky_sphere', fog_volume: 'create_fog_volume', time_of_day_system: 'create_time_of_day_system' },
-    },
-    {
-        primary: 'configure_weather', selector: 'setting',
-        summary: 'Configure weather effects: rain, snow, lightning, wind.',
-        topics: ['rain', 'snow', 'lightning', 'wind', 'weather', 'add snow', 'add rain, snow, wind or lightning'],
-        members: { rain: 'configure_rain_particles', snow: 'configure_snow_particles', lightning: 'configure_lightning', wind: 'configure_wind' },
-    },
-    {
-        primary: 'create_water_body', selector: 'kind',
-        summary: 'Create a water body (ocean, lake, river or custom) with the Water plugin: real water that takes the editor\'s default materials and, for an ocean or lake, its default waves, as placing one in the editor does (listed under defaultsApplied).',
-        topics: ['water body', 'ocean', 'lake', 'river', 'add a lake or ocean', 'add a river', 'create a river', 'make a river'],
-        members: byTarget('create_water_body_', ['create_water_body_ocean', 'create_water_body_lake', 'create_water_body_river', 'create_water_body_custom']),
-    },
-    {
-        primary: 'configure_water', selector: 'setting',
-        summary: 'Configure a water body: its Gerstner waves (height, wavelength, steepness, direction), material or collision.',
-        topics: ['water waves', 'water material', 'water collision'],
-        members: byTarget('configure_water_', ['configure_water_waves', 'configure_water_material', 'configure_water_collision']),
-    },
-];
-//# sourceMappingURL=build-environment.folds.js.map

package/dist/tools/catalog/capabilities/records/folds/control-actor.folds.d.ts

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

package/dist/tools/catalog/capabilities/records/folds/control-actor.folds.js

@@ -1,61 +0,0 @@
-export const CONTROL_ACTOR_FOLDS = [
-    {
-        primary: 'spawn', selector: 'spawnKind',
-        summary: 'Spawn an actor from a class or mesh path, or from a Blueprint, or many actors in one batch.',
-        topics: ['spawn actor', 'spawn blueprint', 'place actor', 'add actor to level', 'spawn many actors', 'add player start', 'spawn enemy', 'spawn actors in a row', 'spawn actors in a grid'],
-        members: { class: 'spawn', blueprint: 'spawn_blueprint', batch: 'spawn_batch' },
-        aliasMembers: ['spawn_actor'],
-    },
-    {
-        primary: 'set_transform', selector: 'transformMode',
-        summary: 'Set an actor\'s transform: full transform, or location, rotation or scale alone, or teleport it.',
-        topics: ['move actor', 'rotate actor', 'scale actor', 'set actor location', 'set actor rotation', 'teleport actor', 'make actor bigger', 'make actor smaller', 'resize actor', 'shrink actor'],
-        members: { transform: 'set_transform', location: 'set_actor_location', rotation: 'set_actor_rotation', scale: 'set_actor_scale', teleport: 'teleport_actor' },
-        aliasMembers: ['set_actor_transform'],
-    },
-    {
-        primary: 'get_transform', selector: 'readMode',
-        summary: 'Read where an actor is (the player\'s pawn too): its transform now, or watch it over game time in PIE (motion): location, velocity, rotation, chosen properties and points on it (bones, sockets, components, with their height over the ground) at every interval, to prove a jump, launch, patrol, fall, foot plant or a rocking hull in one call.',
-        topics: ['actor location', 'where is the actor', 'where is the player', 'player location', 'actor position', 'sample motion', 'record trajectory', 'track actor over time', 'foot sliding', 'feet slide', 'foot contact', 'bone position over time'],
-        members: { transform: 'get_transform', motion: 'sample_motion' },
-        aliasMembers: ['get_actor_transform'],
-    },
-    {
-        primary: 'edit_component', selector: 'edit',
-        summary: 'Add or remove an actor component, or set one or more of its properties (a placed mesh\'s StaticMesh or OverrideMaterials, a light\'s Intensity or LightColor, a TextRender\'s Text).',
-        topics: ['add component', 'remove component', 'component property', 'set static mesh', 'change mesh', 'swap mesh', 'replace actor mesh', 'override materials', 'set component property value', 'actor component', 'text render text', 'change sign text', 'set light intensity', 'light color', 'light radius', 'change light color', '3d text', 'world text', 'floating text above actor', 'text above head'],
-        members: { add: 'add_component', remove: 'remove_component', set_property: 'set_component_property', set_properties: 'set_component_properties' },
-    },
-    {
-        primary: 'get_components', selector: 'info',
-        summary: 'List an actor\'s components, or read its bounds.',
-        topics: ['actor components', 'actor bounds', 'bounding box'],
-        members: { components: 'get_components', bounds: 'get_actor_bounds' },
-        aliasMembers: ['get_actor_components'],
-    },
-    {
-        primary: 'add_tag', selector: 'tagOp',
-        summary: 'Add a tag to an actor, or remove one.',
-        members: { add: 'add_tag', remove: 'remove_tag' },
-    },
-    { primary: 'find_by_tag', summary: 'Find actors carrying a tag.', members: ['find_actors_by_tag'] },
-    { primary: 'set_material', summary: 'Apply a material to an actor\'s mesh component(s).', members: ['apply_material', 'set_actor_material'] },
-    { primary: 'attach', summary: 'Attach an actor to a parent actor.', members: ['attach_actor'] },
-    { primary: 'detach', topics: ['unparent actor', 'remove actor from parent'], summary: 'Detach an actor from its parent.', members: ['detach_actor'] },
-    {
-        primary: 'delete', selector: 'deleteScope',
-        summary: 'Delete actors by name, or every actor carrying a tag.',
-        topics: ['delete actor', 'destroy actor', 'remove actor', 'delete by tag', 'delete spawned actor', 'delete selected actor', 'remove actor from level'],
-        members: { actors: 'delete', by_tag: 'delete_by_tag' },
-        aliasMembers: ['destroy_actor'],
-    },
-    {
-        primary: 'find', selector: 'findBy',
-        summary: 'Find actors by class, by name, by the static mesh they draw (mesh) or by a material in any of their slots (material); the mesh and material finds name the matching components.',
-        topics: ['find actor', 'find actor by name', 'find actors by class', 'search actors'],
-        members: { class: 'find_by_class', name: 'find_by_name', mesh: 'find_by_mesh', material: 'find_by_material' },
-        aliasMembers: { class: 'find_actors_by_class', name: 'find_actors_by_name' },
-    },
-    { primary: 'set_visibility', summary: 'Show or hide an actor, or many at once with actorNames.', members: ['set_actor_visible'] },
-];
-//# sourceMappingURL=control-actor.folds.js.map

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

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

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

@@ -1,52 +0,0 @@
-export const CONTROL_EDITOR_FOLDS = [
-    {
-        primary: 'play', selector: 'control',
-        summary: 'Control Play In Editor with control: play (starts it), pause, resume, stop, eject (leave the pawn for a free camera) or possess (take it back).',
-        topics: ['play in editor', 'press play', 'start the game', 'run the game', 'start pie', 'stop pie', 'pause pie', 'pause game', 'pause simulation', 'resume game', 'eject', 'possess', 'quit game'],
-        members: { play: 'play', pause: 'pause', resume: 'resume', stop: 'stop', eject: 'eject', possess: 'possess' },
-        aliasMembers: { stop: 'stop_pie' },
-    },
-    {
-        primary: 'set_game_speed', selector: 'control',
-        summary: 'Control the clock of the running game during Play In Editor: game speed (slow motion), a fixed delta time, or step frames.',
-        topics: ['game speed', 'time dilation', 'fixed delta time', 'step frame', 'slow motion', 'game too fast'],
-        members: { speed: 'set_game_speed', fixed_delta_time: 'set_fixed_delta_time', step_frame: 'step_frame' },
-        aliasMembers: { step_frame: 'single_frame_step' },
-    },
-    {
-        primary: 'start_recording', selector: 'control',
-        summary: 'Start or stop an editor gameplay recording.',
-        members: { start: 'start_recording', stop: 'stop_recording' },
-    },
-    {
-        primary: 'set_camera', selector: 'cameraOp',
-        summary: 'Set the viewport camera transform, its field of view, or the view target actor. While Play In Editor runs, the transform moves the free camera of an ejected player and is refused until the player is ejected.',
-        topics: ['viewport camera', 'camera position', 'camera fov', 'view target', 'look at actor', 'move the camera', 'move camera', 'game camera', 'pie camera'],
-        members: { transform: 'set_camera', fov: 'set_camera_fov', view_target: 'set_view_target' },
-        aliasMembers: { transform: ['set_camera_position', 'set_viewport_camera'], view_target: 'set_game_view_target' },
-    },
-    {
-        primary: 'configure_viewport', selector: 'setting',
-        summary: 'Configure the editor viewport: view mode, editor mode, game view, immersive mode, realtime, show or hide stats.',
-        topics: ['view mode', 'editor mode', 'game view', 'immersive mode', 'realtime viewport', 'viewport stats', 'show stats'],
-        members: { view_mode: 'set_view_mode', editor_mode: 'set_editor_mode', game_view: 'set_game_view', immersive_mode: 'set_immersive_mode', realtime: 'set_viewport_realtime', show_stats: 'show_stats', hide_stats: 'hide_stats' },
-    },
-    { primary: 'console_command', summary: 'Run a validated console command in the editor.', members: ['execute_command'] },
-    {
-        primary: 'configure_editor', selector: 'setting',
-        summary: 'Open an editor tab, set editor preferences, or restore or minimize the main editor window without focus (restoring unthrottles Play In Editor).',
-        topics: ['editor tab', 'editor preferences', 'open tab', 'restore editor window', 'minimize editor window', 'editor minimized', 'pie slow 3 fps', 'throttle'],
-        members: { open_tab: 'open_editor_tab', preferences: 'set_preferences', window: 'restore_editor_window' },
-    },
-    {
-        primary: 'screenshot', summary: 'Capture a screenshot of the level viewport (optionally from a camera location and rotation given in the same call), of the running game view, or of the whole editor window with the game UI.', members: ['take_screenshot'],
-        topics: ['capture viewport', 'screen capture', 'viewport image', 'snapshot', 'take picture', 'look from here', 'camera screenshot', 'game view screenshot', 'screenshot hud'],
-    },
-    {
-        primary: 'undo', selector: 'history',
-        summary: 'Undo or redo the last editor transaction; the reply names the transaction, or says there was none.',
-        topics: ['undo', 'redo', 'transaction history'],
-        members: { undo: 'undo', redo: 'redo' },
-    },
-];
-//# sourceMappingURL=control-editor.folds.js.map

package/dist/tools/catalog/capabilities/records/folds/inspect.folds.d.ts

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

package/dist/tools/catalog/capabilities/records/folds/inspect.folds.js

@@ -1,50 +0,0 @@
-export const INSPECT_FOLDS = [
-    {
-        primary: 'inspect_object', selector: 'objectKind',
-        summary: 'Deep-inspect an actor or asset, or read a typed detail view of an actor, level, material, texture or mesh (its size, bounds, pivot, LODs and material slots, each with the triangles and bounds of the geometry it covers).',
-        topics: ['inspect actor', 'introspect object', 'object properties', 'read all properties', 'actor details', 'level details', 'material details', 'mesh details', 'texture details', 'mesh size', 'mesh dimensions', 'mesh bounds', 'how big is a mesh', 'mesh pivot'],
-        members: { object: 'inspect_object', actor: 'get_actor_details', level: 'get_level_details', material: 'get_material_details', mesh: 'get_mesh_details', texture: 'get_texture_details' },
-    },
-    {
-        primary: 'inspect_class', selector: 'kind',
-        summary: 'Inspect a class, a struct, or a Blueprint\'s class default object.',
-        topics: ['class reflection', 'inspect struct', 'class default object', 'cdo'],
-        members: { class: 'inspect_class', struct: 'inspect_struct', cdo: 'inspect_cdo' },
-    },
-    {
-        primary: 'get_component_details', selector: 'info',
-        summary: 'Read one component of an actor or Blueprint: class, relative and world transform, mobility, visibility, attachment, bounds, collision, mesh and chosen property values; info=property returns a single property\'s value.',
-        topics: ['bounds and mobility', 'collision and mesh', 'world transform'],
-        members: { details: 'get_component_details', property: 'get_component_property' },
-    },
-    {
-        primary: 'query_object', selector: 'lookup',
-        summary: 'Query objects: list them, find by tag, read metadata or a bounding box, or export one.',
-        topics: ['list objects', 'find by tag', 'metadata', 'bounding box', 'export'],
-        members: { list: 'list_objects', by_tag: 'find_by_tag', metadata: 'get_metadata', bounding_box: 'get_bounding_box', export: 'export' },
-    },
-    {
-        primary: 'create_snapshot', selector: 'snapshotOp',
-        summary: 'Create a snapshot of an object\'s state, or restore one.',
-        members: { create: 'create_snapshot', restore: 'restore_snapshot' },
-    },
-    {
-        primary: 'get_editor_state', selector: 'editorState',
-        summary: 'Read editor state: selected actors, viewport, world settings, project settings, editor settings.',
-        topics: ['selected actors', 'what is selected', 'viewport info', 'world settings', 'project settings', 'editor settings'],
-        members: { selected_actors: 'get_selected_actors', viewport: 'get_viewport_info', world_settings: 'get_world_settings', project_settings: 'get_project_settings', editor_settings: 'get_editor_settings' },
-    },
-    {
-        primary: 'get_stats', selector: 'statsKind',
-        summary: 'Read performance (FPS, frame rate and time, thread and GPU ms), memory usage (used, available, peak) or scene statistics (actors by category, components, hidden actors).',
-        topics: ['performance stats', 'memory stats', 'scene stats', 'fps'],
-        members: { performance: 'get_performance_stats', memory: 'get_memory_stats', scene: 'get_scene_stats' },
-    },
-    {
-        primary: 'runtime_report',
-        summary: 'Report the live state of a running PIE game: up to 25 matching actors with class, transform, tags and components, plus the player controller, pawn, view target and camera; actors are reported only while PIE runs.',
-        topics: ['pie state', 'inspect running game', 'live actors'],
-        members: ['pie_report'],
-    },
-];
-//# sourceMappingURL=inspect.folds.js.map

package/dist/tools/catalog/capabilities/records/folds/manage-ai.folds.d.ts

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

package/dist/tools/catalog/capabilities/records/folds/manage-ai.folds.js

@@ -1,96 +0,0 @@
-export const MANAGE_AI_FOLDS = [
-    {
-        primary: 'create_behavior_tree', selector: 'kind',
-        summary: 'Create a Behavior Tree (directly or through the graph route) or a Blackboard asset.',
-        topics: ['behavior tree', 'blackboard', 'create ai asset'],
-        members: { behavior_tree: 'create_behavior_tree', graph_route: 'create', blackboard: 'create_blackboard' },
-        aliasMembers: { blackboard: 'create_blackboard_asset' },
-    },
-    {
-        primary: 'edit_behavior_tree', selector: 'edit',
-        summary: 'Edit a Behavior Tree graph: add composite, task, decorator, service or generic nodes and subnodes, connect or break connections, configure or remove nodes.',
-        topics: ['behavior tree node', 'composite node', 'task node', 'decorator', 'service', 'bt node'],
-        members: {
-            add_composite: 'add_composite_node', add_task: 'add_task_node', add_decorator: 'add_decorator', add_service: 'add_service', add_node: 'add_node', add_subnode: 'add_subnode',
-            connect: 'connect_nodes', break_connections: 'break_connections', configure_node: 'configure_bt_node', set_node_properties: 'set_node_properties', remove_node: 'remove_node',
-        },
-    },
-    {
-        primary: 'edit_blackboard', selector: 'edit',
-        summary: 'Edit a Blackboard: add a key, set a key value, or mark a key instance-synced.',
-        topics: ['blackboard key', 'blackboard value', 'instance synced'],
-        members: { add_key: 'add_blackboard_key', set_value: 'set_blackboard_value', set_key_instance_synced: 'set_key_instance_synced' },
-    },
-    {
-        primary: 'run_behavior_tree', selector: 'control',
-        summary: 'Run or stop a Behavior Tree on an AI controller, or assign a tree or blackboard to it.',
-        topics: ['run behavior tree', 'stop behavior tree', 'assign behavior tree', 'assign blackboard'],
-        members: { run: 'run_behavior_tree', stop: 'stop_behavior_tree', assign_tree: 'assign_behavior_tree', assign_blackboard: 'assign_blackboard' },
-    },
-    {
-        primary: 'get_tree', selector: 'info',
-        summary: 'Read a Behavior Tree as a nested node tree: root composite with its tasks, decorators and services, node counts and assigned Blackboard; info=blackboard_value reads a Blackboard key\'s type and default value.',
-        topics: ['behavior structure', 'nodes and services', 'blackboard key default'],
-        members: { tree: 'get_tree', blackboard_value: 'get_blackboard_value' },
-    },
-    {
-        primary: 'setup_perception', selector: 'setting',
-        summary: 'Set up AI perception on a Blueprint or controller: add the component, configure sight, hearing or damage senses, team, or runtime perception.',
-        topics: ['ai perception', 'sight config', 'hearing config', 'damage sense', 'perception team', 'sight range'],
-        members: {
-            setup: 'setup_perception', add_component: 'add_ai_perception_component', sight: 'configure_sight_config', hearing: 'configure_hearing_config',
-            damage: 'configure_damage_sense_config', team: 'set_perception_team', controller: 'set_ai_perception',
-        },
-    },
-    {
-        primary: 'configure_navigation', selector: 'setting',
-        summary: 'Configure navigation: nav mesh settings, agent properties, area cost or class, nav links, smart links, or rebuild the nav mesh.',
-        topics: ['nav mesh', 'navigation', 'nav agent', 'nav area', 'nav link', 'smart link', 'rebuild navigation', 'navmesh', 'add navmesh'],
-        members: {
-            mesh_settings: 'configure_nav_mesh_settings', agent_properties: 'set_nav_agent_properties', area_cost: 'configure_nav_area_cost', area_class: 'set_nav_area_class',
-            nav_link: 'configure_nav_link', link_type: 'set_nav_link_type', smart_link_behavior: 'configure_smart_link_behavior', rebuild: 'rebuild_navigation',
-        },
-    },
-    {
-        primary: 'create_nav_actor', selector: 'kind',
-        summary: 'Create a nav link proxy, a smart link, or a nav modifier (actor or component).',
-        topics: ['nav link proxy', 'smart link', 'nav modifier', 'add nav modifier'],
-        members: { link_proxy: 'create_nav_link_proxy', smart_link: 'create_smart_link', modifier: 'create_nav_modifier', modifier_component: 'create_nav_modifier_component' },
-    },
-    {
-        primary: 'set_focus', topics: ['make look player'], selector: 'focusOp',
-        summary: 'Set or clear an AI controller\'s focus actor.',
-        members: { set: 'set_focus', clear: 'clear_focus' },
-    },
-    {
-        primary: 'edit_eqs_query', selector: 'edit',
-        summary: 'Create an EQS query or edit it: add generators, tests and contexts, configure test scoring.',
-        topics: ['eqs', 'environment query', 'eqs generator', 'eqs test'],
-        members: { create: 'create_eqs_query', add_generator: 'add_eqs_generator', add_test: 'add_eqs_test', add_context: 'add_eqs_context', configure_test_scoring: 'configure_test_scoring' },
-    },
-    {
-        primary: 'edit_mass_entity', selector: 'edit',
-        summary: 'Create a Mass entity config, configure its traits, or add a Mass spawner.',
-        topics: ['mass entity', 'mass spawner', 'mass config'],
-        members: { create_config: 'create_mass_entity_config', configure: 'configure_mass_entity', add_spawner: 'add_mass_spawner' },
-    },
-    {
-        primary: 'edit_smart_object', selector: 'edit',
-        summary: 'Create a Smart Object definition, add slots, configure slot behavior, or add a Smart Object component.',
-        topics: ['smart object', 'smart object slot', 'smart object definition'],
-        members: { create_definition: 'create_smart_object_definition', add_slot: 'add_smart_object_slot', configure_slot: 'configure_slot_behavior', add_component: 'add_smart_object_component' },
-    },
-    {
-        primary: 'edit_state_tree', selector: 'edit',
-        summary: 'Create a State Tree or edit it: add states and transitions, configure tasks.',
-        topics: ['state tree', 'state tree state', 'state tree transition', 'state tree task', 'make a state tree'],
-        members: { create: 'create_state_tree', add_state: 'add_state_tree_state', add_transition: 'add_state_tree_transition', configure_task: 'configure_state_tree_task' },
-    },
-    {
-        primary: 'get_ai_info', selector: 'info',
-        summary: 'Read an AI asset: a pawn or AI controller Blueprint (perception, team, movement), a Behavior Tree summary, Blackboard keys, State Tree states or EQS query options; info=navigation returns NavMesh and agent settings.',
-        topics: ['controller settings', 'list blackboard keys', 'navmesh settings', 'state tree states'],
-        members: { ai: 'get_ai_info', navigation: 'get_navigation_info' },
-    },
-];
-//# sourceMappingURL=manage-ai.folds.js.map

package/dist/tools/catalog/capabilities/records/folds/manage-asset.folds.d.ts

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