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

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

@@ -1,4 +1,5 @@
 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';
@@ -14,7 +15,7 @@ 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 or a module input as get_niagara_info lists it (InitializeParticle.Lifetime), 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.',
+    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,
@@ -23,10 +24,10 @@ export const EFFECT_RECORDS = [
         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: 'Author a Niagara system.', 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 }, required: ['systemPath'],
+        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, actorGuid: P.string_, existsAfter: P.bool_, actorClass: P.string_ }, outputRequired: [],
+        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.'],
@@ -66,56 +67,59 @@ export const EFFECT_RECORDS = [
         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.', whenToUse: ['A trailing effect is needed.'], whenNotToUse: ['Use create_niagara_ribbon for a ribbon-based trail.'],
+        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).', whenToUse: ['Ambient FX needed.'], whenNotToUse: ['Use build_environment weather.'],
+        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.', whenToUse: ['Hit FX needed.'], whenNotToUse: ['Use create_niagara_system.'],
+        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.', whenToUse: ['Trail/ribbon FX needed.'], whenNotToUse: ['Use create_niagara_system.'],
+        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 spawned effect component (PIE).', whenToUse: ['Effect must turn on at runtime.'], whenNotToUse: ['Author the effect.'],
+        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: ['pie', 'simulate'], behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: NIAGARA,
+        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: ['pie', 'simulate'], behavior: {}, latency: 'instant', resources: 'low', plugins: NIAGARA,
+        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 runtime effect component.', whenToUse: ['Effect must turn off.'], whenNotToUse: ['Use activate.'],
+        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: ['pie', 'simulate'], behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: NIAGARA,
+        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: 'Reset a runtime effect to initial state.', whenToUse: ['Effect must restart.'], whenNotToUse: ['Use deactivate.'],
+        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: ['pie', 'simulate'], behavior: { safeToRetry: true }, latency: 'instant', resources: 'low', plugins: NIAGARA,
+        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,
-        summary: 'Advance a Niagara simulation by time (PIE/editor).', whenToUse: ['Step the sim manually.'], whenNotToUse: ['Let it run.'],
-        inputProps: { actorName: P.actorName, deltaTime: E.deltaTime, steps: E.steps }, required: [],
+        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', deltaTime: 0.016, steps: 2 } }),
+        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/Emitter/EmitterState.EmitterState', scriptType: 'Update' }, exampleOutput: { success: true, message: 'Niagara module added', nodeId: 'A1B2C3' } }),
+        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,
@@ -215,24 +219,31 @@ export const EFFECT_RECORDS = [
         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, or a module input named as get_niagara_info lists it (InitializeParticle.Lifetime); 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.'],
+        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 match to this emitter (user parameters are system-wide).' }, parameterName: E.parameterName, parameterValue: E.parameterValue, parameters: PARAMETER_LIST, save: SAVE }, required: [], requiredOneOf: ['parameterName', 'parameters'],
+        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.' },
+            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: 'Bind a parameter to a data source.', whenToUse: ['Param driven externally.'], whenNotToUse: ['Use set_parameter_value.'],
-        inputProps: { systemPath: E.systemPath, assetPath: P.assetPath, emitterName: E.emitterName, parameterName: E.parameterName, parameterType: E.parameterType, sourceBinding: E.sourceBinding, save: SAVE }, required: ['parameterName'], requiredOneOf: SYSTEM_ONE_OF,
+        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: 'Intensity', sourceBinding: 'Emitter.Age' } }),
+        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,
@@ -245,7 +256,7 @@ export const EFFECT_RECORDS = [
         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: P.meshPath, save: SAVE }, required: EMITTER_ONLY, requiredOneOf: SYSTEM_ONE_OF,
+        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,

package/dist/tools/catalog/capabilities/records/inspect/component-actor.data.js

@@ -33,7 +33,7 @@ export const COMPONENT_ACTOR_RECORDS = [
         effect: 'read',
         exampleInput: { action: 'get_component_property', actorName: 'PlayerStart_1', componentName: 'Billboard', propertyName: 'Sprite' },
         exampleOutput: { success: true, message: 'Component property read', value: null },
-        outputProps: { value: P.value },
+        outputProps: { value: P.valueRead },
     }),
     buildCoreRecord({
         parentTool: 'inspect', action: 'set_component_property', dispatchAction: 'control_actor', domain: D, family: 'components',

package/dist/tools/catalog/capabilities/records/inspect/object-property.data.js

@@ -1,4 +1,4 @@
-import { buildCoreRecord } from '../core/builder.js';
+import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
 import { P } from './properties.js';
 const D = 'inspect';
 const INSPECT_OBJECT_OUTPUT = {
@@ -132,6 +132,171 @@ export const OBJECT_PROPERTY_RECORDS = [
             },
         },
     }),
