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

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

@@ -1,481 +0,0 @@
-import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-const D = 'inspect';
-const INSPECT_OBJECT_OUTPUT = {
-    objectName: { type: 'string', description: 'Object name.' },
-    objectPath: { type: 'string', description: 'Full object path of the inspected object.' },
-    class: { type: 'string', description: 'Class name of the inspected object.' },
-    className: { type: 'string', description: 'Class name of the inspected object (alias of class).' },
-    classPath: { type: 'string', description: 'Full /Script class path of the inspected object.' },
-    actorLabel: { type: 'string', description: 'Editor display label. Actors only.' },
-    isActor: { type: 'boolean', description: 'True when the object is a world actor rather than an asset.' },
-    isStaticMesh: { type: 'boolean', description: 'True when the object is a StaticMesh asset.' },
-    isSceneComponent: { type: 'boolean', description: 'True when the object is a scene component.' },
-    isSelected: { type: 'boolean', description: 'True when the actor is selected in the editor.' },
-    isHidden: { type: 'boolean', description: 'True when the actor is hidden in the editor viewport.' },
-    isVisible: { type: 'boolean', description: 'True when the object is visible.' },
-    isActive: { type: 'boolean', description: 'True when the component is active.' },
-    staticMesh: { type: 'string', description: 'Static mesh asset path assigned to the object, when it has one.' },
-    location: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'World location as {x, y, z}.' },
-    rotation: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'World rotation as {pitch, yaw, roll} in degrees.' },
-    scale: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'World scale as {x, y, z}.' },
-    transform: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Combined transform: location, rotation and scale.' },
-    components: { type: 'array', description: 'Attached components with their names, classes and transforms.' },
-    componentCount: { type: 'number', description: 'Number of attached components.' },
-    tags: { type: 'array', items: { type: 'string' }, description: 'Actor tags.' },
-};
-const MESH_DETAILS_OUTPUT = {
-    ...INSPECT_OBJECT_OUTPUT,
-    materialSlots: {
-        type: 'array',
-        items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-        description: 'Mesh assets: every material slot as {slotIndex, slotName, material (asset path, empty for none), triangles and sections (what LOD0 draws with the slot), bounds (where that geometry is, in mesh space: origin is its center, extent its half size, with min, max, size and radius)}. bounds is absent for a slot LOD0 draws nothing with, and for every slot when slotBoundsAvailable is false. A Nanite mesh reports its fallback mesh. A skeletal mesh is read in its reference pose.',
-    },
-    materialSlotCount: { type: 'number', description: 'Mesh assets: how many material slots the mesh has.' },
-    slotBoundsAvailable: { type: 'boolean', description: 'Mesh assets: false when the render data keeps no CPU copy of its vertices, so each slot has its triangle count but no bounds.' },
-};
-export const OBJECT_PROPERTY_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'inspect_object', dispatchAction: 'inspect_object', domain: D, family: 'object',
-        topics: ['inspect actor', 'object details', 'actor properties', 'dump object', 'all properties', 'introspect object'],
-        aliases: ['inspect.inspect_actor'],
-        summary: 'Inspect a world actor or asset object by path, returning detailed properties.',
-        whenToUse: ['An object\'s properties and structure must be read.'],
-        whenNotToUse: ['A Blueprint CDO without a spawned actor is needed; use inspect_cdo.'],
-        inputProps: { objectPath: P.objectPath, actorName: P.actorName, name: P.name, componentName: P.componentName, detailed: P.detailed, propertyNames: P.propertyNames },
-        required: [],
-        outputProps: INSPECT_OBJECT_OUTPUT,
-        effect: 'read',
-        exampleInput: { action: 'inspect_object', objectPath: '/Game/Maps/Demo.Demo_PersistentLevel.PlayerStart_1' },
-        exampleOutput: { success: true, message: 'Object inspected', objectName: 'PlayerStart_1', class: 'PlayerStart', isActor: true, location: { x: 0, y: 0, z: 100 } },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_actor_details', dispatchAction: 'inspect_object', domain: D, family: 'object',
-        summary: 'Inspect a world actor (alias of inspect_object).',
-        whenToUse: ['A world actor\'s details must be read using the get_actor_details verb.'],
-        whenNotToUse: ['Prefer the canonical inspect_object verb.'],
-        inputProps: { objectPath: P.objectPath, actorName: P.actorName, name: P.name, componentName: P.componentName, detailed: P.detailed, propertyNames: P.propertyNames },
-        required: [],
-        outputProps: INSPECT_OBJECT_OUTPUT,
-        effect: 'read',
-        exampleInput: { action: 'get_actor_details', actorName: 'PlayerStart_1' },
-        exampleOutput: { success: true, message: 'Object inspected', objectName: 'PlayerStart_1', isActor: true },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_blueprint_details', dispatchAction: 'blueprint_get', domain: D, family: 'object',
-        topics: ['compile status', 'parent class', 'graph node counts'],
-        summary: 'Read a Blueprint asset without spawning it: parent class, type, compile status, variables with defaults, functions, events, graph node counts, and components with transforms, meshes and materials.',
-        whenToUse: ['A Blueprint asset\'s structure must be read without spawning an actor.'],
-        whenNotToUse: ['A world actor is in scope; use inspect_object.'],
-        inputProps: { objectPath: P.objectPath, blueprintPath: P.blueprintPath },
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'get_blueprint_details', blueprintPath: '/Game/Blueprints/BP_Test' },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_mesh_details', dispatchAction: 'inspect_object', domain: D, family: 'object',
-        summary: 'Inspect a static or skeletal mesh asset: size, bounds, pivot, LODs, and every material slot with the triangles and bounds of the geometry it covers. Any other object is refused with TYPE_MISMATCH.',
-        topics: ['material slot bounds', 'which slot is which part'],
-        whenToUse: ['A mesh asset\'s details must be read.', 'It is not known which material slot holds which part of a mesh (legs, hull, claws): each slot lists the triangles and mesh-space bounds of its LOD0 geometry.'],
-        whenNotToUse: ['Prefer the canonical inspect_object verb.'],
-        inputProps: { objectPath: P.objectPath, actorName: P.actorName, name: P.name, detailed: P.detailed, propertyNames: P.propertyNames },
-        required: [],
-        outputProps: MESH_DETAILS_OUTPUT,
-        effect: 'read',
-        exampleInput: { action: 'get_mesh_details', objectPath: '/Game/Meshes/SM_Cube' },
-        exampleOutput: {
-            success: true, message: 'Object inspected', objectName: 'SM_Cube', isStaticMesh: true, materialSlotCount: 1, slotBoundsAvailable: true,
-            materialSlots: [{ slotIndex: 0, slotName: 'Cube', material: '/Engine/BasicShapes/BasicShapeMaterial.BasicShapeMaterial', triangles: 12, sections: 1, bounds: { origin: { x: 0, y: 0, z: 50 }, extent: { x: 50, y: 50, z: 50 } } }],
-        },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'raycast_mesh', dispatchAction: 'raycast_mesh', domain: D, family: 'object',
-        summary: 'Cast rays at a static mesh asset in its own local space and read where each one meets the surface: the point, the surface normal and the material slot. Places a part, a print or a decal on a curved surface without a placed actor or collision.',
-        topics: ['raycast mesh', 'surface point', 'where is the surface', 'line trace mesh', 'surface normal'],
-        whenToUse: ['A part, decal or print must sit exactly on a mesh surface (a chest, a hull, a rock) and the surface position at a given height or side is unknown; the decalRotation and location of a hit place a DecalComponent there directly.', 'A surface profile must be sampled: one ray per row or column across the area.'],
-        whenNotToUse: ['Only the overall size or pivot of the mesh is needed (use get_mesh_details).', 'Parts of a Blueprint must be checked for sinking into each other (use control_actor.audit_placement).'],
-        inputProps: {
-            meshPath: { type: 'string', description: 'Static mesh asset path, e.g. /Game/Meshes/SM_Rock. Rays meet its source triangles, so a Nanite mesh answers at full detail.' },
-            rays: {
-                type: 'array', minItems: 1, maxItems: 256,
-                items: {
-                    type: 'object', additionalProperties: false, required: ['origin', 'direction'],
-                    properties: {
-                        origin: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Ray start {x, y, z} in the mesh\'s local space, in cm; start outside the mesh to find its outer surface.' },
-                        direction: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Ray direction {x, y, z}; any length, it is normalized.' },
-                    },
-                },
-                description: 'Rays in the mesh\'s local space; each answers in hits at the same index.',
-            },
-        },
-        required: ['meshPath', 'rays'],
-        effect: 'read',
-        exampleInput: { action: 'raycast_mesh', meshPath: '/Engine/BasicShapes/Cube', rays: [{ origin: { x: 200, y: 0, z: 50 }, direction: { x: -1, y: 0, z: 0 } }] },
-        exampleOutput: { success: true, meshPath: '/Engine/BasicShapes/Cube', hitCount: 1, hits: [{ hit: true, location: { x: 50, y: 0, z: 50 }, normal: { x: 1, y: 0, z: 0 }, distance: 150, materialSlot: 'Cube' }] },
-        outputProps: {
-            meshPath: { type: 'string', description: 'The mesh the rays were cast at.' },
-            hitCount: { type: 'number', description: 'How many rays met the surface.' },
-            hits: {
-                type: 'array',
-                items: {
-                    type: 'object', additionalProperties: false,
-                    properties: {
-                        hit: { type: 'boolean', description: 'Whether this ray met the surface.' },
-                        location: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Nearest point where the ray meets the surface, {x, y, z} in local space.' },
-                        normal: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Surface normal there, turned to face back along the ray (from outside, the outward normal).' },
-                        distance: { type: 'number', description: 'Distance from the ray origin, in cm.' },
-                        materialSlot: { type: 'string', description: 'Name of the material slot whose triangle was hit.' },
-                        decalRotation: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Rotation {pitch, yaw, roll} for a DecalComponent placed at location in the same space, so its texture prints upright and readable on this surface: the decal projects into the surface along its X axis, and its DecalSize is (projection depth, half the print height, half the print width).' },
-                    },
-                },
-                description: 'One entry per ray, in order.',
-            },
-        },
-    }),
-    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.',
-        whenToUse: ['A texture asset\'s details must be read.'],
-        whenNotToUse: ['Prefer the canonical inspect_object verb.'],
-        inputProps: { objectPath: P.objectPath, actorName: P.actorName, name: P.name, detailed: P.detailed, propertyNames: P.propertyNames },
-        required: [],
-        outputProps: INSPECT_OBJECT_OUTPUT,
-        effect: 'read',
-        exampleInput: { action: 'get_texture_details', objectPath: '/Game/Textures/T_Base' },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_material_details', dispatchAction: 'inspect_object', domain: D, family: 'object',
-        summary: 'Inspect a material or material instance: blend mode, parameters and textures. Any other object is refused with TYPE_MISMATCH.',
-        whenToUse: ['A material asset\'s details must be read.'],
-        whenNotToUse: ['Prefer the canonical inspect_object verb.'],
-        inputProps: { objectPath: P.objectPath, actorName: P.actorName, name: P.name, detailed: P.detailed, propertyNames: P.propertyNames },
-        required: [],
-        outputProps: INSPECT_OBJECT_OUTPUT,
-        effect: 'read',
-        exampleInput: { action: 'get_material_details', objectPath: '/Game/Materials/M_Base' },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_level_details', dispatchAction: 'get_world_settings', domain: D, family: 'object',
-        summary: 'Inspect the current level/world summary (TS normalizes to get_world_settings).',
-        whenToUse: ['The current level\'s world settings summary must be read.'],
-        whenNotToUse: ['A specific actor is in scope; use inspect_object.'],
-        inputProps: {},
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'get_level_details' },
-        exampleOutput: { success: true, message: 'World settings', worldName: 'Demo' },
-        outputProps: { worldName: { type: 'string', description: 'Current world name.' } },
-    }),
-    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).'],
-        whenNotToUse: ['All properties are needed; use inspect_object or inspect_cdo.'],
-        inputProps: {
-            objectPath: P.runtimeObjectPath, actorName: P.actorName, name: P.name, blueprintPath: P.blueprintPath, propertyName: P.propertyName, propertyPath: P.propertyPath,
-            propertyNames: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 64, description: 'Several properties of the same target in one call, in place of propertyName: each read as a single call would (dotted paths too, such as CharacterMovement.MaxWalkSpeed). Answered under properties; a name that does not resolve is listed under missingProperties with the reason, and the others still answer.' },
-        },
-        required: [],
-        requiredOneOf: ['propertyName', 'propertyPath', 'propertyNames'],
-        effect: 'read',
-        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.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; 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: {
-                type: 'object',
-                additionalProperties: true,
-                '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). 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.' },
-                },
-                additionalProperties: false,
-            },
-        },
-        required: [],
-        requiredOneOf: ['propertyName', 'propertyPath', 'properties'],
-        effect: 'write', costLatency: 'interactive',
-        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}.' },
-            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.' },
-        },
-        exampleInput: { action: 'set_property', objectPath: '/Game/Maps/Demo.Demo_PersistentLevel.PlayerStart_1', propertyName: 'ActorLabel', value: 'Spawn_01' },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'inspect_class', dispatchAction: 'inspect_class', domain: D, family: 'class',
-        topics: ['class info', 'class metadata', 'reflection', 'class properties', 'uclass'],
-        summary: 'Inspect a UClass: metadata, parent, default CDO properties.',
-        whenToUse: ['A class\'s hierarchy and defaults must be read.'],
-        whenNotToUse: ['A specific instance is in scope; use inspect_object.'],
-        inputProps: { className: P.className, classPath: P.classPath },
-        required: ['className'],
-        effect: 'read',
-        exampleInput: { action: 'inspect_class', className: 'PointLight' },
-        exampleOutput: { success: true, message: 'Class inspected', className: 'PointLight', classPath: '/Script/Engine.PointLight', parentClass: 'Light' },
-        outputProps: {
-            className: P.className,
-            classPath: { type: 'string', description: 'Full /Script path of the resolved class.' },
-            parentClass: { type: 'string', description: 'Immediate super-class name ("None" when the class has no super).' },
-            parentClassPath: { type: 'string', description: 'Full path of the super-class.' },
-            module: { type: 'string', description: 'Module that declares a C++ class (empty for a Blueprint class).' },
-            isNative: { type: 'boolean', description: 'True for a C++ class.' },
-            isBlueprintGenerated: { type: 'boolean', description: 'True for a Blueprint-generated class.' },
-            generatedBy: { type: 'string', description: 'Blueprint asset that generated the class, when it is Blueprint-generated.' },
-            ancestors: { type: 'array', items: { type: 'string' }, description: 'Super-classes from the parent up to Object.' },
-            flags: { type: 'object', properties: { abstract: { type: 'boolean' }, blueprintable: { type: 'boolean' }, blueprintType: { type: 'boolean' }, deprecated: { type: 'boolean' }, transient: { type: 'boolean' }, config: { type: 'boolean' }, interface: { type: 'boolean' }, isActor: { type: 'boolean' }, isComponent: { type: 'boolean' } }, additionalProperties: false, description: 'Class flags as booleans.' },
-            properties: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'kind=class: every property the class declares or inherits (name, type, category, declaredIn, editable, blueprintVisible, deprecated). kind=cdo: the requested property values by name.' },
-            propertyCount: { type: 'number', description: 'Properties the class has, including any past the 200 listed.' },
-            propertiesTruncated: { type: 'boolean', description: 'True when the class has more than the 200 properties listed.' },
-            defaultProperties: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Default value of each property on the class default object, as text.' },
-            defaultObjectPath: { type: 'string', description: 'Path of the class default object.' },
-            functionCount: { type: 'number', description: 'Functions the class declares or inherits.' },
-        },
-        outputRequired: [],
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'inspect_cdo', dispatchAction: 'inspect_cdo', domain: D, family: 'class',
-        summary: 'Inspect a Blueprint Class Default Object (CDO) and its default components without spawning an actor.',
-        whenToUse: ['A Blueprint\'s default properties and components must be read.'],
-        whenNotToUse: ['A spawned world actor is in scope; use inspect_object.'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, componentName: P.componentName, propertyNames: P.propertyNames, detailed: P.detailed,
-            componentNames: { type: 'array', items: { type: 'string' }, description: 'Return only these components in components, by name (case-insensitive); a name that matches none is listed under missingComponents.' },
-        },
-        required: ['blueprintPath'],
-        effect: 'read',
-        outputProps: {
-            className: { type: 'string', description: 'Generated class name of the inspected CDO.' },
-            classPath: { type: 'string', description: 'Full path of the generated class.' },
-            blueprintPath: P.blueprintPath,
-            parentClass: { type: 'string', description: 'Parent class name.' },
-            componentCount: { type: 'number', description: 'Number of default components on the CDO.' },
-            cdoProperties: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Default property values on the Class Default Object.' },
-            properties: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Requested property values.' },
-            components: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Default component descriptors (name, class, attachParent).' },
-            missingComponents: { type: 'array', items: { type: 'string' }, description: 'componentNames that matched no component.' },
-        },
-        outputRequired: [],
-        exampleInput: { action: 'inspect_cdo', blueprintPath: '/Game/Blueprints/BP_Test' },
-        exampleOutput: { success: true, message: 'CDO inspected', className: 'BP_Test_C', componentCount: 3 },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'inspect_struct', dispatchAction: 'inspect_struct', domain: D, family: 'class',
-        summary: 'Inspect a UserDefinedStruct layout (member names, types, defaults) read-only.',
-        whenToUse: ['A Blueprint Struct\'s member layout must be read.'],
-        whenNotToUse: ['Struct values must be read or written; use manage_asset struct actions.'],
-        inputProps: { structPath: P.structPath },
-        required: ['structPath'],
-        effect: 'read',
-        exampleInput: { action: 'inspect_struct', structPath: '/Game/Structs/S_Test' },
-        exampleOutput: { success: true, message: 'Struct inspected', result: { structName: 'S_Test', memberCount: 3 } },
-        outputProps: {
-            result: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Struct layout: structName, structPath, parentStruct(Path), isRowStruct, isUserDefined, members[] (name/type/default/tooltip/guid/metadata/innerStruct), memberCount.' },
-        },
-        outputRequired: [],
-    }),
-];
-//# sourceMappingURL=object-property.data.js.map

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

