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

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

@@ -1,82 +0,0 @@
-import { bool, num, str, vec3 } from '../../shared/schema-props.js';
-const objectList = (desc) => ({
-    type: 'array',
-    items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-    description: desc,
-});
-export const A = {
-    save: bool('Save the asset to disk after the change (default true). With false the change stays in memory only and is lost when the editor restarts.'),
-    savePath: str('Canonical /Game directory for generated assets.'),
-    positionX: num('Graph X position of the new node (default 0).'),
-    positionY: num('Graph Y position of the new node (default 0).'),
-    graphBlueprintPath: str('Animation Blueprint whose AnimGraph is edited.'),
-    abpParentClass: str('AnimInstance subclass the Blueprint derives from (default AnimInstance): a native class name or an Animation Blueprint path.'),
-    meshSkeleton: str('Skeletal mesh whose skeleton to use when skeletonPath is omitted.'),
-    outputPath: str('Canonical /Game path for the generated Physics Asset.'),
-    rootBoneName: str('Root bone name for the created skeleton.'),
-    attachBoneName: str('Bone the socket attaches to.'),
-    relativeLocation: vec3('Socket location relative to its attach bone as [x, y, z].'),
-    relativeRotation: vec3('Socket rotation relative to its attach bone as [pitch, yaw, roll].'),
-    relativeScale: vec3('Socket scale relative to its attach bone as [x, y, z].'),
-    scale: { description: 'Uniform scale factor, or non-uniform scale as [x, y, z].' },
-    removeChildren: bool('Whether child bones are removed with the target bone.'),
-    stateMachineName: str('Target state machine name inside the Animation Blueprint.'),
-    conditionVariable: str('Animation Blueprint variable the transition rule tests, e.g. Speed or bFalling. Without it the rule graph is left unconnected, which reads as false forever and the state machine never leaves its entry state.'),
-    conditionComparison: str('How conditionVariable is tested: greater (default), less, greater_equal, less_equal for a numeric variable; true or false for a bool.'),
-    conditionValue: num('Right-hand value for a numeric conditionComparison (default 0). Ignored for true/false.'),
-    crossfadeDuration: num('Transition blend duration in seconds. blendTime is accepted as an alias.'),
-    priorityOrder: num('Evaluation order when several transitions out of one state can fire on the same frame; the lowest wins.'),
-    automaticRule: bool('Fire the transition when the source state\'s sequence player reaches the end of its animation instead of testing a condition. Left alone when omitted.'),
-    bidirectional: bool('Whether the transition also applies from toState back to fromState. Left alone when omitted.'),
-    blendType: str('Blend node type (TwoWayBlend, BlendListByBool, BlendListByInt).'),
-    layerSetup: objectList('Layered blend-per-bone branch filter descriptors.'),
-    boneTracks: objectList('Bone tracks to key: [{ boneName, frames: [{ frame, rotationDelta?: {pitch,yaw,roll}, '
-        + 'rotation?: {pitch,yaw,roll}|{x,y,z,w}, location?: {x,y,z}, scale?: {x,y,z} }] }]. '
-        + 'frame runs 0 to numFrames inclusive. Only the poses that matter need keys: frames between '
-        + 'two keys of a channel are blended (rotation slerped), frames before its first key or '
-        + 'after its last hold that key. Channels left out keep the reference pose of that bone, so '
-        + 'a rotation-only track poses without collapsing the skeleton. Prefer rotationDelta, which '
-        + 'bends the bone relative to its rest orientation; plain rotation replaces the local '
-        + 'rotation outright and needs the rest orientation to already be known. Calling it again with '
-        + 'the name of an existing clip re-keys that clip from empty (its additive settings are kept).'),
-    weights: objectList('Per-vertex skin weight descriptors with bone influences.'),
-    deltas: objectList('Per-vertex morph target position deltas.'),
-    pitch: num('Aim offset pitch in degrees.'),
-    yaw: num('Aim offset yaw in degrees.'),
-    startFrame: num('First frame of the notify state range.'),
-    endFrame: num('Last frame of the notify state range.'),
-    trackIndex: num('Notify track index within the animation sequence.'),
-    notifyClass: str('AnimNotify (or AnimNotifyState) class name; prefixed with AnimNotify_/AnimNotifyState_ automatically when missing.'),
-    basePoseFrame: num('Frame used as the additive base pose.'),
-    forceRootLock: bool('Whether root motion is force-locked to the reference pose.'),
-    bodyType: str('Physics body primitive type (Sphere, Box, Capsule).'),
-    center: vec3('Physics body centre offset relative to its bone as [x, y, z].'),
-    constraintName: str('Name of the created physics constraint.'),
-    physicsAssetName: str('Name of the generated Physics Asset.'),
-    assignToMesh: bool('Whether the generated Physics Asset is assigned to the mesh.'),
-    axis: str('Mirror or blend axis (X, Y, Z).'),
-    profileName: str('Skin weight profile name.'),
-    lodIndex: num('Skeletal mesh LOD index (default 0).'),
-    dropRenderOnlyMorphs: bool('The edit rebuilds the mesh from its source data, which deletes morph targets that exist only in render data (made by create_morph_target or set_morph_target_deltas). Without true, a mesh that has any is refused with RENDER_ONLY_MORPHS naming them and nothing changes (default false).'),
-    limits: {
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-            swing1LimitAngle: num('Swing 1 limit in degrees.'), swing2LimitAngle: num('Swing 2 limit in degrees.'), twistLimitAngle: num('Twist limit in degrees.'),
-            swing1Motion: str('Free, Limited or Locked.'), swing2Motion: str('Free, Limited or Locked.'), twistMotion: str('Free, Limited or Locked.'),
-        },
-        description: 'Angular limits. Only the axes named change; an angle without a motion makes that axis Limited.',
-    },
-    assets: {
-        type: 'array',
-        items: { type: 'string' },
-        description: 'Canonical /Game animation asset paths to retarget.',
-    },
-    artifacts: {
-        type: 'array',
-        items: { type: 'string' },
-        description: 'Canonical /Game asset paths to delete during cleanup.',
-    },
-    suffix: str('Suffix appended to each retargeted asset name.'),
-};
-//# sourceMappingURL=animation-properties.js.map

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

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

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

