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

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

@@ -3,6 +3,8 @@ 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,
@@ -28,7 +30,7 @@ export const TIMING_RECORDS = [
     }),
     buildCoreRecord({
         parentTool: 'control_editor', action: 'step_frame', domain: D, family: F,
-        summary: 'Advance the PIE simulation by one or more frames.',
+        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 },
@@ -36,7 +38,7 @@ export const TIMING_RECORDS = [
         effect: 'write', editorStates: RUNNING,
         exampleInput: { action: 'step_frame', steps: 1 },
         exampleOutput: { success: true, message: 'Stepped 1 frame(s)', steps: 1 },
-        outputProps: { steps: P.steps },
+        outputProps: { steps: P.steps, gameSeconds: STEP_GAME_SECONDS, timeDilation: STEP_DILATION },
         outputRequired: ['steps'],
     }),
     buildCoreRecord({
@@ -50,7 +52,7 @@ export const TIMING_RECORDS = [
         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 },
+        outputProps: { steps: P.steps, gameSeconds: STEP_GAME_SECONDS, timeDilation: STEP_DILATION },
         outputRequired: ['steps'],
     }),
 ];

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

@@ -1,6 +1,7 @@
 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;

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

@@ -1,5 +1,6 @@
 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],

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

@@ -151,13 +151,13 @@ export const BUILD_ENVIRONMENT_FOLDS = [
     },
     {
         primary: 'create_water_body', selector: 'kind',
-        summary: 'Create a water body: ocean, lake, river or custom.',
+        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 water: waves, material, collision.',
+        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']),
     },

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

@@ -15,8 +15,8 @@ export const CONTROL_ACTOR_FOLDS = [
     },
     {
         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 and chosen properties at every interval, to prove a jump, launch, patrol or fall 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'],
+        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'],
     },

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