+    buildCoreRecord({
+        parentTool: 'inspect', action: 'check_mesh', dispatchAction: 'check_mesh', domain: D, family: 'object',
+        editorStates: ANY_EDITOR_STATE,
+        summary: 'Check whether a static mesh\'s geometry is sound, from its source triangles: closed (watertight) or open with how many holes, edges shared by three or more faces, faces turned inside out, faces with no area, seams where faces do not share their corners, and how many separate parts it is made of, with its size, surface area and (when closed) volume.',
+        topics: ['check mesh', 'mesh holes', 'mesh has holes', 'watertight', 'non manifold edges', 'flipped normals', 'inside out faces', 'mesh parts', 'broken mesh', 'mesh volume'],
+        whenToUse: ['An imported, downloaded or generated mesh must be proven sound before it is placed, merged, used for collision or booleans, or shipped.', 'A mesh shows see-through gaps, black or inside-out faces, or splits into loose pieces.'],
+        whenNotToUse: ['Only the mesh\'s size, pivot, slots or triangle counts per material are needed (use inspect_object objectKind mesh).', 'The mesh must be cut into one asset per part (use manage_geometry split_mesh).'],
+        inputProps: {
+            meshPath: { type: 'string', description: 'Static mesh asset path, e.g. /Game/Meshes/SM_Rock. Its source triangles (LOD 0 as imported or built) are checked, so a Nanite mesh answers at full detail. A placed actor\'s mesh is named by get_components.' },
+        },
+        required: ['meshPath'],
+        effect: 'read',
+        costLatency: 'interactive',
+        exampleInput: { action: 'check_mesh', meshPath: '/Engine/BasicShapes/Cube' },
+        exampleOutput: {
+            success: true, message: 'Cube: 48 triangles in 1 part(s), closed.', meshPath: '/Engine/BasicShapes/Cube.Cube',
+            triangles: 48, vertices: 26, size: [100, 100, 100], surfaceArea: 60000, closed: true, volume: 1000000,
+            openEdges: 0, holes: 0, seamEdges: 0, nonManifoldEdges: 0, flippedEdges: 0, degenerateTriangles: 0, parts: 1,
+            largestParts: [{ triangles: 48, size: [100, 100, 100], center: [0, 0, 0] }],
+        },
+        outputProps: {
+            meshPath: { type: 'string', description: 'The mesh checked.' },
+            triangles: { type: 'number', description: 'Source triangles (LOD 0).' },
+            vertices: { type: 'number', description: 'Distinct corner positions (to 0.01 cm): corners at one place count once, whether or not the source shares the vertex.' },
+            size: { type: 'array', items: { type: 'number' }, description: 'Extent [x, y, z] in cm, in the mesh\'s own space.' },
+            surfaceArea: { type: 'number', description: 'Total face area in cm².' },
+            closed: { type: 'boolean', description: 'True when every edge joins exactly two faces (seams count as joined): the surface is watertight (a solid, not a sheet or a shell with gaps).' },
+            volume: { type: 'number', description: 'With closed: the volume it encloses, in cm³.' },
+            openEdges: { type: 'number', description: 'Edges with a face on one side only and none on the other at that place: the outlines of holes and open rims.' },
+            holes: { type: 'number', description: 'Separate outlines those open edges form (one per hole or open rim).' },
+            seamEdges: { type: 'number', description: 'Places where two faces meet without sharing their corners (split for flat shading or UV seams): the surface renders whole, but booleans, remeshing and collision built from the mesh need it welded.' },
+            nonManifoldEdges: { type: 'number', description: 'Edges shared by three or more faces (fins, faces stacked on one edge); they break booleans, remeshing and collision generation.' },
+            flippedEdges: { type: 'number', description: 'Edges (seams included) whose two faces wind the same way along them, so one of the two faces points inward (a face turned inside out renders dark or vanishes).' },
+            degenerateTriangles: { type: 'number', description: 'Faces with no area (slivers or a repeated corner).' },
+            parts: { type: 'number', description: 'Separate pieces: groups of faces joined by corners at the same place.' },
+            largestParts: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Up to 8 pieces, largest first: triangles, size [x, y, z] and center [x, y, z] in cm, in the mesh\'s own space.' },
+        },
+        outputRequired: ['meshPath', 'triangles', 'closed', 'parts'],
+    }),
+    buildCoreRecord({
+        parentTool: 'inspect', action: 'describe_view', dispatchAction: 'describe_view', domain: D, family: 'object',
+        editorStates: ['edit', 'simulate'],
+        summary: 'Describe what the level viewport\'s camera sees, as text: each actor in view with its share of the frame, its box on screen, how bright it is drawn and its distance, the share that is background (sky, void), and the frame\'s brightness. location and rotation place the camera first, as control_editor screenshot takes them.',
+        topics: ['what is visible', 'what the camera sees', 'describe view', 'describe frame', 'is it on screen', 'player on screen', 'screen coverage', 'check the camera shot', 'in shot', 'visible actors', 'frame brightness', 'too dark'],
+        whenToUse: ['A shot must be checked without looking at a picture: is the subject in view, how much of the frame it fills, where it sits, whether it is lit or lost in the dark.', 'A camera placement must be compared or tuned by numbers (subject coverage, sky share, brightness).'],
+        whenNotToUse: ['A picture is wanted (use control_editor screenshot).', 'Play In Editor runs: the level viewport does not show the running game (stop it, or use Simulate).', 'Whether something blocks a line of sight (use raycast_world).'],
+        inputProps: {
+            location: { type: 'object', properties: { x: { type: 'number' }, y: { type: 'number' }, z: { type: 'number' } }, additionalProperties: false, description: 'Camera location {x, y, z} in cm; omitted, the viewport\'s current one. The camera stays there.' },
+            rotation: { type: 'object', properties: { pitch: { type: 'number' }, yaw: { type: 'number' }, roll: { type: 'number' } }, additionalProperties: false, description: 'Camera rotation {pitch, yaw, roll} in degrees; omitted, the viewport\'s current one.' },
+            limit: { type: 'number', description: 'Most actors to list, largest share first (default 20, at most 100); visibleActors counts them all.' },
+        },
+        required: [],
+        effect: 'read',
+        costLatency: 'interactive',
+        exampleInput: { action: 'describe_view', location: { x: 0, y: -600, z: 200 }, rotation: { pitch: -10, yaw: 90, roll: 0 } },
+        exampleOutput: {
+            success: true, message: '2 actor(s) in view; the largest is Floor at 41.2% of the frame.',
+            cameraLocation: { x: 0, y: -600, z: 200 }, cameraRotation: { pitch: -10, yaw: 90, roll: 0 }, visibleActors: 2,
+            actors: [
+                { name: 'Floor', class: 'StaticMeshActor', coverage: 41.2, box: [0, 52.4, 100, 100], brightness: 0.34, distance: 220 },
+                { name: 'Crate', class: 'StaticMeshActor', coverage: 6.8, box: [44.1, 38.2, 55.9, 61.3], brightness: 0.51, distance: 560 },
+            ],
+            background: 52, other: 0, brightness: { p10: 0.05, median: 0.31, p90: 0.62, clipped: 0, dark: 4.1 },
+        },
+        outputProps: {
+            cameraLocation: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Where the camera was.' },
+            cameraRotation: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Where it looked.' },
+            visibleActors: { type: 'number', description: 'Actors the game would draw with at least one pixel in the frame.' },
+            actors: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Largest share first: name (actor label), class, coverage (percent of the frame), box [left, top, right, bottom] in percent of the frame\'s width and height, brightness (0-1, as drawn) and distance (cm from the camera to its bounds). Editor icons and shapes hidden in game are left out.' },
+            background: { type: 'number', description: 'Percent of the frame where no object was drawn (sky, void).' },
+            other: { type: 'number', description: 'Percent drawn by what only the editor shows (icons, gizmos, shapes hidden in game) or no actor owns (BSP).' },
+            brightness: { type: 'object', properties: { p10: { type: 'number' }, median: { type: 'number' }, p90: { type: 'number' }, clipped: { type: 'number' }, dark: { type: 'number' } }, additionalProperties: false, description: 'The frame as drawn: p10, median and p90 brightness (0-1), and the percent of the frame clipped (a channel at full) or dark (below 0.05).' },
+        },
+        outputRequired: ['visibleActors', 'actors', 'background', 'brightness'],
+    }),
+    buildCoreRecord({
+        parentTool: 'inspect', action: 'capture_passes', dispatchAction: 'capture_passes', domain: D, family: 'object',
+        editorStates: ['edit', 'simulate'],
+        summary: 'Capture the level viewport\'s view as machine-readable passes, aligned pixel for pixel: id (a PNG with one colour per actor, and the legend naming each colour\'s actor), depth (an EXR of the distance in cm) and normal (a PNG of the world normal, RGB = normal x 0.5 + 0.5), with a summary of each. location and rotation place the camera first, as describe_view and control_editor screenshot take them.',
+        topics: ['capture passes', 'id pass', 'object id', 'depth pass', 'depth map', 'normal pass', 'normal map of the view', 'segmentation mask', 'render passes'],
+        whenToUse: ['A frame must be analysed by a script, a probe or a model: which actor covers a region (id), how far each pixel is (depth), which way surfaces face (normal).', 'Regions of a screenshot must be attributed to actors, or distances in a shot measured.'],
+        whenNotToUse: ['A picture to look at is wanted (use control_editor screenshot).', 'Only which actors are in view and their share is needed (use describe_view, which writes no files).', 'Passes of a rendered sequence are needed (use manage_sequence add_render_pass).'],
+        inputProps: {
+            location: { type: 'object', properties: { x: { type: 'number' }, y: { type: 'number' }, z: { type: 'number' } }, additionalProperties: false, description: 'Camera location {x, y, z} in cm; omitted, the viewport\'s current one. The camera stays there.' },
+            rotation: { type: 'object', properties: { pitch: { type: 'number' }, yaw: { type: 'number' }, roll: { type: 'number' } }, additionalProperties: false, description: 'Camera rotation {pitch, yaw, roll} in degrees; omitted, the viewport\'s current one.' },
+            passes: { type: 'array', items: { type: 'string', enum: ['id', 'depth', 'normal'] }, description: 'Passes to write (default all three).' },
+            width: { type: 'number', description: 'Width of every pass in pixels (default 960, 64 to 4096); the height follows the viewport\'s shape so the passes line up with it.' },
+            outputPath: { type: 'string', description: 'Folder inside the project, project-relative or absolute (default Saved/Captures).' },
+            name: { type: 'string', description: 'File name prefix (default Passes_<date>_<time>): files are <name>_id.png, <name>_depth.exr and <name>_normal.png.' },
+        },
+        required: [],
+        effect: 'read',
+        costLatency: 'interactive',
+        exampleInput: { action: 'capture_passes', location: { x: 0, y: -600, z: 200 }, rotation: { pitch: -10, yaw: 90, roll: 0 }, name: 'Crate' },
+        exampleOutput: {
+            success: true, message: 'Captured 3 pass(es) at 960x404.', cameraLocation: { x: 0, y: -600, z: 200 }, cameraRotation: { pitch: -10, yaw: 90, roll: 0 },
+            fov: 90, width: 960, height: 404,
+            files: { id: 'X:/Games/MyGame/Saved/Captures/Crate_id.png', depth: 'X:/Games/MyGame/Saved/Captures/Crate_depth.exr', normal: 'X:/Games/MyGame/Saved/Captures/Crate_normal.png' },
+            ids: [{ color: '#ff3333', name: 'Floor', class: 'StaticMeshActor', coverage: 41.2 }, { color: '#33ffb2', name: 'Crate', class: 'StaticMeshActor', coverage: 6.8 }],
+            depth: { min: 220, median: 640, max: 2400, sky: 52 }, normal: { up: 61.3, down: 0, side: 38.7 },
+        },
+        outputProps: {
+            cameraLocation: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Where the camera was.' },
+            cameraRotation: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Where it looked.' },
+            fov: { type: 'number', description: 'Horizontal field of view in degrees.' },
+            width: { type: 'number', description: 'Pass width in pixels.' },
+            height: { type: 'number', description: 'Pass height in pixels.' },
+            files: { type: 'object', properties: { id: { type: 'string' }, depth: { type: 'string' }, normal: { type: 'string' } }, additionalProperties: false, description: 'Absolute path of each pass written.' },
+            ids: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'id: each actor in the id image, largest first (up to 256): color (#rrggbb in the PNG), name (actor label), class and coverage (percent of the frame). Black is background (sky, void), dark grey (#404040) what only the editor draws.' },
+            depth: { type: 'object', properties: { min: { type: 'number' }, median: { type: 'number' }, max: { type: 'number' }, sky: { type: 'number' } }, additionalProperties: false, description: 'depth: nearest, median and farthest distance of the drawn pixels in cm, and the percent that is sky (nothing within 100 km).' },
+            normal: { type: 'object', properties: { up: { type: 'number' }, down: { type: 'number' }, side: { type: 'number' } }, additionalProperties: false, description: 'normal: percent of the drawn pixels facing up (normal z above 0.7), down (below -0.7) and sideways.' },
+        },
+        outputRequired: ['files'],
+    }),
+    buildCoreRecord({
+        parentTool: 'inspect', action: 'raycast_world', dispatchAction: 'raycast_world', domain: D, family: 'object',
+        editorStates: ANY_EDITOR_STATE,
+        summary: 'Trace lines through the level against collision and read what each one hits first: the point, the surface normal, the distance, the actor and the component. Finds the ground under a point, checks a line of sight, and proves a wall, floor or volume really blocks. Traces the running game while Play In Editor runs.',
+        topics: ['line trace', 'raycast world', 'what is below', 'ground height', 'line of sight', 'does it block', 'collision test', 'trace channel'],
+        whenToUse: [
+            'The ground height under a point, or what a jump or a drop would land on, must be known.',
+            'A line of sight between two points (a camera, an enemy, the player) must be checked.',
+            'A placed wall, floor, platform or blocking volume must be proven to block: a mesh or volume with no collision is traced straight through.',
+        ],
+        whenNotToUse: ['The surface of a mesh asset must be found without placing it (use raycast_mesh).', 'Only an actor\'s overall size is needed (use query_object lookup bounding_box).'],
+        inputProps: {
+            rays: {
+                type: 'array', minItems: 1, maxItems: 256,
+                items: {
+                    type: 'object', additionalProperties: false, required: ['start', 'end'],
+                    properties: {
+                        start: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Line start {x, y, z} in world space, in cm.' },
+                        end: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Line end {x, y, z} in world space; nothing past it is reported.' },
+                    },
+                },
+                description: 'Lines in world space; each answers in hits at the same index.',
+            },
+            channel: { type: 'string', description: 'Collision channel traced: Visibility (default), Camera, WorldStatic, WorldDynamic, Pawn, PhysicsBody, Vehicle, Destructible, or a project trace channel by its name. What blocks depends on each component\'s response to that channel: most meshes block Visibility, a character capsule blocks Pawn.' },
+            traceComplex: { type: 'boolean', description: 'Trace the render triangles of meshes that allow it instead of their simple collision (default false: the shapes the game\'s movement collides with).' },
+            ignoreActors: { type: 'array', items: { type: 'string' }, description: 'Actors (label, name or path) the lines pass through, such as the player pawn a line starts inside; an unknown name is refused.' },
+        },
+        required: ['rays'],
+        effect: 'read',
+        exampleInput: { action: 'raycast_world', rays: [{ start: { x: 0, y: 0, z: 1000 }, end: { x: 0, y: 0, z: -1000 } }] },
+        exampleOutput: { success: true, hitCount: 1, hits: [{ hit: true, location: { x: 0, y: 0, z: 0 }, normal: { x: 0, y: 0, z: 1 }, distance: 1000, actorName: 'Floor', componentName: 'StaticMeshComponent0' }] },
+        outputProps: {
+            hitCount: { type: 'number', description: 'How many lines hit something.' },
+            hits: {
+                type: 'array',
+                items: {
+                    type: 'object', additionalProperties: false,
+                    properties: {
+                        hit: { type: 'boolean', description: 'Whether this line hit something that blocks the channel.' },
+                        location: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Where the line first hits, {x, y, z} in world space.' },
+                        normal: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Surface normal there.' },
+                        distance: { type: 'number', description: 'Distance from start, in cm.' },
+                        actorName: { type: 'string', description: 'Label of the actor hit.' },
+                        componentName: { type: 'string', description: 'Component whose collision the line hit.' },
+                        startedInside: { type: 'boolean', description: 'True when start was already inside the collision it reports: the line begins in a wall, or in a pawn left out of ignoreActors.' },
+                    },
+                },
+                description: 'One entry per line, in order.',
+            },
+        },
+    }),
     buildCoreRecord({
         parentTool: 'inspect', action: 'get_texture_details', dispatchAction: 'inspect_object', domain: D, family: 'object',
         summary: 'Inspect a texture asset: dimensions, format and settings. Any other object is refused with TYPE_MISMATCH.',
@@ -168,6 +333,7 @@ export const OBJECT_PROPERTY_RECORDS = [
     }),
     buildCoreRecord({
         parentTool: 'inspect', action: 'get_property', dispatchAction: 'get_property', domain: D, family: 'property',
+        editorStates: ANY_EDITOR_STATE,
         topics: ['read property', 'property value', 'get value', 'read field', 'actor property', 'object property', 'game instance variable', 'read live widget property', 'widget value during play'],
         summary: 'Read a property value from a world actor, asset, or Blueprint class defaults (blueprintPath, or the Blueprint asset\'s own path), or several at once (propertyNames).',
         whenToUse: ['A single property value must be read.', 'Several properties of one target must be read in one call (propertyNames).'],
@@ -182,17 +348,26 @@ export const OBJECT_PROPERTY_RECORDS = [
         exampleInput: { action: 'get_property', objectPath: '/Game/Maps/Demo.Demo_PersistentLevel.PlayerStart_1', propertyName: 'ActorLabel' },
         exampleOutput: { success: true, message: 'Property read', value: 'PlayerStart_1' },
         outputProps: {
-            value: P.value,
-            properties: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, 'x-unreal-reflection-boundary': true, description: 'With propertyNames: each property that resolved, as {propertyName (its own spelling), value}.' },
+            value: P.valueRead,
+            properties: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, 'x-unreal-reflection-boundary': true, description: 'With propertyNames: each property that resolved, as {propertyName (its own spelling), value}, plus propertyPath (the path as asked) when that differs, so two .Text reads stay apart.' },
             missingProperties: { type: 'array', items: { type: 'string' }, description: 'With propertyNames: each name that did not resolve, as "Name: reason".' },
         },
     }),
     buildCoreRecord({
         parentTool: 'inspect', action: 'set_property', dispatchAction: 'set_property', domain: D, family: 'property',
+        editorStates: ANY_EDITOR_STATE,
         topics: ['write property', 'set value', 'change property', 'modify property', 'edit property', 'set field', 'set property on actor', 'set game instance variable'],
-        summary: 'Write a property value on a world actor, asset, or Blueprint CDO, or several at once (properties).',
-        whenToUse: ['A single property value must be written.', 'Several properties of one target must be written in one call (properties).'],
-        whenNotToUse: ['The property is read-only or the target is a packed asset.'],
+        summary: 'Write a property value on a world actor, asset, or Blueprint CDO; several at once (properties), or the same on several objects (objectPaths).',
+        whenToUse: [
+            'A single property value must be written.',
+            'Several properties of one target must be written in one call (properties).',
+            'The same property must be written on several objects in one call (objectPaths), e.g. one volume on every ambient sound.',
+            'A placed actor\'s component property must be written ("StaticMeshComponent0.StaticMesh", "Mesh.BodyInstance.CollisionEnabled"): a StaticMesh, collision, SimulatePhysics or Mobility key goes through the component\'s own setter, as control_actor edit_component writes it.',
+        ],
+        whenNotToUse: [
+            'The property is read-only or the target is a packed asset.',
+            'A value the object works out from another of its settings: the object puts the write back and the call fails with PROPERTY_SET_FAILED naming both values, so change that setting instead. A value the object only adjusts (a clamp) is written, and the message names what it became.',
+        ],
         inputProps: {
             objectPath: P.runtimeObjectPath, actorName: P.actorName, name: P.name, blueprintPath: P.blueprintPath, propertyName: P.propertyName, propertyPath: P.propertyPath, value: P.value, markDirty: P.markDirty,
             properties: {
@@ -201,16 +376,16 @@ export const OBJECT_PROPERTY_RECORDS = [
                 'x-unreal-reflection-boundary': true,
                 description: 'Several writes on the same target in place of propertyName and value: {name or dotted path: value}, e.g. {"BoxExtent": {"X": 20, "Y": 90, "Z": 100}, "CollisionProfileName": "OverlapAllDynamic"}. Each is written as a single call would be and reported under properties; the call fails naming any that did not apply. watch applies to single writes only.',
             },
+            objectPaths: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 64, description: 'The same write on several targets in one call, in place of objectPath: each entry is a target as objectPath takes it (an actor, "Actor.Component", an asset, a class default), written as a single call would be, with properties too. Answered under targets; the call fails naming each target that did not take the write, and the others keep it.' },
             watch: {
                 type: 'object',
                 description: 'Sample a property right after the write, in the same call, to see what the write sets off before it ends: a HUD pop or fade runs on real time, even with PIE paused, and is over before a later call can read it. The reply lists each value the property took with its time t in seconds (Lives on GameInstance with watch {objectPath: "WBP_HUD", propertyName: "LivesBox.RenderTransform"}).',
                 properties: {
-                    propertyName: { type: 'string', description: 'The property to sample; a dotted path reaches through widgets and structs (LivesBox.RenderTransform).' },
+                    propertyName: { type: 'string', description: 'The property to sample; a dotted path reaches through widgets and structs (LivesBox.RenderTransform). Omitted, the property the call writes.' },
                     objectPath: { type: 'string', description: 'The object to sample, as objectPath takes it (GameInstance, a live widget such as WBP_HUD); omitted, the object written.' },
                     durationSeconds: { type: 'number', description: 'Real seconds to sample (default 0.5, at most 20).' },
                     intervalSeconds: { type: 'number', description: 'Seconds between samples (default 0: every frame); a sample is kept only when the value changed.' },
                 },
-                required: ['propertyName'],
                 additionalProperties: false,
             },
         },
@@ -220,8 +395,11 @@ export const OBJECT_PROPERTY_RECORDS = [
         outputProps: {
             watch: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'With watch: objectPath, propertyName, samples ({t, value}, kept when the value changed), sampleCount, changed (it took more than one value) and frames.' },
             properties: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, 'x-unreal-reflection-boundary': true, description: 'With properties: each write as {propertyName, applied, value read back}.' },
-            applied: { type: 'number', description: 'With properties: how many writes applied.' },
-            instancesUpdated: { type: 'number', description: 'A write to a class default or component template: how many placed copies that still held the old default took the new one, as the details panel does; copies that override the value keep theirs. Absent for any other target.' },
+            targets: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, 'x-unreal-reflection-boundary': true, description: 'With objectPaths: each target as {objectPath as given, applied, the value read back (properties with properties), actorPath, saved, saveSkippedReason}.' },
+            applied: { type: 'number', description: 'With properties: how many writes applied; with objectPaths: how many targets.' },
+            saved: { type: 'boolean', description: 'Whether the target\'s package was written to disk after the write; with properties, the last write\'s save, which holds every write of the call. False with saveSkippedReason when nothing was saved.' },
+            saveSkippedReason: { type: 'string', description: 'Why nothing was saved: markDirty was false, a running-game or transient object (the change lasts until PIE stops), level content (saved with its level), engine content, or a save that failed (the change is only in memory).' },
+            instancesUpdated: { type: 'number', description: 'A write to a class default or component template: how many placed copies, and derived Blueprints\' defaults with their own copies, still held the old default and took the new one, as the details panel does; one that overrides the value keeps it. Absent for any other target.' },
             blueprintCompiled: { type: 'boolean', description: 'True when the target was a Blueprint CDO and the Blueprint was recompiled, so the value now applies to newly spawned instances. The reply (value, actorPath, actorClass) is read back from the recompiled class default object and the Blueprint package is saved; a variable the Blueprint declares keeps the value as its default, and the call fails with PROPERTY_SET_FAILED, never success, when the compile did not keep it. A Default__ objectPath resolves to the Blueprint\'s current default object; a copy a compile left behind (a REINST_ class, or a Blueprint object in /Engine/Transient with no game running) fails with STALE_TARGET. False for plain world actors and assets, where no compile is involved.' },
             materialRebuilt: { type: 'boolean', description: 'True when the target lives inside a material or material function (a material expression such as a TextureObjectParameter, as <material>.<material>:<nodeName>) and that material was rebuilt, so its parameter lists, which every material instance reads, show the write at once (a new ParameterName, a new default Texture). Absent for any other target.' },
         },

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

