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

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

@@ -1,42 +0,0 @@
-export const MANAGE_GAS_FOLDS = [
-    {
-        primary: 'create_gas_asset', selector: 'kind',
-        summary: 'Create a Gameplay Ability System asset: gameplay ability, gameplay effect, attribute set, gameplay cue notify, execution calculation.',
-        topics: ['gameplay ability', 'gameplay effect', 'attribute set', 'gameplay cue', 'execution calculation', 'make an ability'],
-        members: {
-            gameplay_ability: 'create_gameplay_ability', gameplay_effect: 'create_gameplay_effect', attribute_set: 'create_attribute_set',
-            gameplay_cue_notify: 'create_gameplay_cue_notify', execution_calculation: 'create_execution_calculation',
-        },
-    },
-    {
-        primary: 'configure_ability', selector: 'setting',
-        summary: 'Configure a gameplay ability: tags, cooldown, costs, activation and instancing policies; add it to an ability set.',
-        topics: ['ability tags', 'ability cooldown', 'ability cost', 'activation policy'],
-        members: {
-            tags: 'set_ability_tags', cooldown: 'set_ability_cooldown', costs: 'set_ability_costs', activation_policy: 'set_activation_policy',
-            instancing_policy: 'set_instancing_policy', add_to_set: 'add_ability',
-        },
-    },
-    {
-        primary: 'configure_gameplay_effect', selector: 'setting',
-        summary: 'Configure a gameplay effect: duration, stacking, tags, modifiers and magnitudes, execution calculations, cues.',
-        topics: ['effect duration', 'effect stacking', 'effect modifier', 'effect tags', 'gameplay cue'],
-        members: {
-            duration: 'set_effect_duration', stacking: 'set_effect_stacking', tags: 'set_effect_tags', add_modifier: 'add_effect_modifier', modifier_magnitude: 'set_modifier_magnitude',
-            add_execution_calculation: 'add_effect_execution_calculation', add_cue: 'add_effect_cue',
-        },
-    },
-    {
-        primary: 'configure_attribute_set', selector: 'setting',
-        summary: 'Configure an attribute set: add an attribute or set its base value.',
-        topics: ['attribute', 'attribute base value', 'add health attribute', 'health attribute'],
-        members: { add_attribute: 'add_attribute', base_value: 'set_attribute_base_value' },
-    },
-    {
-        primary: 'configure_asc', selector: 'setting',
-        summary: 'Add an Ability System Component to a Blueprint, or configure its replication mode.',
-        topics: ['ability system component', 'asc replication'],
-        members: { configure: 'configure_asc', add_component: 'add_ability_system_component' },
-    },
-];
-//# sourceMappingURL=manage-gas.folds.js.map

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

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

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