@@ -56,8 +56,8 @@ export const MANAGE_ASSET_FOLDS = [
     },
     {
         primary: 'query_asset', selector: 'lookup',
-        summary: 'Query assets: existence, search by name/class, find by tag, find where a text appears inside assets, the node graph inside a material or Blueprint, material stats, source-control state.',
-        topics: ['find assets', 'search assets', 'asset exists', 'find by tag', 'find assets by tag', 'find text', 'where is text used', 'analyze graph', 'material stats', 'source control state', 'list all widget blueprints', 'asset name', 'project assets', 'list all meshes', 'is asset checked out'],
+        summary: 'Query assets: existence, search by name/class, find by tag, find where a text appears inside assets (graph nodes by title too, so every call of a function), the node graph inside a material or Blueprint, material stats, source-control state.',
+        topics: ['find assets', 'search assets', 'asset exists', 'find by tag', 'find assets by tag', 'find text', 'where is text used', 'where is function called', 'find function calls', 'analyze graph', 'material stats', 'source control state', 'list all widget blueprints', 'asset name', 'project assets', 'list all meshes', 'is asset checked out'],
         members: {
             exists: 'exists', search: 'search_assets', by_tag: 'find_by_tag', text: 'find_text', graph: 'analyze_graph',
             material_stats: 'get_material_stats', source_control_state: 'get_source_control_state',
@@ -83,9 +83,9 @@ export const MANAGE_ASSET_FOLDS = [
     },
     {
         primary: 'process_asset', selector: 'process',
-        summary: 'Process an asset: render a thumbnail, generate mesh LODs, or set the materials in the slots of a static or skeletal mesh asset (mesh_materials) so every placement shows them.',
-        topics: ['thumbnail', 'generate lods', 'material thumbnail'],
-        members: { thumbnail: 'create_thumbnail', lods: 'generate_lods', mesh_materials: 'set_mesh_materials' },
+        summary: 'Process an asset: render a thumbnail, generate mesh LODs, set the materials in the slots of a static or skeletal mesh asset (mesh_materials), or set a static mesh asset\'s collision (mesh_collision), so every placement shows or uses them.',
+        topics: ['thumbnail', 'generate lods', 'material thumbnail', 'mesh collision', 'static mesh collision'],
+        members: { thumbnail: 'create_thumbnail', lods: 'generate_lods', mesh_materials: 'set_mesh_materials', mesh_collision: 'set_mesh_collision' },
     },
     {
         primary: 'inspect_asset', selector: 'lookup',
@@ -146,9 +146,9 @@ export const MANAGE_ASSET_FOLDS = [
     },
     {
         primary: 'create_material', selector: 'kind',
-        summary: 'Create a material asset: a standard material, a decal, landscape or post-process material, or a material function.',
-        topics: ['create material', 'decal material', 'landscape material', 'post process material', 'material function'],
-        members: { material: 'create_material', decal: 'create_decal_material', landscape: 'create_landscape_material', post_process: 'create_post_process_material', function: 'create_material_function' },
+        summary: 'Create a material asset: a standard material, a decal, landscape or post-process material, a material function, or a Material Parameter Collection (values every material reading it shares).',
+        topics: ['create material', 'decal material', 'landscape material', 'post process material', 'material function', 'material parameter collection'],
+        members: { material: 'create_material', decal: 'create_decal_material', landscape: 'create_landscape_material', post_process: 'create_post_process_material', function: 'create_material_function', parameter_collection: 'create_parameter_collection' },
     },
     { primary: 'connect_nodes', topics: ['connect texture to base color', 'connect node to base color'], summary: 'Connect two material graph pins.', members: ['connect_material_pins'] },
     { primary: 'disconnect_nodes', summary: 'Disconnect a material graph pin or node.', members: ['break_material_connections'] },

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

@@ -1,9 +1,9 @@
 export const MANAGE_AUDIO_FOLDS = [
     {
         primary: 'play_sound', selector: 'playback',
-        summary: 'Play a sound: 2D, at a location (played or spawned), attached to an actor, or prime it for playback. A 2D sound (looping music too) plays until stop_sound.',
-        topics: ['play sound', 'play sound 2d', 'play sound at location', 'attached sound', 'prime sound', 'preview sound', 'preload sound'],
-        members: { '2d': 'play_sound_2d', at_location: 'play_sound_at_location', spawn_at_location: 'spawn_sound_at_location', attached: 'play_sound_attached', prime: 'prime_sound' },
+        summary: 'Play a sound: 2D, at a location (played or spawned), attached to an actor, or prime it for playback. A 2D sound (looping music too) plays until stop_sound. measure plays it 2D and reports how loud it played (peak and average dB, silent).',
+        topics: ['play sound', 'play sound 2d', 'play sound at location', 'attached sound', 'prime sound', 'preview sound', 'preload sound', 'measure sound', 'is sound audible'],
+        members: { '2d': 'play_sound_2d', at_location: 'play_sound_at_location', spawn_at_location: 'spawn_sound_at_location', attached: 'play_sound_attached', prime: 'prime_sound', measure: 'play_sound_measure' },
     },
     {
         primary: 'fade_sound', selector: 'fade',
@@ -47,8 +47,8 @@ export const MANAGE_AUDIO_FOLDS = [
     },
     {
         primary: 'configure_sound_attenuation', selector: 'setting',
-        summary: 'Configure sound attenuation: distance falloff, spatialization, occlusion, reverb send, or a named attenuation preset.',
-        topics: ['attenuation', 'spatialization', 'occlusion', 'reverb send', 'falloff distance', 'make sound 3d', 'sound blocked by walls'],
+        summary: 'Configure sound attenuation: distance falloff and air absorption, spatialization, occlusion, reverb send, or a named attenuation preset.',
+        topics: ['attenuation', 'spatialization', 'occlusion', 'reverb send', 'falloff distance', 'make sound 3d', 'sound blocked by walls', 'air absorption', 'muffled with distance'],
         members: {
             distance: 'configure_distance_attenuation', spatialization: 'configure_spatialization', occlusion: 'configure_occlusion', reverb_send: 'configure_reverb_send',
             audio_occlusion: 'set_audio_occlusion', preset: 'set_sound_attenuation',

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

@@ -43,7 +43,7 @@ export const MANAGE_BLUEPRINT_FOLDS = [
     },
     {
         primary: 'add_function', selector: 'kind',
-        summary: 'Add a function or an event to a Blueprint; an event can be bound to a component\'s or a Widget Blueprint widget\'s delegate (OnClicked).',
+        summary: 'Add a function or an event to a Blueprint; an event can be bound to a component\'s or a Widget Blueprint widget\'s delegate (OnClicked), and a function named after one the parent lets a Blueprint override (a widget\'s OnKeyDown) is made as that override.',
         topics: ['add function', 'add event', 'custom event', 'blueprint function', 'pure function'],
         members: { function: 'add_function', event: 'add_event' },
     },
@@ -55,7 +55,7 @@ export const MANAGE_BLUEPRINT_FOLDS = [
     {
         primary: 'inspect_graph', selector: 'info',
         summary: 'Inspect a Blueprint graph: its nodes (every one, or those whose title, pin default, text or object path matches a filter), node details, pin details, or the available node types.',
-        topics: ['graph details', 'node details', 'pin details', 'node types', 'find nodes', 'search graph nodes'],
+        topics: ['graph details', 'node details', 'pin details', 'node types', 'find nodes', 'search graph nodes', 'filter graph nodes'],
         members: { graph: 'get_graph_details', node: 'get_node_details', pins: 'get_pin_details', node_types: 'list_node_types' },
     },
     {

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

@@ -37,7 +37,7 @@ export const MANAGE_EFFECT_FOLDS = [
     {
         primary: 'edit_niagara_system', selector: 'edit',
         summary: 'Edit a Niagara system: add an emitter, user parameters or parameter bindings, set parameter values or dynamic inputs, emitter properties, GPU simulation, connect pins.',
-        topics: ['niagara parameter', 'user parameter', 'emitter properties', 'dynamic input', 'gpu simulation', 'add emitter', 'gpu particles', 'particle lifetime'],
+        topics: ['niagara parameter', 'user parameter', 'emitter properties', 'dynamic input', 'gpu simulation', 'add emitter', 'gpu particles', 'particle lifetime', 'static switch', 'ribbon width'],
         members: {
             add_emitter: 'add_emitter_to_system', add_user_parameter: 'add_user_parameter', bind_parameter: 'bind_parameter_to_source', set_parameter_value: 'set_parameter_value',
             set_parameter: 'set_niagara_parameter', set_dynamic_input: 'set_niagara_dynamic_input', set_emitter_properties: 'set_emitter_properties',
@@ -51,8 +51,8 @@ export const MANAGE_EFFECT_FOLDS = [
     },
     {
         primary: 'get_niagara_info', selector: 'info',
-        summary: 'Read a Niagara system: each emitter (enabled, CPU or GPU, stack modules, current module input values) and its user parameters; an emitter asset gives its name and CPU or GPU target. info=validate lists errors and warnings.',
-        topics: ['emitter list', 'stack modules', 'user parameters'],
+        summary: 'Read a Niagara system: each emitter (enabled, CPU or GPU, stack modules, current module input values, an input that reads a parameter or a dynamic input as {linkedTo}, the static switches such as Ribbon Width Mode that gate them, and its renderers with the object path inspect.set_property writes and their material) and its user parameters; an emitter asset gives its name and CPU or GPU target. info=validate lists errors and warnings.',
+        topics: ['emitter list', 'stack modules', 'user parameters', 'static switches'],
         members: { info: 'get_niagara_info', validate: 'validate_niagara_system' },
     },
 ];

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

@@ -19,9 +19,9 @@ export const MANAGE_SEQUENCE_FOLDS = [
     },
     {
         primary: 'edit_sequence_tracks', selector: 'edit',
-        summary: 'Edit sequence tracks: add a track, section or keyframe; lock, mute or solo a track.',
-        topics: ['sequence track', 'add track', 'add section', 'keyframe', 'mute track', 'solo track', 'lock track', 'keyframe actor location'],
-        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' },
+        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',
@@ -64,9 +64,9 @@ export const MANAGE_SEQUENCE_FOLDS = [
     },
     {
         primary: 'create_render_job', selector: 'control',
-        summary: 'Movie Render Queue: create a render job, queue it, or start rendering.',
-        topics: ['movie render queue', 'render job', 'queue render', 'start render', 'mrq', 'render video'],
-        members: { create: 'create_render_job', queue: 'queue_render', start: 'start_render' },
+        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',

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

@@ -42,8 +42,8 @@ export const SYSTEM_CONTROL_FOLDS = [
     },
     {
         primary: 'run_build', selector: 'kind',
-        summary: 'Run automation tests, or run UnrealBuildTool for a target.',
-        topics: ['automation tests', 'run tests', 'ubt', 'unreal build tool', 'build target'],
+        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' },
     },
     {

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

@@ -32,10 +32,13 @@ export const A = {
     layerSetup: objectList('Layered blend-per-bone branch filter descriptors.'),
     boneTracks: objectList('Bone tracks to key: [{ boneName, frames: [{ frame, rotationDelta?: {pitch,yaw,roll}, '
         + 'rotation?: {pitch,yaw,roll}|{x,y,z,w}, location?: {x,y,z}, scale?: {x,y,z} }] }]. '
-        + 'Channels left out keep the reference pose of that bone, so a rotation-only track poses '
-        + 'without collapsing the skeleton. Prefer rotationDelta, which bends the bone relative '
-        + 'to its rest orientation; plain rotation replaces the local rotation outright and needs '
-        + 'the rest orientation to already be known.'),
+        + 'frame runs 0 to numFrames inclusive. Only the poses that matter need keys: frames between '
+        + 'two keys of a channel are blended (rotation slerped), frames before its first key or '
+        + 'after its last hold that key. Channels left out keep the reference pose of that bone, so '
+        + 'a rotation-only track poses without collapsing the skeleton. Prefer rotationDelta, which '
+        + 'bends the bone relative to its rest orientation; plain rotation replaces the local '
+        + 'rotation outright and needs the rest orientation to already be known. Calling it again with '
+        + 'the name of an existing clip re-keys that clip from empty (its additive settings are kept).'),
     weights: objectList('Per-vertex skin weight descriptors with bone influences.'),
     deltas: objectList('Per-vertex morph target position deltas.'),
     pitch: num('Aim offset pitch in degrees.'),
@@ -44,7 +47,6 @@ export const A = {
     endFrame: num('Last frame of the notify state range.'),
     trackIndex: num('Notify track index within the animation sequence.'),
     notifyClass: str('AnimNotify (or AnimNotifyState) class name; prefixed with AnimNotify_/AnimNotifyState_ automatically when missing.'),
-    basePoseType: str('Additive base pose type (RefPose, AnimScaled, AnimFrame).'),
     basePoseFrame: num('Frame used as the additive base pose.'),
     forceRootLock: bool('Whether root motion is force-locked to the reference pose.'),
     bodyType: str('Physics body primitive type (Sphere, Box, Capsule).'),

package/dist/tools/catalog/capabilities/records/gameplay/animation-physics/authoring-1.data.js

@@ -1,7 +1,8 @@
 import { buildRecord } from '../helpers.js';
+import { ANY_EDITOR_STATE } from '../../core/builder.js';
 import { P } from '../properties.js';
 import { A } from './animation-properties.js';
-import { bool, num, str } from '../../shared/schema-props.js';
+import { bool, num, str, vec3 } from '../../shared/schema-props.js';
 const T = 'animation_physics';
 const F = 'animation';
 const W = ['An animation asset or graph must be authored.'];
@@ -135,5 +136,89 @@ export const ANIM_AUTHORED_1 = [
         inputProps: { name: P.name, path: P.path, skeletonPath: P.skeletonPath, skeletalMeshPath: str('Skeletal mesh to build the rig from; wins over skeletonPath.'), modularRig: bool('Create a Modular Rig (UE 5.5+; older engines report modularRig false).'), save: A.save }, required: ['name'],
         effect: 'write', latency: 'interactive', resources: 'medium', plugins: ['ControlRig', 'RigVM', 'EditorScriptingUtilities'],
         exampleInput: { action: 'create_control_rig', name: 'CR_Char', skeletonPath: '/Game/SK_Char' } }),
+    buildRecord({ parentTool: T, id: `${T}.edit_control_rig`, action: 'edit_control_rig', family: F,
+        topics: ['control rig graph', 'rig unit', 'add rig node', 'connect rig pins', 'wire control rig pins', 'control rig hierarchy', 'add control', 'rig bones'],
+        summary: 'Edit a Control Rig: add a unit node (list_rig_units finds them), connect or disconnect pins, set a pin value, remove a node, import the skeleton\'s bones, add a bone, null or control, or remove an element; one edit or many steps, then one compile and save. The reply lists what each edit made (a new node with its pins).',
+        whenToUse: ['A Control Rig needs its logic built: units such as Get Transform, Two Bone IK or Set Transform wired from the Forwards Solve event (a new rig may have none: add_unit BeginExecution adds it).', 'A rig needs bones from its skeleton, or controls and nulls to drive them.'],
+        whenNotToUse: ['The rig asset does not exist yet (use create_control_rig).', 'Only reading the rig (use get_control_rig).', 'An IK Rig or retargeter (use create_ik_rig, setup_ik).'],
+        inputProps: {
+            assetPath: str('Control Rig asset path, e.g. /Game/Rigs/CR_Arm.'),
+            edit: { type: 'string', enum: ['add_unit', 'connect', 'disconnect', 'set_pin', 'remove_node', 'import_bones', 'add_bone', 'add_null', 'add_control', 'remove_element'], description: 'The edit to make (each step of steps names its own).' },
+            unit: str('add_unit: the unit, as an object path (/Script/ControlRig.RigUnit_SetTransform), its struct name with or without RigUnit_ (SetTransform), or its display name.'),
+            name: str('add_unit: the new node\'s name (default the unit\'s, made unique); add_bone, add_null, add_control, remove_element: the element\'s name.'),
+            position: { type: 'array', items: { type: 'number' }, minItems: 2, maxItems: 2, description: 'add_unit: graph position [x, y] (default right of the last node).' },
+            from: str('connect, disconnect: the output pin, Node.Pin as get_control_rig lists it; execution runs from the event\'s execute pin to each unit\'s (ExecutePin in UE 5.8).'),
+            to: str('connect, disconnect: the input pin, Node.Pin.'),
+            pin: str('set_pin: the pin, Node.Pin; a struct member has its own pin (SetTransform.Item.Name, SetTransform.Transform.Translation.X).'),
+            value: { type: ['string', 'number', 'boolean'], description: 'set_pin: the value as text (Bone, foot_l), a number, or true/false.' },
+            node: str('remove_node: the node\'s name.'),
+            skeletonPath: str('import_bones: the skeleton whose bones are imported (default the skeleton of the rig\'s preview mesh).'),
+            parent: str('add_bone, add_null, add_control: the parent element\'s name (a bone, null or control); omitted, the top of the hierarchy.'),
+            location: vec3('add_bone, add_null, add_control: location [x, y, z] in cm (a control\'s offset), relative to the parent unless global.'),
+            rotation: vec3('add_bone, add_null, add_control: rotation [pitch, yaw, roll] in degrees.'),
+            scale: vec3('add_bone, add_null, add_control: scale [x, y, z] (default 1).'),
+            global: bool('add_bone, add_null: location, rotation and scale are in rig space, not relative to the parent.'),
+            controlType: { type: 'string', enum: ['transform', 'float', 'bool', 'position', 'rotator'], description: 'add_control: the value the control drives (default transform).' },
+            steps: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Several edits in order, each an object with edit and its own fields as above; the first that fails stops the rest, and those before it stay (failedStep names it).' },
+            save: A.save,
+        },
+        required: ['assetPath'],
+        effect: 'write', latency: 'interactive', resources: 'medium', plugins: CR_ESU,
+        exampleInput: { action: 'edit_control_rig', assetPath: '/Game/Rigs/CR_Arm', steps: [{ edit: 'add_unit', unit: 'BeginExecution', name: 'ForwardsSolve' }, { edit: 'add_unit', unit: 'SetTransform', name: 'SetHand' }, { edit: 'set_pin', pin: 'SetHand.Item.Name', value: 'hand_r' }, { edit: 'connect', from: 'ForwardsSolve.ExecutePin', to: 'SetHand.ExecutePin' }] },
+        exampleOutput: { success: true, message: 'Applied 4 edit(s) to CR_Arm.', assetPath: '/Game/Rigs/CR_Arm.CR_Arm', applied: 4, compiled: true, saved: true,
+            made: [{ node: 'SetHand', unit: '/Script/ControlRig.RigUnit_SetTransform', pins: [{ pin: 'SetHand.Item', direction: 'Input', type: 'FRigElementKey' }] }, { pin: 'SetHand.Item.Name', value: 'hand_r' }] },
+        outputProps: {
+            assetPath: str('The rig edited.'),
+            applied: num('Edits applied.'),
+            made: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'What the edits made: {node, unit, pins} for an added unit, {pin, value} for a set pin (the value as stored), {element} for an added element, {importedFrom, bones} for a skeleton\'s bones imported (bones the rig already had are matched in place).' },
+            compiled: bool('Whether the rig compiled after the edits.'),
+            compileErrors: { type: 'array', items: { type: 'string' }, description: 'The compile errors, when there were any.' },
+            saved: bool('Whether the rig was saved.'),
+            failedStep: num('steps: the step that failed (0-based); the ones before it were applied, compiled and saved.'),
+        },
+        outputRequired: ['assetPath', 'applied'] }),
+    buildRecord({ parentTool: T, id: `${T}.get_control_rig`, action: 'get_control_rig', family: F,
+        topics: ['read control rig', 'control rig nodes', 'rig pins', 'rig hierarchy'],
+        summary: 'Read a Control Rig: each node of its graph with its unit and pins (path, direction, type, default, linked), the links between pins, its hierarchy (bones, nulls, controls with their parents) and whether it compiled; node names one node with every struct member pin.',
+        whenToUse: ['Before editing a rig: the exact pin paths connect and set_pin take, and what is already wired.', 'To check a rig after edits: links, hierarchy, compile state.'],
+        whenNotToUse: ['Finding a unit to add (use list_rig_units).'],
+        inputProps: {
+            assetPath: str('Control Rig asset path, e.g. /Game/Rigs/CR_Arm.'),
+            node: str('One node\'s name: only that node, with every struct member pin by its full path.'),
+        },
+        required: ['assetPath'],
+        effect: 'read', editorStates: ANY_EDITOR_STATE, latency: 'instant', resources: 'low', plugins: CR_ESU,
+        exampleInput: { action: 'get_control_rig', assetPath: '/Game/Rigs/CR_Arm' },
+        exampleOutput: { success: true, message: 'CR_Arm: 2 node(s), 1 link(s), 3 hierarchy element(s).', assetPath: '/Game/Rigs/CR_Arm.CR_Arm',
+            nodes: [{ name: 'ForwardsSolve', title: 'Forwards Solve', unit: '/Script/ControlRig.RigUnit_BeginExecution', position: [0, 0], pins: [{ pin: 'ForwardsSolve.ExecutePin', direction: 'Output', type: 'FRigVMExecuteContext', linked: true }] }],
+            links: [{ from: 'ForwardsSolve.ExecutePin', to: 'SetHand.ExecutePin' }], elements: [{ type: 'Bone', name: 'root' }, { type: 'Bone', name: 'hand_r', parent: 'root' }], elementCount: 3, compiled: true },
+        outputProps: {
+            assetPath: str('The rig read.'),
+            nodes: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Each node: name, title, unit (struct path), position [x, y] and pins [{pin, direction, type, default, linked}].' },
+            links: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Each link: from (output pin) and to (input pin).' },
+            elements: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Hierarchy elements in order (up to 500): type (Bone, Null, Control, Curve ...), name and parent.' },
+            elementCount: num('All hierarchy elements.'),
+            compiled: bool('Whether the rig is compiled and up to date.'),
+            nodeNames: { type: 'array', items: { type: 'string' }, description: 'With a node that is not there: the nodes there are.' },
+        },
+        outputRequired: ['assetPath', 'nodes'] }),
+    buildRecord({ parentTool: T, id: `${T}.list_rig_units`, action: 'list_rig_units', family: F,
+        topics: ['rig units', 'find rig unit', 'control rig node types'],
+        summary: 'Find the units a Control Rig graph can hold (Get Transform, Two Bone IK, Aim, math and more): each unit\'s object path, name and category, for edit_control_rig add_unit.',
+        whenToUse: ['A unit is needed for add_unit and its name is not known.'],
+        whenNotToUse: ['Reading what a rig already holds (use get_control_rig).'],
+        inputProps: {
+            query: str('Words to match in the unit\'s name, display name, category or keywords (spaces ignored), e.g. two bone, aim, set transform.'),
+            limit: num('Most units to list (default 50, up to 500); matched counts them all.'),
+        },
+        required: [],
+        effect: 'read', editorStates: ANY_EDITOR_STATE, latency: 'instant', resources: 'low', plugins: CR_ESU,
+        exampleInput: { action: 'list_rig_units', query: 'two bone' },
+        exampleOutput: { success: true, message: '2 rig unit(s) match.', matched: 2, units: [{ unit: '/Script/ControlRig.RigUnit_TwoBoneIKSimplePerItem', name: 'Basic IK', category: 'Hierarchy' }] },
+        outputProps: {
+            units: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Matching units sorted by struct name: unit (the object path add_unit takes), name and category.' },
+            matched: num('Units that match.'),
+        },
+        outputRequired: ['units', 'matched'] }),
 ];
 //# sourceMappingURL=authoring-1.data.js.map

package/dist/tools/catalog/capabilities/records/gameplay/animation-physics/authoring-2.data.js

@@ -116,8 +116,13 @@ export const ANIM_AUTHORED_2 = [
         plugins: ESU, exampleInput: { action: 'set_root_motion_settings', assetPath: '/Game/A_Run', enableRootMotion: true, rootMotionRootLock: 'RefPose' },
         exampleOutput: { success: true, message: 'Root motion settings set' } }),
     buildRecord({ parentTool: T, id: `${T}.set_additive_settings`, action: 'set_additive_settings', family: F,
-        summary: 'Configure additive animation settings.', whenToUse: ['Additive layering needed.'], whenNotToUse: ['Absolute pose.'],
-        inputProps: { assetPath: P.assetPath, animationPath: P.animationPath, additiveAnimType: P.string_, basePoseType: A.basePoseType, basePoseFrame: A.basePoseFrame, basePoseAnimation: str('Animation sequence to take the additive base pose from.'), save: A.save }, required: [],
+        summary: 'Configure additive animation settings.', whenToUse: ['Additive layering needed.', 'A hand-keyed move (an arm raise, a head turn) must play on top of a mocap clip: key it as a procedural clip relative to the reference pose, then make it LocalSpaceAdditive with basePoseType RefPose.'], whenNotToUse: ['Absolute pose.'],
+        inputProps: {
+            assetPath: P.assetPath, animationPath: P.animationPath,
+            additiveAnimType: { type: 'string', enum: ['NoAdditive', 'LocalSpaceAdditive', 'MeshSpaceAdditive'], description: 'NoAdditive (default) plays the clip as a full pose. LocalSpaceAdditive keeps only its difference from the base pose and adds that on top of whatever plays under it (a Sequencer section on another row, Apply Additive in an Animation Blueprint). MeshSpaceAdditive adds rotations in mesh space, for aim offsets; Sequencer cannot play it.' },
+            basePoseType: { type: 'string', enum: ['RefPose', 'AnimScaled', 'AnimFrame'], description: 'What the additive difference is taken from (default RefPose): RefPose = the skeleton reference pose, AnimScaled = basePoseAnimation frame by frame, AnimFrame = one frame (basePoseFrame) of basePoseAnimation.' },
+            basePoseFrame: A.basePoseFrame, basePoseAnimation: str('Animation sequence to take the additive base pose from.'), save: A.save,
+        }, required: [],
         effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: ESU,
         exampleInput: { action: 'set_additive_settings', assetPath: '/Game/A_Run', additiveAnimType: 'NoAdditive', basePoseType: 'RefPose', basePoseFrame: 0 } }),
     buildRecord({ parentTool: T, id: `${T}.create_montage`, action: 'create_montage', family: F,

package/dist/tools/catalog/capabilities/records/gameplay/manage-effect/effect-properties.js

@@ -21,11 +21,11 @@ export const E = {
     emitterProperties: {
         type: 'object',
         additionalProperties: true,
-        description: 'Emitter settings to change. Supported key: enabled (boolean); any other key is refused. Module inputs are set with set_parameter_value.',
+        description: 'Emitter settings to change: enabled (boolean) turns the emitter on or off; moduleEnabled ({ModuleName: boolean}, names as get_niagara_info lists them) turns stack modules on or off, so a template module that works against the values set (a size curve, wind) can be switched off. Any other key is refused. Module inputs are set with set_parameter_value.',
         'x-unreal-reflection-boundary': true,
     },
     savePath: str('Canonical /Game directory for the created asset.'),
-    scriptType: str('Niagara script usage (System, Emitter, Particle).'),
+    scriptType: str('Which script the graph edit works in: Spawn (default) or Update. With emitterName that is the particle spawn or particle update stack of that emitter; without it, the system spawn or update script.'),
     modulePath: str('Canonical /Niagara module script path to insert.'),
     nodeId: str('Niagara graph node identifier.'),
     targetNodeId: str('Niagara graph node the dynamic input is attached to.'),
@@ -34,13 +34,14 @@ export const E = {
     inputName: str('Module input name receiving the dynamic input.'),
     replaceExisting: bool('Whether an existing dynamic input is replaced.'),
     parameterName: str('Niagara parameter name.'),
-    parameterType: str('Niagara parameter type (Float, Vector, Color, ...).'),
+    parameterType: str('Niagara parameter type (Float, Vector, Color or LinearColor, ...).'),
     parameterValue: { description: 'Niagara parameter value (any type).' },
     sourceBinding: str('Data source the parameter binds to.'),
     forceType: str('Force module type (Gravity, Drag, Wind, Curl, Vortex, PointAttraction).'),
     velocityMode: str('Velocity module mode (Linear, Cone, FromPoint).'),
     color: { description: 'Color as an {r, g, b, a} object or an [r, g, b, a] array: 0 to 255 channels for debug_shape, 0 to 1 for a light.' },
-    materialPath: str('Canonical /Game material asset path for the renderer.'),
+    materialPath: str('Canonical /Game material asset path for the renderer; its Niagara sprite or ribbon usage flag is set and the material saved, so the renderer never falls back to the default material.'),
+    meshPath: str('Canonical /Game static mesh for the mesh renderer; its materials get their Niagara mesh-particle usage flag set and saved, so the particles never fall back to the default material.'),
     lightRadius: num('Multiplier on each particle\'s light radius (the renderer RadiusScale, engine default 1). Left unchanged when omitted.'),
     eventName: str('Niagara event name.'),
     eventType: str('Niagara event generator type (Location, Death, Collision).'),
@@ -52,8 +53,8 @@ export const E = {
     fixedBoundsEnabled: bool('Whether fixed system bounds are enabled.'),
     attachToActor: str('Name of the actor the spawned system attaches to.'),
     reset: bool('Whether the effect restarts from its initial state.'),
-    deltaTime: num('Simulation delta time per step, in seconds.'),
-    steps: num('Number of simulation steps to advance.'),
+    deltaTime: num('Seconds per step (default 0.1); steps of about a frame (0.02) simulate the way the game does.'),
+    steps: num('Steps to run (default 1): the system ages steps x deltaTime seconds.'),
     filter: str('Actor name prefix selecting which transient effects are cleaned up.'),
     preset: str('Particle preset name or canonical /Game particle asset path.'),
     shapeType: str('Debug shape type (Sphere, Box, Line, Capsule).'),