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

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

@@ -1,345 +0,0 @@
-import { buildRecord } from '../helpers.js';
-import { ANY_EDITOR_STATE } from '../../core/builder.js';
-import { P } from '../properties.js';
-import { E } from './effect-properties.js';
-import { bool } from '../../shared/schema-props.js';
-import { LIGHT_COLOR_TEXT } from '../../shared/light-text.js';
-const T = 'manage_effect';
-const SAVE = bool('Persist the asset to disk (default true); false leaves the change in memory only.');
-const F = 'effect';
-const W = ['A particle, Niagara or debug effect must be authored or run.'];
-const NIAGARA = ['Niagara'];
-const EMITTER_REQUIRED = ['systemPath', 'emitterName'];
-const EMITTER_ONLY = ['emitterName'];
-const SYSTEM_ONE_OF = ['systemPath', 'assetPath'];
-const PARAMETER_LIST = {
-    type: 'array', minItems: 1, maxItems: 200,
-    items: { type: 'object', properties: { parameterName: E.parameterName, parameterValue: E.parameterValue }, required: ['parameterName', 'parameterValue'], additionalProperties: false },
-    description: 'Several values written together and saved once, in place of parameterName and parameterValue: each {parameterName, parameterValue} names a user parameter, a module input or a module\'s static switch as get_niagara_info lists it (InitializeParticle.Lifetime, InitializeParticle.Ribbon Width Mode), and emitterName and save apply to every entry. The reply lists every entry (parameterName, applied, error); the call fails PARAMETER_BATCH_INCOMPLETE naming any that did not apply, and the others stay written.',
-};
-export const EFFECT_RECORDS = [
-    buildRecord({ parentTool: T, id: `${T}.particle`, action: 'particle', family: F,
-        summary: 'Spawn a particle effect (Cascade or Niagara) from a preset name or a system asset.', whenToUse: W, whenNotToUse: ['Use niagara.'],
-        inputProps: { name: P.name, preset: E.preset, systemPath: E.systemPath, location: P.location, rotation: P.rotation }, required: [], requiredOneOf: ['preset', 'systemPath'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: NIAGARA,
-        exampleInput: { action: 'particle', preset: 'Default', location: [0, 0, 100] } }),
-    buildRecord({ parentTool: T, id: `${T}.niagara`, action: 'niagara', family: F,
-        summary: 'Place a Niagara system in the level as a Niagara actor, at a location or attached to an actor; autoActivate false places it switched off, for a sequence particle track or gameplay to start.', whenToUse: W, whenNotToUse: ['Use particle.'],
-        inputProps: { name: P.name, actorName: P.actorName, systemPath: E.systemPath, attachToActor: E.attachToActor, location: P.location, rotation: P.rotation, scale: E.scale, autoActivate: { type: 'boolean', description: 'false places the effect switched off so it waits for its cue (a particle track trigger key, Activate); default true, which also fires it when the level starts.' } }, required: ['systemPath'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: NIAGARA,
-        outputProps: { actorPath: P.string_, actorName: P.actorName, existsAfter: P.bool_, actorClass: P.string_ }, outputRequired: [],
-        exampleInput: { action: 'niagara', systemPath: '/Game/NS_Explosion', actorName: 'FX_1' }, exampleOutput: { success: true, message: 'Niagara system authored', actorName: 'FX_1' } }),
-    buildRecord({ parentTool: T, id: `${T}.debug_shape`, action: 'debug_shape', topics: ['draw debug shape', 'debug sphere box line arrow capsule', 'show debug shape', 'draw a debug line', 'draw debug line'], family: F,
-        summary: 'Spawn a debug shape in the editor viewport.', whenToUse: ['Visualize a region/volume.'], whenNotToUse: ['Use spawn_niagara.'],
-        inputProps: { shape: P.string_, shapeType: E.shapeType, location: P.location, radius: P.radius, color: E.color, duration: P.duration, thickness: E.thickness,
-            boxSize: E.boxSize, endLocation: E.endLocation, rotation: P.rotation, direction: E.direction, length: E.length, angle: E.angle, halfHeight: E.halfHeight }, required: [],
-        effect: 'write', editorStates: ['edit'], latency: 'instant', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'debug_shape', shape: 'Sphere', location: [0, 0, 0], radius: 100 } }),
-    buildRecord({ parentTool: T, id: `${T}.spawn_niagara`, action: 'spawn_niagara', family: F,
-        topics: ['spawn particle', 'play effect', 'spawn vfx', 'spawn niagara system', 'emit particles', 'spawn explosion effect', 'spawn effect at location'],
-        summary: 'Spawn a Niagara system instance at runtime (PIE).', whenToUse: ['A Niagara effect must play on a live actor.'], whenNotToUse: ['Author the system.'],
-        inputProps: { actorName: P.actorName, assetPath: P.assetPath, system: E.system, systemPath: E.systemPath, attachToActor: E.attachToActor, location: P.location, rotation: P.rotation, scale: E.scale }, required: [],
-        effect: 'write', editorStates: ['edit', 'pie', 'simulate'], behavior: {}, latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'spawn_niagara', system: '/Game/NS_Explosion', location: [0, 0, 100] } }),
-    buildRecord({ parentTool: T, id: `${T}.create_dynamic_light`, action: 'create_dynamic_light', topics: ['add a dynamic light'], family: F,
-        summary: 'Create a dynamic light actor.',
-        whenToUse: ['A light must appear in the running game (PIE), or a point, spot, directional or rect light with just an intensity and a color is enough.'],
-        whenNotToUse: ['A rotation, a sky light, or settings such as castShadows, attenuationRadius or the cone angles are needed: use build_environment.create_light, which takes them and spawns into the level being edited.'],
-        inputProps: { name: P.name, location: P.location, lightType: E.lightType, intensity: E.intensity,
-            color: { ...E.color, description: `Light color as an {r, g, b, a} object or an [r, g, b, a] array. ${LIGHT_COLOR_TEXT}` } }, required: ['name'],
-        effect: 'write', editorStates: ['edit', 'pie'], latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'create_dynamic_light', name: 'Light_1', lightType: 'Point', intensity: 750 } }),
-    buildRecord({ parentTool: T, id: `${T}.create_niagara_system`, action: 'create_niagara_system', family: F,
-        topics: ['niagara', 'particle system', 'vfx', 'particle effect', 'new niagara system'],
-        summary: 'Create a Niagara System asset.', whenToUse: W, whenNotToUse: ['Use niagara.'],
-        inputProps: { name: P.name, path: P.path, savePath: E.savePath, save: SAVE }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: NIAGARA,
-        outputProps: { systemPath: P.assetPath }, outputRequired: ['systemPath'],
-        exampleInput: { action: 'create_niagara_system', name: 'NS_Fire' }, exampleOutput: { success: true, message: 'Niagara system created', systemPath: '/Game/NS_Fire' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_niagara_emitter`, action: 'create_niagara_emitter', family: F,
-        summary: 'Create a Niagara Emitter asset.', whenToUse: ['A reusable emitter is needed.'], whenNotToUse: ['Use create_niagara_system.'],
-        inputProps: { name: P.name, path: P.path, savePath: E.savePath, save: SAVE }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: NIAGARA,
-        exampleInput: { action: 'create_niagara_emitter', name: 'NE_Spark' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_volumetric_fog`, action: 'create_volumetric_fog', family: F,
-        summary: 'Create a volumetric fog effect.', whenToUse: ['Volumetric fog needed.'], whenNotToUse: ['Use build_environment fog.'],
-        inputProps: { name: P.name, location: P.location, density: E.density, scattering: E.scattering, extinction: E.extinction }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: NIAGARA,
-        exampleInput: { action: 'create_volumetric_fog', name: 'VF_Mist', density: 0.02 } }),
-    buildRecord({ parentTool: T, id: `${T}.create_particle_trail`, action: 'create_particle_trail', family: F,
-        summary: 'Create a particle trail effect: by default a ribbon (the engine LocationBasedRibbon template given its own SpawnRate of 60 a second, Ribbon Width Mode Direct Set and an infinite loop) that trails whatever it is attached to, placed in the level only when location is given; tune SpawnRate.SpawnRate, InitializeParticle.Lifetime, Ribbon Width and Color with set_parameter_value.', whenToUse: ['A trailing effect is needed.'], whenNotToUse: ['Use create_niagara_ribbon for a ribbon-based trail.'],
-        inputProps: { name: P.name, path: P.path, systemPath: E.systemPath, templateEmitterPath: E.templateEmitterPath, location: P.location, save: SAVE }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: NIAGARA,
-        exampleInput: { action: 'create_particle_trail', name: 'PT_Trail' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_environment_effect`, action: 'create_environment_effect', family: F,
-        summary: 'Create an environment effect (weather/atmosphere) system asset, placed in the level only when location is given.', whenToUse: ['Ambient FX needed.'], whenNotToUse: ['Use build_environment weather.'],
-        inputProps: { name: P.name, path: P.path, systemPath: E.systemPath, templateEmitterPath: E.templateEmitterPath, location: P.location, save: SAVE }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: NIAGARA,
-        exampleInput: { action: 'create_environment_effect', name: 'EE_Rain' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_impact_effect`, action: 'create_impact_effect', family: F,
-        summary: 'Create an impact effect system asset (the engine OmnidirectionalBurst template by default), placed in the level only when location is given.', whenToUse: ['Hit FX needed.'], whenNotToUse: ['Use create_niagara_system.'],
-        inputProps: { name: P.name, path: P.path, systemPath: E.systemPath, templateEmitterPath: E.templateEmitterPath, location: P.location, save: SAVE }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: NIAGARA,
-        exampleInput: { action: 'create_impact_effect', name: 'IE_Bullet' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_niagara_ribbon`, action: 'create_niagara_ribbon', family: F,
-        summary: 'Create a Niagara ribbon effect: by default the engine LocationBasedRibbon template given its own SpawnRate of 60 a second, Ribbon Width Mode Direct Set and an infinite loop, so it trails whatever it is attached to, placed in the level only when location is given; tune SpawnRate.SpawnRate, InitializeParticle.Lifetime, Ribbon Width and Color with set_parameter_value.', whenToUse: ['Trail/ribbon FX needed.'], whenNotToUse: ['Use create_niagara_system.'],
-        inputProps: { name: P.name, path: P.path, systemPath: E.systemPath, templateEmitterPath: E.templateEmitterPath, location: P.location, save: SAVE }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: NIAGARA,
-        exampleInput: { action: 'create_niagara_ribbon', name: 'NR_Slash' } }),
-    buildRecord({ parentTool: T, id: `${T}.activate`, action: 'activate', family: F,
-        summary: 'Activate a placed Niagara component, in the level editor or a running game; reset restarts it from age 0.', whenToUse: ['Effect must turn on.'], whenNotToUse: ['Author the effect.'],
-        inputProps: { actorName: P.actorName, reset: E.reset }, required: ['actorName'],
-        effect: 'write', editorStates: ANY_EDITOR_STATE, behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'activate', actorName: 'FX_1', reset: false } }),
-    buildRecord({ parentTool: T, id: `${T}.activate_effect`, action: 'activate_effect', family: F,
-        summary: 'Activate a Niagara component by actor, or by the system asset it plays (on actorName, else anywhere in the world).', whenToUse: ['Asset-driven runtime FX.'], whenNotToUse: ['Use activate.'],
-        inputProps: { actorName: P.actorName, assetPath: { type: 'string', description: 'Niagara system asset the component plays; picks that component on actorName, or the first one in the world without actorName.' }, systemName: E.systemName, reset: E.reset }, required: [], requiredOneOf: ['actorName', 'assetPath', 'systemName'],
-        effect: 'write', editorStates: ANY_EDITOR_STATE, behavior: {}, latency: 'instant', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'activate_effect', systemName: 'FX_1' } }),
-    buildRecord({ parentTool: T, id: `${T}.deactivate`, action: 'deactivate', family: F,
-        summary: 'Deactivate a placed Niagara component, in the level editor or a running game.', whenToUse: ['Effect must turn off.'], whenNotToUse: ['Use activate.'],
-        inputProps: { actorName: P.actorName }, required: ['actorName'],
-        effect: 'write', editorStates: ANY_EDITOR_STATE, behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'deactivate', actorName: 'FX_1' } }),
-    buildRecord({ parentTool: T, id: `${T}.reset`, action: 'reset', family: F,
-        summary: 'Restart a placed Niagara component from age 0, in the level editor or a running game.', whenToUse: ['Effect must restart.'], whenNotToUse: ['Use deactivate.'],
-        inputProps: { actorName: P.actorName }, required: ['actorName'],
-        effect: 'write', editorStates: ANY_EDITOR_STATE, behavior: { safeToRetry: true }, latency: 'instant', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'reset', actorName: 'FX_1' } }),
-    buildRecord({ parentTool: T, id: `${T}.advance_simulation`, action: 'advance_simulation', family: F,
-        topics: ['preview effect', 'effect at an age', 'scrub particles', 'step niagara'],
-        summary: 'Advance a placed Niagara system by steps of deltaTime right away, in the level editor as in a running game, to look at it at a chosen age: spawn it with spawn_niagara, advance it, then capture it with control_editor screenshot from a camera location. The reply gives the age reached and whether the system has finished; NOT_ADVANCED means it did not move (finished, paused or not running).',
-        whenToUse: ['An effect must be judged at chosen ages (a splash 0.2 s and 0.6 s after it starts) without starting Play In Editor: advance with reset true to the first age, screenshot, advance again; the ages add up.'],
-        whenNotToUse: ['The effect should simply play in a running game (it runs by itself).'],
-        inputProps: { actorName: P.actorName, deltaTime: E.deltaTime, steps: E.steps, reset: bool('Restart the system from age 0 before stepping, so it ends at exactly steps x deltaTime seconds; also plays a finished system again. Without it the steps add to the age it has.') }, required: ['actorName'],
-        effect: 'write', editorStates: ['edit', 'pie', 'simulate'], latency: 'instant', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'advance_simulation', actorName: 'FX_Splash', reset: true, deltaTime: 0.02, steps: 10 } }),
-    buildRecord({ parentTool: T, id: `${T}.add_niagara_module`, action: 'add_niagara_module', family: F,
-        summary: 'Add a module to a Niagara emitter.', whenToUse: ['Emitter needs a module.'], whenNotToUse: ['Use connect_niagara_pins.'],
-        inputProps: { assetPath: P.assetPath, systemPath: E.systemPath, emitterName: E.emitterName, modulePath: E.modulePath, scriptType: E.scriptType, save: SAVE }, required: [], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        outputProps: { nodeId: E.nodeId }, outputRequired: [],
-        exampleInput: { action: 'add_niagara_module', assetPath: '/Game/NS_Fire', emitterName: 'Spark', modulePath: '/Niagara/Modules/Update/Color/ScaleColor.ScaleColor', scriptType: 'Update' }, exampleOutput: { success: true, message: 'Niagara module added', nodeId: 'A1B2C3' } }),
-    buildRecord({ parentTool: T, id: `${T}.connect_niagara_pins`, action: 'connect_niagara_pins', family: F,
-        summary: 'Connect two Niagara graph pins (fromNode, fromPin, toNode, toPin), or with autoConnect wire the first compatible free pins.', whenToUse: ['Modules must wire together.'], whenNotToUse: ['Use add_niagara_module.'],
-        inputProps: { assetPath: P.assetPath, systemPath: E.systemPath, emitterName: E.emitterName, scriptType: E.scriptType, fromNode: E.fromNode, fromPin: E.fromPin, toNode: E.toNode, toPin: E.toPin, autoConnect: E.autoConnect, save: SAVE }, required: [], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'connect_niagara_pins', assetPath: '/Game/NS_Fire', scriptType: 'Update', autoConnect: true } }),
-    buildRecord({ parentTool: T, id: `${T}.remove_niagara_node`, action: 'remove_niagara_node', family: F,
-        summary: 'Remove a Niagara graph node.', whenToUse: ['Node must be removed.'], whenNotToUse: ['Use connect_niagara_pins.'],
-        inputProps: { assetPath: P.assetPath, systemPath: E.systemPath, emitterName: E.emitterName, scriptType: E.scriptType, nodeId: E.nodeId, save: SAVE }, required: ['assetPath'],
-        effect: 'destructive', behavior: { safeToRetry: false }, latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'remove_niagara_node', assetPath: '/Game/NS_Fire', nodeId: 'A1B2C3' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_niagara_parameter`, action: 'set_niagara_parameter', family: F,
-        summary: 'Set a Niagara user parameter: on a spawned effect\'s component (actorName), or its default on the system asset (assetPath).', whenToUse: ['A parameter value must change.'], whenNotToUse: ['Use set_parameter_value.'],
-        inputProps: { actorName: P.actorName, systemPath: E.systemPath, assetPath: { type: 'string', description: 'Niagara system asset whose user parameter default to set, when no actorName is given; saved to disk.' },
-            parameterName: E.parameterName, parameterType: { type: 'string', description: 'Type for the actor form: Float, Vector, Color or Bool (default Float). The asset form uses the parameter\'s own type.' }, value: P.value },
-        required: ['parameterName'], requiredOneOf: ['actorName', 'assetPath', 'systemPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'set_niagara_parameter', actorName: 'FX_1', parameterName: 'SpawnRate', parameterType: 'Float', value: 1.25 } }),
-    buildRecord({ parentTool: T, id: `${T}.clear_debug_shapes`, action: 'clear_debug_shapes', family: F,
-        summary: 'Clear all editor debug shapes.', whenToUse: ['Debug shapes must be removed.'], whenNotToUse: ['Use debug_shape.'],
-        inputProps: {}, required: [], effect: 'write', editorStates: ['edit'], behavior: { safeToRetry: true }, latency: 'instant', resources: 'low',
-        exampleInput: { action: 'clear_debug_shapes' } }),
-    buildRecord({ parentTool: T, id: `${T}.cleanup`, action: 'cleanup', family: F,
-        summary: 'Clean up transient effect authoring state.', whenToUse: ['Reset authoring session.'], whenNotToUse: ['Persist work.'],
-        inputProps: { filter: E.filter }, required: [], effect: 'write', behavior: { safeToRetry: true }, latency: 'instant', resources: 'low',
-        exampleInput: { action: 'cleanup', filter: 'MCP_ManageEffectDefaultActor_' } }),
-    buildRecord({ parentTool: T, id: `${T}.list_debug_shapes`, action: 'list_debug_shapes', family: F,
-        topics: ['drawable types', 'lines drawn', 'draw count'],
-        summary: 'List the debug shape types that can be drawn (sphere, box, line, arrow, capsule and more) and count the debug lines, points and meshes currently drawn in the editor world.',
-        whenToUse: ['The drawable debug shape types, or how many debug primitives are on screen, must be read.'], whenNotToUse: ['Mutate shapes.'],
-        inputProps: {}, required: [], effect: 'read', editorStates: ['edit'], latency: 'instant', resources: 'low',
-        outputProps: { shapes: P.arrayOfStrings }, outputRequired: [],
-        exampleInput: { action: 'list_debug_shapes' }, exampleOutput: { success: true, message: 'Debug shapes listed', shapes: ['Sphere_0'] } }),
-    buildRecord({ parentTool: T, id: `${T}.add_emitter_to_system`, action: 'add_emitter_to_system', family: F,
-        summary: 'Add an emitter to a Niagara system.', whenToUse: ['System needs an emitter.'], whenNotToUse: ['Use create_niagara_emitter.'],
-        inputProps: { assetPath: P.assetPath, systemPath: E.systemPath, emitterPath: P.assetPath, emitterName: { type: 'string', description: 'Name for the new emitter handle (default the emitter asset name).' }, save: SAVE }, required: [], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        outputProps: { emitterName: E.emitterName }, outputRequired: [],
-        exampleInput: { action: 'add_emitter_to_system', systemPath: '/Game/NS_Fire', emitterPath: '/Game/NE_Spark', save: false }, exampleOutput: { success: true, message: 'Emitter added', emitterName: 'NE_Spark' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_emitter_properties`, action: 'set_emitter_properties', family: F,
-        summary: 'Enable or disable an emitter in a Niagara system (emitterProperties.enabled).', whenToUse: ['Emitter config must change.'], whenNotToUse: ['Use add_emitter_to_system.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, emitterProperties: E.emitterProperties, save: SAVE }, required: ['emitterName', 'emitterProperties'], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'set_emitter_properties', systemPath: '/Game/NS_Fire', emitterName: 'Spark', emitterProperties: { enabled: true } } }),
-    buildRecord({ parentTool: T, id: `${T}.add_spawn_rate_module`, action: 'add_spawn_rate_module', family: F,
-        summary: 'Insert the SpawnRate module with its default inputs; tune them with set_parameter_value (parameterName "<Module>.<Input>").', whenToUse: ['Emitter spawns over time.'], whenNotToUse: ['Use add_spawn_burst_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, emitter: E.emitter, save: SAVE }, required: [], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_spawn_rate_module', systemPath: '/Game/NS_Fire', emitterName: 'Spark' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_spawn_burst_module`, action: 'add_spawn_burst_module', family: F,
-        summary: 'Insert the SpawnBurst_Instantaneous module with its default inputs; tune them with set_parameter_value (parameterName "<Module>.<Input>").', whenToUse: ['Burst spawn needed.'], whenNotToUse: ['Use add_spawn_rate_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, save: SAVE }, required: ['emitterName'], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_spawn_burst_module', systemPath: '/Game/NS_Fire', emitterName: 'Spark' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_spawn_per_unit_module`, action: 'add_spawn_per_unit_module', family: F,
-        summary: 'Insert the SpawnPerUnit module with its default inputs; tune them with set_parameter_value (parameterName "<Module>.<Input>").', whenToUse: ['Spawn along a path/unit.'], whenNotToUse: ['Use add_spawn_rate_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, save: SAVE }, required: ['emitterName'], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_spawn_per_unit_module', systemPath: '/Game/NS_Fire', emitterName: 'Spark' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_initialize_particle_module`, action: 'add_initialize_particle_module', family: F,
-        summary: 'Insert the InitializeParticle module with its default inputs; tune them with set_parameter_value (parameterName "<Module>.<Input>").', whenToUse: ['Particle init needed.'], whenNotToUse: ['Use add_particle_state_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, save: SAVE }, required: ['emitterName'], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_initialize_particle_module', systemPath: '/Game/NS_Fire', emitterName: 'Spark' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_particle_state_module`, action: 'add_particle_state_module', family: F,
-        summary: 'Add a particle-state module.', whenToUse: ['Particle lifecycle state needed.'], whenNotToUse: ['Use add_initialize_particle_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, save: SAVE }, required: ['emitterName'], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_particle_state_module', systemPath: '/Game/NS_Fire', emitterName: 'Spark' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_force_module`, action: 'add_force_module', family: F,
-        summary: 'Insert the the chosen force module with its default inputs; tune them with set_parameter_value (parameterName "<Module>.<Input>").', whenToUse: ['Particles need force.'], whenNotToUse: ['Use add_velocity_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, forceType: E.forceType, save: SAVE }, required: ['emitterName', 'forceType'], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_force_module', systemPath: '/Game/NS_Fire', emitterName: 'Spark', forceType: 'Gravity' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_velocity_module`, action: 'add_velocity_module', family: F,
-        summary: 'Add a velocity module.', whenToUse: ['Particles need velocity.'], whenNotToUse: ['Use add_force_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, velocityMode: E.velocityMode, save: SAVE }, required: ['emitterName'], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_velocity_module', systemPath: '/Game/NS_Fire', emitterName: 'Spark', velocityMode: 'Linear' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_acceleration_module`, action: 'add_acceleration_module', family: F,
-        summary: 'Insert the AccelerationForce module with its default inputs; tune them with set_parameter_value (parameterName "<Module>.<Input>").', whenToUse: ['Particles need acceleration.'], whenNotToUse: ['Use add_velocity_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, save: SAVE }, required: ['emitterName'], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_acceleration_module', systemPath: '/Game/NS_Fire', emitterName: 'Spark' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_size_module`, action: 'add_size_module', family: F,
-        summary: 'Insert the ScaleSpriteSize module with its default inputs; tune them with set_parameter_value (parameterName "<Module>.<Input>").', whenToUse: ['Particle size must change.'], whenNotToUse: ['Use add_color_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, save: SAVE }, required: ['emitterName'], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_size_module', systemPath: '/Game/NS_Fire', emitterName: 'Spark' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_color_module`, action: 'add_color_module', family: F,
-        summary: 'Insert the Color module with its default inputs; tune them with set_parameter_value (parameterName "<Module>.<Input>").', whenToUse: ['Particle color must change.'], whenNotToUse: ['Use add_size_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, save: SAVE }, required: ['emitterName'], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_color_module', systemPath: '/Game/NS_Fire', emitterName: 'Spark' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_user_parameter`, action: 'add_user_parameter', family: F,
-        summary: 'Add a user parameter to a system.', whenToUse: ['Expose a user param.'], whenNotToUse: ['Use set_parameter_value.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, parameterName: E.parameterName, parameterType: E.parameterType, save: SAVE }, required: ['parameterName'], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_user_parameter', systemPath: '/Game/NS_Fire', parameterName: 'Intensity', parameterType: 'Float' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_parameter_value`, action: 'set_parameter_value', family: F,
-        summary: 'Set Niagara parameter values: a user parameter, a module input named as get_niagara_info lists it (InitializeParticle.Lifetime), or a module\'s static switch (InitializeParticle.Ribbon Width Mode, an enum by its display name such as Direct Set); one with parameterName and parameterValue, or several with parameters, written together and saved once.',
-        whenToUse: ['A user parameter or a module input value must change.', 'Several values of one system or emitter must change together (parameters): one call, one save.',
-            'A module input changes nothing because a static switch gates it (a Ribbon Width written while InitializeParticle.Ribbon Width Mode is Unset): set the switch; get_niagara_info lists every staticSwitches value.'],
-        whenNotToUse: ['The user parameter does not exist yet (use add_user_parameter).'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: { type: 'string', description: 'Limit a module-input or static-switch match to this emitter (user parameters are system-wide).' }, parameterName: E.parameterName, parameterValue: E.parameterValue, parameters: PARAMETER_LIST, save: SAVE }, required: [], requiredOneOf: ['parameterName', 'parameters'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        outputProps: {
-            parameterName: E.parameterName,
-            moduleInputCopiesWritten: { type: 'number', description: 'Module input: how many copies of it (one per script that runs the module) took the value; static switch: how many module nodes took it.' },
-            saved: bool('Whether the system was saved afterwards.'),
-            parameters: { type: 'array', items: { type: 'object', 'x-unreal-reflection-boundary': true }, description: 'A parameters call: each entry {parameterName, applied, error (when it did not apply), moduleInputCopiesWritten}.' },
-            applied: { type: 'number', description: 'A parameters call: how many entries were written.' },
-        }, outputRequired: [],
-        exampleInput: { action: 'set_parameter_value', systemPath: '/Game/NS_Fire', parameterName: 'Intensity', parameterValue: 2 } }),
-    buildRecord({ parentTool: T, id: `${T}.bind_parameter_to_source`, action: 'bind_parameter_to_source', family: F,
-        summary: 'Drive a Niagara value from a parameter: a module input named as get_niagara_info lists it (InitializeParticle.Color) is linked to sourceBinding, as the stack\'s Link Inputs menu does; any other parameterName gets a Set Variables module in particle update that writes it from sourceBinding every frame.',
-        whenToUse: ['A Blueprint sets a value at run time (Set Niagara Variable on a user parameter): parameterName is the module input as get_niagara_info lists it (InitializeParticle.Color), sourceBinding the user parameter (User.Tint).', 'A value must follow an engine, system or emitter parameter (sourceBinding Emitter.Age).'],
-        whenNotToUse: ['A fixed value is enough (use set_parameter_value).', 'The user parameter does not exist yet (use add_user_parameter first).'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName,
-            parameterName: { type: 'string', description: 'The module input to link (InitializeParticle.Color, as get_niagara_info lists moduleInputs), or a variable for a Set Variables module to write (Particles.Glow).' },
-            parameterType: { type: 'string', description: 'Set Variables only: the type of the variable it writes (Float, Vector, LinearColor ...); a module input keeps its own type.' },
-            sourceBinding: { type: 'string', description: 'The parameter to read: a user parameter of the same type (User.Tint) or an engine, system or emitter one (Emitter.Age).' },
-            save: SAVE }, required: ['parameterName', 'sourceBinding'], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'bind_parameter_to_source', systemPath: '/Game/NS_Fire', parameterName: 'InitializeParticle.Color', sourceBinding: 'User.Tint' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_niagara_dynamic_input`, action: 'set_niagara_dynamic_input', family: F,
-        summary: 'Configure a Niagara dynamic input expression.', whenToUse: ['Expression-driven value needed.'], whenNotToUse: ['Use set_parameter_value.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, targetNodeId: E.targetNodeId, moduleName: { type: 'string', description: 'Module (function call) name that owns inputName; alternative to targetNodeId.' }, inputName: E.inputName, dynamicInputScriptPath: E.dynamicInputScriptPath, replaceExisting: E.replaceExisting, save: SAVE }, required: ['inputName'], requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'set_niagara_dynamic_input', systemPath: '/Game/NS_Fire', inputName: 'EmitterState.ScaleSpawnCountCurve', dynamicInputScriptPath: '/Niagara/DynamicInputs/Add/Add_Float.Add_Float' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_sprite_renderer_module`, action: 'add_sprite_renderer_module', family: F,
-        summary: 'Add a sprite renderer module.', whenToUse: ['Sprite rendering needed.'], whenNotToUse: ['Use add_mesh_renderer_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, materialPath: E.materialPath, save: SAVE }, required: EMITTER_ONLY, requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_sprite_renderer_module', systemPath: '/Game/NS_Fire', emitterName: 'Spark', materialPath: '/Engine/BasicShapes/BasicShapeMaterial.BasicShapeMaterial' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_mesh_renderer_module`, action: 'add_mesh_renderer_module', family: F,
-        summary: 'Add a mesh renderer module.', whenToUse: ['Mesh rendering needed.'], whenNotToUse: ['Use add_sprite_renderer_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, meshPath: E.meshPath, save: SAVE }, required: EMITTER_ONLY, requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_mesh_renderer_module', systemPath: '/Game/NS_Debris', emitterName: 'Chunks', meshPath: '/Engine/BasicShapes/Cube.Cube' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_ribbon_renderer_module`, action: 'add_ribbon_renderer_module', family: F,
-        summary: 'Add a ribbon renderer module.', whenToUse: ['Ribbon/trail rendering.'], whenNotToUse: ['Use add_mesh_renderer_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, materialPath: E.materialPath, save: SAVE }, required: EMITTER_ONLY, requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_ribbon_renderer_module', systemPath: '/Game/NS_Trail', emitterName: 'Trail' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_light_renderer_module`, action: 'add_light_renderer_module', family: F,
-        summary: 'Add a light renderer module.', whenToUse: ['Per-particle light needed.'], whenNotToUse: ['Use add_sprite_renderer_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, lightRadius: E.lightRadius, save: SAVE }, required: EMITTER_ONLY, requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_light_renderer_module', systemPath: '/Game/NS_Fire', emitterName: 'Spark', lightRadius: 200 } }),
-    buildRecord({ parentTool: T, id: `${T}.add_collision_module`, action: 'add_collision_module', family: F,
-        summary: 'Insert the Collision module with its default inputs; tune them with set_parameter_value (parameterName "<Module>.<Input>").', whenToUse: ['Particles must collide.'], whenNotToUse: ['Use add_kill_particles_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, save: SAVE }, required: EMITTER_ONLY, requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_collision_module', systemPath: '/Game/NS_Debris', emitterName: 'Chunks' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_kill_particles_module`, action: 'add_kill_particles_module', family: F,
-        summary: 'Insert the KillParticles module with its default inputs; tune them with set_parameter_value (parameterName "<Module>.<Input>").', whenToUse: ['Particles must die on condition.'], whenNotToUse: ['Use add_collision_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, save: SAVE }, required: EMITTER_ONLY, requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_kill_particles_module', systemPath: '/Game/NS_Fire', emitterName: 'Spark' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_camera_offset_module`, action: 'add_camera_offset_module', family: F,
-        summary: 'Insert the CameraOffset module with its default inputs; tune them with set_parameter_value (parameterName "<Module>.<Input>").', whenToUse: ['Camera-relative particles.'], whenNotToUse: ['Use add_velocity_module.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, save: SAVE }, required: EMITTER_ONLY, requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_camera_offset_module', systemPath: '/Game/NS_Fire', emitterName: 'Spark' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_skeletal_mesh_data_interface`, action: 'add_skeletal_mesh_data_interface', family: F,
-        summary: 'Add a skeletal-mesh data interface.', whenToUse: ['Read skeletal mesh data.'], whenNotToUse: ['Use add_static_mesh_data_interface.'],
-        inputProps: { systemPath: E.systemPath, emitterName: E.emitterName, parameterName: E.parameterName, save: SAVE }, required: EMITTER_REQUIRED,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_skeletal_mesh_data_interface', systemPath: '/Game/NS_Fire', emitterName: 'Spark', parameterName: 'SkelDI' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_static_mesh_data_interface`, action: 'add_static_mesh_data_interface', family: F,
-        summary: 'Add a static-mesh data interface.', whenToUse: ['Read static mesh data.'], whenNotToUse: ['Use add_skeletal_mesh_data_interface.'],
-        inputProps: { systemPath: E.systemPath, emitterName: E.emitterName, parameterName: E.parameterName, save: SAVE }, required: EMITTER_REQUIRED,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_static_mesh_data_interface', systemPath: '/Game/NS_Fire', emitterName: 'Spark', parameterName: 'StaticDI' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_spline_data_interface`, action: 'add_spline_data_interface', family: F,
-        summary: 'Add a spline data interface.', whenToUse: ['Sample spline data.'], whenNotToUse: ['Use add_static_mesh_data_interface.'],
-        inputProps: { systemPath: E.systemPath, emitterName: E.emitterName, parameterName: E.parameterName, save: SAVE }, required: EMITTER_REQUIRED,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_spline_data_interface', systemPath: '/Game/NS_Fire', emitterName: 'Spark', parameterName: 'SplineDI' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_audio_spectrum_data_interface`, action: 'add_audio_spectrum_data_interface', family: F,
-        summary: 'Add an audio-spectrum data interface.', whenToUse: ['Audio-reactive particles.'], whenNotToUse: ['Use add_spline_data_interface.'],
-        inputProps: { systemPath: E.systemPath, emitterName: E.emitterName, parameterName: E.parameterName, save: SAVE }, required: EMITTER_REQUIRED,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_audio_spectrum_data_interface', systemPath: '/Game/NS_Fire', emitterName: 'Spark', parameterName: 'AudioDI' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_collision_query_data_interface`, action: 'add_collision_query_data_interface', family: F,
-        summary: 'Add a collision-query data interface.', whenToUse: ['Query collisions in graph.'], whenNotToUse: ['Use add_collision_module.'],
-        inputProps: { systemPath: E.systemPath, emitterName: E.emitterName, parameterName: E.parameterName, save: SAVE }, required: EMITTER_REQUIRED,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_collision_query_data_interface', systemPath: '/Game/NS_Fire', emitterName: 'Spark', parameterName: 'CollisionDI' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_event_generator`, action: 'add_event_generator', family: F,
-        summary: 'Add a Niagara event generator.', whenToUse: ['Emitter emits events.'], whenNotToUse: ['Use add_event_receiver.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, eventName: E.eventName, eventType: E.eventType, save: SAVE }, required: EMITTER_ONLY, requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_event_generator', systemPath: '/Game/NS_Fire', emitterName: 'Spark', eventName: 'Burst', eventType: 'Location' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_event_receiver`, action: 'add_event_receiver', family: F,
-        summary: 'Add a Niagara event receiver.', whenToUse: ['Emitter consumes events.'], whenNotToUse: ['Use add_event_generator.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, eventName: E.eventName, spawnOnEvent: E.spawnOnEvent, eventSpawnCount: E.eventSpawnCount, save: SAVE }, required: EMITTER_ONLY, requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_event_receiver', systemPath: '/Game/NS_Fire', emitterName: 'Spark', eventName: 'Burst', spawnOnEvent: true, eventSpawnCount: 2 } }),
-    buildRecord({ parentTool: T, id: `${T}.enable_gpu_simulation`, action: 'enable_gpu_simulation', family: F,
-        summary: 'Enable GPU simulation on a system.', whenToUse: ['GPU particles needed.'], whenNotToUse: ['Use add_simulation_stage.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, fixedBoundsEnabled: E.fixedBoundsEnabled, deterministicEnabled: E.deterministicEnabled, save: SAVE }, required: EMITTER_ONLY, requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'medium', plugins: NIAGARA,
-        exampleInput: { action: 'enable_gpu_simulation', systemPath: '/Game/NS_Fire', emitterName: 'Spark', fixedBoundsEnabled: true } }),
-    buildRecord({ parentTool: T, id: `${T}.add_simulation_stage`, action: 'add_simulation_stage', family: F,
-        summary: 'Add a simulation stage.', whenToUse: ['Custom sim stage needed.'], whenNotToUse: ['Use enable_gpu_simulation.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, stageName: E.stageName, stageIterationSource: E.stageIterationSource, save: SAVE }, required: EMITTER_ONLY, requiredOneOf: SYSTEM_ONE_OF,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: NIAGARA,
-        exampleInput: { action: 'add_simulation_stage', systemPath: '/Game/NS_Fire', emitterName: 'Spark', stageName: 'Stage_0', stageIterationSource: 'Particles' } }),
-    buildRecord({ parentTool: T, id: `${T}.get_niagara_info`, action: 'get_niagara_info', family: F,
-        summary: 'Read Niagara system metadata.', whenToUse: ['Inspect a Niagara system.'], whenNotToUse: ['Mutate the system.'],
-        inputProps: { assetPath: P.assetPath, systemPath: E.systemPath, system: E.system }, required: [], requiredOneOf: ['assetPath', 'systemPath', 'system'],
-        effect: 'read', latency: 'instant', resources: 'low', plugins: NIAGARA,
-        outputProps: { emitterCount: P.num_ }, outputRequired: [],
-        exampleInput: { action: 'get_niagara_info', assetPath: '/Game/NS_Fire' }, exampleOutput: { success: true, message: 'Niagara info', emitterCount: 2 } }),
-    buildRecord({ parentTool: T, id: `${T}.validate_niagara_system`, action: 'validate_niagara_system', family: F,
-        summary: 'Validate a Niagara system for errors.', whenToUse: ['Catch authoring errors.'], whenNotToUse: ['Use get_niagara_info.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, system: E.system }, required: [], requiredOneOf: ['systemPath', 'assetPath', 'system'],
-        effect: 'read', latency: 'instant', resources: 'low', plugins: NIAGARA,
-        outputProps: { valid: P.bool_, errors: P.arrayOfStrings, warnings: P.arrayOfStrings }, outputRequired: ['valid'],
-        exampleInput: { action: 'validate_niagara_system', systemPath: '/Game/NS_Fire' }, exampleOutput: { success: true, message: 'Niagara validated', valid: true, errors: [] } }),
-];
-//# sourceMappingURL=effect.data.js.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-effect/index.d.ts

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

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

@@ -1,8 +0,0 @@
-import { EFFECT_RECORDS } from './effect.data.js';
-import { applyFolds } from '../../shared/fold.js';
-import { MANAGE_EFFECT_FOLDS } from '../../folds/manage-effect.folds.js';
-export const MANAGE_EFFECT_UNFOLDED_SOURCES = [
-    ...EFFECT_RECORDS,
-];
-export const MANAGE_EFFECT_SOURCES = applyFolds(MANAGE_EFFECT_UNFOLDED_SOURCES, MANAGE_EFFECT_FOLDS, 'manage_effect');
-//# sourceMappingURL=index.js.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-gas/gas.data.d.ts

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

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

@@ -1,146 +0,0 @@
-import { buildRecord } from '../helpers.js';
-import { P } from '../properties.js';
-import { GAS_P as G } from './gas.props.js';
-const T = 'manage_gas';
-const F = 'gas';
-const W = ['A Gameplay Ability System asset must be authored.'];
-const GAS_PLUGIN = ['GameplayAbilities'];
-export const GAS_RECORDS = [
-    buildRecord({ parentTool: T, id: `${T}.add_ability_system_component`, action: 'add_ability_system_component', family: F,
-        summary: 'Add an AbilitySystemComponent to a Blueprint.', whenToUse: W, whenNotToUse: ['Component exists.'],
-        inputProps: { blueprintPath: P.blueprintPath, componentName: G.componentName }, required: ['blueprintPath'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'add_ability_system_component', blueprintPath: '/Game/BP_Char', componentName: 'AbilitySystemComponent' } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_asc`, action: 'configure_asc', family: F,
-        summary: 'Configure an AbilitySystemComponent.', whenToUse: ['ASC defaults must change.'], whenNotToUse: ['Use add_ability_system_component.'],
-        inputProps: { blueprintPath: P.blueprintPath, componentName: G.componentName, replicationMode: G.replicationMode }, required: ['blueprintPath', 'replicationMode'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'configure_asc', blueprintPath: '/Game/BP_Char', replicationMode: 'Mixed' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_attribute_set`, action: 'create_attribute_set', family: F,
-        summary: 'Create an AttributeSet class/asset.', whenToUse: W, whenNotToUse: ['Use add_attribute.'],
-        inputProps: { name: P.name, path: P.path }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'create_attribute_set', name: 'AS_Char' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_attribute`, action: 'add_attribute', family: F,
-        summary: 'Add an attribute to an AttributeSet.', whenToUse: ['An attribute is needed.'], whenNotToUse: ['Use create_attribute_set.'],
-        inputProps: { attributeSetPath: P.attributeSetPath, attributeName: P.attributeName, defaultValue: G.defaultValue }, required: ['attributeSetPath', 'attributeName'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'add_attribute', attributeSetPath: '/Game/AS_Char', attributeName: 'Health', defaultValue: 100 } }),
-    buildRecord({ parentTool: T, id: `${T}.set_attribute_base_value`, action: 'set_attribute_base_value', family: F,
-        summary: 'Set an attribute base value.', whenToUse: ['Default value must change.'], whenNotToUse: ['Use add_attribute.'],
-        inputProps: { attributeSetPath: P.attributeSetPath, attributeName: P.attributeName, baseValue: G.baseValue }, required: ['attributeSetPath', 'attributeName'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'set_attribute_base_value', attributeSetPath: '/Game/AS_Char', attributeName: 'Health', baseValue: 100 } }),
-    buildRecord({ parentTool: T, id: `${T}.create_gameplay_ability`, action: 'create_gameplay_ability', family: F,
-        topics: ['gameplay ability', 'ability', 'gas ability', 'new ability', 'skill'],
-        summary: 'Create a Gameplay Ability asset.', whenToUse: W, whenNotToUse: ['Use add_ability_task.'],
-        inputProps: { name: P.name, path: P.path }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: GAS_PLUGIN,
-        outputProps: { assetPath: P.assetPath }, outputRequired: ['assetPath'],
-        exampleInput: { action: 'create_gameplay_ability', name: 'GA_Fire' }, exampleOutput: { success: true, message: 'Ability created', assetPath: '/Game/GA_Fire' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_ability_tags`, action: 'set_ability_tags', family: F,
-        summary: 'Configure ability tag requirements/granted.', whenToUse: ['Ability tags must change.'], whenNotToUse: ['Use create_gameplay_ability.'],
-        inputProps: { abilityPath: P.abilityPath, abilityTags: G.abilityTags, cancelAbilitiesWithTag: G.cancelAbilitiesWithTag, blockAbilitiesWithTag: G.blockAbilitiesWithTag, activationRequiredTags: G.activationRequiredTags, activationBlockedTags: G.activationBlockedTags }, required: ['abilityPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'set_ability_tags', abilityPath: '/Game/GA_Fire', abilityTags: ['Ability.Fire'] } }),
-    buildRecord({ parentTool: T, id: `${T}.set_ability_costs`, action: 'set_ability_costs', family: F,
-        summary: 'Configure ability cost (attribute spend).', whenToUse: ['Ability has a cost.'], whenNotToUse: ['Use set_ability_cooldown.'],
-        inputProps: { abilityPath: P.abilityPath, costEffectPath: G.costEffectPath }, required: ['abilityPath', 'costEffectPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'set_ability_costs', abilityPath: '/Game/GA_Fire', costEffectPath: '/Game/GE_ManaCost' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_ability_cooldown`, action: 'set_ability_cooldown', family: F,
-        summary: 'Configure ability cooldown.', whenToUse: ['Ability needs cooldown.'], whenNotToUse: ['Use set_ability_costs.'],
-        inputProps: { abilityPath: P.abilityPath, cooldownEffectPath: G.cooldownEffectPath }, required: ['abilityPath', 'cooldownEffectPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'set_ability_cooldown', abilityPath: '/Game/GA_Fire', cooldownEffectPath: '/Game/GE_Cooldown' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_activation_policy`, action: 'set_activation_policy', family: F,
-        summary: 'Set where an ability activates: its net execution policy (local only, locally predicted, server only, or server initiated).', whenToUse: ['An ability must run on the server or be predicted by the client.'], whenNotToUse: ['The default LocalPredicted policy is wanted.'],
-        inputProps: { abilityPath: P.abilityPath, activationPolicy: G.activationPolicy }, required: ['abilityPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'set_activation_policy', abilityPath: '/Game/GA_Fire', activationPolicy: 'ServerOnly' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_instancing_policy`, action: 'set_instancing_policy', family: F,
-        summary: 'Configure ability instancing policy.', whenToUse: ['Instancing must change.'], whenNotToUse: ['Use set_activation_policy.'],
-        inputProps: { abilityPath: P.abilityPath, instancingPolicy: G.instancingPolicy }, required: ['abilityPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'set_instancing_policy', abilityPath: '/Game/GA_Fire', instancingPolicy: 'InstancedPerActor' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_gameplay_effect`, action: 'create_gameplay_effect', family: F,
-        summary: 'Create a Gameplay Effect asset.', whenToUse: W, whenNotToUse: ['Use add_effect_modifier.'],
-        inputProps: { name: P.name, path: P.path, durationType: G.durationType, duration: { type: 'number', description: 'Duration in seconds for a HasDuration effect (ignored for Instant).' }, period: { type: 'number', description: 'Period in seconds for a periodic non-Instant effect.' } }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'create_gameplay_effect', name: 'GE_Damage', durationType: 'Instant' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_effect_duration`, action: 'set_effect_duration', family: F,
-        summary: 'Set a Gameplay Effect duration.', whenToUse: ['Effect has a duration.'], whenNotToUse: ['Use create_gameplay_effect.'],
-        inputProps: { effectPath: P.effectPath, durationType: G.durationType, duration: P.duration, period: G.period }, required: ['effectPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'set_effect_duration', effectPath: '/Game/GE_Damage', durationType: 'HasDuration', duration: 5, period: 1 } }),
-    buildRecord({ parentTool: T, id: `${T}.add_effect_modifier`, action: 'add_effect_modifier', family: F,
-        summary: 'Add a modifier to a Gameplay Effect.', whenToUse: ['Effect modifies an attribute.'], whenNotToUse: ['Use set_effect_duration.'],
-        inputProps: { effectPath: P.effectPath, attributeName: P.attributeName, modifierOperation: G.modifierOperation, modifierMagnitude: G.modifierMagnitude, targetAttribute: G.targetAttribute }, required: ['effectPath', 'attributeName'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'add_effect_modifier', effectPath: '/Game/GE_Damage', attributeName: 'Health', modifierOperation: 'Add', modifierMagnitude: -10 } }),
-    buildRecord({ parentTool: T, id: `${T}.set_modifier_magnitude`, action: 'set_modifier_magnitude', family: F,
-        summary: 'Set a modifier magnitude.', whenToUse: ['Modifier amount must change.'], whenNotToUse: ['Use add_effect_modifier.'],
-        inputProps: { effectPath: P.effectPath, modifierIndex: G.modifierIndex, modifierMagnitude: G.modifierMagnitude, magnitudeCalculationType: G.magnitudeCalculationType, setByCallerTag: G.setByCallerTag }, required: ['effectPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'set_modifier_magnitude', effectPath: '/Game/GE_Damage', modifierIndex: 0, modifierMagnitude: -15 } }),
-    buildRecord({ parentTool: T, id: `${T}.add_effect_execution_calculation`, action: 'add_effect_execution_calculation', family: F,
-        summary: 'Add an execution calculation to an effect.', whenToUse: ['Complex magnitude calc needed.'], whenNotToUse: ['Simple modifier suffices.'],
-        inputProps: { effectPath: P.effectPath, calculationClass: P.string_ }, required: ['effectPath', 'calculationClass'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'add_effect_execution_calculation', effectPath: '/Game/GE_Damage', calculationClass: '/Script/Game.DamageExecCalc' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_effect_cue`, action: 'add_effect_cue', family: F,
-        summary: 'Add a gameplay cue to an effect.', whenToUse: ['Effect needs a cue.'], whenNotToUse: ['Use create_gameplay_cue_notify.'],
-        inputProps: { effectPath: P.effectPath, cueTag: P.tag }, required: ['effectPath', 'cueTag'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'add_effect_cue', effectPath: '/Game/GE_Damage', cueTag: 'GameplayCue.Damage' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_effect_stacking`, action: 'set_effect_stacking', family: F,
-        summary: 'Configure effect stacking rules.', whenToUse: ['Effects must stack.'], whenNotToUse: ['Use set_effect_duration.'],
-        inputProps: { effectPath: P.effectPath, stackingType: G.stackingType, stackLimitCount: G.stackLimitCount, stackDurationRefreshPolicy: G.stackDurationRefreshPolicy, stackPeriodResetPolicy: G.stackPeriodResetPolicy, stackExpirationPolicy: G.stackExpirationPolicy }, required: ['effectPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'set_effect_stacking', effectPath: '/Game/GE_Damage', stackingType: 'AggregateByTarget', stackLimitCount: 3 } }),
-    buildRecord({ parentTool: T, id: `${T}.set_effect_tags`, action: 'set_effect_tags', family: F,
-        summary: 'Configure effect granted, required, removal and immunity tags.', whenToUse: ['Effect tags must change.'], whenNotToUse: ['Use add_effect_cue.'],
-        inputProps: { effectPath: P.effectPath, grantedTags: G.grantedTags, applicationRequiredTags: G.applicationRequiredTags, removalTags: G.removalTags, immunityTags: G.immunityTags }, required: ['effectPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'set_effect_tags', effectPath: '/Game/GE_Damage', grantedTags: ['State.Burning'] } }),
-    buildRecord({ parentTool: T, id: `${T}.create_gameplay_cue_notify`, action: 'create_gameplay_cue_notify', family: F,
-        summary: 'Create a Gameplay Cue Notify asset.', whenToUse: W, whenNotToUse: ['Use add_effect_cue.'],
-        inputProps: { name: P.name, path: P.path, cueType: P.string_, cueTag: P.tag }, required: ['name', 'cueType'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'create_gameplay_cue_notify', name: 'GC_Damage', cueType: 'Static', cueTag: 'GameplayCue.Damage' } }),
-    buildRecord({ parentTool: T, id: `${T}.get_gas_info`, action: 'get_gas_info', family: F,
-        topics: ['gameplay ability', 'gameplay effect', 'instancing policy', 'duration policy'],
-        summary: 'Read a Gameplay Ability System Blueprint: its kind (ability, effect, attribute set, cue notify), parent class, and an ability\'s instancing and net execution policy or an effect\'s duration policy, stacking type, modifier and cue counts.',
-        whenToUse: ['A GAS Blueprint\'s kind, ability policies or effect duration, stacking and modifier counts must be read.'], whenNotToUse: ['Mutate assets.'],
-        inputProps: { assetPath: P.assetPath }, required: ['assetPath'],
-        effect: 'read', latency: 'instant', resources: 'low', plugins: GAS_PLUGIN,
-        outputProps: {
-            gasType: P.string_, assetName: P.string_, assetPath: P.assetPath,
-            class: P.string_, parentClass: P.string_, generatedClass: P.string_,
-            durationPolicy: P.string_, instancingPolicy: P.string_,
-            netExecutionPolicy: P.string_, stackingType: P.string_,
-            modifierCount: P.num_, cueCount: P.num_,
-        }, outputRequired: [],
-        exampleInput: { action: 'get_gas_info', assetPath: '/Game/BP_Char' }, exampleOutput: { success: true, message: 'GAS info', gasType: 'GameplayAbility', assetName: 'GA_Dash', instancingPolicy: 'InstancedPerActor' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_ability`, action: 'add_ability', family: F,
-        summary: 'Add an ability to an existing Gameplay Ability Set.',
-        whenToUse: ['An ability must join a set that already exists.'],
-        whenNotToUse: ['The ability is granted directly to an actor; use grant_ability.'],
-        inputProps: { setPath: G.setPath, abilityPath: P.abilityPath, abilityClass: G.abilityClass },
-        required: ['setPath'], requiredOneOf: ['abilityPath', 'abilityClass'],
-        outputProps: { setPath: G.setPath, abilityPath: P.abilityPath, abilityClass: G.abilityClass, note: P.string_ }, outputRequired: [],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'add_ability', setPath: '/Game/GAS/AS_Hero', abilityPath: '/Game/GAS/GA_Dash' },
-        exampleOutput: { success: true, message: 'Ability added', setPath: '/Game/GAS/AS_Hero', abilityPath: '/Game/GAS/GA_Dash' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_execution_calculation`, action: 'create_execution_calculation', family: F,
-        summary: 'Create a GameplayEffectExecutionCalculation blueprint for custom effect math.',
-        whenToUse: ['Effect magnitude needs code the modifier curve cannot express.'],
-        whenNotToUse: ['A scalable float or attribute-based modifier is enough.'],
-        inputProps: { name: P.name, path: P.path },
-        required: ['name'],
-        outputProps: { assetPath: P.assetPath, name: P.name, parentClass: P.string_, reusedExisting: P.bool_, note: P.string_ }, outputRequired: [],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: GAS_PLUGIN,
-        exampleInput: { action: 'create_execution_calculation', name: 'GEEC_Damage', path: '/Game/GAS' },
-        exampleOutput: { success: true, message: 'Execution calculation created', assetPath: '/Game/GAS/GEEC_Damage', name: 'GEEC_Damage', reusedExisting: false } }),
-];
-//# sourceMappingURL=gas.data.js.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-gas/gas.props.d.ts

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