@@ -1,224 +0,0 @@
-import { buildRecord } from '../helpers.js';
-import { ANY_EDITOR_STATE } from '../../core/builder.js';
-import { P } from '../properties.js';
-import { A } from './animation-properties.js';
-import { bool, num, str, vec3 } from '../../shared/schema-props.js';
-const T = 'animation_physics';
-const F = 'animation';
-const W = ['An animation asset or graph must be authored.'];
-const ESU = ['EditorScriptingUtilities'];
-const CR_ESU = ['ControlRig', 'EditorScriptingUtilities'];
-const TRANSITION_SETTINGS = { blendTime: P.blendTime, crossfadeDuration: A.crossfadeDuration, priorityOrder: A.priorityOrder, automaticRule: A.automaticRule, bidirectional: A.bidirectional, conditionVariable: A.conditionVariable, conditionComparison: A.conditionComparison, conditionValue: A.conditionValue };
-const BS_2D_AXES = {
-    horizontalAxisName: str('Horizontal axis label (default Direction).'), horizontalMin: num('Horizontal axis minimum (default -180).'), horizontalMax: num('Horizontal axis maximum (default 180).'),
-    verticalAxisName: str('Vertical axis label (default Speed).'), verticalMin: num('Vertical axis minimum (default 0).'), verticalMax: num('Vertical axis maximum (default 600).'),
-};
-export const ANIM_AUTHORED_1 = [
-    buildRecord({ parentTool: T, id: `${T}.create_animation_blueprint`, action: 'create_animation_blueprint', family: F,
-        topics: ['anim blueprint', 'abp', 'animation bp', 'anim graph', 'animbp'],
-        summary: 'Create an Animation Blueprint asset.', whenToUse: W, whenNotToUse: ['A SkeletalMesh suffices.'],
-        inputProps: { name: P.name, path: P.path, skeletonPath: P.skeletonPath, skeletalMeshPath: A.meshSkeleton, parentClass: A.abpParentClass, save: A.save },
-        required: ['name'], effect: 'write', latency: 'interactive', resources: 'medium', plugins: CR_ESU,
-        outputProps: { assetPath: P.assetPath }, outputRequired: ['assetPath'],
-        exampleInput: { action: 'create_animation_blueprint', name: 'ABP_Char', skeletonPath: '/Game/SK_Char', parentClass: 'AnimInstance' }, exampleOutput: { success: true, message: 'Animation Blueprint created', assetPath: '/Game/ABP_Char' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_animation_bp`, action: 'create_animation_bp', family: F,
-        summary: 'Alias of create_animation_blueprint (short form).', whenToUse: ['Caller uses the create_animation_bp verb.'], whenNotToUse: ['Use create_animation_blueprint.'],
-        inputProps: { name: P.name, path: P.path, skeletonPath: P.skeletonPath, skeletalMeshPath: A.meshSkeleton, parentClass: A.abpParentClass, save: A.save }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: CR_ESU,
-        exampleInput: { action: 'create_animation_bp', name: 'ABP_Char', skeletonPath: '/Game/SK_Char' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_anim_blueprint`, action: 'create_anim_blueprint', family: F,
-        summary: 'Alias of create_animation_blueprint (short form).', whenToUse: ['Caller uses the create_anim_blueprint verb.'], whenNotToUse: ['Use create_animation_blueprint.'],
-        inputProps: { name: P.name, path: P.path, skeletonPath: P.skeletonPath, skeletalMeshPath: A.meshSkeleton, parentClass: A.abpParentClass, save: A.save }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: CR_ESU,
-        exampleInput: { action: 'create_anim_blueprint', name: 'ABP_Char', skeletonPath: '/Game/SK_Char' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_blend_space`, action: 'create_blend_space', family: F,
-        summary: 'Create a 2D Blend Space asset.', whenToUse: W, whenNotToUse: ['Use create_blend_space_1d for one axis.'],
-        inputProps: { name: P.name, path: P.path, skeletonPath: P.skeletonPath, ...BS_2D_AXES, save: A.save }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        outputProps: { assetPath: P.assetPath }, outputRequired: [],
-        exampleInput: { action: 'create_blend_space', name: 'BS_Locomotion', skeletonPath: '/Game/SK_Char' }, exampleOutput: { success: true, message: 'Blend Space created', assetPath: '/Game/BS_Locomotion' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_blend_space_1d`, action: 'create_blend_space_1d', family: F,
-        summary: 'Create a 1D Blend Space asset.', whenToUse: ['A single-axis blend is needed.'], whenNotToUse: ['Use create_blend_space for 2D.'],
-        inputProps: { name: P.name, path: P.path, skeletonPath: P.skeletonPath, axisName: str('Axis label (default Speed).'), axisMin: num('Axis minimum (default 0).'), axisMax: num('Axis maximum (default 600).'), save: A.save }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        outputProps: { assetPath: P.assetPath }, outputRequired: [],
-        exampleInput: { action: 'create_blend_space_1d', name: 'BS1D_Speed', skeletonPath: '/Game/SK_Char' }, exampleOutput: { success: true, message: 'Blend Space 1D created', assetPath: '/Game/BS1D_Speed' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_blend_space_2d`, action: 'create_blend_space_2d', family: F,
-        summary: 'Create a 2D Blend Space asset.', whenToUse: ['A two-axis blend is needed.'], whenNotToUse: ['Use create_blend_space_1d for one axis.'],
-        inputProps: { name: P.name, path: P.path, skeletonPath: P.skeletonPath, ...BS_2D_AXES, save: A.save }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        outputProps: { assetPath: P.assetPath }, outputRequired: [],
-        exampleInput: { action: 'create_blend_space_2d', name: 'BS2D_DirSpeed', skeletonPath: '/Game/SK_Char' }, exampleOutput: { success: true, message: 'Blend Space 2D created', assetPath: '/Game/BS2D_DirSpeed' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_blend_tree`, action: 'create_blend_tree', family: F,
-        summary: 'Author a blend tree in an AnimBlueprint AnimGraph: a Blend List (by int) node fed by one Sequence Player per animation, optionally wired to the output pose.', whenToUse: ['Several animations must be switchable through one blend node in an AnimBlueprint.'], whenNotToUse: ['A single add_blend_node suffices.'],
-        inputProps: { name: P.name, blueprintPath: P.blueprintPath, treeName: { type: 'string', description: 'Comment/name for the blend node (alias of name).' }, animations: { type: 'array', items: { type: 'string' }, description: 'Animation asset paths; one Sequence Player is created and connected per entry.' }, connectToOutput: { type: 'boolean', description: 'Wire the blend node into the AnimGraph output pose (default true).' } }, required: ['blueprintPath'], requiredOneOf: ['name', 'treeName'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'create_blend_tree', name: 'BT_Move', blueprintPath: '/Game/ABP_Char' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_procedural_anim`, action: 'create_procedural_anim', family: F,
-        summary: 'Create a procedural anim asset.', whenToUse: ['A runtime-authored animation is needed.'], whenNotToUse: ['Use a static sequence.'],
-        inputProps: { name: P.name, path: P.path, skeletonPath: P.skeletonPath, boneTracks: A.boneTracks, numFrames: num('Length in frames (default 30).'), frameRate: P.frameRate, save: A.save }, required: ['name', 'skeletonPath', 'boneTracks'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'create_procedural_anim', name: 'PA_Wave', skeletonPath: '/Game/SK_Char', frameRate: 30 } }),
-    buildRecord({ parentTool: T, id: `${T}.create_aim_offset`, action: 'create_aim_offset', family: F,
-        summary: 'Create an Aim Offset asset.', whenToUse: ['Aim blending by look direction is needed.'], whenNotToUse: ['Use a blend space.'],
-        inputProps: { name: P.name, path: P.path, skeletonPath: P.skeletonPath, save: A.save }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        outputProps: { assetPath: P.assetPath }, outputRequired: [],
-        exampleInput: { action: 'create_aim_offset', name: 'AO_Aim', skeletonPath: '/Game/SK_Char' }, exampleOutput: { success: true, message: 'Aim Offset created', assetPath: '/Game/AO_Aim' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_aim_offset_sample`, action: 'add_aim_offset_sample', family: F,
-        summary: 'Add a sample pose to an Aim Offset.', whenToUse: ['Aim sample must be added.'], whenNotToUse: ['Use create_aim_offset.'],
-        inputProps: { assetPath: P.assetPath, animationPath: P.animationPath, yaw: A.yaw, pitch: A.pitch }, required: ['assetPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_aim_offset_sample', assetPath: '/Game/AO_Aim', animationPath: '/Game/A_Idle', yaw: 0, pitch: 0 },
-        exampleOutput: { success: true, message: 'Aim sample added' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_state_machine`, action: 'create_state_machine', family: F,
-        summary: 'Create a State Machine graph asset.', whenToUse: ['State-driven animation is needed.'], whenNotToUse: ['A single graph suffices.'],
-        inputProps: { blueprintPath: A.graphBlueprintPath, machineName: str('State machine name (default StateMachine).'), states: { type: 'array', items: { type: 'object', additionalProperties: false, properties: { name: { type: 'string' } }, required: ['name'] }, description: 'States to create, as [{ name }].' }, transitions: { type: 'array', items: { type: 'object', additionalProperties: false, properties: { sourceState: { type: 'string' }, targetState: { type: 'string' } }, required: ['sourceState', 'targetState'] }, description: 'Transitions to create between the listed states, as [{ sourceState, targetState }].' } }, required: ['blueprintPath'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        outputProps: { blueprintPath: P.blueprintPath, machineName: P.machineName }, outputRequired: [],
-        exampleInput: { action: 'create_state_machine', blueprintPath: '/Game/ABP_Char', machineName: 'SM_Locomotion' }, exampleOutput: { success: true, message: 'State machine created', machineName: 'SM_Locomotion' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_state_machine`, action: 'add_state_machine', family: F,
-        summary: 'Add a State Machine node to an AnimGraph.', whenToUse: ['A state machine must be embedded.'], whenNotToUse: ['Use create_state_machine.'],
-        inputProps: { blueprintPath: A.graphBlueprintPath, stateMachineName: A.stateMachineName, machineName: P.machineName, positionX: A.positionX, positionY: A.positionY, save: A.save }, required: ['blueprintPath'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        outputProps: { blueprintPath: P.blueprintPath, machineName: P.machineName }, outputRequired: [],
-        exampleInput: { action: 'add_state_machine', blueprintPath: '/Game/ABP_Char', stateMachineName: 'SM_Loco' },
-        exampleOutput: { success: true, message: 'State machine node added', machineName: 'SM_Loco' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_state`, action: 'add_state', family: F,
-        summary: 'Add a state to a State Machine.', whenToUse: ['A new animation state is needed.'], whenNotToUse: ['Use add_transition.'],
-        inputProps: { blueprintPath: A.graphBlueprintPath, stateMachineName: A.stateMachineName, machineName: { type: 'string', description: 'Alias of stateMachineName. Omitting both matches every state machine in the graph.' }, stateName: P.stateName, animations: { type: 'array', items: { type: 'string' }, description: 'Animation asset paths to play in this state; one Sequence Player is created per entry and the first drives the state Result pose. Without it the state is created empty and the character holds its reference pose.' }, positionX: num('Graph X position of the state (default 200).'), positionY: A.positionY, save: A.save }, required: ['blueprintPath', 'stateName'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        outputProps: { blueprintPath: P.blueprintPath, machineName: P.machineName, stateName: P.stateName, animationsApplied: { type: 'array', items: { type: 'object', properties: { animationPath: { type: 'string' }, nodeId: { type: 'string' }, connected: { type: 'boolean' } }, required: ['animationPath', 'nodeId', 'connected'], additionalProperties: false }, description: 'One entry per created Sequence Player. Only the first can be connected to the state Result pose.' }, animationsFailed: { type: 'array', items: { type: 'string' }, description: 'Requested animation paths that could not be loaded.' } }, outputRequired: [],
-        exampleInput: { action: 'add_state', blueprintPath: '/Game/ABP_Char', stateMachineName: 'SM_Loco', stateName: 'Idle', animations: ['/Game/Anims/A_Idle'] },
-        exampleOutput: { success: true, message: 'State added', stateName: 'Idle' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_transition`, action: 'add_transition', family: F,
-        summary: 'Add a transition between two states.', whenToUse: ['States must connect.'], whenNotToUse: ['Use add_state.'],
-        inputProps: { blueprintPath: A.graphBlueprintPath, stateMachineName: A.stateMachineName, fromState: P.fromState, toState: P.toState, ...TRANSITION_SETTINGS, save: A.save }, required: ['blueprintPath', 'fromState', 'toState'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_transition', blueprintPath: '/Game/ABP_Char', stateMachineName: 'SM_Loco', fromState: 'Idle', toState: 'Run' },
-        exampleOutput: { success: true, message: 'Transition added' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_transition_rules`, action: 'set_transition_rules', family: F,
-        summary: 'Set transition rule logic: the condition a transition tests, plus its blend timing.',
-        whenToUse: ['Transition condition must change.', 'A state machine must actually be able to leave a state: author the condition here after add_transition.'],
-        whenNotToUse: ['Use add_transition.'],
-        inputProps: { blueprintPath: A.graphBlueprintPath, stateMachineName: A.stateMachineName, fromState: P.fromState, toState: P.toState, ...TRANSITION_SETTINGS, save: A.save }, required: ['blueprintPath', 'fromState', 'toState'],
-        outputProps: { condition: { type: 'string', description: 'The rule that was written into the transition graph. Absent means no conditionVariable was given, so the transition stays false and the state is never left.' } },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'set_transition_rules', blueprintPath: '/Game/ABP_Char', stateMachineName: 'SM_Loco', fromState: 'Idle', toState: 'Run', conditionVariable: 'Speed', conditionComparison: 'greater', conditionValue: 10 },
-        exampleOutput: { success: true, message: 'Transition rules updated', condition: 'Speed greater 10' } }),
-    buildRecord({ parentTool: T, id: `${T}.delete_transition`, action: 'delete_transition', family: F,
-        summary: 'Delete a transition from a State Machine.',
-        whenToUse: ['A transition was authored between the wrong two states.', 'A transition is dead weight and its rule graph should go with it.'],
-        whenNotToUse: ['The transition should stay but never fire: use set_transition_rules.', 'The state itself must go, not just the transition.'],
-        inputProps: { blueprintPath: A.graphBlueprintPath, stateMachineName: A.stateMachineName, fromState: P.fromState, toState: P.toState, save: A.save }, required: ['blueprintPath', 'fromState', 'toState'],
-        outputProps: { deleted: { type: 'boolean', description: 'True when the transition and its rule graph were removed.' } },
-        effect: 'write', behavior: { idempotency: 'non-idempotent' }, latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'delete_transition', blueprintPath: '/Game/ABP_Char', stateMachineName: 'SM_Loco', fromState: 'Jump', toState: 'Idle' },
-        exampleOutput: { success: true, message: 'Transition deleted', deleted: true } }),
-    buildRecord({ parentTool: T, id: `${T}.add_blend_node`, action: 'add_blend_node', family: F,
-        summary: 'Add a blend node to an AnimGraph.', whenToUse: ['Graph needs a blend node.'], whenNotToUse: ['Use create_blend_tree.'],
-        inputProps: { blueprintPath: A.graphBlueprintPath, blendType: { type: 'string', enum: ['TwoWayBlend', 'BlendListByBool', 'BlendListByInt', 'LayeredBoneBlend'], description: 'Blend node type (default TwoWayBlend).' }, nodeName: P.nodeName, positionX: A.positionX, positionY: A.positionY, save: A.save }, required: ['blueprintPath'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_blend_node', blueprintPath: '/Game/ABP_Char', blendType: 'TwoWayBlend', nodeName: 'Blend_0' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_cached_pose`, action: 'add_cached_pose', family: F,
-        summary: 'Add a cached pose node.', whenToUse: ['Pose reuse optimization needed.'], whenNotToUse: ['Inline pose suffices.'],
-        inputProps: { blueprintPath: A.graphBlueprintPath, cacheName: P.cacheName, positionX: A.positionX, positionY: A.positionY, save: A.save }, required: ['blueprintPath', 'cacheName'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_cached_pose', blueprintPath: '/Game/ABP_Char', cacheName: 'LocomotionPose' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_slot_node`, action: 'add_slot_node', family: F,
-        summary: 'Add an animation slot node.', whenToUse: ['Montage slot must be exposed.'], whenNotToUse: ['Use create_montage.'],
-        inputProps: { blueprintPath: A.graphBlueprintPath, slotName: P.slotName, groupName: str('Slot group the slot belongs to (default DefaultGroup).'), positionX: A.positionX, positionY: A.positionY, save: A.save }, required: ['blueprintPath', 'slotName'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_slot_node', blueprintPath: '/Game/ABP_Char', slotName: 'DefaultSlot' },
-        exampleOutput: { success: true, message: 'Slot node added' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_control_rig`, action: 'create_control_rig', topics: ['control rig blueprint'], family: F,
-        summary: 'Create a Control Rig asset.', whenToUse: ['Procedural rigging/IK needed (ControlRig).'], whenNotToUse: ['Use create_ik_rig.'],
-        inputProps: { name: P.name, path: P.path, skeletonPath: P.skeletonPath, skeletalMeshPath: str('Skeletal mesh to build the rig from; wins over skeletonPath.'), modularRig: bool('Create a Modular Rig (UE 5.5+; older engines report modularRig false).'), save: A.save }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: ['ControlRig', 'RigVM', 'EditorScriptingUtilities'],
-        exampleInput: { action: 'create_control_rig', name: 'CR_Char', skeletonPath: '/Game/SK_Char' } }),
-    buildRecord({ parentTool: T, id: `${T}.edit_control_rig`, action: 'edit_control_rig', family: F,
-        topics: ['control rig graph', 'rig unit', 'add rig node', 'connect rig pins', 'wire control rig pins', 'control rig hierarchy', 'add control', 'rig bones'],
-        summary: 'Edit a Control Rig: add a unit node (list_rig_units finds them), connect or disconnect pins, set a pin value, remove a node, import the skeleton\'s bones, add a bone, null or control, or remove an element; one edit or many steps, then one compile and save. The reply lists what each edit made (a new node with its pins).',
-        whenToUse: ['A Control Rig needs its logic built: units such as Get Transform, Two Bone IK or Set Transform wired from the Forwards Solve event (a new rig may have none: add_unit BeginExecution adds it).', 'A rig needs bones from its skeleton, or controls and nulls to drive them.'],
-        whenNotToUse: ['The rig asset does not exist yet (use create_control_rig).', 'Only reading the rig (use get_control_rig).', 'An IK Rig or retargeter (use create_ik_rig, setup_ik).'],
-        inputProps: {
-            assetPath: str('Control Rig asset path, e.g. /Game/Rigs/CR_Arm.'),
-            edit: { type: 'string', enum: ['add_unit', 'connect', 'disconnect', 'set_pin', 'remove_node', 'import_bones', 'add_bone', 'add_null', 'add_control', 'remove_element'], description: 'The edit to make (each step of steps names its own).' },
-            unit: str('add_unit: the unit, as an object path (/Script/ControlRig.RigUnit_SetTransform), its struct name with or without RigUnit_ (SetTransform), or its display name.'),
-            name: str('add_unit: the new node\'s name (default the unit\'s, made unique); add_bone, add_null, add_control, remove_element: the element\'s name.'),
-            position: { type: 'array', items: { type: 'number' }, minItems: 2, maxItems: 2, description: 'add_unit: graph position [x, y] (default right of the last node).' },
-            from: str('connect, disconnect: the output pin, Node.Pin as get_control_rig lists it; execution runs from the event\'s execute pin to each unit\'s (ExecutePin in UE 5.8).'),
-            to: str('connect, disconnect: the input pin, Node.Pin.'),
-            pin: str('set_pin: the pin, Node.Pin; a struct member has its own pin (SetTransform.Item.Name, SetTransform.Transform.Translation.X).'),
-            value: { type: ['string', 'number', 'boolean'], description: 'set_pin: the value as text (Bone, foot_l), a number, or true/false.' },
-            node: str('remove_node: the node\'s name.'),
-            skeletonPath: str('import_bones: the skeleton whose bones are imported (default the skeleton of the rig\'s preview mesh).'),
-            parent: str('add_bone, add_null, add_control: the parent element\'s name (a bone, null or control); omitted, the top of the hierarchy.'),
-            location: vec3('add_bone, add_null, add_control: location [x, y, z] in cm (a control\'s offset), relative to the parent unless global.'),
-            rotation: vec3('add_bone, add_null, add_control: rotation [pitch, yaw, roll] in degrees.'),
-            scale: vec3('add_bone, add_null, add_control: scale [x, y, z] (default 1).'),
-            global: bool('add_bone, add_null: location, rotation and scale are in rig space, not relative to the parent.'),
-            controlType: { type: 'string', enum: ['transform', 'float', 'bool', 'position', 'rotator'], description: 'add_control: the value the control drives (default transform).' },
-            steps: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Several edits in order, each an object with edit and its own fields as above; the first that fails stops the rest, and those before it stay (failedStep names it).' },
-            save: A.save,
-        },
-        required: ['assetPath'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: CR_ESU,
-        exampleInput: { action: 'edit_control_rig', assetPath: '/Game/Rigs/CR_Arm', steps: [{ edit: 'add_unit', unit: 'BeginExecution', name: 'ForwardsSolve' }, { edit: 'add_unit', unit: 'SetTransform', name: 'SetHand' }, { edit: 'set_pin', pin: 'SetHand.Item.Name', value: 'hand_r' }, { edit: 'connect', from: 'ForwardsSolve.ExecutePin', to: 'SetHand.ExecutePin' }] },
-        exampleOutput: { success: true, message: 'Applied 4 edit(s) to CR_Arm.', assetPath: '/Game/Rigs/CR_Arm.CR_Arm', applied: 4, compiled: true, saved: true,
-            made: [{ node: 'SetHand', unit: '/Script/ControlRig.RigUnit_SetTransform', pins: [{ pin: 'SetHand.Item', direction: 'Input', type: 'FRigElementKey' }] }, { pin: 'SetHand.Item.Name', value: 'hand_r' }] },
-        outputProps: {
-            assetPath: str('The rig edited.'),
-            applied: num('Edits applied.'),
-            made: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'What the edits made: {node, unit, pins} for an added unit, {pin, value} for a set pin (the value as stored), {element} for an added element, {importedFrom, bones} for a skeleton\'s bones imported (bones the rig already had are matched in place).' },
-            compiled: bool('Whether the rig compiled after the edits.'),
-            compileErrors: { type: 'array', items: { type: 'string' }, description: 'The compile errors, when there were any.' },
-            saved: bool('Whether the rig was saved.'),
-            failedStep: num('steps: the step that failed (0-based); the ones before it were applied, compiled and saved.'),
-        },
-        outputRequired: ['assetPath', 'applied'] }),
-    buildRecord({ parentTool: T, id: `${T}.get_control_rig`, action: 'get_control_rig', family: F,
-        topics: ['read control rig', 'control rig nodes', 'rig pins', 'rig hierarchy'],
-        summary: 'Read a Control Rig: each node of its graph with its unit and pins (path, direction, type, default, linked), the links between pins, its hierarchy (bones, nulls, controls with their parents) and whether it compiled; node names one node with every struct member pin.',
-        whenToUse: ['Before editing a rig: the exact pin paths connect and set_pin take, and what is already wired.', 'To check a rig after edits: links, hierarchy, compile state.'],
-        whenNotToUse: ['Finding a unit to add (use list_rig_units).'],
-        inputProps: {
-            assetPath: str('Control Rig asset path, e.g. /Game/Rigs/CR_Arm.'),
-            node: str('One node\'s name: only that node, with every struct member pin by its full path.'),
-        },
-        required: ['assetPath'],
-        effect: 'read', editorStates: ANY_EDITOR_STATE, latency: 'instant', resources: 'low', plugins: CR_ESU,
-        exampleInput: { action: 'get_control_rig', assetPath: '/Game/Rigs/CR_Arm' },
-        exampleOutput: { success: true, message: 'CR_Arm: 2 node(s), 1 link(s), 3 hierarchy element(s).', assetPath: '/Game/Rigs/CR_Arm.CR_Arm',
-            nodes: [{ name: 'ForwardsSolve', title: 'Forwards Solve', unit: '/Script/ControlRig.RigUnit_BeginExecution', position: [0, 0], pins: [{ pin: 'ForwardsSolve.ExecutePin', direction: 'Output', type: 'FRigVMExecuteContext', linked: true }] }],
-            links: [{ from: 'ForwardsSolve.ExecutePin', to: 'SetHand.ExecutePin' }], elements: [{ type: 'Bone', name: 'root' }, { type: 'Bone', name: 'hand_r', parent: 'root' }], elementCount: 3, compiled: true },
-        outputProps: {
-            assetPath: str('The rig read.'),
-            nodes: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Each node: name, title, unit (struct path), position [x, y] and pins [{pin, direction, type, default, linked}].' },
-            links: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Each link: from (output pin) and to (input pin).' },
-            elements: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Hierarchy elements in order (up to 500): type (Bone, Null, Control, Curve ...), name and parent.' },
-            elementCount: num('All hierarchy elements.'),
-            compiled: bool('Whether the rig is compiled and up to date.'),
-            nodeNames: { type: 'array', items: { type: 'string' }, description: 'With a node that is not there: the nodes there are.' },
-        },
-        outputRequired: ['assetPath', 'nodes'] }),
-    buildRecord({ parentTool: T, id: `${T}.list_rig_units`, action: 'list_rig_units', family: F,
-        topics: ['rig units', 'find rig unit', 'control rig node types'],
-        summary: 'Find the units a Control Rig graph can hold (Get Transform, Two Bone IK, Aim, math and more): each unit\'s object path, name and category, for edit_control_rig add_unit.',
-        whenToUse: ['A unit is needed for add_unit and its name is not known.'],
-        whenNotToUse: ['Reading what a rig already holds (use get_control_rig).'],
-        inputProps: {
-            query: str('Words to match in the unit\'s name, display name, category or keywords (spaces ignored), e.g. two bone, aim, set transform.'),
-            limit: num('Most units to list (default 50, up to 500); matched counts them all.'),
-        },
-        required: [],
-        effect: 'read', editorStates: ANY_EDITOR_STATE, latency: 'instant', resources: 'low', plugins: CR_ESU,
-        exampleInput: { action: 'list_rig_units', query: 'two bone' },
-        exampleOutput: { success: true, message: '2 rig unit(s) match.', matched: 2, units: [{ unit: '/Script/ControlRig.RigUnit_TwoBoneIKSimplePerItem', name: 'Basic IK', category: 'Hierarchy' }] },
-        outputProps: {
-            units: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Matching units sorted by struct name: unit (the object path add_unit takes), name and category.' },
-            matched: num('Units that match.'),
-        },
-        outputRequired: ['units', 'matched'] }),
-];
-//# sourceMappingURL=authoring-1.data.js.map

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

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

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

@@ -1,179 +0,0 @@
-import { buildRecord } from '../helpers.js';
-import { P } from '../properties.js';
-import { A } from './animation-properties.js';
-import { bool, num, str, vec3 } from '../../shared/schema-props.js';
-const T = 'animation_physics';
-const F = 'animation';
-const W = ['An animation asset or graph must be authored.'];
-const ESU = ['EditorScriptingUtilities'];
-const IK = ['ControlRig', 'IKRig', 'EditorScriptingUtilities'];
-const BLEND_OPTION = { type: 'string', enum: ['Linear', 'Cubic', 'Sinusoidal'], description: 'Blend curve; left as it is when omitted.' };
-export const ANIM_AUTHORED_2 = [
-    buildRecord({ parentTool: T, id: `${T}.create_ik_rig`, action: 'create_ik_rig', family: F,
-        summary: 'Create an IK Rig asset.', whenToUse: ['IK retargeting source needed.'], whenNotToUse: ['Use create_control_rig.'],
-        inputProps: { name: P.name, path: P.path, skeletonPath: P.skeletonPath, skeletalMeshPath: str('Skeletal mesh the IK Rig is built on; its skeleton is used.'), save: A.save }, required: ['name'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: IK,
-        exampleInput: { action: 'create_ik_rig', name: 'IKR_Char', skeletonPath: '/Game/SK_Char' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_ik_retargeter`, action: 'create_ik_retargeter', family: F,
-        summary: 'Create an IK Retargeter asset.', whenToUse: ['Retarget between two skeletons.'], whenNotToUse: ['Single skeleton.'],
-        inputProps: { name: P.name, path: P.path, sourceIKRigPath: P.assetPath, targetIKRigPath: P.assetPath, save: A.save },
-        required: ['name'], effect: 'write', latency: 'interactive', resources: 'medium', plugins: IK,
-        exampleInput: { action: 'create_ik_retargeter', name: 'IKRT_Char', sourceIKRigPath: '/Game/IKR_A', targetIKRigPath: '/Game/IKR_B', save: true } }),
-    buildRecord({ parentTool: T, id: `${T}.setup_ik`, action: 'setup_ik', family: F,
-        summary: 'Create a Control Rig Blueprint bound to a skeleton to host IK solvers.', whenToUse: ['IK chains must be authored in a Control Rig.'], whenNotToUse: ['An IK Rig asset is needed (kind rig).'],
-        inputProps: { name: P.name, path: str('Folder for the Control Rig (default /Game/Animations).'), skeletonPath: P.skeletonPath }, required: ['name', 'skeletonPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: IK,
-        exampleInput: { action: 'setup_ik', name: 'TestIK', skeletonPath: '/Game/SK_Char' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_retarget_chain_mapping`, action: 'set_retarget_chain_mapping', family: F,
-        topics: ['retarget chain mapping', 'map retarget chains', 'fix retargeted limb'],
-        summary: 'Set which source IK Rig chain drives a target chain in an IK Retargeter (None clears it), or auto-map every unmapped chain by name; replies with the whole mapping.',
-        whenToUse: ['A limb retargets from the wrong source chain after setup_retargeting or create_ik_retargeter.'], whenNotToUse: ['The retargeter does not exist yet (kind retargeter).'],
-        inputProps: {
-            assetPath: str('IK Retargeter asset to edit.'),
-            targetChain: str('Target IK Rig chain to map; required unless autoMap.'),
-            sourceChain: str('Source IK Rig chain that drives it; empty or None clears the mapping.'),
-            autoMap: bool('Map every unmapped chain: exact name matches first, then the closest names (default false).'),
-            save: A.save,
-        },
-        required: ['assetPath'], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: IK,
-        outputProps: {
-            mapping: { type: 'array', items: { type: 'object', properties: { targetChain: { type: 'string', description: 'Target IK Rig chain.' }, sourceChain: { type: 'string', description: 'Source chain driving it, or None.' } }, additionalProperties: false }, description: 'Every target chain with the source chain now driving it (None when unmapped).' },
-            changed: { type: 'boolean', description: 'Whether any mapping changed.' },
-            saved: { type: 'boolean', description: 'Whether the retargeter was saved.' },
-        },
-        exampleInput: { action: 'set_retarget_chain_mapping', assetPath: '/Game/Retargeting/IKRT_Char', targetChain: 'LeftArm', sourceChain: 'LeftArm' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_animation_asset`, action: 'create_animation_asset', family: F,
-        summary: 'Create an empty Animation Sequence or Montage on a skeleton.', whenToUse: W, whenNotToUse: ['Use create_animation_sequence.'],
-        inputProps: { name: P.name, path: P.path, skeletonPath: P.skeletonPath, assetType: { type: 'string', enum: ['sequence', 'montage'], description: 'Asset class to create (default sequence).' } }, required: ['name', 'skeletonPath'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'create_animation_asset', name: 'A_Run', skeletonPath: '/Game/SK_Char' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_pose_library`, action: 'create_pose_library', family: F,
-        topics: ['pose asset', 'pose library', 'facial poses'],
-        summary: 'Create a Pose Asset from an animation sequence, one pose per key frame, on the sequence\'s skeleton; PoseByName and PoseBlender nodes play its poses.',
-        whenToUse: ['Named poses (facial shapes, hand poses, correctives) must be blended by name in an Animation Blueprint.'], whenNotToUse: ['A playable clip is needed; use kind sequence or montage.'],
-        inputProps: {
-            name: P.name,
-            path: str('Folder for the new asset (default /Game/Animations).'),
-            sourceAnimationPath: str('AnimSequence whose key frames become the poses; its skeleton is used.'),
-            poseNames: { type: 'array', items: { type: 'string' }, description: 'Distinct names for the poses in frame order; frames without a name keep the engine default name.' },
-            additive: bool('Make the poses additive against pose 0, as facial and corrective poses are (default false).'),
-        },
-        required: ['name', 'sourceAnimationPath'], effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        outputProps: {
-            assetPath: P.assetPath,
-            skeletonPath: str('Skeleton the pose asset uses.'),
-            poseCount: num('Poses in the asset.'),
-            poseNames: { type: 'array', items: { type: 'string' }, description: 'Pose names read back from the asset.' },
-            additive: bool('Whether the poses are additive.'),
-            saved: bool('Whether the pose asset was saved.'),
-            skeletonSaved: bool('UE 5.0 to 5.2: whether the skeleton, which holds the pose curve names there, was saved.'),
-        },
-        exampleInput: { action: 'create_pose_library', name: 'PA_Face', sourceAnimationPath: '/Game/Animations/A_FacePoses', poseNames: ['Neutral', 'Smile', 'Blink'] } }),
-    buildRecord({ parentTool: T, id: `${T}.create_animation_sequence`, action: 'create_animation_sequence', family: F,
-        summary: 'Create an Animation Sequence asset.', whenToUse: ['A keyframed clip is needed.'], whenNotToUse: ['Use create_animation_asset.'],
-        inputProps: { name: P.name, path: P.path, skeletonPath: P.skeletonPath, numFrames: num('Length in frames (default 30).'), frameRate: num('Frames per second (default 30).'), save: A.save },
-        required: ['name'], effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'create_animation_sequence', name: 'A_Run', skeletonPath: '/Game/SK_Char', numFrames: 30, frameRate: 30 },
-        exampleOutput: { success: true, message: 'Animation sequence created' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_sequence_length`, action: 'set_sequence_length', family: F,
-        summary: 'Set the length of an Animation Sequence.', whenToUse: ['Clip duration must change.'], whenNotToUse: ['Use create_animation_sequence.'],
-        inputProps: { assetPath: P.assetPath, animationPath: P.animationPath, numFrames: num('New length in frames.'), length: num('New length in seconds, used when numFrames is omitted.'), frameRate: num('Frames per second; the sequence keeps its current rate when omitted.'), save: A.save }, required: [], requiredOneOf: ['numFrames', 'length'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'set_sequence_length', assetPath: '/Game/A_Run', numFrames: 60 },
-        exampleOutput: { success: true, message: 'Sequence length set' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_bone_track`, action: 'add_bone_track', family: F,
-        summary: 'Add a bone animation track.', whenToUse: ['A bone must be animated.'], whenNotToUse: ['Track exists.'],
-        inputProps: { assetPath: P.assetPath, animationPath: P.animationPath, boneName: P.boneName, save: A.save }, required: ['boneName'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_bone_track', assetPath: '/Game/A_Run', boneName: 'spine_01' },
-        exampleOutput: { success: true, message: 'Bone track added' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_bone_key`, action: 'set_bone_key', family: F,
-        summary: 'Set a bone transform key.', whenToUse: ['Keyframe a bone pose.'], whenNotToUse: ['Use add_bone_track.'],
-        inputProps: { assetPath: P.assetPath, animationPath: P.animationPath, boneName: P.boneName, frame: P.frame, location: P.location, rotation: P.rotation, scale: vec3('Bone scale as [x, y, z] (default [1, 1, 1]).'), save: A.save },
-        required: ['boneName'], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        plugins: ESU, exampleInput: { action: 'set_bone_key', assetPath: '/Game/A_Run', boneName: 'spine_01', frame: 0 },
-        exampleOutput: { success: true, message: 'Bone key set' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_curve_key`, action: 'set_curve_key', family: F,
-        summary: 'Set an animation curve key.', whenToUse: ['Animate a curve.'], whenNotToUse: ['Use add_bone_track.'],
-        inputProps: { assetPath: P.assetPath, animationPath: P.animationPath, curveName: P.curveName, frame: P.frame, value: P.value, createIfMissing: bool('Create the curve when the sequence does not have it (default true).'), save: A.save },
-        required: ['curveName'], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        plugins: ESU, exampleInput: { action: 'set_curve_key', assetPath: '/Game/A_Run', curveName: 'Weight', frame: 0, value: 1 },
-        exampleOutput: { success: true, message: 'Curve key set' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_notify_state`, action: 'add_notify_state', family: F,
-        summary: 'Add a notify state spanning a frame range.', whenToUse: ['A ranged notify is needed.'], whenNotToUse: ['Use add_notify.'],
-        inputProps: { assetPath: P.assetPath, animationPath: P.animationPath, notifyClass: A.notifyClass, notifyName: P.notifyName, startFrame: A.startFrame, endFrame: A.endFrame, trackIndex: A.trackIndex, save: A.save },
-        required: [], requiredOneOf: ['notifyClass', 'notifyName'], effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_notify_state', assetPath: '/Game/A_Run', notifyName: 'Windup', startFrame: 1, endFrame: 10, trackIndex: 0 } }),
-    buildRecord({ parentTool: T, id: `${T}.add_sync_marker`, action: 'add_sync_marker', family: F,
-        summary: 'Add a sync marker to a sequence.', whenToUse: ['Sync groups needed.'], whenNotToUse: ['No sync required.'],
-        inputProps: { assetPath: P.assetPath, animationPath: P.animationPath, markerName: P.markerName, frame: P.frame, save: A.save }, required: [],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_sync_marker', assetPath: '/Game/A_Run', markerName: 'FootL', frame: 5 } }),
-    buildRecord({ parentTool: T, id: `${T}.set_root_motion_settings`, action: 'set_root_motion_settings', family: F,
-        summary: 'Configure root motion on a sequence.', whenToUse: ['Root motion locomotion needed.'], whenNotToUse: ['In-place animation.'],
-        inputProps: { assetPath: P.assetPath, animationPath: P.animationPath, enableRootMotion: P.bool_, rootMotionRootLock: P.string_, forceRootLock: A.forceRootLock, save: A.save },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        plugins: ESU, exampleInput: { action: 'set_root_motion_settings', assetPath: '/Game/A_Run', enableRootMotion: true, rootMotionRootLock: 'RefPose' },
-        exampleOutput: { success: true, message: 'Root motion settings set' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_additive_settings`, action: 'set_additive_settings', family: F,
-        summary: 'Configure additive animation settings.', whenToUse: ['Additive layering needed.', 'A hand-keyed move (an arm raise, a head turn) must play on top of a mocap clip: key it as a procedural clip relative to the reference pose, then make it LocalSpaceAdditive with basePoseType RefPose.'], whenNotToUse: ['Absolute pose.'],
-        inputProps: {
-            assetPath: P.assetPath, animationPath: P.animationPath,
-            additiveAnimType: { type: 'string', enum: ['NoAdditive', 'LocalSpaceAdditive', 'MeshSpaceAdditive'], description: 'NoAdditive (default) plays the clip as a full pose. LocalSpaceAdditive keeps only its difference from the base pose and adds that on top of whatever plays under it (a Sequencer section on another row, Apply Additive in an Animation Blueprint). MeshSpaceAdditive adds rotations in mesh space, for aim offsets; Sequencer cannot play it.' },
-            basePoseType: { type: 'string', enum: ['RefPose', 'AnimScaled', 'AnimFrame'], description: 'What the additive difference is taken from (default RefPose): RefPose = the skeleton reference pose, AnimScaled = basePoseAnimation frame by frame, AnimFrame = one frame (basePoseFrame) of basePoseAnimation.' },
-            basePoseFrame: A.basePoseFrame, basePoseAnimation: str('Animation sequence to take the additive base pose from.'), save: A.save,
-        }, required: [],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'set_additive_settings', assetPath: '/Game/A_Run', additiveAnimType: 'NoAdditive', basePoseType: 'RefPose', basePoseFrame: 0 } }),
-    buildRecord({ parentTool: T, id: `${T}.create_montage`, action: 'create_montage', family: F,
-        topics: ['anim montage', 'montage asset', 'new montage'],
-        summary: 'Create a montage asset, optionally from a sequence.', whenToUse: ['A playable montage is needed.'], whenNotToUse: ['Use create_animation_sequence.'],
-        inputProps: { name: P.name, path: P.path, skeletonPath: P.skeletonPath, animationPath: str('Sequence the montage plays; its skeleton is used when skeletonPath is omitted.'), slotName: str('Name of the montage slot (default DefaultSlot).'), save: A.save }, required: ['name'], requiredOneOf: ['skeletonPath', 'animationPath'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'create_montage', name: 'MT_Slash', skeletonPath: '/Game/SK_Char' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_montage_section`, action: 'add_montage_section', family: F,
-        summary: 'Add a section to a montage.', whenToUse: ['Montage needs a section.'], whenNotToUse: ['Use create_montage.'],
-        inputProps: { assetPath: P.assetPath, montagePath: P.assetPath, sectionName: P.sectionName, startTime: P.startTime, save: A.save }, required: ['sectionName'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_montage_section', assetPath: '/Game/MT_Slash', sectionName: 'Hit', startTime: 0 },
-        exampleOutput: { success: true, message: 'Montage section added' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_montage_slot`, action: 'add_montage_slot', family: F,
-        summary: 'Add a slot to a montage.', whenToUse: ['Montage must expose a slot.'], whenNotToUse: ['Default slot.'],
-        inputProps: { assetPath: P.assetPath, montagePath: P.assetPath, animationPath: str('Sequence to add as a segment of the slot.'), slotName: P.slotName, startTime: P.startTime, save: A.save }, required: ['animationPath'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_montage_slot', assetPath: '/Game/MT_Slash', animationPath: '/Game/A_Slash', slotName: 'DefaultSlot' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_section_timing`, action: 'set_section_timing', family: F,
-        summary: 'Move a montage section to a new start time (a section runs until the next one starts).', whenToUse: ['Section timing must change.'], whenNotToUse: ['Use add_montage_section.'],
-        inputProps: { assetPath: P.assetPath, montagePath: P.assetPath, sectionName: P.sectionName, startTime: P.startTime, save: A.save },
-        required: ['sectionName'], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        plugins: ESU,
-        exampleInput: { action: 'set_section_timing', assetPath: '/Game/MT_Slash', sectionName: 'Hit', startTime: 0 },
-        exampleOutput: { success: true, message: 'Section timing updated' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_montage_notify`, action: 'add_montage_notify', family: F,
-        summary: 'Add a notify to a montage.', whenToUse: ['Timed event needed in montage.'], whenNotToUse: ['Use add_notify_state.'],
-        inputProps: { assetPath: P.assetPath, montagePath: P.assetPath, notifyClass: A.notifyClass, notifyName: P.notifyName, time: P.time, trackIndex: A.trackIndex, save: A.save }, required: [],
-        requiredOneOf: ['notifyClass', 'notifyName'], effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_montage_notify', assetPath: '/Game/MT_Slash', notifyName: 'Hit', time: 0.5 } }),
-    buildRecord({ parentTool: T, id: `${T}.set_blend_in`, action: 'set_blend_in', family: F,
-        summary: 'Set montage blend-in time.', whenToUse: ['Smooth entry needed.'], whenNotToUse: ['Use set_blend_out.'],
-        inputProps: { assetPath: P.assetPath, montagePath: P.assetPath, blendTime: P.blendTime, blendOption: BLEND_OPTION, save: A.save }, required: [],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'set_blend_in', assetPath: '/Game/MT_Slash', blendTime: 0.2 } }),
-    buildRecord({ parentTool: T, id: `${T}.set_blend_out`, action: 'set_blend_out', family: F,
-        summary: 'Set montage blend-out time.', whenToUse: ['Smooth exit needed.'], whenNotToUse: ['Use set_blend_in.'],
-        inputProps: { assetPath: P.assetPath, montagePath: P.assetPath, blendTime: P.blendTime, blendOption: BLEND_OPTION, save: A.save }, required: [],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'set_blend_out', assetPath: '/Game/MT_Slash', blendTime: 0.2 } }),
-    buildRecord({ parentTool: T, id: `${T}.link_sections`, action: 'link_sections', family: F,
-        summary: 'Link two montage sections.', whenToUse: ['Sections must chain.'], whenNotToUse: ['Use add_montage_section.'],
-        inputProps: { assetPath: P.assetPath, montagePath: P.assetPath, fromSection: P.fromSection, toSection: P.toSection, save: A.save }, required: [],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'link_sections', assetPath: '/Game/MT_Slash', fromSection: 'Start', toSection: 'Hit' },
-        exampleOutput: { success: true, message: 'Sections linked' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_notify`, action: 'add_notify', family: F,
-        summary: 'Add a frame notify to a sequence (authoring).', whenToUse: ['Frame event in a sequence.'], whenNotToUse: ['Use add_montage_notify.'],
-        inputProps: { assetPath: P.assetPath, animationPath: P.animationPath, notifyClass: A.notifyClass, notifyName: P.notifyName, frame: P.frame, time: num('Trigger time in seconds, used when frame is omitted.'), trackIndex: A.trackIndex, save: A.save }, required: [],
-        requiredOneOf: ['notifyClass', 'notifyName'], effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_notify', assetPath: '/Game/A_Run', notifyName: 'Step', frame: 10 } }),
-];
-//# sourceMappingURL=authoring-2.data.js.map

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

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