@@ -1,69 +0,0 @@
-import { byName, byTarget } from '../shared/fold-spec.js';
-export const MANAGE_GEOMETRY_FOLDS = [
-    {
-        primary: 'create_primitive', selector: 'primitive',
-        summary: 'Create a primitive mesh actor: box, sphere, cylinder, cone, capsule, plane, disc, ring, torus, pipe, arch, ramp, stairs, spiral stairs, or one smooth organic mesh from blended shapes (sdf) with soft fillets where they meet.',
-        topics: ['create box', 'create sphere', 'create cylinder', 'create plane', 'box mesh', 'primitive mesh', 'stairs', 'torus', 'make a cube or ramp',
-            'signed distance field', 'smooth blend shapes', 'organic mesh'],
-        members: byTarget('create_', ['create_box', 'create_sphere', 'create_cylinder', 'create_cone', 'create_capsule', 'create_plane', 'create_disc',
-            'create_ring', 'create_torus', 'create_pipe', 'create_arch', 'create_ramp', 'create_stairs', 'create_spiral_stairs', 'create_sdf']),
-    },
-    {
-        primary: 'boolean_mesh', selector: 'booleanOp',
-        summary: 'Boolean mesh operations: union, subtract, intersection, trim, self-union.',
-        topics: ['boolean', 'union', 'subtract', 'intersection', 'trim mesh', 'csg', 'cut a hole in a mesh'],
-        members: { union: 'boolean_union', subtract: 'boolean_subtract', intersection: 'boolean_intersection', trim: 'boolean_trim', self_union: 'self_union' },
-    },
-    {
-        primary: 'model_mesh', selector: 'modeling',
-        summary: 'Polygon modeling on a mesh: extrude, inset, outset, offset faces, bevel, chamfer, bridge, loft, sweep, revolve, shell, loop cut, edge split, poke faces, group triangles into quads, or extrude/duplicate along a spline. Extrude, inset, outset, offset, bevel, chamfer and poke work on every triangle, on triangleIndices, or on a region picked by box, facing direction, polygroup or material id. Dynamic meshes are always triangles.',
-        topics: ['extrude', 'inset', 'bevel', 'chamfer', 'bridge', 'loft', 'sweep', 'revolve', 'poke faces', 'triangles to quads', 'select faces by region', 'extrude the top faces'],
-        members: byName(['extrude', 'inset', 'outset', 'offset_faces', 'bevel', 'chamfer', 'bridge', 'loft', 'sweep', 'revolve', 'shell', 'loop_cut',
-            'edge_split', 'poke', 'quadrangulate', 'extrude_along_spline', 'duplicate_along_spline']),
-    },
-    {
-        primary: 'deform_mesh', selector: 'deform',
-        summary: 'Deform a mesh: bend, twist, taper, stretch, spherify, cylindrify, smooth, relax, noise, lattice, displace by texture.',
-        topics: ['bend', 'twist', 'taper', 'smooth mesh', 'noise deform', 'lattice', 'displace', 'spherify'],
-        members: byName(['bend', 'twist', 'taper', 'stretch', 'spherify', 'cylindrify', 'smooth', 'relax', 'noise_deform', 'lattice_deform', 'displace_by_texture']),
-    },
-    {
-        primary: 'optimize_mesh', selector: 'optimization',
-        summary: 'Optimize, smooth or repair a mesh: simplify, remesh (uniform or voxel), subdivide (pn tessellation, or Catmull-Clark, Loop and bilinear surfaces from a polygroup cage), morphology (voxel offset: dilate, contract, close to fillet where unioned parts meet, open), merge or weld vertices, remove degenerates, fill holes, flip or recalculate normals, recompute tangents.',
-        topics: ['simplify mesh', 'remesh', 'subdivide', 'weld vertices', 'fill holes', 'recalculate normals', 'flip normals', 'decimate', 'reduce triangles', 'catmull clark', 'smooth subdivision', 'fillet'],
-        members: byName(['simplify_mesh', 'remesh_uniform', 'remesh_voxel', 'subdivide', 'morphology', 'merge_vertices', 'weld_vertices', 'remove_degenerates', 'fill_holes',
-            'flip_normals', 'recalculate_normals', 'recompute_tangents']),
-    },
-    {
-        primary: 'edit_uvs', selector: 'uvOp',
-        summary: 'Edit mesh UVs: auto-generate, unwrap, project, pack islands, transform.',
-        topics: ['uv', 'unwrap', 'auto uv', 'pack uv islands', 'project uv'],
-        members: { auto: 'auto_uv', unwrap: 'unwrap_uv', project: 'project_uv', pack_islands: 'pack_uv_islands', transform: 'transform_uvs' },
-    },
-    {
-        primary: 'configure_mesh_collision', selector: 'collisionOp',
-        summary: 'Generate simple or complex collision for a mesh, or simplify its collision.',
-        topics: ['generate collision', 'complex collision', 'simplify collision', 'convex hull'],
-        members: { generate: 'generate_collision', generate_complex: 'generate_complex_collision', simplify: 'simplify_collision' },
-    },
-    {
-        primary: 'configure_mesh_lods', selector: 'lodOp',
-        summary: 'Generate mesh LODs, or set LOD settings and screen sizes.',
-        topics: ['generate lods', 'lod settings', 'lod screen size'],
-        members: { generate: 'generate_lods', set_settings: 'set_lod_settings', set_screen_sizes: 'set_lod_screen_sizes' },
-    },
-    {
-        primary: 'array_mesh', selector: 'arrayMode',
-        summary: 'Duplicate a mesh in a linear or radial array.',
-        topics: ['linear array', 'radial array', 'array duplicate'],
-        members: { linear: 'array_linear', radial: 'array_radial' },
-    },
-    {
-        primary: 'edit_dynamic_mesh', selector: 'edit',
-        summary: 'Edit a procedural/dynamic mesh: create one, append vertices, triangles or a whole polygon cage in one call (append_polygons), give triangles material ids by region (set_material_id), bake AO, edge, cavity and height masks for materials to read (bake_vertex_colors), set vertex positions, colors or UVs, split normals, translate, or subtract another mesh.',
-        topics: ['procedural mesh', 'dynamic mesh', 'append vertex', 'append triangle', 'vertex color', 'vertex position', 'move a vertex', 'create a mesh from vertices', 'polygon cage', 'material ids', 'bake masks'],
-        members: { create: 'create_procedural_mesh', append_vertex: 'append_vertex', append_triangle: 'append_triangle', append_polygons: 'append_polygons', set_vertex_position: 'set_vertex_position',
-            set_vertex_color: 'set_vertex_color', bake_vertex_colors: 'bake_vertex_colors', set_material_id: 'set_material_id', set_uvs: 'set_uvs', split_normals: 'split_normals', translate: 'translate_mesh', difference: 'difference' },
-    },
-];
-//# sourceMappingURL=manage-geometry.folds.js.map

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

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

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