@@ -19,6 +19,7 @@ export declare const P: {
     readonly propertyNames: JsonObject;
     readonly componentNames: JsonObject;
     readonly value: Prop;
+    readonly valueRead: Prop;
     readonly structPath: JsonObject;
     readonly limit: JsonObject;
     readonly offset: JsonObject;

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

@@ -6,7 +6,7 @@ export const P = {
     actorName: str('World actor name to inspect.'),
     actorNames: arrStr('Several world actors to act on in one call, in place of actorName; names not found are listed back.'),
     name: str('Actor name identifier (alias of actorName).'),
-    propertyName: str('Property to read or write: a name, or a dotted path through structs at any depth (BodyInstance.CollisionEnabled). A bare name that is not on the object itself resolves to the one struct member carrying it. Give this or propertyPath.'),
+    propertyName: str('Property to read or write: a name, or a dotted path through structs and object references at any depth (BodyInstance.CollisionEnabled). On an actor the path may start with a component\'s name, including one added in the level (MyAudio.VolumeMultiplier). A bare name that is not on the object itself resolves to the one struct member carrying it. Give this or propertyPath.'),
     propertyPath: str('Same as propertyName (a name or dotted path); used when propertyName is absent. Give this or propertyName.'),
     componentName: str('Component name on the actor.'),
     className: str('Class name or /Script/ class path to inspect.'),
@@ -19,6 +19,7 @@ export const P = {
     propertyNames: arrStr('Specific property names to include.'),
     componentNames: arrStr('Specific component names to include.'),
     value: { description: 'Property value to set (type depends on the target property).' },
+    valueRead: { description: 'The value read; its type follows the property.' },
     structPath: str('UserDefinedStruct asset /Game path to introspect.'),
     limit: num('Maximum objects to return (default 100).'),
     offset: num('Matching objects to skip before the first one returned, for paging (default 0); hasMore says whether more follow.'),

package/dist/tools/catalog/capabilities/records/inspect/runtime.data.js

@@ -1,4 +1,4 @@
-import { buildCoreRecord } from '../core/builder.js';
+import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
 import { P } from './properties.js';
 const D = 'inspect';
 const RUNTIME_REPORT_OUTPUT = {
@@ -17,6 +17,7 @@ const RUNTIME_REPORT_OUTPUT = {
 export const RUNTIME_RECORDS = [
     buildCoreRecord({
         parentTool: 'inspect', action: 'runtime_report', dispatchAction: 'runtime_report', domain: D, family: 'runtime',
+        editorStates: ANY_EDITOR_STATE,
         summary: 'Return a runtime report for the current PIE/simulate session.',
         whenToUse: ['Runtime state of actors/components/properties must be inspected during PIE.', 'PIE-only runtime state must be inspected.'],
         whenNotToUse: ['The editor is not in PIE; the report will be empty.'],

package/dist/tools/catalog/capabilities/records/inspect/stats.data.js

@@ -1,8 +1,9 @@
-import { buildCoreRecord } from '../core/builder.js';
+import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
 const D = 'inspect';
 export const STATS_RECORDS = [
     buildCoreRecord({
         parentTool: 'inspect', action: 'get_scene_stats', dispatchAction: 'get_scene_stats', domain: D, family: 'stats',
+        editorStates: ANY_EDITOR_STATE,
         summary: 'Return scene statistics (actor counts, component counts, etc.).',
         whenToUse: ['Scene-level statistics must be inspected.'],
         whenNotToUse: ['Runtime performance is needed; use get_performance_stats.'],
@@ -15,6 +16,7 @@ export const STATS_RECORDS = [
     }),
     buildCoreRecord({
         parentTool: 'inspect', action: 'get_performance_stats', dispatchAction: 'get_performance_stats', domain: D, family: 'stats',
+        editorStates: ANY_EDITOR_STATE,
         summary: 'Return performance statistics (frame rate, frame time, game, render and GPU thread times, actor count).',
         whenToUse: ['Performance metrics must be inspected.'],
         whenNotToUse: ['Scene composition is needed; use get_scene_stats.'],
@@ -38,7 +40,8 @@ export const STATS_RECORDS = [
             frameTimeMs: { type: 'number', description: 'Frame time in milliseconds.' },
             estimatedFps: { type: 'number', description: 'Estimated frames per second from delta time.' },
             fps: { type: 'number', description: 'Reported frames per second (same as estimatedFps).' },
-            gameThreadMs: { type: 'number', description: 'Game thread time in milliseconds.' },
+            gameThreadMs: { type: 'number', description: 'Game thread time in milliseconds; while Play In Editor runs it also holds the editor\'s own UI and viewports, so worldTickMs is the game\'s share.' },
+            worldTickMs: { type: 'number', description: 'The measured world\'s own tick in milliseconds (actors, components and physics, from the start of its tick to the end of its tick groups), averaged over about 30 frames: the game\'s share of gameThreadMs. Absent until the world has ticked.' },
             renderThreadMs: { type: 'number', description: 'Render thread time in milliseconds.' },
             rhiThreadMs: { type: 'number', description: 'RHI thread time in milliseconds.' },
             gpuMs: { type: 'number', description: 'GPU frame time in milliseconds.' },
@@ -49,6 +52,7 @@ export const STATS_RECORDS = [
     }),
     buildCoreRecord({
         parentTool: 'inspect', action: 'get_memory_stats', dispatchAction: 'get_memory_stats', domain: D, family: 'stats',
+        editorStates: ANY_EDITOR_STATE,
         summary: 'Return memory statistics (allocated, virtual, resource counts).',
         whenToUse: ['Memory usage must be inspected.'],
         whenNotToUse: ['Performance timing is needed; use get_performance_stats.'],