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

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

@@ -1,233 +0,0 @@
-import { BT, EQS, MASS_AI, SMART_OBJECTS, STATE_TREE, aiRecord } from './builder.js';
-import { NAV } from './properties-navigation.js';
-import { AI, xyz } from './properties.js';
-const A = AI;
-const N = NAV;
-const reflObj = { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true };
-const createProps = { name: A.name, path: A.path };
-export const AI_CREATE_READ_RECORDS = [
-    aiRecord({
-        action: 'create', summary: 'Create a Behavior Tree through the graph compatibility route.',
-        use: 'A caller uses the short create verb with savePath.',
-        avoid: 'Use create_behavior_tree for the asset-level route.',
-        props: { name: A.name, savePath: A.savePath }, required: ['name'], plugins: BT,
-        out: { assetPath: A.assetPath },
-        example: { name: 'BT_Enemy', savePath: '/Game/AI' }, result: 'Behavior Tree created',
-    }),
-    aiRecord({
-        topics: ['ai controller', 'aicontroller', 'npc controller', 'enemy ai', 'add enemy ai'],
-        action: 'create_ai_controller', summary: 'Create an AIController Blueprint asset.',
-        use: 'A pawn needs a dedicated AIController asset.',
-        avoid: 'Use manage_blueprint for a general Blueprint.',
-        props: createProps, required: ['name'],
-        out: { assetPath: A.assetPath },
-        example: { name: 'AIC_Enemy', path: '/Game/AI' }, result: 'AIController created',
-    }),
-    aiRecord({
-        topics: ['behavior tree', 'bt asset', 'ai behavior', 'new behavior tree'],
-        action: 'create_behavior_tree', summary: 'Create a Behavior Tree asset.',
-        use: 'An AI needs a new Behavior Tree asset.',
-        avoid: 'Use create for the graph compatibility route.',
-        props: createProps, required: ['name'], plugins: BT,
-        out: { behaviorTreePath: A.behaviorTreePath },
-        example: { name: 'BT_Enemy', path: '/Game/AI' }, result: 'Behavior Tree created',
-    }),
-    aiRecord({
-        action: 'create_blackboard', summary: 'Create a Blackboard asset through the compatibility route.',
-        use: 'A caller uses the short create_blackboard verb.',
-        avoid: 'Use create_blackboard_asset for the canonical route.',
-        props: createProps, required: ['name'], plugins: BT,
-        out: {
-            blackboardPath: A.blackboardPath,
-            alreadyExisted: { type: 'boolean', description: 'Whether the Blackboard already existed and was reused.' },
-        },
-        example: { name: 'BB_Enemy', path: '/Game/AI' }, result: 'Blackboard created',
-    }),
-    aiRecord({
-        action: 'create_blackboard_asset', summary: 'Create a Blackboard data asset.',
-        use: 'A Behavior Tree needs a backing Blackboard asset.',
-        avoid: 'Use add_blackboard_key to populate it.',
-        props: createProps, required: ['name'], plugins: BT,
-        out: { blackboardPath: A.blackboardPath },
-        example: { name: 'BB_Enemy', path: '/Game/AI' }, result: 'Blackboard created',
-    }),
-    aiRecord({
-        action: 'create_eqs_query', summary: 'Create an Environment Query asset.',
-        use: 'An AI needs a spatial query asset.',
-        avoid: 'Use add_eqs_generator to give the query an item set.',
-        props: createProps, required: ['name'], plugins: EQS,
-        out: { assetPath: A.assetPath },
-        example: { name: 'EQS_Cover', path: '/Game/AI' }, result: 'Environment Query created',
-    }),
-    aiRecord({
-        action: 'create_mass_entity_config', summary: 'Create a Mass Entity configuration asset.',
-        use: 'Crowd simulation needs an entity config asset.',
-        avoid: 'Use configure_mass_entity to edit an existing config.',
-        props: createProps, required: ['name'], plugins: MASS_AI,
-        out: { configPath: A.configPath },
-        example: { name: 'MEC_Crowd', path: '/Game/AI/Mass' }, result: 'Mass entity config created',
-    }),
-    aiRecord({
-        action: 'create_nav_link_proxy', summary: 'Create a NavLinkProxy actor in the editor world.',
-        use: 'A level needs an authored navigation link between two points.',
-        avoid: 'Use create_smart_link for a state-switching link.',
-        props: {
-            actorName: A.actorName, location: N.location, rotation: A.rotation,
-            startPoint: N.startPoint, endPoint: N.endPoint, direction: N.direction,
-        },
-        out: { actorName: A.actorName },
-        example: { actorName: 'NavLinkProxy_0', location: { x: 0, y: 0, z: 100 } },
-        result: 'NavLinkProxy created',
-    }),
-    aiRecord({
-        action: 'create_nav_modifier_component', summary: 'Add a navigation modifier component to a Blueprint asset or to a placed actor.',
-        use: 'A Blueprint or a placed actor should carve or alter navigation around itself.',
-        avoid: 'Use set_nav_area_class to change the area of an existing component.',
-        props: {
-            blueprintPath: A.blueprintPath,
-            actorName: { type: 'string', description: 'Placed actor that receives an instance component when no blueprintPath is given.' },
-            componentName: A.componentName,
-            areaClass: N.areaClass, failsafeExtent: N.failsafeExtent,
-            save: { type: 'boolean', description: 'Save the Blueprint asset after adding the component (Blueprint form only).' },
-        },
-        requiredOneOf: ['blueprintPath', 'actorName'],
-        out: { blueprintPath: A.blueprintPath, actorName: A.actorName },
-        example: { blueprintPath: '/Game/AI/BP_Blocker', componentName: 'NavModifier' },
-        result: 'Nav modifier component added',
-    }),
-    aiRecord({
-        action: 'create_smart_link', summary: 'Create a smart navigation link.',
-        use: 'A level needs a navigation link that can toggle its area class.',
-        avoid: 'Use create_nav_link_proxy for a static link.',
-        props: {
-            actorName: A.actorName, location: N.location, rotation: A.rotation,
-            startPoint: N.startPoint, endPoint: N.endPoint, direction: N.direction,
-        },
-        out: { actorName: A.actorName },
-        example: { actorName: 'SmartLink_0', location: { x: 0, y: 200, z: 100 } },
-        result: 'Smart link created',
-    }),
-    aiRecord({
-        action: 'create_smart_object_definition', summary: 'Create a Smart Object definition.',
-        use: 'An interactable needs a Smart Object definition asset.',
-        avoid: 'Use add_smart_object_slot to add interaction slots.',
-        props: createProps, required: ['name'], plugins: SMART_OBJECTS,
-        out: { definitionPath: A.definitionPath },
-        example: { name: 'SO_Bench', path: '/Game/AI' }, result: 'Smart Object definition created',
-    }),
-    aiRecord({
-        action: 'create_state_tree', summary: 'Create a StateTree asset.',
-        use: 'An AI needs a StateTree instead of a Behavior Tree.',
-        avoid: 'Use create_behavior_tree for Behavior Tree logic.',
-        props: createProps, required: ['name'], plugins: STATE_TREE,
-        out: { assetPath: A.assetPath },
-        example: { name: 'ST_Enemy', path: '/Game/AI' }, result: 'StateTree created',
-    }),
-    aiRecord({
-        action: 'get_ai_info', summary: 'Read AI asset information.',
-        use: 'A caller needs the current state of an AI asset.',
-        avoid: 'Use get_navigation_info for navigation state.',
-        props: { controllerPath: A.controllerPath, behaviorTreePath: A.behaviorTreePath, assetPath: A.assetPath, blackboardPath: A.blackboardPath, queryPath: A.queryPath, stateTreePath: A.stateTreePath, blueprintPath: A.blueprintPath },
-        effect: 'read',
-        out: {
-            aiInfo: {
-                type: 'object',
-                description: 'AI asset state (HandleGetAIInfo).',
-                properties: {
-                    keyCount: { type: 'number', description: 'Blackboard key count.' },
-                    rootDecoratorClasses: { type: 'array', items: { type: 'string' }, description: 'Class paths of decorators attached to the root node.' },
-                    rootDecorators: { type: 'array', items: reflObj, description: 'Decorator objects attached to the root node.' },
-                    childDecorators: { type: 'array', items: reflObj, description: 'Child decorators.' },
-                    services: { type: 'array', items: reflObj, description: 'Services.' },
-                    blackboardKeys: { type: 'array', items: reflObj, description: 'Blackboard keys.' },
-                    parentBlackboard: { type: 'string', description: 'Parent blackboard asset path.' },
-                    rootGraphBlackboard: { type: 'string', description: 'Blackboard assigned on the root graph node.' },
-                    rootGraphBlackboardMatchesAssigned: { type: 'boolean', description: 'Whether the root graph blackboard matches the assigned blackboard.' },
-                    controllerClass: { type: 'string', description: 'AIController class path.' },
-                    assignedBehaviorTree: { type: 'string', description: 'Behavior Tree asset path assigned to the controller.' },
-                    assignedBlackboard: { type: 'string', description: 'Blackboard asset path assigned to the tree/controller.' },
-                    hasRootNode: { type: 'boolean', description: 'Whether the Behavior Tree has a root node.' },
-                    rootDecoratorCount: { type: 'number', description: 'Number of root decorators.' },
-                    btNodeCount: { type: 'number', description: 'Number of Behavior Tree nodes.' },
-                    queryName: { type: 'string', description: 'Environment Query asset name.' },
-                    queryPath: { type: 'string', description: 'Environment Query asset object path.' },
-                    optionCount: { type: 'number', description: 'Number of query options (generator + tests).' },
-                    testCount: { type: 'number', description: 'Total number of tests across all options.' },
-                    options: { type: 'array', items: reflObj, description: 'Query options: generator class, item type and their tests.' },
-                },
-                additionalProperties: false,
-            },
-        },
-        example: { controllerPath: '/Game/AI/AIC_Enemy' }, result: 'AI info read',
-    }),
-    aiRecord({
-        action: 'get_blackboard_value', summary: 'Read a Blackboard key value.',
-        use: 'A caller needs the authored default of a Blackboard key.',
-        avoid: 'Use set_blackboard_value to change it.',
-        props: { blackboardPath: A.blackboardPath, keyName: A.keyName },
-        required: ['blackboardPath', 'keyName'], effect: 'read', plugins: BT,
-        out: {
-            valueAvailable: { type: 'boolean', description: 'Whether the typed default value was available to read (false on UE 5.0-5.4).' },
-            value: A.value,
-        },
-        example: { blackboardPath: '/Game/AI/BB_Enemy', keyName: 'TargetActor' },
-        result: 'Blackboard value read',
-    }),
-    aiRecord({
-        action: 'get_navigation_info', summary: 'Read navigation state and settings.',
-        use: 'A caller needs current NavMesh and agent settings.',
-        avoid: 'Use get_ai_info for AI asset state.',
-        props: {}, effect: 'read',
-        out: {
-            navMeshInfo: {
-                type: 'object',
-                description: 'Navigation mesh and agent settings reported by the native Navigation domain (HandleGetNavigationInfo).',
-                properties: {
-                    agentRadius: N.agentRadius, agentHeight: N.agentHeight, agentMaxSlope: N.agentMaxSlope,
-                    tileSizeUU: N.tileSizeUU, cellSize: N.cellSize, cellHeight: N.cellHeight,
-                    agentStepHeight: N.agentStepHeight,
-                    navLinkCount: { type: 'number', description: 'Number of navigation links.' },
-                    boundsVolumes: { type: 'number', description: 'Number of navigation bounds volumes.' },
-                    isNavigationBuildInProgress: { type: 'boolean', description: 'Whether a navigation build is running.' },
-                },
-                additionalProperties: false,
-            },
-        },
-        example: {}, result: 'Navigation info read',
-    }),
-    aiRecord({
-        action: 'get_tree', summary: 'Read a Behavior Tree graph.',
-        use: 'A caller needs the node graph of a Behavior Tree.',
-        avoid: 'Use get_ai_info for asset-level metadata.',
-        props: { assetPath: A.assetPath, behaviorTreePath: A.behaviorTreePath },
-        requiredOneOf: ['assetPath', 'behaviorTreePath'], effect: 'read', plugins: BT,
-        out: {
-            assetPath: A.assetPath,
-            tree: {
-                type: 'object',
-                description: 'Serialized Behavior Tree graph (root node, children, decorators, services) reported by the native BehaviorTree domain (HandleGetTree).',
-                additionalProperties: true,
-                'x-unreal-reflection-boundary': true,
-            },
-        },
-        example: { assetPath: '/Game/AI/BT_Enemy' }, result: 'Behavior Tree read',
-    }),
-    aiRecord({
-        action: 'create_nav_modifier',
-        summary: 'Stamp a navigation area: place a NavModifierVolume in the level, or with blueprintPath add a NavModifier component to a Blueprint.',
-        use: 'A region or an actor must mark the navmesh under it as a different area class.',
-        avoid: 'A placed actor needs the component itself; use create_nav_modifier_component with actorName.',
-        props: {
-            blueprintPath: { type: 'string', description: 'Blueprint that receives a NavModifier component; omit to place a NavModifierVolume in the editor level instead.' },
-            componentName: A.componentName,
-            areaClass: N.areaClass, failsafeToDefaultNavmesh: A.failsafeToDefaultNavmesh,
-            actorName: { type: 'string', description: 'Label for the placed NavModifierVolume (volume form only).' },
-            location: xyz('World location of the placed NavModifierVolume (volume form only).'),
-            extent: xyz('Half-size of the placed NavModifierVolume (volume form only; default 200, 200, 100).'),
-        },
-        out: { blueprintPath: A.blueprintPath, componentName: A.componentName, areaClass: N.areaClass, actorName: A.actorName },
-        example: { blueprintPath: '/Game/AI/BP_Obstacle', componentName: 'NavModifier', areaClass: 'NavArea_Obstacle' },
-        result: 'Nav modifier component added',
-    }),
-];
-//# sourceMappingURL=create-read-actions.data.js.map

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