@@ -1,17 +0,0 @@
-export const MANAGE_INTERACTION_FOLDS = [
-    {
-        primary: 'create_interactable', selector: 'kind',
-        summary: 'Create an interactable: door, chest, switch, lever or trigger actor, an interactable interface, or an interaction component.',
-        topics: ['door', 'chest', 'switch', 'lever', 'trigger actor', 'interactable interface', 'interaction component', 'create door', 'make a treasure chest', 'add a light switch'],
-        members: { door: 'create_door_actor', chest: 'create_chest_actor', switch: 'create_switch_actor', lever: 'create_lever_actor', trigger: 'create_trigger_actor', interface: 'create_interactable_interface', component: 'create_interaction_component' },
-    },
-    {
-        primary: 'configure_interactable', selector: 'setting',
-        summary: 'Configure an interactable: door, chest or switch properties, or its interaction trace.',
-        topics: ['door properties', 'chest properties', 'switch properties', 'interaction trace', 'set door open speed'],
-        members: {
-            door: 'configure_door_properties', chest: 'configure_chest_properties', switch: 'configure_switch_properties', trace: 'configure_interaction_trace',
-        },
-    },
-];
-//# sourceMappingURL=manage-interaction.folds.js.map

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

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

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

@@ -1,27 +0,0 @@
-export const MANAGE_INVENTORY_FOLDS = [
-    {
-        primary: 'create_inventory_asset', selector: 'kind',
-        summary: 'Create an inventory asset: item data asset, item category, loot table, crafting recipe, crafting station.',
-        topics: ['item data asset', 'item category', 'loot table', 'crafting recipe', 'crafting station', 'make an item'],
-        members: { item_data_asset: 'create_item_data_asset', item_category: 'create_item_category', loot_table: 'create_loot_table', crafting_recipe: 'create_crafting_recipe', crafting_station: 'create_crafting_station' },
-    },
-    {
-        primary: 'configure_item', selector: 'setting',
-        summary: 'Configure an item: properties, icon, stacking, category.',
-        topics: ['item properties', 'item icon', 'item stacking', 'item category'],
-        members: { properties: 'set_item_properties', icon: 'set_item_icon', stacking: 'configure_item_stacking', category: 'assign_item_category' },
-    },
-    {
-        primary: 'configure_loot', selector: 'setting',
-        summary: 'Configure a loot table: add or remove entries, set quality tiers.',
-        topics: ['loot entry', 'loot quality', 'loot drop rate'],
-        members: { add_entry: 'add_loot_entry', remove_entry: 'remove_loot_entry', quality_tiers: 'set_loot_quality_tiers' },
-    },
-    {
-        primary: 'configure_crafting', selector: 'setting',
-        summary: 'Configure a crafting recipe: add ingredients or set its requirements.',
-        topics: ['recipe ingredient', 'recipe requirements'],
-        members: { add_recipe_ingredient: 'add_recipe_ingredient', recipe_requirements: 'configure_recipe_requirements' },
-    },
-];
-//# sourceMappingURL=manage-inventory.folds.js.map

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

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

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

@@ -1,30 +0,0 @@
-export const MANAGE_LEVEL_STRUCTURE_FOLDS = [
-    {
-        primary: 'create_level_structure', selector: 'kind',
-        summary: 'Create level structure: a level, sublevel, level instance, packed level blueprint, data layer, or minimap volume.',
-        topics: ['create level', 'create sublevel', 'level instance', 'packed level actor', 'data layer', 'minimap volume'],
-        members: { level: 'create_level', sublevel: 'create_sublevel', level_instance: 'create_level_instance', packed_level_actor: 'create_packed_level_actor', data_layer: 'create_data_layer', minimap_volume: 'create_minimap_volume' },
-    },
-    {
-        primary: 'configure_level_streaming', selector: 'setting',
-        summary: 'Configure streaming and partition: level streaming, streaming distance, World Partition, grid size, HLOD layer, data-layer assignment.',
-        topics: ['level streaming', 'streaming distance', 'world partition', 'grid size', 'hlod', 'data layer assignment'],
-        members: {
-            streaming: 'configure_level_streaming', streaming_distance: 'set_streaming_distance', world_partition: 'enable_world_partition',
-            grid_size: 'configure_grid_size', hlod_layer: 'configure_hlod_layer', data_layer_assignment: 'assign_actor_to_data_layer',
-        },
-    },
-    {
-        primary: 'edit_level_blueprint', selector: 'edit',
-        summary: 'Edit the level Blueprint: open it, add or remove nodes, connect nodes.',
-        topics: ['level blueprint', 'level blueprint node'],
-        members: { open: 'open_level_blueprint', add_node: 'add_level_blueprint_node', connect_nodes: 'connect_level_blueprint_nodes', remove_node: 'remove_level_blueprint_node' },
-    },
-    {
-        primary: 'set_volume_properties', selector: 'volumeProperty',
-        summary: 'Set a volume\'s properties, its extent, or its bounds.',
-        topics: ['volume extent', 'volume bounds', 'volume properties', 'resize volume'],
-        members: { properties: 'set_volume_properties', extent: 'set_volume_extent', bounds: 'set_volume_bounds' },
-    },
-];
-//# sourceMappingURL=manage-level-structure.folds.js.map

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

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

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