@@ -1,31 +0,0 @@
-import type { JsonObject } from '../../model.js';
-type Prop = JsonObject;
-export declare const P: {
-    readonly objectPath: JsonObject;
-    readonly runtimeObjectPath: JsonObject;
-    readonly actorName: JsonObject;
-    readonly actorNames: JsonObject;
-    readonly name: JsonObject;
-    readonly propertyName: JsonObject;
-    readonly propertyPath: JsonObject;
-    readonly componentName: JsonObject;
-    readonly className: JsonObject;
-    readonly classPath: JsonObject;
-    readonly tag: JsonObject;
-    readonly filter: JsonObject;
-    readonly snapshotName: JsonObject;
-    readonly blueprintPath: JsonObject;
-    readonly detailed: JsonObject;
-    readonly propertyNames: JsonObject;
-    readonly componentNames: JsonObject;
-    readonly value: Prop;
-    readonly valueRead: Prop;
-    readonly structPath: JsonObject;
-    readonly limit: JsonObject;
-    readonly offset: JsonObject;
-    readonly markDirty: JsonObject;
-    readonly format: JsonObject;
-    readonly outputPath: JsonObject;
-};
-export {};
-//# sourceMappingURL=properties.d.ts.map

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

@@ -1,30 +0,0 @@
-import { str, bool, num } from '../shared/schema-props.js';
-const arrStr = (description) => ({ type: 'array', items: { type: 'string' }, description });
-export const P = {
-    objectPath: str('Object path of the world actor or asset (e.g. /Game/Maps/Demo.Demo_PersistentLevel).'),
-    runtimeObjectPath: str('Object path of the world actor or asset (e.g. /Game/Maps/Demo.Demo_PersistentLevel); while PIE runs, GameInstance, GameMode, GameState, PlayerController, PlayerPawn, PlayerState or HUD names that object of the running game, and a live widget goes by the name control_editor simulate_input widget_list reports (WBP_HUD_C_0 or WBP_HUD; its widgets are properties: CoinBox.RenderTransform).'),
-    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 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.'),
-    classPath: str('Class asset path (alias of className).'),
-    tag: str('Actor tag to match.'),
-    filter: str('Runtime report filter expression.'),
-    snapshotName: str('Snapshot name for create/restore.'),
-    blueprintPath: str('Blueprint asset /Game path (for CDO/component inspection without spawning).'),
-    detailed: bool('Return detailed property/component information.'),
-    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.'),
-    markDirty: bool('Default true: mark the package dirty and save an asset package. false leaves the package untouched and unsaved, so the change lives in memory only.'),
-    format: str('Exporter format by file extension, default T3D (the text form of the object); fails with EXPORT_FAILED when no exporter for that format handles the object.'),
-    outputPath: str('File to also write the export to, inside the project (relative to it, or absolute under it), e.g. Saved/Exports/Actor.t3d. A path outside the project is refused with INVALID_PATH.'),
-};
-//# sourceMappingURL=properties.js.map