@@ -1,32 +0,0 @@
-import type { JsonObject } from '../../../model.js';
-export declare const NAV: {
-    agentRadius: JsonObject;
-    agentHeight: JsonObject;
-    agentStepHeight: JsonObject;
-    agentMaxSlope: JsonObject;
-    cellSize: JsonObject;
-    cellHeight: JsonObject;
-    tileSizeUU: JsonObject;
-    minRegionArea: JsonObject;
-    mergeRegionSize: JsonObject;
-    maxSimplificationError: JsonObject;
-    areaClass: JsonObject;
-    areaCost: JsonObject;
-    failsafeExtent: JsonObject;
-    location: JsonObject;
-    startPoint: JsonObject;
-    endPoint: JsonObject;
-    direction: JsonObject;
-    snapRadius: JsonObject;
-    linkEnabled: JsonObject;
-    linkType: JsonObject;
-    enabledAreaClass: JsonObject;
-    disabledAreaClass: JsonObject;
-    broadcastRadius: JsonObject;
-    broadcastInterval: JsonObject;
-    bCreateBoxObstacle: JsonObject;
-    obstacleOffset: JsonObject;
-    obstacleExtent: JsonObject;
-    obstacleAreaClass: JsonObject;
-};
-//# sourceMappingURL=properties-navigation.d.ts.map

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

