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

package/dist/tools/catalog/capabilities/records/control-actor/index.d.ts

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

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

@@ -1,18 +0,0 @@
-import { ADVANCED_RECORDS } from './advanced-records.js';
-import { COMPONENT_RECORDS } from './component-records.js';
-import { SEARCH_RECORDS } from './search-records.js';
-import { SPAWN_RECORDS } from './spawn-records.js';
-import { STATE_RECORDS } from './state-records.js';
-import { TRANSFORM_RECORDS } from './transform-records.js';
-import { applyFolds } from '../shared/fold.js';
-import { CONTROL_ACTOR_FOLDS } from '../folds/control-actor.folds.js';
-export const CONTROL_ACTOR_UNFOLDED_SOURCES = [
-    ...SPAWN_RECORDS,
-    ...TRANSFORM_RECORDS,
-    ...COMPONENT_RECORDS,
-    ...STATE_RECORDS,
-    ...SEARCH_RECORDS,
-    ...ADVANCED_RECORDS,
-];
-export const CONTROL_ACTOR_SOURCES = applyFolds(CONTROL_ACTOR_UNFOLDED_SOURCES, CONTROL_ACTOR_FOLDS, 'control_actor');
-//# sourceMappingURL=index.js.map

package/dist/tools/catalog/capabilities/records/control-actor/properties.d.ts

@@ -1,103 +0,0 @@
-export declare const P: {
-    readonly actorName: import("../../model.js").JsonObject;
-    readonly pieActorName: import("../../model.js").JsonObject;
-    readonly actorNames: {
-        readonly type: "array";
-        readonly items: import("../../model.js").JsonObject;
-        readonly description: "Actor names to act on (batch delete).";
-    };
-    readonly classPath: import("../../model.js").JsonObject;
-    readonly actorClass: import("../../model.js").JsonObject;
-    readonly meshPath: import("../../model.js").JsonObject;
-    readonly materialPath: import("../../model.js").JsonObject;
-    readonly materialSlot: import("../../model.js").JsonObject;
-    readonly materialIndex: import("../../model.js").JsonObject;
-    readonly allComponents: import("../../model.js").JsonObject;
-    readonly blueprintPath: import("../../model.js").JsonObject;
-    readonly location: import("../../model.js").JsonObject;
-    readonly rotation: import("../../model.js").JsonObject;
-    readonly scale: import("../../model.js").JsonObject;
-    readonly force: import("../../model.js").JsonObject;
-    readonly offset: import("../../model.js").JsonObject;
-    readonly componentType: import("../../model.js").JsonObject;
-    readonly componentName: import("../../model.js").JsonObject;
-    readonly propertyName: import("../../model.js").JsonObject;
-    readonly propertyPath: import("../../model.js").JsonObject;
-    readonly templateBlueprintPath: import("../../model.js").JsonObject;
-    readonly properties: {
-        readonly type: "object";
-        readonly description: "Component property key-value pairs. Each key is a name or dotted path, as propertyName takes it (BodyInstance.CollisionEnabled works).";
-        readonly additionalProperties: true;
-        readonly 'x-unreal-reflection-boundary': true;
-    };
-    readonly value: {
-        readonly description: "Property value (any type).";
-    };
-    readonly visible: import("../../model.js").JsonObject;
-    readonly newName: import("../../model.js").JsonObject;
-    readonly tag: import("../../model.js").JsonObject;
-    readonly variables: {
-        readonly type: "object";
-        readonly description: "Blueprint variable name to value map.";
-        readonly additionalProperties: true;
-        readonly 'x-unreal-reflection-boundary': true;
-    };
-    readonly snapshotName: import("../../model.js").JsonObject;
-    readonly className: import("../../model.js").JsonObject;
-    readonly collisionEnabled: import("../../model.js").JsonObject;
-    readonly functionName: import("../../model.js").JsonObject;
-    readonly arguments: {
-        readonly description: "Function arguments (any type).";
-    };
-    readonly childActor: import("../../model.js").JsonObject;
-    readonly parentActor: import("../../model.js").JsonObject;
-    readonly limit: import("../../model.js").JsonObject;
-    readonly filter: import("../../model.js").JsonObject;
-    readonly name: import("../../model.js").JsonObject;
-    readonly actors: {
-        readonly type: "array";
-        readonly items: {
-            readonly type: "object";
-            readonly properties: {
-                readonly label: import("../../model.js").JsonObject;
-                readonly name: import("../../model.js").JsonObject;
-                readonly path: import("../../model.js").JsonObject;
-                readonly class: import("../../model.js").JsonObject;
-            };
-            readonly additionalProperties: true;
-            readonly 'x-unreal-reflection-boundary': true;
-        };
-        readonly description: "Matched actors.";
-    };
-    readonly components: {
-        readonly type: "array";
-        readonly items: {
-            readonly type: "object";
-            readonly properties: {
-                readonly name: import("../../model.js").JsonObject;
-                readonly class: import("../../model.js").JsonObject;
-                readonly relativeLocation: import("../../model.js").JsonObject;
-                readonly relativeRotation: import("../../model.js").JsonObject;
-                readonly relativeScale: import("../../model.js").JsonObject;
-                readonly staticMesh: import("../../model.js").JsonObject;
-                readonly materials: {
-                    readonly type: "array";
-                    readonly items: {
-                        readonly type: "string";
-                    };
-                    readonly description: "Material drawn in each slot, overrides included (mesh components).";
-                };
-            };
-            readonly additionalProperties: true;
-            readonly 'x-unreal-reflection-boundary': true;
-        };
-        readonly description: "Actor components.";
-    };
-    readonly count: import("../../model.js").JsonObject;
-    readonly totalCount: import("../../model.js").JsonObject;
-    readonly excludedCount: import("../../model.js").JsonObject;
-    readonly isPieWorld: import("../../model.js").JsonObject;
-    readonly worldName: import("../../model.js").JsonObject;
-};
-export declare const DOMAIN: "actor";
-//# sourceMappingURL=properties.d.ts.map

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