@@ -1,28 +0,0 @@
-export const MANAGE_LEVEL_FOLDS = [
-    { primary: 'load', summary: 'Load a level in the editor.', members: ['load_level'] },
-    {
-        primary: 'save', selector: 'saveMode',
-        summary: 'Save the current or a named level, or save it under a new path.',
-        topics: [],
-        members: { save: 'save', as: 'save_as' },
-        aliasMembers: ['save_level', 'save_level_as'],
-    },
-    {
-        primary: 'duplicate_level', topics: ['copy level', 'copy map'], selector: 'levelOp',
-        summary: 'Duplicate a level to a new path, or rename it.',
-        members: { duplicate: 'duplicate_level', rename: 'rename_level' },
-    },
-    { primary: 'delete', summary: 'Delete one or more level assets.', members: ['delete_level'] },
-    {
-        primary: 'get_summary', selector: 'info',
-        summary: 'Read a level (path, name, actor count, asset data) or the one open in the editor, and whether it has unsaved changes, with every unsaved level and asset listed.',
-        topics: ['level summary', 'current level', 'what is the current level', 'unsaved changes'],
-        members: { summary: 'get_summary', current_level: 'get_current_level' },
-    },
-    {
-        primary: 'stream', topics: ['load sublevel', 'unload sublevel'], selector: 'streamOp',
-        summary: 'Stream a sublevel in or out, or unload it.',
-        members: { stream: 'stream', unload: 'unload' },
-    },
-];
-//# sourceMappingURL=manage-level.folds.js.map

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

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

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