@@ -1,34 +0,0 @@
-import { xyz } from './properties.js';
-import { str, num, bool } from '../../shared/schema-props.js';
-const pick = (description, values) => ({ type: 'string', enum: [...values], description });
-export const NAV = {
-    agentRadius: num('Navigation agent radius (default: 35).'),
-    agentHeight: num('Navigation agent height (default: 144).'),
-    agentStepHeight: num('Maximum step height the agent can climb (default: 35).'),
-    agentMaxSlope: num('Maximum slope angle in degrees (default: 44).'),
-    cellSize: num('NavMesh cell size (default: 19).'),
-    cellHeight: num('NavMesh cell height (default: 10).'),
-    tileSizeUU: num('NavMesh tile size in Unreal units (default: 1000).'),
-    minRegionArea: num('Minimum region area to keep.'),
-    mergeRegionSize: num('Region merge threshold.'),
-    maxSimplificationError: num('Edge simplification error.'),
-    areaClass: str('Navigation area class path.'),
-    areaCost: num('Pathfinding cost multiplier for the area (1.0 = normal).'),
-    failsafeExtent: xyz('Failsafe extent used when the actor has no collision.'),
-    location: xyz('World location for the spawned link actor.'),
-    startPoint: xyz('Start point of the navigation link (relative to the actor).'),
-    endPoint: xyz('End point of the navigation link (relative to the actor).'),
-    direction: pick('Link traversal direction.', ['BothWays', 'LeftToRight', 'RightToLeft']),
-    snapRadius: num('Snap radius for link endpoints (default: 30).'),
-    linkEnabled: bool('Whether the link is enabled.'),
-    linkType: pick('Type of navigation link.', ['simple', 'smart']),
-    enabledAreaClass: str('Area class applied while the smart link is enabled.'),
-    disabledAreaClass: str('Area class applied while the smart link is disabled.'),
-    broadcastRadius: num('Radius for the state-change broadcast.'),
-    broadcastInterval: num('Interval for the state-change broadcast (0 = single).'),
-    bCreateBoxObstacle: bool('Add a box obstacle during navigation generation.'),
-    obstacleOffset: xyz('Offset of the simple box obstacle.'),
-    obstacleExtent: xyz('Extent of the simple box obstacle.'),
-    obstacleAreaClass: str('Area class for the box obstacle.'),
-};
-//# sourceMappingURL=properties-navigation.js.map

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