@@ -1,94 +0,0 @@
-import { bool, num, str, vec3 } from '../shared/schema-props.js';
-export const P = {
-    actorName: str('Target actor name in the current level.'),
-    pieActorName: str('Target actor name in the current level; while PIE runs, PlayerPawn names the player\'s pawn (PlayerController, GameMode, GameState, PlayerState and HUD work too).'),
-    actorNames: {
-        type: 'array',
-        items: str('Actor name.'),
-        description: 'Actor names to act on (batch delete).',
-    },
-    classPath: str('Unreal class path (e.g. /Script/Engine.PointLight) for the actor to spawn.'),
-    actorClass: str('Alias of classPath accepted by the spawn handler (normalizeArgs alias).'),
-    meshPath: str('Canonical /Game mesh asset path to assign on spawn.'),
-    materialPath: str('Canonical /Game material asset path to apply.'),
-    materialSlot: num('Material slot/index to override (0-based).'),
-    materialIndex: num('Alias of materialSlot accepted by the material handlers (normalizeArgs alias).'),
-    allComponents: bool('When true, apply the material to all mesh components.'),
-    blueprintPath: str('Canonical /Game Blueprint asset path to spawn from.'),
-    location: vec3('World or relative location as [x, y, z].'),
-    rotation: vec3('Rotation as [pitch, yaw, roll] in degrees.'),
-    scale: vec3('Scale as [x, y, z].'),
-    force: vec3('Force vector to apply as [x, y, z].'),
-    offset: vec3('Spawn/duplicate offset as [x, y, z].'),
-    componentType: str('Component class to add.'),
-    componentName: str('Target component name on the actor.'),
-    propertyName: str('Component property to read or write: a name (Intensity), or a dotted path through structs at any depth (BodyInstance.CollisionEnabled, LightmassSettings.bShadowIndirectOnly). A bare name that is not on the component itself resolves to the one struct member carrying it (CollisionEnabled reads and writes BodyInstance.CollisionEnabled); a name several structs carry is refused with the full paths to choose from.'),
-    propertyPath: str('Same as propertyName (a name or a dotted path such as BodyInstance.CollisionEnabled); used when propertyName is absent.'),
-    templateBlueprintPath: str('Canonical /Game Blueprint asset path. Reads the component template on the Blueprint CDO instead of a live actor, so a Blueprint with no instance in the level can still be inspected. Supply this or actorName.'),
-    properties: {
-        type: 'object',
-        description: 'Component property key-value pairs. Each key is a name or dotted path, as propertyName takes it (BodyInstance.CollisionEnabled works).',
-        additionalProperties: true,
-        'x-unreal-reflection-boundary': true,
-    },
-    value: { description: 'Property value (any type).' },
-    visible: bool('Desired visibility state.'),
-    newName: str('New name for the duplicate or renamed actor.'),
-    tag: str('Actor tag: one entry in the Tags list of an actor (not a Gameplay Tag) to add, remove, find or delete by.'),
-    variables: {
-        type: 'object',
-        description: 'Blueprint variable name to value map.',
-        additionalProperties: true,
-        'x-unreal-reflection-boundary': true,
-    },
-    snapshotName: str('Name for the actor snapshot.'),
-    className: str('Unreal class name or path to find actors by class.'),
-    collisionEnabled: bool('Desired collision enabled state.'),
-    functionName: str('Actor function name to call.'),
-    arguments: { description: 'Function arguments (any type).' },
-    childActor: str('Child actor name to attach.'),
-    parentActor: str('Parent actor name to attach to.'),
-    limit: num('Maximum number of actors to return in a list.'),
-    filter: str('Optional name substring filter for list.'),
-    name: str('Actor name or search query.'),
-    actors: {
-        type: 'array',
-        items: {
-            type: 'object',
-            properties: {
-                label: str('Actor label.'),
-                name: str('Actor name.'),
-                path: str('Actor path.'),
-                class: str('Actor class.'),
-            },
-            additionalProperties: true,
-            'x-unreal-reflection-boundary': true,
-        },
-        description: 'Matched actors.',
-    },
-    components: {
-        type: 'array',
-        items: {
-            type: 'object',
-            properties: {
-                name: str('Component name.'),
-                class: str('Component class.'),
-                relativeLocation: vec3('Relative location [x, y, z].'),
-                relativeRotation: vec3('Relative rotation [pitch, yaw, roll].'),
-                relativeScale: vec3('Relative scale [x, y, z].'),
-                staticMesh: str('Static mesh asset path (static mesh components).'),
-                materials: { type: 'array', items: { type: 'string' }, description: 'Material drawn in each slot, overrides included (mesh components).' },
-            },
-            additionalProperties: true,
-            'x-unreal-reflection-boundary': true,
-        },
-        description: 'Actor components.',
-    },
-    count: num('Number of actors returned.'),
-    totalCount: num('Listable actors matching the filter, before the limit is applied.'),
-    excludedCount: num('Actors present in the world but never listable here: templates, transient actors, the builder brush and WorldSettings. Explains why this total is below the actorCount get_editor_state reports for the same world.'),
-    isPieWorld: bool('Whether the list was produced while a Play-In-Editor (PIE) session is active.'),
-    worldName: str('Name of the active world (or PIE world) the actors were listed from.'),
-};
-export const DOMAIN = 'actor';
-//# sourceMappingURL=properties.js.map

