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

package/dist/tools/catalog/capabilities/records/gameplay/animation-physics/skeleton-socket-weight.data.js

@@ -1,80 +0,0 @@
-import { buildRecord } from '../helpers.js';
-import { P } from '../properties.js';
-import { A } from './animation-properties.js';
-import { num, str } from '../../shared/schema-props.js';
-const T = 'animation_physics';
-const F = 'skeleton';
-const ESU = ['EditorScriptingUtilities'];
-const MESH_REQUIRED = ['skeletalMeshPath'];
-const TRANSFER_OUT = {
-    boneVertexCounts: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'before and after: bone name to the number of vertices it influences, read back from the source data.' },
-    morphTargetsDropped: { type: 'array', items: { type: 'string' }, description: 'Render-only morph targets (made by create_morph_target or set_morph_target_deltas) the rebuild removed, only with dropRenderOnlyMorphs true; import_morph_targets writes morphs that survive.' },
-    saved: { type: 'boolean', description: 'Whether the mesh was saved.' },
-};
-export const SKELETON_SOCKET_WEIGHT_RECORDS = [
-    buildRecord({ parentTool: T, id: `${T}.create_socket`, action: 'create_socket', family: F,
-        summary: 'Create a socket on a bone.', whenToUse: ['An attach point is needed.'], whenNotToUse: ['Use an existing socket.'],
-        inputProps: { skeletonPath: P.skeletonPath, socketName: P.socketName, attachBoneName: A.attachBoneName, relativeLocation: A.relativeLocation, relativeRotation: A.relativeRotation, relativeScale: A.relativeScale, save: A.save },
-        required: ['skeletonPath', 'socketName'], effect: 'write', latency: 'interactive', resources: 'low',
-        plugins: ESU, outputProps: { socketName: P.socketName, boneName: P.boneName, skeletonPath: P.skeletonPath }, outputRequired: [],
-        exampleInput: { action: 'create_socket', skeletonPath: '/Game/SK_Char', socketName: 'Weapon', attachBoneName: 'hand_r', relativeLocation: [1, 2, 3], save: true },
-        exampleOutput: { success: true, message: 'Socket created' } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_socket`, action: 'configure_socket', family: F,
-        summary: 'Configure an existing socket transform.', whenToUse: ['Socket offset must change.'], whenNotToUse: ['Use create_socket.'],
-        inputProps: { skeletonPath: P.skeletonPath, socketName: P.socketName, attachBoneName: A.attachBoneName, relativeLocation: A.relativeLocation, relativeRotation: A.relativeRotation, relativeScale: A.relativeScale, save: A.save },
-        required: ['skeletonPath', 'socketName'], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        plugins: ESU, outputProps: { socketName: P.socketName, skeletonPath: P.skeletonPath }, outputRequired: [],
-        exampleInput: { action: 'configure_socket', skeletonPath: '/Game/SK_Char', socketName: 'Weapon', relativeLocation: [4, 5, 6], save: true },
-        exampleOutput: { success: true, message: 'Socket configured' } }),
-    buildRecord({ parentTool: T, id: `${T}.auto_skin_weights`, action: 'auto_skin_weights', family: F,
-        summary: 'Recompute LOD 0 skin weights of a skeletal mesh by smooth binding to its own skeleton (UE 5.5+ with GeometryScripting).', whenToUse: ['A mesh needs skinning.'], whenNotToUse: ['Weights already exist.', 'The weights should be copied from a dressed body mesh (use skin_mesh_to_skeleton).'],
-        inputProps: { skeletalMeshPath: P.skeletalMeshPath, save: A.save }, required: MESH_REQUIRED,
-        effect: 'write', behavior: { longRunning: true }, latency: 'long-running', resources: 'high', plugins: ESU,
-        exampleInput: { action: 'auto_skin_weights', skeletalMeshPath: '/Game/SM_Char', save: false } }),
-    buildRecord({ parentTool: T, id: `${T}.set_vertex_weights`, action: 'set_vertex_weights', family: F,
-        summary: 'Set explicit vertex skin weights.', whenToUse: ['Manual weight painting is required.'], whenNotToUse: ['Auto-skin suffices.'],
-        inputProps: { skeletalMeshPath: P.skeletalMeshPath, profileName: A.profileName, lodIndex: A.lodIndex, weights: A.weights, save: A.save },
-        required: MESH_REQUIRED, effect: 'write', behavior: { longRunning: true }, latency: 'long-running', resources: 'high',
-        plugins: ESU, exampleInput: { action: 'set_vertex_weights', skeletalMeshPath: '/Game/SM_Char', profileName: 'Default', lodIndex: 0, weights: [{ vertexIndex: 0, influences: [{ boneIndex: 0, weight: 1 }] }] },
-        exampleOutput: { success: true, message: 'Vertex weights set' } }),
-    buildRecord({ parentTool: T, id: `${T}.copy_weights`, action: 'copy_weights', family: F,
-        topics: ['copy skin weights', 'transfer weights', 'weight transfer'],
-        summary: 'Replace the skin weights of an existing skeletal mesh with those of another skinned mesh (for example the body under a garment), vertex by nearest vertex, mapping bones by name; the mesh keeps its geometry, physics asset, sockets and LODs.',
-        whenToUse: ['A new or re-modelled mesh must deform like an already skinned one.'], whenNotToUse: ['The mesh has no weights and no skinned mesh to copy from (edit auto).'],
-        inputProps: {
-            sourceMeshPath: str('Skinned mesh to copy the weights FROM (its LOD 0).'),
-            targetMeshPath: str('Skeletal mesh whose weights are replaced in place.'),
-            lodIndex: A.lodIndex, dropRenderOnlyMorphs: A.dropRenderOnlyMorphs, save: A.save,
-        },
-        required: ['sourceMeshPath', 'targetMeshPath'], effect: 'write', behavior: { longRunning: true }, latency: 'long-running', resources: 'high', plugins: ESU,
-        outputProps: { ...TRANSFER_OUT, verticesWritten: num('Target vertices that took new weights.'), verticesFarFromSource: num('Target vertices farther than 2% of the source size from any source vertex; check those areas.'), unmappedBones: { type: 'array', items: { type: 'string' }, description: 'Source bones the target lacks; their weight went to the nearest parent bone it has.' } },
-        exampleInput: { action: 'copy_weights', sourceMeshPath: '/Game/Characters/SK_Body', targetMeshPath: '/Game/Characters/SK_Jacket' } }),
-    buildRecord({ parentTool: T, id: `${T}.mirror_weights`, action: 'mirror_weights', family: F,
-        topics: ['mirror skin weights', 'symmetric weights'],
-        summary: 'Mirror the skin weights of one side of a skeletal mesh onto the other, swapping left and right bones by name (_l and _r, Left and Right, .L and .R); vertices on the symmetry plane keep their weights.',
-        whenToUse: ['One side of a symmetric character is weighted and the other must match.'], whenNotToUse: ['The mesh is not symmetric or has no left and right bones.'],
-        inputProps: {
-            skeletalMeshPath: P.skeletalMeshPath,
-            axis: str('Symmetry axis in mesh space: X (default), Y or Z.'),
-            direction: str('positive_to_negative (default: the positive side is copied onto the negative side) or negative_to_positive.'),
-            lodIndex: A.lodIndex, dropRenderOnlyMorphs: A.dropRenderOnlyMorphs, save: A.save,
-        },
-        required: MESH_REQUIRED, effect: 'write', behavior: { longRunning: true }, latency: 'long-running', resources: 'high', plugins: ESU,
-        outputProps: { ...TRANSFER_OUT, verticesMirrored: num('Vertices that took the mirrored weights.'), unmatchedVertices: num('Destination-side vertices with no mirror partner; they kept their weights.'), bonePairs: { type: 'array', items: { type: 'object', properties: { from: { type: 'string', description: 'Bone.' }, to: { type: 'string', description: 'Its opposite-side bone.' } }, additionalProperties: false }, description: 'Left and right bone pairs that were swapped.' } },
-        exampleInput: { action: 'mirror_weights', skeletalMeshPath: '/Game/Characters/SK_Hero', axis: 'X' } }),
-    buildRecord({ parentTool: T, id: `${T}.prune_weights`, action: 'prune_weights', family: F,
-        topics: ['prune weights', 'remove small influences', 'clean skin weights'],
-        summary: 'Remove skin influences below a weight threshold (each vertex keeps its strongest bone) and renormalize; a mesh with nothing below it is left untouched.',
-        whenToUse: ['Auto-skinning or a transfer left tiny noisy influences.'], whenNotToUse: ['Joints should stay soft; a high threshold stiffens them.'],
-        inputProps: { skeletalMeshPath: P.skeletalMeshPath, threshold: num('Influences below this weight are removed, above 0 and below 0.5 (default 0.01).'), lodIndex: A.lodIndex, dropRenderOnlyMorphs: A.dropRenderOnlyMorphs, save: A.save },
-        required: MESH_REQUIRED, effect: 'write', behavior: { idempotency: 'idempotent', longRunning: true }, latency: 'long-running', resources: 'high', plugins: ESU,
-        outputProps: { influencesRemoved: num('Influences removed.'), verticesChanged: num('Vertices that lost an influence.'), maxInfluencesBefore: num('Most influences on one vertex before.'), maxInfluencesAfter: num('Most influences on one vertex after.'), morphTargetsDropped: TRANSFER_OUT.morphTargetsDropped, saved: TRANSFER_OUT.saved },
-        exampleInput: { action: 'prune_weights', skeletalMeshPath: '/Game/Characters/SK_Hero', threshold: 0.02 } }),
-    buildRecord({ parentTool: T, id: `${T}.create_physics_asset`, action: 'create_physics_asset', family: F,
-        summary: 'Create a PhysicsAsset for a skeletal mesh.', whenToUse: ['Ragdoll/physics needed.'], whenNotToUse: ['PhysicsAsset exists.'],
-        inputProps: { skeletonPath: P.skeletonPath, skeletalMeshPath: P.skeletalMeshPath, outputPath: A.outputPath, name: { type: 'string', description: 'Asset name (alternative to outputPath).' }, path: { type: 'string', description: 'Destination folder (with name).' }, geomType: { type: 'string', description: 'Body primitive: Sphyl, Box, Sphere, TaperedCapsule, MultiConvexHull or SingleConvexHull.' }, minBoneSize: { type: 'number', description: 'Bones smaller than this get no body.' }, createConstraints: { type: 'boolean', description: 'Create joint constraints between bodies.' }, bodyForAll: { type: 'boolean', description: 'Create a body for every bone regardless of size.' }, assignToMesh: { type: 'boolean', description: 'Assign the new asset to the skeletal mesh.' }, save: A.save }, required: [],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: ESU,
-        outputProps: { assetPath: P.assetPath, physicsAssetPath: P.physicsAssetPath }, outputRequired: [],
-        exampleInput: { action: 'create_physics_asset', skeletalMeshPath: '/Game/SM_Char', outputPath: '/Game/PA_Char', save: true }, exampleOutput: { success: true, message: 'PhysicsAsset created', assetPath: '/Game/PA_Char' } }),
-];
-//# sourceMappingURL=skeleton-socket-weight.data.js.map

package/dist/tools/catalog/capabilities/records/gameplay/animation-physics/skeleton.data.d.ts

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

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

@@ -1,11 +0,0 @@
-import { SKELETON_BONE_RECORDS } from './skeleton-bone.data.js';
-import { SKELETON_SOCKET_WEIGHT_RECORDS } from './skeleton-socket-weight.data.js';
-import { SKELETON_PHYSICS_MORPH_RECORDS } from './skeleton-physics-morph.data.js';
-import { SKELETON_READ_ALIAS_RECORDS } from './skeleton-read-alias.data.js';
-export const SKELETON_RECORDS = [
-    ...SKELETON_BONE_RECORDS,
-    ...SKELETON_SOCKET_WEIGHT_RECORDS,
-    ...SKELETON_PHYSICS_MORPH_RECORDS,
-    ...SKELETON_READ_ALIAS_RECORDS,
-];
-//# sourceMappingURL=skeleton.data.js.map

package/dist/tools/catalog/capabilities/records/gameplay/helpers.d.ts

@@ -1,10 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-import { type CoreRecordSpec } from '../core/builder.js';
-export type RecordSpec = Omit<CoreRecordSpec, 'domain' | 'bareInput' | 'costLatency' | 'costResources' | 'required' | 'id'> & {
-    readonly id: string;
-    readonly required: readonly string[];
-    readonly latency: NonNullable<CoreRecordSpec['costLatency']>;
-    readonly resources: NonNullable<CoreRecordSpec['costResources']>;
-};
-export declare const buildRecord: ({ latency, resources, ...spec }: RecordSpec) => CapabilityRecordSource;
-//# sourceMappingURL=helpers.d.ts.map

package/dist/tools/catalog/capabilities/records/gameplay/helpers.js

@@ -1,3 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-export const buildRecord = ({ latency, resources, ...spec }) => buildCoreRecord({ ...spec, domain: spec.parentTool.replace(/_/g, ' '), bareInput: true, costLatency: latency, costResources: resources });
-//# sourceMappingURL=helpers.js.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-ai/add-actions.data.d.ts

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

package/dist/tools/catalog/capabilities/records/gameplay/manage-ai/add-actions.data.js

@@ -1,200 +0,0 @@
-import { BT, EQS, MASS_AI, SMART_OBJECTS, STATE_TREE, aiRecord } from './builder.js';
-import { AI } from './properties.js';
-const A = AI;
-export const AI_ADD_RECORDS = [
-    aiRecord({
-        action: 'add_ai_perception_component', summary: 'Add an AI perception component to a Blueprint asset.',
-        use: 'A Blueprint needs an AIPerception component before senses are configured.',
-        avoid: 'Use setup_perception to add and configure senses in one call.',
-        props: { blueprintPath: A.blueprintPath }, required: ['blueprintPath'],
-        out: { blueprintPath: A.blueprintPath },
-        example: { blueprintPath: '/Game/AI/BP_Enemy' }, result: 'Perception component added',
-    }),
-    aiRecord({
-        action: 'add_blackboard_key', summary: 'Add a typed key to a Blackboard asset.',
-        use: 'A Blackboard needs a new typed entry.',
-        avoid: 'Use set_key_instance_synced to change sync on an existing key.',
-        props: {
-            blackboardPath: A.blackboardPath, keyName: A.keyName, keyType: A.keyType,
-            baseObjectClass: A.baseObjectClass, isInstanceSynced: A.isInstanceSynced,
-        },
-        required: ['blackboardPath', 'keyName', 'keyType'], plugins: BT,
-        out: { assetPath: A.assetPath },
-        example: { blackboardPath: '/Game/AI/BB_Enemy', keyName: 'TargetActor', keyType: 'Object' },
-        result: 'Blackboard key added',
-    }),
-    aiRecord({
-        action: 'add_composite_node', summary: 'Add a composite node to a Behavior Tree asset.',
-        use: 'A Behavior Tree needs a Selector or Sequence branch.',
-        avoid: 'Use add_task_node for leaf behavior.',
-        props: {
-            behaviorTreePath: A.behaviorTreePath,
-            compositeType: A.compositeType,
-            nodeName: { type: 'string', description: 'Name for the created composite node.' },
-            parentNodeId: A.parentNodeId,
-        },
-        required: ['behaviorTreePath', 'compositeType'], plugins: BT,
-        out: {
-            assetPath: A.assetPath,
-            nodeName: { type: 'string', description: 'Resolved name of the created composite node.' },
-            isRoot: { type: 'boolean', description: 'Whether this node became the tree root.' },
-        },
-        example: { behaviorTreePath: '/Game/AI/BT_Enemy', compositeType: 'Sequence', nodeName: 'RootSelector' },
-        result: 'Composite node added',
-    }),
-    aiRecord({
-        action: 'add_decorator', summary: 'Add a decorator to a Behavior Tree node, or to the root when no node is named.',
-        use: 'A Behavior Tree branch needs a conditional gate.',
-        avoid: 'Use add_service for recurring background ticks.',
-        props: {
-            behaviorTreePath: A.behaviorTreePath, decoratorType: A.decoratorType,
-            parentNodeId: { type: 'string', description: "Composite or task node the decorator guards (a nodeId from add_composite or add_task); omit or pass 'root' for a root decorator." },
-        },
-        required: ['behaviorTreePath', 'decoratorType'], plugins: BT,
-        out: { assetPath: A.assetPath },
-        example: { behaviorTreePath: '/Game/AI/BT_Enemy', decoratorType: 'Blackboard' },
-        result: 'Decorator added',
-    }),
-    aiRecord({
-        action: 'add_eqs_context', summary: 'Add a context to an Environment Query.',
-        use: 'An Environment Query needs a querier or item context.',
-        avoid: 'Use add_eqs_generator to produce the item set.',
-        props: { queryPath: A.queryPath, contextType: A.contextType },
-        required: ['queryPath', 'contextType'], plugins: EQS,
-        out: { assetPath: A.assetPath },
-        example: { queryPath: '/Game/AI/EQS_Cover', contextType: 'Querier' }, result: 'EQS context added',
-    }),
-    aiRecord({
-        action: 'add_eqs_generator', summary: 'Add a generator to an Environment Query.',
-        use: 'An Environment Query needs its candidate item set.',
-        avoid: 'Use add_eqs_test to score existing items.',
-        props: {
-            queryPath: A.queryPath, generatorType: A.generatorType,
-            generatorSettings: A.generatorSettings,
-        },
-        required: ['queryPath', 'generatorType'], plugins: EQS,
-        out: { assetPath: A.assetPath },
-        example: { queryPath: '/Game/AI/EQS_Cover', generatorType: 'ActorsOfClass' },
-        result: 'EQS generator added',
-    }),
-    aiRecord({
-        action: 'add_eqs_test', summary: 'Add a test to an Environment Query.',
-        use: 'Generated Environment Query items need scoring or filtering.',
-        avoid: 'Use configure_test_scoring to tune a test that already exists.',
-        props: { queryPath: A.queryPath, testType: A.testType },
-        required: ['queryPath', 'testType'], plugins: EQS,
-        out: { assetPath: A.assetPath },
-        example: { queryPath: '/Game/AI/EQS_Cover', testType: 'Distance' }, result: 'EQS test added',
-    }),
-    aiRecord({
-        action: 'add_mass_spawner', summary: 'Add Mass spawner reference variables to a Blueprint asset (no AMassSpawner actor is placed).',
-        use: 'A Blueprint should spawn Mass entities from a config.',
-        avoid: 'Use configure_mass_entity to edit the config itself.',
-        props: {
-            blueprintPath: A.blueprintPath, configPath: A.configPath,
-            componentName: A.componentName, spawnCount: A.spawnCount,
-        },
-        required: ['blueprintPath'], plugins: MASS_AI,
-        out: { blueprintPath: A.blueprintPath },
-        example: { blueprintPath: '/Game/AI/BP_Crowd', spawnCount: 100 }, result: 'Mass spawner added',
-    }),
-    aiRecord({
-        action: 'add_node', summary: 'Add a node through the Behavior Tree graph route.',
-        use: 'A Behavior Tree graph needs a node placed at explicit coordinates.',
-        avoid: 'Use add_task_node or add_composite_node for the asset-level route.',
-        props: {
-            assetPath: A.assetPath, behaviorTreePath: A.behaviorTreePath, nodeType: A.nodeType,
-            nodeId: A.nodeId, x: A.x, y: A.y,
-        },
-        requiredOneOf: ['assetPath', 'behaviorTreePath'], plugins: BT,
-        out: { nodeId: A.nodeId },
-        example: { assetPath: '/Game/AI/BT_Enemy', nodeType: 'Sequence', x: 0, y: 0 },
-        result: 'Graph node added',
-    }),
-    aiRecord({
-        action: 'add_service', summary: 'Add a service to a Behavior Tree asset.',
-        use: 'A Behavior Tree branch needs recurring background work.',
-        avoid: 'Use add_decorator for a pass/fail condition.',
-        props: { behaviorTreePath: A.behaviorTreePath, serviceType: A.serviceType },
-        required: ['behaviorTreePath', 'serviceType'], plugins: BT,
-        out: { assetPath: A.assetPath },
-        example: { behaviorTreePath: '/Game/AI/BT_Enemy', serviceType: 'DefaultFocus' },
-        result: 'Service added',
-    }),
-    aiRecord({
-        action: 'add_smart_object_component', summary: 'Add a Smart Object component to a Blueprint asset.',
-        use: 'An actor Blueprint should expose a Smart Object definition.',
-        avoid: 'Use create_smart_object_definition to author the definition asset.',
-        props: {
-            blueprintPath: A.blueprintPath,
-            definitionPath: A.definitionPath, componentName: A.componentName,
-        },
-        required: ['blueprintPath'], plugins: SMART_OBJECTS,
-        out: { blueprintPath: A.blueprintPath },
-        example: { blueprintPath: '/Game/AI/BP_Bench' }, result: 'Smart Object component added',
-    }),
-    aiRecord({
-        action: 'add_smart_object_slot', summary: 'Add a slot to a Smart Object definition.',
-        use: 'A Smart Object definition needs another interaction slot.',
-        avoid: 'Use configure_slot_behavior to edit an existing slot.',
-        props: {
-            definitionPath: A.definitionPath,
-            offset: A.offset, rotation: A.rotation, enabled: A.enabled,
-        },
-        required: ['definitionPath'], plugins: SMART_OBJECTS,
-        out: { definitionPath: A.definitionPath },
-        example: { definitionPath: '/Game/AI/SO_Bench', enabled: true }, result: 'Smart Object slot added',
-    }),
-    aiRecord({
-        action: 'add_state_tree_state', summary: 'Add a state to a StateTree asset.',
-        use: 'A StateTree needs another state under a parent.',
-        avoid: 'Use add_state_tree_transition to link existing states.',
-        props: {
-            stateTreePath: A.stateTreePath, stateName: A.stateName,
-            parentStateName: A.parentStateName, stateType: A.stateType,
-        },
-        required: ['stateTreePath', 'stateName'], plugins: STATE_TREE,
-        out: { assetPath: A.assetPath },
-        example: { stateTreePath: '/Game/AI/ST_Enemy', stateName: 'Patrol' }, result: 'State added',
-    }),
-    aiRecord({
-        action: 'add_state_tree_transition', summary: 'Add a transition to a StateTree asset.',
-        use: 'Two StateTree states need a trigger-driven link.',
-        avoid: 'Use add_state_tree_state to create the endpoints first.',
-        props: {
-            stateTreePath: A.stateTreePath, fromState: A.fromState,
-            toState: A.toState, triggerType: A.triggerType,
-        },
-        required: ['stateTreePath', 'fromState', 'toState'], plugins: STATE_TREE,
-        out: { assetPath: A.assetPath },
-        example: { stateTreePath: '/Game/AI/ST_Enemy', fromState: 'Root', toState: 'Patrol' },
-        result: 'Transition added',
-    }),
-    aiRecord({
-        action: 'add_subnode', summary: 'Add a Behavior Tree decorator or service subnode.',
-        use: 'A graph node needs a decorator or service attached by class.',
-        avoid: 'Use add_decorator or add_service for the asset-level route.',
-        props: {
-            assetPath: A.assetPath, behaviorTreePath: A.behaviorTreePath,
-            parentNodeId: A.parentNodeId, subnodeType: A.subnodeType, nodeClass: A.nodeClass,
-        },
-        required: ['parentNodeId', 'subnodeType', 'nodeClass'],
-        requiredOneOf: ['assetPath', 'behaviorTreePath'], plugins: BT,
-        out: { nodeId: A.nodeId },
-        example: {
-            assetPath: '/Game/AI/BT_Enemy', parentNodeId: 'BTComposite_Selector_0',
-            subnodeType: 'Decorator', nodeClass: '/Script/AIModule.BTDecorator_Blackboard',
-        },
-        result: 'Subnode added',
-    }),
-    aiRecord({
-        action: 'add_task_node', summary: 'Add a task node to a Behavior Tree asset.',
-        use: 'A Behavior Tree branch needs a leaf task.',
-        avoid: 'Use add_composite_node for flow control.',
-        props: { behaviorTreePath: A.behaviorTreePath, taskType: A.taskType, parentNodeId: A.parentNodeId },
-        required: ['behaviorTreePath', 'taskType'], plugins: BT,
-        out: { assetPath: A.assetPath, nodeId: A.nodeId },
-        example: { behaviorTreePath: '/Game/AI/BT_Enemy', taskType: 'Wait' }, result: 'Task node added',
-    }),
-];
-//# sourceMappingURL=add-actions.data.js.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-ai/builder.d.ts

@@ -1,24 +0,0 @@
-import type { CapabilityRecordSource, JsonObject } from '../../../model.js';
-import type { PropertyMap } from '../properties.js';
-export declare const BT: readonly ["BehaviorTreeEditor"];
-export declare const EQS: readonly ["EnvironmentQueryEditor"];
-export declare const STATE_TREE: readonly ["StateTree"];
-export declare const SMART_OBJECTS: readonly ["SmartObjects"];
-export declare const MASS_AI: readonly ["MassAI"];
-export type AiRecordSpec = {
-    readonly action: string;
-    readonly summary: string;
-    readonly topics?: readonly string[];
-    readonly use: string;
-    readonly avoid: string;
-    readonly props: PropertyMap;
-    readonly required?: readonly string[];
-    readonly requiredOneOf?: readonly string[];
-    readonly out?: PropertyMap;
-    readonly effect?: 'read' | 'write';
-    readonly plugins?: readonly string[];
-    readonly example: JsonObject;
-    readonly result: string;
-};
-export declare function aiRecord(spec: AiRecordSpec): CapabilityRecordSource;
-//# sourceMappingURL=builder.d.ts.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-ai/builder.js

@@ -1,34 +0,0 @@
-import { buildRecord } from '../helpers.js';
-const T = 'manage_ai';
-const F = 'ai';
-export const BT = ['BehaviorTreeEditor'];
-export const EQS = ['EnvironmentQueryEditor'];
-export const STATE_TREE = ['StateTree'];
-export const SMART_OBJECTS = ['SmartObjects'];
-export const MASS_AI = ['MassAI'];
-export function aiRecord(spec) {
-    const effect = spec.effect ?? 'write';
-    return buildRecord({
-        parentTool: T,
-        id: `${T}.${spec.action}`,
-        action: spec.action,
-        family: F,
-        summary: spec.summary,
-        topics: spec.topics,
-        whenToUse: [spec.use],
-        whenNotToUse: [spec.avoid],
-        inputProps: spec.props,
-        required: spec.required ?? [],
-        ...(spec.requiredOneOf === undefined ? {} : { requiredOneOf: spec.requiredOneOf }),
-        outputProps: spec.out,
-        outputRequired: [],
-        effect,
-        latency: 'interactive',
-        resources: 'medium',
-        plugins: spec.plugins,
-        editorStates: ['edit'],
-        exampleInput: { action: spec.action, ...spec.example },
-        exampleOutput: { success: true, message: spec.result },
-    });
-}
-//# sourceMappingURL=builder.js.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-ai/configure-actions.data.d.ts

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

package/dist/tools/catalog/capabilities/records/gameplay/manage-ai/configure-actions.data.js

@@ -1,203 +0,0 @@
-import { BT, EQS, MASS_AI, SMART_OBJECTS, STATE_TREE, aiRecord } from './builder.js';
-import { NAV } from './properties-navigation.js';
-import { AI } from './properties.js';
-const A = AI;
-const N = NAV;
-export const AI_CONFIGURE_RECORDS = [
-    aiRecord({
-        action: 'assign_behavior_tree', summary: 'Store a Behavior Tree reference variable on an AIController asset (run it from BeginPlay with RunBehaviorTree).',
-        use: 'A controller asset should run a specific Behavior Tree.',
-        avoid: 'Use assign_blackboard to bind the Blackboard.',
-        props: { controllerPath: A.controllerPath, behaviorTreePath: A.behaviorTreePath },
-        required: ['controllerPath', 'behaviorTreePath'], plugins: BT,
-        out: { assetPath: A.assetPath },
-        example: { controllerPath: '/Game/AI/AIC_Enemy', behaviorTreePath: '/Game/AI/BT_Enemy' },
-        result: 'Behavior Tree assigned',
-    }),
-    aiRecord({
-        action: 'assign_blackboard', summary: 'Assign a Blackboard to an AIController or Behavior Tree asset.',
-        use: 'A controller or Behavior Tree needs its Blackboard bound.',
-        avoid: 'Use add_blackboard_key to author the Blackboard contents.',
-        props: {
-            blackboardPath: A.blackboardPath,
-            controllerPath: A.controllerPath, behaviorTreePath: A.behaviorTreePath,
-        },
-        required: ['blackboardPath'], plugins: BT,
-        out: { assetPath: A.assetPath },
-        example: { behaviorTreePath: '/Game/AI/BT_Enemy', blackboardPath: '/Game/AI/BB_Enemy' },
-        result: 'Blackboard assigned',
-    }),
-    aiRecord({
-        action: 'break_connections', summary: 'Break Behavior Tree graph connections.',
-        use: 'A graph node must be detached from its links.',
-        avoid: 'Use remove_node to delete the node outright.',
-        props: { assetPath: A.assetPath, behaviorTreePath: A.behaviorTreePath, nodeId: A.nodeId },
-        requiredOneOf: ['assetPath', 'behaviorTreePath'], plugins: BT,
-        out: { assetPath: A.assetPath },
-        example: { assetPath: '/Game/AI/BT_Enemy', nodeId: 'Node_0' }, result: 'Connections broken',
-    }),
-    aiRecord({
-        action: 'clear_focus', summary: 'Clear the authored focus target on an AIController asset.',
-        use: 'A controller asset should stop targeting a focus actor.',
-        avoid: 'Use set_focus to assign a target.',
-        props: { controllerPath: A.controllerPath }, required: ['controllerPath'],
-        out: { assetPath: A.assetPath },
-        example: { controllerPath: '/Game/AI/AIC_Enemy' }, result: 'Focus cleared',
-    }),
-    aiRecord({
-        action: 'configure_bt_node', summary: 'Configure a Behavior Tree node.',
-        use: 'An existing Behavior Tree node needs property edits.',
-        avoid: 'Use set_node_properties for the graph route.',
-        props: {
-            behaviorTreePath: A.behaviorTreePath,
-            nodeId: A.nodeId, properties: A.properties,
-        },
-        required: ['behaviorTreePath', 'nodeId'], plugins: BT,
-        out: { assetPath: A.assetPath },
-        example: { behaviorTreePath: '/Game/AI/BT_Enemy', nodeId: 'Root' }, result: 'Node configured',
-    }),
-    aiRecord({
-        action: 'configure_damage_sense_config', summary: 'Configure damage perception on a Blueprint asset.',
-        use: 'An AIPerception component needs damage-sense tuning.',
-        avoid: 'Use configure_sight_config or configure_hearing_config for other senses.',
-        props: { blueprintPath: A.blueprintPath, damageConfig: A.damageConfig },
-        required: ['blueprintPath'],
-        out: { blueprintPath: A.blueprintPath },
-        example: { blueprintPath: '/Game/AI/BP_Enemy', damageConfig: { maxAge: 10 } },
-        result: 'Damage sense configured',
-    }),
-    aiRecord({
-        action: 'configure_hearing_config', summary: 'Configure hearing perception on a Blueprint asset.',
-        use: 'An AIPerception component needs hearing-sense tuning.',
-        avoid: 'Use setup_perception to configure several senses at once.',
-        props: {
-            blueprintPath: A.blueprintPath,
-            hearingConfig: A.hearingConfig, hearingRange: A.hearingRange,
-        },
-        required: ['blueprintPath'],
-        out: { blueprintPath: A.blueprintPath },
-        example: { blueprintPath: '/Game/AI/BP_Enemy', hearingConfig: { hearingRange: 2000 } },
-        result: 'Hearing sense configured',
-    }),
-    aiRecord({
-        action: 'configure_mass_entity', summary: 'Configure a Mass Entity config: parent config and trait properties.',
-        use: 'A Mass Entity config needs its parent config set.',
-        avoid: 'Use add_mass_spawner to spawn from the config.',
-        props: { configPath: A.configPath, parentConfigPath: { type: 'string', description: 'Parent Mass entity config asset to inherit from.' }, traitClass: { type: 'string', description: 'Trait class name whose properties are configured.' }, traitIndex: { type: 'number', description: 'Zero-based trait index (alternative to traitClass).' }, properties: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Trait property values keyed by UPROPERTY name.' } }, required: ['configPath'], plugins: MASS_AI,
-        out: { configPath: A.configPath },
-        example: { configPath: '/Game/AI/Mass/MEC_Crowd' }, result: 'Mass entity configured',
-    }),
-    aiRecord({
-        action: 'configure_nav_area_cost', summary: 'Configure navigation area cost data.',
-        use: 'A navigation area class needs a different traversal cost.',
-        avoid: 'Use set_nav_area_class to apply an area to an actor.',
-        props: {
-            areaClass: N.areaClass, areaCost: N.areaCost,
-            fixedAreaEnteringCost: { type: 'number', description: 'Flat cost added once when a path enters the area; left unchanged when omitted.' },
-        },
-        required: ['areaClass'],
-        example: { areaClass: '/Script/NavigationSystem.NavArea_Obstacle', areaCost: 1 },
-        result: 'Nav area cost configured',
-    }),
-    aiRecord({
-        action: 'configure_nav_link', summary: 'Configure an authored navigation link.',
-        use: 'A placed nav link actor needs endpoint or snap tuning.',
-        avoid: 'Use create_nav_link_proxy to place the link first.',
-        props: {
-            actorName: A.actorName, startPoint: N.startPoint,
-            endPoint: N.endPoint, direction: N.direction, snapRadius: N.snapRadius,
-        },
-        required: ['actorName'],
-        out: { actorName: A.actorName },
-        example: { actorName: 'NavLinkProxy_0', snapRadius: 30 }, result: 'Nav link configured',
-    }),
-    aiRecord({
-        action: 'configure_nav_mesh_settings', summary: 'Configure project NavMesh generation settings.',
-        use: 'The loaded level RecastNavMesh needs generation tuning.',
-        avoid: 'Use set_nav_agent_properties for agent dimensions.',
-        props: {
-            cellSize: N.cellSize, cellHeight: N.cellHeight, tileSizeUU: N.tileSizeUU,
-            minRegionArea: N.minRegionArea, mergeRegionSize: N.mergeRegionSize,
-            maxSimplificationError: N.maxSimplificationError, agentStepHeight: N.agentStepHeight,
-        },
-        example: { cellSize: 19, cellHeight: 10, tileSizeUU: 1000 }, result: 'NavMesh settings configured',
-    }),
-    aiRecord({
-        action: 'configure_sight_config', summary: 'Configure sight perception on a Blueprint asset.',
-        use: 'An AIPerception component needs sight-sense tuning.',
-        avoid: 'Use setup_perception to configure several senses at once.',
-        props: {
-            blueprintPath: A.blueprintPath, sightConfig: A.sightConfig,
-            sightRadius: A.sightRadius, loseSightRadius: A.loseSightRadius,
-            peripheralVisionAngle: A.peripheralVisionAngle,
-        },
-        required: ['blueprintPath'],
-        out: { blueprintPath: A.blueprintPath },
-        example: { blueprintPath: '/Game/AI/BP_Enemy', sightConfig: { sightRadius: 3000 } },
-        result: 'Sight sense configured',
-    }),
-    aiRecord({
-        action: 'configure_slot_behavior', summary: 'Configure Smart Object slot behavior.',
-        use: 'An existing Smart Object slot needs enable/index edits.',
-        avoid: 'Use add_smart_object_slot to create the slot.',
-        props: {
-            definitionPath: A.definitionPath,
-            slotIndex: A.slotIndex, enabled: A.enabled,
-            activityTags: { type: 'array', items: { type: 'string' }, description: 'Registered gameplay tags added to the slot activity tags; an unregistered tag fails the call.' },
-        },
-        required: ['definitionPath'], plugins: SMART_OBJECTS,
-        out: { definitionPath: A.definitionPath },
-        example: { definitionPath: '/Game/AI/SO_Bench', slotIndex: 0, enabled: true },
-        result: 'Slot behavior configured',
-    }),
-    aiRecord({
-        action: 'configure_smart_link_behavior', summary: 'Configure smart navigation link behavior.',
-        use: 'A smart link needs area-class switching or an obstacle.',
-        avoid: 'Use configure_nav_link for a simple link.',
-        props: {
-            actorName: A.actorName, linkEnabled: N.linkEnabled,
-            enabledAreaClass: N.enabledAreaClass, disabledAreaClass: N.disabledAreaClass,
-            broadcastRadius: N.broadcastRadius, broadcastInterval: N.broadcastInterval,
-            bCreateBoxObstacle: N.bCreateBoxObstacle, obstacleAreaClass: N.obstacleAreaClass,
-            obstacleExtent: N.obstacleExtent, obstacleOffset: N.obstacleOffset,
-        },
-        required: ['actorName'],
-        out: { actorName: A.actorName },
-        example: { actorName: 'SmartLink_0', linkEnabled: true }, result: 'Smart link behavior configured',
-    }),
-    aiRecord({
-        action: 'configure_state_tree_task', summary: 'Configure a StateTree task by setting its instance properties or the state selection behavior.',
-        use: 'A StateTree state needs its task settings changed.',
-        avoid: 'Use add_state_tree_state to create the state.',
-        props: { stateTreePath: A.stateTreePath, stateName: A.stateName, taskName: { type: 'string', description: 'Task to configure, matched by class or instance name (defaults to the first task).' }, taskIndex: { type: 'number', description: 'Zero-based task index in the state (alternative to taskName).' }, selectionBehavior: { type: 'string', description: 'State selection behavior (e.g. TryEnterState, TrySelectChildrenInOrder, TryFollowTransitions).' }, properties: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Task property values keyed by UPROPERTY name, imported by reflection onto the task instance.' } },
-        required: ['stateTreePath', 'stateName'], plugins: STATE_TREE,
-        out: { assetPath: A.assetPath },
-        example: { stateTreePath: '/Game/AI/ST_Enemy', stateName: 'Patrol' }, result: 'StateTree task configured',
-    }),
-    aiRecord({
-        action: 'configure_test_scoring', summary: 'Configure Environment Query test scoring.',
-        use: 'An existing Environment Query test needs scoring or filter tuning.',
-        avoid: 'Use add_eqs_test to create the test.',
-        props: {
-            queryPath: A.queryPath,
-            testIndex: A.testIndex, testSettings: A.testSettings,
-        },
-        required: ['queryPath'], plugins: EQS,
-        out: { assetPath: A.assetPath },
-        example: { queryPath: '/Game/AI/EQS_Cover', testIndex: 0 }, result: 'Test scoring configured',
-    }),
-    aiRecord({
-        action: 'connect_nodes', summary: 'Connect Behavior Tree graph nodes.',
-        use: 'A parent graph node must be linked to a child.',
-        avoid: 'Use break_connections to detach them again.',
-        props: {
-            assetPath: A.assetPath, behaviorTreePath: A.behaviorTreePath,
-            parentNodeId: A.parentNodeId, childNodeId: A.childNodeId,
-        },
-        requiredOneOf: ['assetPath', 'behaviorTreePath'], plugins: BT,
-        out: { assetPath: A.assetPath },
-        example: { assetPath: '/Game/AI/BT_Enemy', parentNodeId: 'Node_0', childNodeId: 'Node_1' },
-        result: 'Nodes connected',
-    }),
-];
-//# sourceMappingURL=configure-actions.data.js.map

package/dist/tools/catalog/capabilities/records/gameplay/manage-ai/create-read-actions.data.d.ts

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