@@ -1,74 +0,0 @@
-import type { JsonObject } from '../../../model.js';
-export declare const xyz: (description: string) => JsonObject;
-export declare const AI: {
-    name: JsonObject;
-    path: JsonObject;
-    assetPath: JsonObject;
-    blueprintPath: JsonObject;
-    actorName: JsonObject;
-    controllerPath: JsonObject;
-    behaviorTreePath: JsonObject;
-    blackboardPath: JsonObject;
-    stateTreePath: JsonObject;
-    stateName: JsonObject;
-    fromState: JsonObject;
-    toState: JsonObject;
-    properties: JsonObject;
-    value: JsonObject;
-    save: JsonObject;
-    savePath: JsonObject;
-    queryPath: JsonObject;
-    definitionPath: JsonObject;
-    configPath: JsonObject;
-    componentName: JsonObject;
-    keyName: JsonObject;
-    keyType: JsonObject;
-    baseObjectClass: JsonObject;
-    isInstanceSynced: JsonObject;
-    compositeType: JsonObject;
-    taskType: JsonObject;
-    decoratorType: JsonObject;
-    serviceType: JsonObject;
-    subnodeType: JsonObject;
-    nodeClass: JsonObject;
-    nodeId: JsonObject;
-    parentNodeId: JsonObject;
-    childNodeId: JsonObject;
-    nodeType: JsonObject;
-    comment: JsonObject;
-    x: JsonObject;
-    y: JsonObject;
-    generatorType: JsonObject;
-    contextType: JsonObject;
-    testType: JsonObject;
-    testIndex: JsonObject;
-    generatorSettings: JsonObject;
-    testSettings: JsonObject;
-    sightConfig: JsonObject;
-    hearingConfig: JsonObject;
-    damageConfig: JsonObject;
-    teamId: JsonObject;
-    dominantSense: JsonObject;
-    enableSight: JsonObject;
-    enableHearing: JsonObject;
-    enableDamage: JsonObject;
-    sightRadius: JsonObject;
-    loseSightRadius: JsonObject;
-    peripheralVisionAngle: JsonObject;
-    hearingRange: JsonObject;
-    focusActorName: JsonObject;
-    parentStateName: JsonObject;
-    stateType: JsonObject;
-    triggerType: JsonObject;
-    slotIndex: JsonObject;
-    enabled: JsonObject;
-    offset: JsonObject;
-    rotation: JsonObject;
-    spawnCount: JsonObject;
-    failsafeToDefaultNavmesh: JsonObject;
-    maxWalkSpeed: JsonObject;
-    maxAcceleration: JsonObject;
-    brakingDeceleration: JsonObject;
-    rotationRate: JsonObject;
-};
-//# sourceMappingURL=properties.d.ts.map

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