package/dist/tools/catalog/capabilities/records/control-actor/search-records.d.ts

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

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

@@ -1,322 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-import { DOMAIN, P } from './properties.js';
-const FAMILY_TAGS = 'tags';
-const FAMILY_FIND = 'find';
-const FIND_OUTPUT = { actors: P.actors, count: P.count };
-const FIND_BY_NAME_OUTPUT = {
-    ...FIND_OUTPUT,
-    similar: { type: 'array', items: { type: 'string' }, description: 'Only when nothing matched: up to 10 labels that contain the query once case, separators and leading zeros are ignored ("Bug1" finds Bug_01 and Bug_10).' },
-};
-const FIND_BY_ASSET_OUTPUT = {
-    actors: {
-        type: 'array',
-        items: {
-            type: 'object',
-            properties: {
-                label: { type: 'string', description: 'Actor label.' },
-                name: { type: 'string', description: 'Actor name.' },
-                path: { type: 'string', description: 'Actor path.' },
-                class: { type: 'string', description: 'Actor class.' },
-                components: {
-                    type: 'array',
-                    items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-                    description: 'The actor\'s components that matched, each {name, class}; a mesh find adds instances (how many instances an instanced or foliage component holds), a material find adds slots (the indexes of the material slots using it).',
-                },
-            },
-            additionalProperties: true,
-            'x-unreal-reflection-boundary': true,
-        },
-        description: 'Matched actors, each with the components that matched.',
-    },
-    count: P.count,
-    totalCount: { type: 'number', description: 'Present only when limit cut the list: how many actors matched in all.' },
-    truncated: { type: 'boolean', description: 'True when limit cut the list short; totalCount says how many matched.' },
-    worldSearched: { type: 'string', description: 'The world searched: the Play-In-Editor world while a session runs, else the editor world.' },
-};
-const FIND_LIMIT = { type: 'number', minimum: 1, maximum: 1000, description: 'Most actors to return (1-1000, default 200); a longer match list is cut and reports truncated and totalCount.' };
-export const SEARCH_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'add_tag',
-        domain: DOMAIN,
-        family: FAMILY_TAGS,
-        topics: ['tag actor', 'actor tag', 'label actor'],
-        summary: 'Add a gameplay tag to an actor, or to many actors at once with actorNames.',
-        whenToUse: [
-            'An actor must be tagged for later lookup or grouping.',
-            'Many deliberate compositions must be marked mcp.placement.ok for audit_placement in one call.',
-        ],
-        whenNotToUse: ['The tag is already present (idempotent re-add is a no-op).'],
-        inputProps: {
-            actorName: P.actorName,
-            actorNames: { type: 'array', items: { type: 'string' }, description: 'Several actors to tag in one call and one undo step, in place of actorName; names not found are listed back under missing, and the actors tagged under affectedActors (which the receipt lists as changes, with an actor handle each).' },
-            tag: P.tag,
-        },
-        required: ['tag'],
-        requiredOneOf: ['actorName', 'actorNames'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'add_tag', actorName: 'Cube1', tag: 'Pickup' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'remove_tag',
-        domain: DOMAIN,
-        family: FAMILY_TAGS,
-        topics: ['remove tag from actor', 'untag actor', 'delete tag'],
-        summary: 'Remove a gameplay tag from an actor.',
-        whenToUse: ['A tag must be removed from an actor.'],
-        whenNotToUse: ['The tag is not present (no-op).'],
-        inputProps: { actorName: P.actorName, tag: P.tag },
-        required: ['actorName', 'tag'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'remove_tag', actorName: 'Cube1', tag: 'Pickup' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'find_by_tag',
-        domain: DOMAIN,
-        family: FAMILY_TAGS,
-        summary: 'Find all actors in the level matching a gameplay tag.',
-        whenToUse: ['Actors sharing a tag must be located.'],
-        whenNotToUse: ['A specific actor name is known (use find_by_name).'],
-        inputProps: { tag: P.tag },
-        required: [],
-        outputProps: FIND_OUTPUT,
-        outputRequired: [],
-        effect: 'read',
-        exampleInput: { action: 'find_by_tag', tag: 'Pickup' },
-        exampleOutput: { success: true, message: 'Found 1 actors by tag', actors: [{ label: 'Cube1', name: 'Cube1' }], count: 1 },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'find_actors_by_tag',
-        domain: DOMAIN,
-        family: FAMILY_TAGS,
-        summary: 'Alias of find_by_tag. The bridge dispatches both names to the same handler.',
-        whenToUse: ['Preferred when callers use the explicit find_actors_by_tag verb.'],
-        whenNotToUse: ['Use find_by_tag to avoid alias normalization.'],
-        inputProps: { tag: P.tag },
-        required: [],
-        outputProps: FIND_OUTPUT,
-        outputRequired: [],
-        effect: 'read',
-        exampleInput: { action: 'find_actors_by_tag', tag: 'Pickup' },
-        exampleOutput: { success: true, message: 'Found 1 actors by tag', actors: [{ label: 'Cube1', name: 'Cube1' }], count: 1 },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'find_by_name',
-        domain: DOMAIN,
-        family: FAMILY_FIND,
-        topics: ['find actor', 'lookup actor by name', 'search actor', 'get actor by name'],
-        summary: 'Find actors in the level whose name matches a query string.',
-        whenToUse: ['One or more actors must be located by name or substring.'],
-        whenNotToUse: ['Actors should be located by tag (use find_by_tag).'],
-        inputProps: { name: P.name },
-        required: ['name'],
-        outputProps: FIND_BY_NAME_OUTPUT,
-        outputRequired: [],
-        effect: 'read',
-        exampleInput: { action: 'find_by_name', name: 'Cube' },
-        exampleOutput: { success: true, message: 'Found 1 actors: Cube1', actors: [{ label: 'Cube1', name: 'Cube1' }], count: 1 },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'find_actors_by_name',
-        domain: DOMAIN,
-        family: FAMILY_FIND,
-        summary: 'Alias of find_by_name. The bridge dispatches both names to the same handler.',
-        whenToUse: ['Preferred when callers use the explicit find_actors_by_name verb.'],
-        whenNotToUse: ['Use find_by_name to avoid alias normalization.'],
-        inputProps: { name: P.name },
-        required: ['name'],
-        outputProps: FIND_BY_NAME_OUTPUT,
-        outputRequired: [],
-        effect: 'read',
-        exampleInput: { action: 'find_actors_by_name', name: 'Cube' },
-        exampleOutput: { success: true, message: 'Found 1 actors: Cube1', actors: [{ label: 'Cube1', name: 'Cube1' }], count: 1 },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'find_by_class',
-        domain: DOMAIN,
-        family: FAMILY_FIND,
-        topics: ['actors of class', 'find actors by type', 'all actors of type'],
-        summary: 'Find all actors in the level matching a Unreal class name or path.',
-        whenToUse: ['All instances of a class must be located.'],
-        whenNotToUse: ['A tag-based lookup is more appropriate (use find_by_tag).'],
-        inputProps: { className: P.className, class: { type: 'string', description: 'Unreal class name or path (alias of className).' }, classPath: { type: 'string', description: 'Unreal class path (e.g. /Script/Engine.PointLight or /Game/Enemies/BP_Enemy) of the actors to find (alias of className).' } },
-        required: [],
-        requiredOneOf: ['className', 'class', 'classPath'],
-        outputProps: FIND_OUTPUT,
-        outputRequired: [],
-        effect: 'read',
-        exampleInput: { action: 'find_by_class', className: 'PointLight' },
-        exampleOutput: { success: true, message: 'Found 2 actors by class', actors: [{ label: 'Light1', name: 'Light1' }], count: 2 },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'find_actors_by_class',
-        domain: DOMAIN,
-        family: FAMILY_FIND,
-        summary: 'Alias of find_by_class. The bridge dispatches both names to the same handler.',
-        whenToUse: ['Preferred when callers use the explicit find_actors_by_class verb.'],
-        whenNotToUse: ['Use find_by_class to avoid alias normalization.'],
-        inputProps: { className: P.className, class: { type: 'string', description: 'Unreal class name or path (alias of className).' }, classPath: { type: 'string', description: 'Unreal class path (e.g. /Script/Engine.PointLight or /Game/Enemies/BP_Enemy) of the actors to find (alias of className).' } },
-        required: [],
-        requiredOneOf: ['className', 'class', 'classPath'],
-        outputProps: FIND_OUTPUT,
-        outputRequired: [],
-        effect: 'read',
-        exampleInput: { action: 'find_actors_by_class', className: 'PointLight' },
-        exampleOutput: { success: true, message: 'Found 2 actors by class', actors: [{ label: 'Light1', name: 'Light1' }], count: 2 },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'find_by_mesh',
-        domain: DOMAIN,
-        family: FAMILY_FIND,
-        topics: ['actors drawing a static mesh', 'actors with a mesh', 'instances of a mesh', 'foliage of a mesh'],
-        summary: 'Find the actors in the level that draw a static mesh (instanced and foliage components included), each with the components that do.',
-        whenToUse: [
-            'All the actors showing one static mesh must be located, to move, swap, tag or delete them.',
-            'A mesh is about to change or go away and its users must be known first.',
-        ],
-        whenNotToUse: [
-            'Actors of one class or name are wanted (use find_by_class or find_by_name).',
-            'The meshes and materials of one known actor are wanted (use get_components).',
-        ],
-        inputProps: {
-            meshPath: { type: 'string', description: 'Static mesh asset path, with or without the object name: /Game/Meshes/SM_Rock or /Engine/BasicShapes/Cube. An actor matches when a StaticMeshComponent of it (an instanced or hierarchical one too) draws exactly this mesh.' },
-            limit: FIND_LIMIT,
-        },
-        required: ['meshPath'],
-        outputProps: FIND_BY_ASSET_OUTPUT,
-        outputRequired: [],
-        effect: 'read',
-        costLatency: 'interactive',
-        exampleInput: { action: 'find_by_mesh', meshPath: '/Game/Meshes/SM_Rock' },
-        exampleOutput: { success: true, message: 'Found 1 actors using the mesh', actors: [{ label: 'Rock1', name: 'Rock1', path: '/Game/Maps/L.L:PersistentLevel.Rock1', class: '/Script/Engine.StaticMeshActor', components: [{ name: 'StaticMeshComponent0', class: 'StaticMeshComponent' }] }], count: 1 },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'find_by_material',
-        domain: DOMAIN,
-        family: FAMILY_FIND,
-        topics: ['actors showing a material', 'actors with a material in a slot'],
-        summary: 'Find the actors in the level with a component that uses a material in any slot, as an override or as its mesh\'s default, each with the components and slots that do.',
-        whenToUse: [
-            'Every actor that shows one material must be located, to restyle, retarget or audit them.',
-            'A material is about to change or go away and its users must be known first.',
-        ],
-        whenNotToUse: [
-            'The materials of one known actor are wanted (use get_components).',
-            'The assets that reference a material are wanted, not the actors placed in the level (use asset.inspect_asset with lookup=dependencies and referencers=true).',
-        ],
-        inputProps: {
-            materialPath: { type: 'string', description: 'Material or material instance asset path, with or without the object name: /Game/Materials/M_Rock. A component matches when a slot of it, an override or the mesh\'s own default, is exactly this asset or a dynamic instance made from it. Instances of a material are not followed: ask for each instance by its own path.' },
-            limit: FIND_LIMIT,
-        },
-        required: ['materialPath'],
-        outputProps: FIND_BY_ASSET_OUTPUT,
-        outputRequired: [],
-        effect: 'read',
-        costLatency: 'interactive',
-        exampleInput: { action: 'find_by_material', materialPath: '/Game/Materials/M_Rock' },
-        exampleOutput: { success: true, message: 'Found 1 actors using the material', actors: [{ label: 'Rock1', name: 'Rock1', path: '/Game/Maps/L.L:PersistentLevel.Rock1', class: '/Script/Engine.StaticMeshActor', components: [{ name: 'StaticMeshComponent0', class: 'StaticMeshComponent', slots: [0] }] }], count: 1 },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'audit_placement',
-        domain: DOMAIN,
-        family: FAMILY_FIND,
-        topics: ['placement problems', 'overlapping actors', 'sunk actors', 'floating actors', 'tilted actors', 'upside down actors', 'level audit', 'intersecting geometry', 'z-fighting', 'flickering surfaces', 'coplanar faces', 'texture flicker', 'check for floating actors', 'actors that overlap', 'sunk parts', 'parts buried in each other', 'legs inside the body', 'feet below the capsule', 'rider clipping through mount', 'blueprint part overlap'],
-        summary: 'Sweep every actor in the level and report the ones that interpenetrate another actor, sit sunk below the surface under them, float above it, lean off vertical, or have a face in the same plane as another surface (z-fighting flicker); or, with blueprintPath, the mesh parts of one actor Blueprint that are buried in each other or sunk below its capsule.',
-        whenToUse: [
-            'A level was assembled programmatically and needs checking before anyone looks at it.',
-            'Actors appear to clip through each other, stand in the ground, or lie on their side.',
-            'A placement pass should be verified without flying the viewport around to eyeball it.',
-            'Surfaces flicker, or another material shows through in ragged patches (z-fighting): the coplanar face pairs responsible are listed under coplanarFaces, with the direction to push each one; control_actor fix_coplanar fixes them all in one call.',
-            'A character, vehicle or prop is assembled from mesh components in a Blueprint (a rider on a mount, legs on a body): blueprintPath checks every part against every other on their real triangles and against the capsule bottom, so a leg sunk into the mount or a foot through the floor is named with its depth.',
-        ],
-        whenNotToUse: [
-            'One actor was just moved; spawn and set_transform already return placementWarning for it.',
-            'A finding is a deliberate composition (a keep bedding its towers into its platform, an island meant to hang in the air, a signpost leaning by design): tag that actor mcp.placement.ok with control_actor.add_tag and it drops out of the sweep entirely -- as tilt subject, and as both subject and target for overlap -- rather than being re-reported every time. Coplanar faces are still reported for tagged actors, because they flicker whatever the intent.',
-        ],
-        inputProps: {
-            nameFilter: { type: 'string', description: 'Only examine actors whose label or object name contains this text (an actor that shares its label with another is reported by object name, e.g. StaticMeshActor_75). Omit to sweep the whole level.' },
-            limit: { type: 'number', description: 'Maximum problem entries to return (1-200, default 25). Entries come worst-first, so a small limit still shows the placements that matter; flagged is always the true total.' },
-            minSeverity: { type: 'number', description: 'Drop findings whose severity (worst penetration, ground error, tilt displacement, or the side of the largest z-fighting patch, in world units) is below this. Use it to skip cosmetic grazes on a large level.' },
-            kinds: { type: 'array', items: { type: 'string', enum: ['sunk', 'floating', 'overlapping', 'unsupported', 'tilted', 'coplanar'] }, description: 'Report only these problem kinds, e.g. ["coplanar"] to list z-fighting alone in a platformer full of platforms that float on purpose. An actor whose worst problem is another kind still counts for coplanar when it has coplanarFaces. An actor whose bounds touch or overlap another actor\'s vertical face (a window band on a hall, an awning on a facade) is mounted, never floating or unsupported. Omit for every kind.' },
-            maxTilt: { type: 'number', description: 'Degrees off vertical an actor may lean before it is reported as tilted (1-90, default 30). Lean is the angle between the up vector of the actor and world up, so yaw never counts and a fully inverted actor reads 180. Raise it for a level whose props are deliberately strewn about; lower it to catch subtler leans.' },
-            blueprintPath: { type: 'string', description: 'Audit the mesh parts of this actor Blueprint instead of the level: a preview instance (the level is untouched) has every visible static mesh part measured against every other and against its ground (a Character\'s capsule bottom). problems[] then lists componentName, kind (buried: inside otherComponent; sunk: below the ground), depth and severity in cm, insideShare and the issue; minSeverity is the tolerance (default 0.5 cm), and kinds, nameFilter and maxTilt are refused (INVALID_ARGUMENT). A part tagged mcp.placement.ok in its ComponentTags is a deliberate embed (an eyeball in its socket) and is left out; mcp.placement.ok:<component> accepts the embed in that one part only and keeps every other check. Blueprint component edits report the same for the parts they touch, as partWarnings.' },
-        },
-        required: [],
-        outputProps: {
-            examined: { type: 'number', description: 'Actors inspected (mesh parts, with blueprintPath).' },
-            flagged: { type: 'number', description: 'Actors with a placement problem (part findings, with blueprintPath), before the limit.' },
-            returned: { type: 'number', description: 'Entries included in problems[].' },
-            byKind: {
-                type: 'object',
-                description: 'Count of flagged actors per problem kind: sunk, floating, overlapping, unsupported, tilted, coplanar.',
-                additionalProperties: true,
-                'x-unreal-reflection-boundary': true,
-            },
-            problems: {
-                type: 'array',
-                description: 'Findings worst-first: actorName, kind, severity in world units, the issue in words, suggestedZ when a resting height can be computed, overlappingActors when it intersects others (up to 8, each with actorName, actorClass and penetrationDepth), and coplanarFaces when faces z-fight: one entry per pair with direction (the axis both faces point along, e.g. -Y), component, otherActor, otherComponent, gap and overlapU x overlapV. Fix a pair by moving the face about 2 units along direction (this piece shows) or against it (the other shows, right for a piece sunk into it, such as a ramp in the floor), by moving or scaling the actor.',
-                items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-                'x-unreal-reflection-boundary': true,
-            },
-            truncationNote: { type: 'string', description: 'Present when the limit cut the list short; says how to reach the rest.' },
-            blueprintPath: { type: 'string', description: 'With blueprintPath: the Blueprint whose parts were measured.' },
-            groundZ: { type: 'number', description: 'With blueprintPath: the ground the parts were measured against (the capsule bottom of the preview instance); absent when the root is not a capsule.' },
-        },
-        outputRequired: [],
-        effect: 'read',
-        costLatency: 'interactive',
-        costResources: 'medium',
-        exampleInput: { action: 'audit_placement', nameFilter: 'HubNPC_' },
-        exampleOutput: { success: true, message: 'Examined 12 actors, 3 with placement problems', examined: 12, flagged: 3, returned: 3, byKind: {}, problems: [] },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'fix_coplanar',
-        domain: DOMAIN,
-        family: FAMILY_FIND,
-        topics: ['fix z-fighting', 'fix flickering', 'coplanar faces', 'texture flicker', 'overlapping faces'],
-        summary: 'Fix z-fighting in one call: every actor with a face in the same plane as another surface moves a unit, so one surface is clearly in front, repeating until nothing is left to move. A piece lying wholly inside the other face (a door on a wall) comes forward; one only partly inside (a ramp sunk into the floor) goes back so the other shows. Two parts of one Blueprint actor are parted in the Blueprint itself, so every placed copy is fixed at once.',
-        whenToUse: [
-            'audit_placement reported coplanar faces, or surfaces flicker between two materials.',
-            'A level was built from boxes placed flush against each other and should be cleaned up before anyone looks at it.',
-        ],
-        whenNotToUse: [
-            'Only some actors may move: limit the call with nameFilter. A tag of mcp.placement.ok does not exempt an actor, because no two faces flicker on purpose.',
-        ],
-        inputProps: {
-            nameFilter: { type: 'string', description: 'Only fix pairs where the label or object name of either actor contains this text. Omit for the whole level.' },
-            distance: { type: 'number', description: 'How far each face moves, in world units (0.1-20, default 1): far enough for the depth buffer, too little to see.' },
-            dryRun: { type: 'boolean', description: 'List the moves without making them (default false).' },
-        },
-        required: [],
-        outputProps: {
-            pairsFound: { type: 'number', description: 'Coplanar face pairs found before fixing.' },
-            actorsMoved: { type: 'number', description: 'Actors moved (0 under dryRun).' },
-            remainingPairs: { type: 'number', description: 'Coplanar pairs still found afterwards; run audit_placement with kinds ["coplanar"] to see them.' },
-            passes: { type: 'number', description: 'Passes made: a move can line an actor up with a neighbour that moved the same way, so the fix repeats (at most four passes; one under dryRun).' },
-            dryRun: { type: 'boolean', description: 'Whether nothing was changed.' },
-            moved: { type: 'array', description: 'One entry per actor: actorName, offset {x, y, z} it moved by, resized when both of its faces on one axis moved (for example "grew 2.0 units along X"), and pairs, each face with the other actor and whether it was brought forward or pulled back.', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, 'x-unreal-reflection-boundary': true },
-            blueprintsFixed: { type: 'array', items: { type: 'string' }, description: 'Pairs inside one Blueprint actor, fixed in the Blueprint: which part moved off which, and where it now sits in every placed copy (the Blueprint is compiled and saved).' },
-            skipped: { type: 'array', items: { type: 'string' }, description: 'Pairs left alone, each with the reason and what to do instead.' },
-        },
-        outputRequired: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        costResources: 'medium',
-        exampleInput: { action: 'fix_coplanar', dryRun: true },
-        exampleOutput: { success: true, message: 'Would move 3 actors and 1 Blueprint parts in 1 passes for 4 coplanar pairs; 4 pairs remain', pairsFound: 4, actorsMoved: 0, remainingPairs: 4, dryRun: true, moved: [], blueprintsFixed: [], skipped: [] },
-    }),
-];
-//# sourceMappingURL=search-records.js.map

package/dist/tools/catalog/capabilities/records/control-actor/spawn-records.d.ts

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