@@ -1,86 +0,0 @@
-import { byTarget } from '../shared/fold-spec.js';
-export const MANAGE_NETWORKING_FOLDS = [
-    {
-        primary: 'configure_replication', selector: 'setting',
-        summary: 'Configure replication on a Blueprint: property replication and conditions, RepNotify, net role, dormancy, relevancy, priority, update frequency, cull distance, push model, replicated movement, replication graph, net driver.',
-        topics: ['replicate variable', 'replication', 'rep notify', 'net dormancy', 'net role', 'relevancy', 'net update frequency', 'push model'],
-        members: {
-            property: 'set_property_replicated', condition: 'set_replication_condition', rep_notify: 'set_replicated_using', net_role: 'set_net_role', dormancy: 'set_net_dormancy',
-            always_relevant: 'set_always_relevant', only_relevant_to_owner: 'set_only_relevant_to_owner', autonomous_proxy: 'set_autonomous_proxy', priority: 'configure_net_priority',
-            update_frequency: 'configure_net_update_frequency', cull_distance: 'configure_net_cull_distance', push_model: 'configure_push_model',
-            replicated_movement: 'configure_replicated_movement', replication_graph: 'configure_replication_graph', net_driver: 'configure_net_driver',
-        },
-    },
-    {
-        primary: 'configure_prediction', selector: 'setting',
-        summary: 'Configure client-side prediction: client, movement, server correction, or add prediction data (a variable replicated only to the owning client).',
-        topics: ['client prediction', 'movement prediction', 'server correction', 'network prediction', 'prediction data', 'owner only variable'],
-        members: { client: 'configure_client_prediction', movement: 'configure_movement_prediction', server_correction: 'configure_server_correction', add_data: 'add_network_prediction_data' },
-    },
-    {
-        primary: 'configure_rpc', selector: 'setting',
-        summary: 'Create an RPC function, or set its validation or reliability.',
-        topics: ['rpc', 'remote procedure call', 'rpc reliability', 'rpc validation'],
-        members: { create: 'create_rpc_function', validation: 'configure_rpc_validation', reliability: 'set_rpc_reliability' },
-    },
-    {
-        primary: 'check_authority', selector: 'check',
-        summary: 'Check an actor\'s network role by actorName: check=has_authority returns hasAuthority and the local net role; check=is_locally_controlled returns whether a pawn is locally controlled and has a local player controller.',
-        topics: ['locally controlled pawn', 'net role of actor', 'is server'],
-        members: { has_authority: 'check_has_authority', is_locally_controlled: 'check_is_locally_controlled' },
-    },
-    {
-        primary: 'create_framework_class', selector: 'kind',
-        summary: 'Create a game framework Blueprint: game mode, game state, game instance, player controller, player state, HUD.',
-        topics: ['game mode', 'game state', 'game instance', 'player controller', 'player state', 'hud class', 'make a game mode'],
-        members: { game_mode: 'create_game_mode', game_state: 'create_game_state', game_instance: 'create_game_instance', player_controller: 'create_player_controller', player_state: 'create_player_state', hud: 'create_hud_class' },
-    },
-    {
-        primary: 'configure_game_mode', selector: 'setting',
-        summary: 'Configure a game mode: default classes (pawn, controller, state, HUD), rules, respawn, spectating.',
-        topics: ['default pawn', 'game rules', 'respawn', 'spectating', 'set game mode', 'change game mode', 'respawn time', 'enable spectator mode'],
-        members: {
-            default_pawn_class: 'set_default_pawn_class', player_controller_class: 'set_player_controller_class', game_state_class: 'set_game_state_class', player_state_class: 'set_player_state_class',
-            hud_class: 'set_hud_class', rules: 'configure_game_rules', respawn: 'set_respawn_rules', spectating: 'configure_spectating',
-        },
-    },
-    {
-        primary: 'configure_voice', selector: 'setting',
-        summary: 'Voice chat: start or stop it now, set the project VoIP settings (online voice on or off, mic gain, noise gate, silence detection, sample rate), or mute a player.',
-        topics: ['voice chat', 'voip settings', 'mic gain', 'noise gate', 'mute player'],
-        members: { enable: 'enable_voice_chat', settings: 'configure_voice_settings', mute_player: 'mute_player' },
-    },
-    {
-        primary: 'configure_session', selector: 'setting',
-        summary: 'Configure multiplayer for the project: the default game port for LAN hosting and joining, the online subsystem (Null, Steam, EOS...), and the local split-screen layout. Written to DefaultEngine.ini.',
-        topics: ['lan play', 'game port', 'server port', 'online subsystem', 'session interface', 'split screen', 'split screen layout'],
-        members: { lan_play: 'configure_lan_play', interface: 'configure_session_interface', split_screen: 'configure_split_screen' },
-        aliasMembers: { split_screen: 'set_split_screen_type' },
-    },
-    {
-        primary: 'host_lan_server', selector: 'serverOp',
-        summary: 'Host a LAN listen server (build the travel URL, optionally travel to it), or make a running Play-In-Editor instance join one.',
-        topics: ['host server', 'join server', 'lan server', 'listen server', 'connect to server'],
-        members: { host: 'host_lan_server', join: 'join_lan_server' },
-    },
-    {
-        primary: 'configure_input', selector: 'setting',
-        summary: 'Enhanced Input: create an input action or mapping context, add or map keys, set triggers and modifiers, enable a context.',
-        topics: ['input action', 'input mapping context', 'enhanced input', 'key mapping', 'input trigger', 'input modifier', 'bind space to jump', 'wasd movement input'],
-        members: {
-            create_action: 'create_input_action', create_mapping_context: 'create_input_mapping_context', add_mapping: 'add_mapping', map_action: 'map_input_action',
-            set_trigger: 'set_input_trigger', set_modifier: 'set_input_modifier', enable_mapping: 'enable_input_mapping',
-        },
-    },
-    {
-        primary: 'add_legacy_mapping', selector: 'mapping',
-        summary: 'Add a legacy input action or axis mapping.',
-        members: byTarget('add_legacy_', ['add_legacy_action_mapping', 'add_legacy_axis_mapping'], '_mapping'),
-    },
-    {
-        primary: 'remove_legacy_mapping', selector: 'mapping',
-        summary: 'Remove a legacy input action or axis mapping.',
-        members: byTarget('remove_legacy_', ['remove_legacy_action_mapping', 'remove_legacy_axis_mapping'], '_mapping'),
-    },
-];
-//# sourceMappingURL=manage-networking.folds.js.map

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

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

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