package/dist/tools/catalog/capabilities/records/inspect/runtime.data.d.ts

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

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

@@ -1,37 +0,0 @@
-import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-const D = 'inspect';
-const RUNTIME_REPORT_OUTPUT = {
-    worldName: { type: 'string', description: 'Name of the world the report describes.' },
-    worldPath: { type: 'string', description: 'Package path of that world.' },
-    worldType: { type: 'string', description: 'World type, e.g. PIE or Editor.' },
-    isPIE: { type: 'boolean', description: 'Whether a PIE session is active.' },
-    actors: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Matching runtime actors and their inspected components/properties.' },
-    count: { type: 'number', description: 'Number of actors returned after filtering.' },
-    totalActorCount: { type: 'number', description: 'Total actors in the inspected world.' },
-    playerController: { type: 'string', description: 'Object path of the active PlayerController (inspect_object it for details).' },
-    pawn: { type: 'string', description: 'Object path of the possessed pawn; inspect it to find where the player actually is.' },
-    viewTarget: { type: 'string', description: 'Object path of the current view target.' },
-    playerCameraManager: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'PlayerCameraManager described as a runtime actor, plus cameraLocation and cameraRotation as {x,y,z} / {pitch,yaw,roll} objects.' },
-};
-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.'],
-        inputProps: {
-            filter: P.filter, actorName: P.actorName, name: P.name,
-            componentName: P.componentName, componentNames: P.componentNames,
-            propertyName: P.propertyName, propertyPath: P.propertyPath, propertyNames: P.propertyNames,
-        },
-        required: [],
-        effect: 'read',
-        outputProps: { ...RUNTIME_REPORT_OUTPUT },
-        outputRequired: [],
-        exampleInput: { action: 'runtime_report', actorName: 'PlayerStart_1' },
-        exampleOutput: { success: true, message: 'Runtime report', worldName: 'Demo', worldType: 'PIE', isPIE: true, count: 1, totalActorCount: 39 },
-    }),
-];
-//# sourceMappingURL=runtime.data.js.map