@@ -1,112 +0,0 @@
-import { P } from '../properties.js';
-import { str, num, bool } from '../../shared/schema-props.js';
-const pick = (description, values) => ({ type: 'string', enum: [...values], description });
-const closed = (description, properties) => ({ type: 'object', properties, description, additionalProperties: false });
-const N = { type: 'number' };
-const B = { type: 'boolean' };
-const S = { type: 'string' };
-export const xyz = (description) => closed(description, { x: N, y: N, z: N });
-const TASK_TYPES = [
-    'MoveTo', 'MoveDirectlyToward', 'RotateToFaceBBEntry', 'Wait', 'WaitBlackboardTime',
-    'PlayAnimation', 'PlaySound', 'RunEQSQuery', 'RunBehaviorDynamic', 'SetBlackboardValue',
-    'PushPawnAction', 'FinishWithResult', 'MakeNoise', 'GameplayTaskBase', 'Custom',
-];
-const DECORATOR_TYPES = [
-    'Blackboard', 'BlackboardBased', 'CompareBBEntries', 'Cooldown', 'ConeCheck',
-    'DoesPathExist', 'IsAtLocation', 'IsBBEntryOfClass', 'KeepInCone', 'Loop',
-    'SetTagCooldown', 'TagCooldown', 'TimeLimit', 'ForceSuccess', 'ConditionalLoop', 'Custom',
-];
-const EQS_GENERATOR_TYPES = [
-    'ActorsOfClass', 'CurrentLocation', 'Donut', 'OnCircle',
-    'PathingGrid', 'SimpleGrid', 'Composite', 'Custom',
-];
-const EQS_TEST_TYPES = [
-    'Distance', 'Dot', 'GameplayTags', 'Overlap', 'Pathfinding',
-    'PathfindingBatch', 'Project', 'Random', 'Trace', 'Custom',
-];
-export const AI = {
-    name: P.name,
-    path: P.path,
-    assetPath: P.assetPath,
-    blueprintPath: P.blueprintPath,
-    actorName: P.actorName,
-    controllerPath: P.controllerPath,
-    behaviorTreePath: P.behaviorTreePath,
-    blackboardPath: P.blackboardPath,
-    stateTreePath: P.stateTreePath,
-    stateName: P.stateName,
-    fromState: P.fromState,
-    toState: P.toState,
-    properties: P.properties,
-    value: P.value,
-    save: P.save,
-    savePath: str('Directory path used when saving the created Behavior Tree.'),
-    queryPath: str('Canonical /Game Environment Query asset path.'),
-    definitionPath: str('Canonical /Game Smart Object definition asset path.'),
-    configPath: str('Canonical /Game Mass Entity config asset path.'),
-    componentName: str('Name of the component to add.'),
-    keyName: str('Blackboard key name.'),
-    keyType: pick('Blackboard key data type.', ['Bool', 'Int', 'Float', 'Vector', 'Rotator', 'Object', 'Class', 'Enum', 'Name', 'String']),
-    baseObjectClass: str('Base class filter for Object/Class blackboard keys.'),
-    isInstanceSynced: bool('Sync key across instances.'),
-    compositeType: pick('Composite node type.', ['Selector', 'Sequence', 'Parallel', 'SimpleParallel']),
-    taskType: pick('Task node type.', TASK_TYPES),
-    decoratorType: pick('Decorator node type.', DECORATOR_TYPES),
-    serviceType: pick('Service node type.', ['DefaultFocus', 'RunEQS', 'Custom']),
-    subnodeType: pick('Behavior Tree subnode kind for add_subnode.', ['Decorator', 'Service']),
-    nodeClass: str('Node class path.'),
-    nodeId: str('ID of the node.'),
-    parentNodeId: str("ID of the parent node: 'root', a node GUID, or a node id as returned by add_composite/add_task (for example BTComposite_Selector_0)."),
-    childNodeId: str('ID of the child node.'),
-    nodeType: str('Behavior Tree graph node type.'),
-    comment: str('Comment text applied to the graph node.'),
-    x: num('Graph node X coordinate.'),
-    y: num('Graph node Y coordinate.'),
-    generatorType: pick('EQS generator type.', EQS_GENERATOR_TYPES),
-    contextType: pick('EQS context type.', ['Querier', 'Item', 'EnvQueryContext_BlueprintBase', 'Custom']),
-    testType: pick('EQS test type.', EQS_TEST_TYPES),
-    testIndex: num('Index of the test to configure.'),
-    generatorSettings: closed('Generator-specific settings.', {
-        searchRadius: N, searchCenter: S, actorClass: S, gridSize: N,
-        spacesBetween: N, innerRadius: N, outerRadius: N,
-    }),
-    testSettings: closed('Test scoring and filter settings.', {
-        scoringEquation: { type: 'string', enum: ['Linear', 'Square', 'InverseLinear', 'Constant'] },
-        clampMin: N, clampMax: N,
-        filterType: { type: 'string', enum: ['Minimum', 'Maximum', 'Range'] },
-        floatMin: N, floatMax: N,
-    }),
-    sightConfig: closed('AI sight sense configuration.', {
-        sightRadius: N, loseSightRadius: N, peripheralVisionAngle: N,
-        pointOfViewBackwardOffset: N, nearClippingRadius: N, autoSuccessRange: N, maxAge: N,
-        detectionByAffiliation: closed('Affiliation detection flags.', { enemies: B, neutrals: B, friendlies: B }),
-    }),
-    hearingConfig: closed('AI hearing sense configuration.', {
-        hearingRange: N, loSHearingRange: N, detectFriendly: B, maxAge: N,
-    }),
-    damageConfig: closed('AI damage sense configuration.', { maxAge: N }),
-    teamId: num('Team ID for perception affiliation (0=Neutral, 1=Player, 2=Enemy, ...).'),
-    dominantSense: pick('Dominant sense for perception prioritization.', ['Sight', 'Hearing', 'Damage', 'Touch', 'None']),
-    enableSight: bool('Enable the sight sense.'),
-    enableHearing: bool('Enable the hearing sense.'),
-    enableDamage: bool('Enable the damage sense.'),
-    sightRadius: num('Sight radius in world units.'),
-    loseSightRadius: num('Radius at which sight is lost.'),
-    peripheralVisionAngle: num('Peripheral vision half-angle in degrees.'),
-    hearingRange: num('Hearing range in world units.'),
-    focusActorName: str('Actor the controller should focus on.'),
-    parentStateName: str('Parent state name for the added state.'),
-    stateType: str('State kind for the added state.'),
-    triggerType: str('Transition trigger kind.'),
-    slotIndex: num('Index of the slot to configure.'),
-    enabled: bool('Whether the slot is enabled.'),
-    offset: xyz('Slot offset relative to the definition origin.'),
-    rotation: closed('Rotation as {pitch, yaw, roll} in degrees.', { pitch: N, yaw: N, roll: N }),
-    spawnCount: num('Number of entities the spawner creates.'),
-    failsafeToDefaultNavmesh: bool('Fall back to the default navmesh area when the modifier area class is unset.'),
-    maxWalkSpeed: num('Maximum ground speed; left unchanged when omitted.'),
-    maxAcceleration: num('Maximum acceleration; left unchanged when omitted.'),
-    brakingDeceleration: num('Braking deceleration while walking; left unchanged when omitted.'),
-    rotationRate: num('Yaw rotation rate in degrees per second; left unchanged when omitted.'),
-};
-//# sourceMappingURL=properties.js.map

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

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

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

@@ -1,14 +0,0 @@
-import { AI_ADD_RECORDS } from './add-actions.data.js';
-import { AI_CONFIGURE_RECORDS } from './configure-actions.data.js';
-import { AI_CREATE_READ_RECORDS } from './create-read-actions.data.js';
-import { AI_SET_RECORDS } from './set-actions.data.js';
-import { applyFolds } from '../../shared/fold.js';
-import { MANAGE_AI_FOLDS } from '../../folds/manage-ai.folds.js';
-export const MANAGE_AI_UNFOLDED_SOURCES = [
-    ...AI_ADD_RECORDS,
-    ...AI_CONFIGURE_RECORDS,
-    ...AI_CREATE_READ_RECORDS,
-    ...AI_SET_RECORDS,
-];
-export const MANAGE_AI_SOURCES = applyFolds(MANAGE_AI_UNFOLDED_SOURCES, MANAGE_AI_FOLDS, 'manage_ai');
-//# sourceMappingURL=records.js.map

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

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