@@ -1,22 +0,0 @@
-import { byTarget } from '../shared/fold-spec.js';
-export const MANAGE_PCG_FOLDS = [
-    {
-        primary: 'add_pcg_node', selector: 'nodeKind',
-        summary: 'Add a node to a PCG graph: any settings class by name, or a typed node (samplers, spawners, filters, data nodes, point operations).',
-        topics: ['pcg node', 'surface sampler', 'static mesh spawner', 'density filter', 'landscape data', 'spline sampler', 'transform points'],
-        members: {
-            node: 'add_pcg_node',
-            ...byTarget('add_', ['add_surface_sampler', 'add_spline_sampler', 'add_mesh_sampler', 'add_volume_sampler', 'add_static_mesh_spawner', 'add_actor_spawner', 'add_spline_spawner',
-                'add_density_filter', 'add_distance_filter', 'add_height_filter', 'add_slope_filter', 'add_bounds_filter', 'add_bounds_modifier',
-                'add_landscape_data_node', 'add_spline_data_node', 'add_actor_data_node', 'add_texture_data_node', 'add_volume_data_node',
-                'add_transform_points', 'add_copy_points', 'add_merge_points', 'add_project_to_surface', 'add_self_pruning']),
-        },
-    },
-    {
-        primary: 'edit_pcg_graph', selector: 'edit',
-        summary: 'Create a PCG graph or subgraph, connect pins, set node settings, or set the partition grid size.',
-        topics: ['pcg graph', 'pcg subgraph', 'connect pcg pins', 'pcg node settings', 'partition grid size'],
-        members: { create: 'create_pcg_graph', create_subgraph: 'create_pcg_subgraph', connect_pins: 'connect_pcg_pins', set_node_settings: 'set_pcg_node_settings', set_partition_grid_size: 'set_pcg_partition_grid_size' },
-    },
-];
-//# sourceMappingURL=manage-pcg.folds.js.map

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

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

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

@@ -1,106 +0,0 @@
-import { byTarget } from '../shared/fold-spec.js';
-export const MANAGE_SEQUENCE_FOLDS = [
-    {
-        primary: 'create', selector: 'sequenceOp',
-        summary: 'Create a level sequence, or duplicate or rename one.',
-        topics: ['level sequence', 'create sequence', 'create cinematic', 'duplicate sequence', 'rename sequence'],
-        members: { create: 'create', duplicate: 'duplicate', rename: 'rename' },
-    },
-    {
-        primary: 'play', selector: 'control',
-        summary: 'Play, pause or stop a level sequence in the editor.',
-        members: { play: 'play', pause: 'pause', stop: 'stop' },
-    },
-    {
-        primary: 'edit_sequence_bindings', selector: 'edit',
-        summary: 'Edit sequence bindings: add one or more actors, a camera, or a spawnable from a class; remove actors.',
-        topics: ['sequence binding', 'add actor to sequence', 'spawnable', 'sequence camera', 'spawn actor in sequence'],
-        members: { add_actor: 'add_actor', add_actors: 'add_actors', add_camera: 'add_camera', add_spawnable: 'add_spawnable_from_class', remove_actors: 'remove_actors' },
-    },
-    {
-        primary: 'edit_sequence_tracks', selector: 'edit',
-        summary: 'Edit sequence tracks: add a track, section or keyframe; move, trim or ease a section; lock, mute or solo a track.',
-        topics: ['sequence track', 'add track', 'add section', 'keyframe', 'mute track', 'solo track', 'lock track', 'keyframe actor location', 'crossfade clips', 'ease section', 'trim section'],
-        members: { add_track: 'add_track', add_section: 'add_section', add_keyframe: 'add_keyframe', set_locked: 'set_track_locked', set_muted: 'set_track_muted', set_solo: 'set_track_solo', set_section: 'set_section' },
-    },
-    {
-        primary: 'set_properties', selector: 'sequenceProperty',
-        summary: 'Set sequence properties: playback range and frame rate, display rate, tick resolution, playback speed, view range, work range.',
-        topics: ['frame rate', 'playback range', 'display rate', 'tick resolution', 'playback speed', 'work range', 'view range', 'cutscene length', 'level sequence length'],
-        members: { properties: 'set_properties', display_rate: 'set_display_rate', tick_resolution: 'set_tick_resolution', playback_speed: 'set_playback_speed', view_range: 'set_view_range', work_range: 'set_work_range' },
-    },
-    {
-        primary: 'delete', topics: ['delete level sequence', 'delete cutscene'], selector: 'deleteScope',
-        summary: 'Delete a level sequence, remove one of its tracks, or remove keyframes from a track.',
-        members: { sequence: 'delete', track: 'remove_track', keyframe: 'remove_keyframe' },
-    },
-    {
-        primary: 'get_properties', selector: 'info',
-        summary: 'Read a sequence: properties, bindings, tracks, the keys on a track, the available track types, list sequences, or open one in Sequencer.',
-        topics: ['sequence properties', 'sequence bindings', 'list tracks', 'track types', 'list sequences', 'open sequencer'],
-        members: { properties: 'get_properties', bindings: 'get_bindings', tracks: 'list_tracks', keys: 'list_track_keys', track_types: 'list_track_types', list: 'list', open: 'open' },
-    },
-    {
-        primary: 'add_cinematic_track', selector: 'trackKind',
-        summary: 'Add a cinematic track: camera cut, camera shake, transform, property, skeletal animation, material parameter, particle, event, fade, level visibility, shot, or subsequence.',
-        topics: ['camera cut track', 'camera shake', 'transform track', 'property track', 'animation track', 'fade track', 'shot track', 'subsequence', 'fade to black', 'add skeletal animation to sequence'],
-        members: {
-            ...byTarget('add_', ['add_camera_cut_track', 'add_camera_shake_track', 'add_transform_track', 'add_property_track', 'add_skeletal_animation_track',
-                'add_material_parameter_track', 'add_particle_track', 'add_event_track', 'add_fade_track', 'add_level_visibility_track', 'add_shot_track'], '_track'),
-            subsequence: 'add_subsequence',
-        },
-    },
-    {
-        primary: 'configure_cinematic', selector: 'setting',
-        summary: 'Configure cinematic cameras and shots: camera settings, crane or rail rigs, shot settings.',
-        topics: ['cine camera settings', 'camera rig crane', 'camera rig rail', 'shot settings', 'focal length', 'aperture', 'set camera focal length'],
-        members: { camera: 'configure_camera_settings', rig_crane: 'configure_camera_rig_crane', rig_rail: 'configure_camera_rig_rail', shot: 'configure_shot_settings' },
-    },
-    {
-        primary: 'create_cinematic_asset', selector: 'kind',
-        summary: 'Create a cine camera actor or a master sequence.',
-        topics: ['cine camera actor', 'master sequence'],
-        members: { cine_camera_actor: 'create_cine_camera_actor', master_sequence: 'create_master_sequence' },
-    },
-    {
-        primary: 'create_render_job', selector: 'control',
-        summary: 'Movie Render Queue: create a render job, queue it, start rendering, or remove jobs from the queue.',
-        topics: ['movie render queue', 'render job', 'queue render', 'start render', 'mrq', 'render video', 'remove render job', 'clear render queue'],
-        members: { create: 'create_render_job', queue: 'queue_render', start: 'start_render', remove: 'remove_render_job' },
-    },
-    {
-        primary: 'configure_render_job', selector: 'setting',
-        summary: 'Configure a Movie Render Queue job: output settings, anti-aliasing, render passes, burn-ins, console variables.',
-        topics: ['render output settings', 'anti aliasing', 'render pass', 'burn in', 'console variables', 'movie output resolution'],
-        members: { output: 'configure_output_settings', anti_aliasing: 'configure_anti_aliasing', add_render_pass: 'add_render_pass', burn_ins: 'configure_burn_ins', console_variables: 'configure_console_variables' },
-    },
-    {
-        primary: 'create_media_asset', selector: 'kind',
-        summary: 'Create a media asset: media source, player, playlist, texture, or sound component.',
-        topics: ['media source', 'media player', 'media playlist', 'media texture', 'media sound'],
-        members: byTarget('create_media_', ['create_media_source', 'create_media_player', 'create_media_playlist', 'create_media_texture', 'create_media_sound_component']),
-    },
-    {
-        primary: 'play_media', topics: ['play video file'], selector: 'control',
-        summary: 'Play, pause or seek a media player.',
-        members: { play: 'play_media', pause: 'pause_media', seek: 'seek_media' },
-    },
-    {
-        primary: 'play_demo', selector: 'control',
-        summary: 'Replay system: play, pause or seek a demo, set playback speed, start or stop recording, start a killcam.',
-        topics: ['replay', 'demo recording', 'play demo', 'killcam', 'demo playback speed'],
-        members: { play: 'play_demo', pause: 'pause_demo', seek: 'seek_demo', set_playback_speed: 'set_demo_playback_speed', start_recording: 'start_demo_recording', stop_recording: 'stop_demo_recording', start_killcam: 'start_killcam' },
-    },
-    {
-        primary: 'configure_demo_settings', selector: 'setting',
-        summary: 'Configure replay demo settings or the killcam duration.',
-        members: { demo: 'configure_demo_settings', killcam_duration: 'configure_killcam_duration' },
-    },
-    {
-        primary: 'configure_take_recorder', selector: 'setting',
-        summary: 'Take Recorder: configure sources and recorded tracks, open the panel, start or stop recording.',
-        topics: ['take recorder', 'take sources', 'recorded tracks', 'start take recording', 'record actor animation'],
-        members: { sources: 'configure_take_sources', recorded_tracks: 'configure_recorded_tracks', panel: 'create_take_recorder_panel', start_recording: 'start_recording', stop_recording: 'stop_recording' },
-    },
-];
-//# sourceMappingURL=manage-sequence.folds.js.map

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

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

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

@@ -1,62 +0,0 @@
-export const SYSTEM_CONTROL_FOLDS = [
-    { primary: 'console_command', summary: 'Run a validated console command.', members: ['execute_command'] },
-    {
-        primary: 'configure_display', selector: 'setting',
-        summary: 'Configure display and rendering variables: resolution, fullscreen, quality, a console variable, FPS counter, profiling overlay.',
-        topics: ['set cvar', 'console variable', 'resolution', 'fullscreen', 'quality settings', 'show fps', 'profile', 'change quality settings'],
-        members: { resolution: 'set_resolution', fullscreen: 'set_fullscreen', quality: 'set_quality', cvar: 'set_cvar', fps: 'show_fps', profile: 'profile' },
-    },
-    {
-        primary: 'configure_performance', selector: 'setting',
-        summary: 'Configure performance settings: scalability, frame rate limit, resolution scale, vsync, LOD, Nanite, occlusion culling, texture streaming, World Partition streaming, GPU timing, draw-call and shader optimization, baseline profile.',
-        topics: ['scalability', 'frame rate limit', 'vsync', 'resolution scale', 'nanite', 'occlusion culling', 'texture streaming', 'performance'],
-        members: {
-            scalability: 'set_scalability', frame_rate_limit: 'set_frame_rate_limit', resolution_scale: 'set_resolution_scale', vsync: 'set_vsync', lod: 'configure_lod',
-            nanite: 'configure_nanite', occlusion_culling: 'configure_occlusion_culling', texture_streaming: 'configure_texture_streaming', world_partition: 'configure_world_partition',
-            gpu_timing: 'enable_gpu_timing', draw_calls: 'optimize_draw_calls', shaders: 'optimize_shaders', baseline: 'apply_baseline_settings',
-        },
-    },
-    {
-        primary: 'profile_performance', selector: 'control',
-        summary: 'Profile performance: start or stop profiling, run a benchmark, generate a memory report, show stats.',
-        topics: ['profiling', 'benchmark', 'memory report', 'stat unit', 'show stats'],
-        members: { start: 'start_profiling', stop: 'stop_profiling', benchmark: 'run_benchmark', memory_report: 'generate_memory_report', show_stats: 'show_stats' },
-    },
-    {
-        primary: 'start_session', selector: 'control',
-        summary: 'Unreal Insights: start, stop, pause or resume a trace session, capture a trace, send or write a snapshot, launch the Insights viewer.',
-        topics: ['unreal insights', 'trace session', 'capture trace', 'trace snapshot'],
-        members: { start: 'start_session', stop: 'stop_session', pause: 'pause_session', resume: 'resume_session', capture_trace: 'capture_insights_trace', send_snapshot: 'send_snapshot', write_snapshot: 'write_snapshot', launch_viewer: 'start_unreal_insights' },
-    },
-    {
-        primary: 'get_trace_status', selector: 'info',
-        summary: 'Read the Unreal Insights trace session status (connected, destination, active channels, connection type, paused); info=analyze reads a .utrace file\'s existence, size and modified time.',
-        topics: ['insights session', 'is tracing active', 'active channels', 'file size'],
-        whenToUse: ['The active trace session status must be read.', 'A captured .utrace file must be checked for existence, size and modified time.'],
-        members: { status: 'get_trace_status', analyze: 'analyze_trace' },
-    },
-    {
-        primary: 'enable_plugin', selector: 'pluginState',
-        summary: 'Enable or disable a plugin.',
-        members: { enable: 'enable_plugin', disable: 'disable_plugin' },
-    },
-    {
-        primary: 'run_build', selector: 'kind',
-        summary: 'Run automation tests and answer with each one\'s result (passed or not, its errors and warnings), or run UnrealBuildTool for a target.',
-        topics: ['automation tests', 'run tests', 'test results', 'ubt', 'unreal build tool', 'build target'],
-        members: { tests: 'run_tests', ubt: 'run_ubt' },
-    },
-    {
-        primary: 'create_widget', selector: 'widgetOp',
-        summary: 'Create a runtime widget, add a child to it, or show it.',
-        topics: ['show widget on screen', 'add widget to viewport', 'display widget'],
-        members: { create: 'create_widget', add_child: 'add_widget_child', show: 'show_widget' },
-    },
-    {
-        primary: 'subscribe', selector: 'control',
-        summary: 'Stream the editor log to this connection (subscribe, unsubscribe), or turn a Gameplay Debugger category on or off.',
-        topics: ['log channels', 'subscribe logs', 'log category', 'watch game logs live', 'log stream'],
-        members: { subscribe: 'subscribe', unsubscribe: 'unsubscribe', spawn_category: 'spawn_category' },
-    },
-];
-//# sourceMappingURL=system-control.folds.js.map

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

@@ -1,3 +0,0 @@
-import type { PropertyMap } from '../properties.js';
-export declare const A: PropertyMap;
-//# sourceMappingURL=animation-properties.d.ts.map