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

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

@@ -1,123 +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 = 'physics';
-const ESU = ['EditorScriptingUtilities'];
-const IK = ['ControlRig', 'IKRig', 'EditorScriptingUtilities'];
-export const ANIM_AUTHORED_3 = [
-    buildRecord({ parentTool: T, id: `${T}.play_montage`, action: 'play_montage', family: F,
-        topics: ['play animation', 'play anim', 'trigger montage'],
-        summary: 'Play a montage on a runtime actor (PIE).', whenToUse: ['A montage must play on a live actor.'], whenNotToUse: ['Author the montage asset.'],
-        inputProps: { actorName: P.actorName, montagePath: P.assetPath, playRate: P.playRate }, required: ['actorName', 'montagePath'],
-        effect: 'write', editorStates: ['pie', 'simulate'], behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        plugins: ESU,
-        exampleInput: { action: 'play_montage', actorName: 'Char_1', montagePath: '/Game/MT_Slash', playRate: 1.25 } }),
-    buildRecord({ parentTool: T, id: `${T}.setup_ragdoll`, action: 'setup_ragdoll', family: F,
-        summary: 'Enable runtime ragdoll physics on a skeletal actor; requires an assigned PhysicsAsset and an editor build.',
-        whenToUse: ['A skeletal actor must enter ragdoll simulation at runtime (editor build).'], whenNotToUse: ['Author the PhysicsAsset (use create_physics_asset).'],
-        inputProps: { actorName: P.actorName, physicsAssetPath: { type: 'string', description: 'Physics asset to assign before simulating; the mesh default is used when omitted.' } }, required: ['actorName'],
-        effect: 'write', editorStates: ['pie', 'simulate'], behavior: { idempotency: 'idempotent', longRunning: false },
-        latency: 'interactive', resources: 'low', plugins: ESU,
-        outputProps: { ragdollActive: P.bool_, hasPhysicsAsset: P.bool_ }, outputRequired: ['ragdollActive'],
-        exampleInput: { action: 'setup_ragdoll', actorName: 'Char_1' }, exampleOutput: { success: true, message: 'Ragdoll setup completed', ragdollActive: true, hasPhysicsAsset: true } }),
-    buildRecord({ parentTool: T, id: `${T}.activate_ragdoll`, action: 'activate_ragdoll', family: F,
-        summary: 'Switch ragdoll simulation on/off at runtime on a skeletal actor via the distinct native activate_ragdoll action (editor build).',
-        whenToUse: ['Ragdoll must be switched on/off at runtime (editor build).'], whenNotToUse: ['Use setup_ragdoll for initial enable/physics asset assignment.'],
-        inputProps: { actorName: P.actorName, activate: P.activate }, required: ['actorName'],
-        effect: 'write', editorStates: ['pie', 'simulate'], behavior: { idempotency: 'idempotent', longRunning: false },
-        latency: 'interactive', resources: 'low', plugins: ESU,
-        outputProps: { ragdollActive: P.bool_, hasPhysicsAsset: P.bool_ }, outputRequired: ['ragdollActive'],
-        exampleInput: { action: 'activate_ragdoll', actorName: 'Char_1', activate: true }, exampleOutput: { success: true, message: 'Ragdoll activation state changed', ragdollActive: true, hasPhysicsAsset: true } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_vehicle`, action: 'configure_vehicle', topics: ['set up vehicle'], family: F,
-        summary: 'Configure vehicle movement on a skeletal actor.', whenToUse: ['A vehicle must be set up (ChaosVehicles).'], whenNotToUse: ['Use configure_physics_simulation.'],
-        inputProps: { actorName: P.actorName, vehicleType: { type: 'string', enum: ['WheeledVehicle4W', 'WheeledVehicle'], description: 'Vehicle movement to set up; only a wheeled vehicle is supported (default WheeledVehicle4W).' }, mass: P.mass, dragCoefficient: P.dragCoefficient,
-            wheels: { type: 'array', items: { type: 'object', additionalProperties: false, properties: { boneName: { type: 'string' }, offset: { type: 'object', additionalProperties: false, properties: { x: { type: 'number' }, y: { type: 'number' }, z: { type: 'number' } } }, radius: { type: 'number' }, width: { type: 'number' }, friction: { type: 'number' } } }, description: 'Wheel setups, replacing the existing ones: [{ boneName, offset {x,y,z}, radius, width, friction }].' },
-            engine: { type: 'object', additionalProperties: false, properties: { maxRPM: { type: 'number' }, maxTorque: { type: 'number' }, gears: { type: 'number' } }, description: 'Engine settings: maxRPM, maxTorque, gears (forward gear count).' },
-            transmission: { type: 'object', additionalProperties: false, properties: { finalDrive: { type: 'number' }, finalDriveRatio: { type: 'number' }, gearRatios: { type: 'array', items: { type: 'number' } } }, description: 'Transmission settings: finalDrive and forward gearRatios.' } }, required: ['actorName'],
-        effect: 'write', editorStates: ['edit'], latency: 'interactive', resources: 'medium', plugins: ['ChaosVehiclesPlugin', 'EditorScriptingUtilities'],
-        exampleInput: { action: 'configure_vehicle', actorName: 'Car_1', vehicleType: 'WheeledVehicle4W', dragCoefficient: 0.32 } }),
-    buildRecord({ parentTool: T, id: `${T}.setup_physics_simulation`, action: 'setup_physics_simulation', topics: ['simulate physics', 'enable skeletal mesh physics'], family: F,
-        summary: 'Generate and assign a Physics Asset so a skeletal mesh can simulate.', whenToUse: ['A skeletal mesh must simulate physics.'], whenNotToUse: ['Use configure_vehicle.'],
-        inputProps: { actorName: P.actorName, skeletonPath: P.skeletonPath, skeletalMeshPath: P.skeletalMeshPath, savePath: A.savePath, physicsAssetName: A.physicsAssetName, assignToMesh: A.assignToMesh }, required: [],
-        effect: 'write', editorStates: ['edit', 'pie'], behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        plugins: ESU, outputProps: { existingAsset: P.bool_, meshPath: P.meshPath }, outputRequired: [],
-        exampleInput: { action: 'setup_physics_simulation', skeletalMeshPath: '/Game/SKM_Char', savePath: '/Game/Physics', physicsAssetName: 'PHYS_Char', assignToMesh: false },
-        exampleOutput: { success: true, message: 'Physics simulation set', existingAsset: false } }),
-    buildRecord({ parentTool: T, id: `${T}.add_blend_sample`, action: 'add_blend_sample', family: F,
-        summary: 'Add a blend sample to a Blend Space.', whenToUse: ['Blend sample needed.'], whenNotToUse: ['Use create_blend_space.'],
-        inputProps: { assetPath: P.assetPath, sampleValue: { description: 'Sample position: a number on a 1D blend space, or {x, y} (or [x, y]) on a 2D one.' }, animationPath: str('Sequence to place at sampleValue.'), save: A.save }, required: ['assetPath', 'animationPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_blend_sample', assetPath: '/Game/BS_Locomotion', animationPath: '/Game/A_Run', sampleValue: 100 } }),
-    buildRecord({ parentTool: T, id: `${T}.force_rebuild_blend_space`, action: 'force_rebuild_blend_space', family: F,
-        summary: 'Force a Blend Space rebuild and recompile referencers.', whenToUse: ['Axis bounds changed and dependents must recompile.'], whenNotToUse: ['Normal save suffices.'],
-        inputProps: { assetPath: P.assetPath, compileReferencers: P.compileReferencers, rebuildBlendParameters: P.rebuildBlendParameters, save: A.save }, required: ['assetPath'],
-        effect: 'write', behavior: { longRunning: true }, latency: 'long-running', resources: 'medium', plugins: ESU,
-        outputProps: { rebuiltBlendParameters: P.bool_, referencersCompiled: P.num_, compiledAnimBlueprints: P.arrayOfStrings }, outputRequired: [],
-        exampleInput: { action: 'force_rebuild_blend_space', assetPath: '/Game/BS_Locomotion', compileReferencers: true, rebuildBlendParameters: true },
-        exampleOutput: { success: true, message: 'Blend space rebuilt', referencersCompiled: 3 } }),
-    buildRecord({ parentTool: T, id: `${T}.set_axis_settings`, action: 'set_axis_settings', family: F,
-        summary: 'Set Blend Space axis settings.', whenToUse: ['Axis labels/ranges must change.'], whenNotToUse: ['Use add_blend_sample.'],
-        inputProps: { assetPath: P.assetPath, axis: str('Axis to change: X or Horizontal (default), Y or Vertical.'), axisName: P.axisName, minValue: P.minValue, maxValue: P.maxValue, gridDivisions: num('Number of grid divisions on the axis.'), save: A.save }, required: ['assetPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'set_axis_settings', assetPath: '/Game/BS_Locomotion', axis: 'X', axisName: 'Speed', minValue: 0, maxValue: 600 } }),
-    buildRecord({ parentTool: T, id: `${T}.set_interpolation_settings`, action: 'set_interpolation_settings', family: F,
-        summary: 'Set Blend Space input smoothing and sample weight speed; only the fields sent change.', whenToUse: ['Interpolation must change.'], whenNotToUse: ['Use set_axis_settings.'],
-        inputProps: { assetPath: P.assetPath, interpolationType: { type: 'string', enum: ['Average', 'Linear', 'Cubic', 'EaseInOut', 'ExponentialDecay', 'SpringDamper'], description: 'Input smoothing type for every axis; it only acts while interpolationTime is above 0.' }, interpolationTime: num('Input smoothing time in seconds for every axis (0 turns smoothing off).'), targetWeightInterpolationSpeed: num('Sample weight speed per second (0 turns weight smoothing off).'), save: A.save }, required: ['assetPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'set_interpolation_settings', assetPath: '/Game/BS_Locomotion', interpolationType: 'SpringDamper', interpolationTime: 0.2 } }),
-    buildRecord({ parentTool: T, id: `${T}.setup_retargeting`, action: 'setup_retargeting', topics: ['retarget to mannequin', 'bake retargeted animations', 'copy animation between characters'], family: F,
-        summary: 'Retarget animation onto another skeleton through an IK Retargeter, baking new AnimSequences.', whenToUse: ['Cross-skeleton retarget needed.', 'Mocap or marketplace clips must play on a different rig.'], whenNotToUse: ['Use create_ik_retargeter to build the retargeter asset without baking.'],
-        inputProps: { sourceSkeleton: P.skeletonPath, targetSkeleton: P.skeletonPath, assets: A.assets, savePath: A.savePath, suffix: A.suffix, overwrite: P.overwrite, sourceMesh: { type: 'string', description: 'SkeletalMesh giving the source proportions. Defaults to the skeleton preview mesh, then any mesh in the project built on it.' }, targetMesh: { type: 'string', description: 'SkeletalMesh to retarget onto. Defaults the same way as sourceMesh.' }, retargeterPath: { type: 'string', description: 'An existing IK Retargeter to bake through. Omit to auto-build one by characterizing both skeletons and mapping their chains.' } }, required: [],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: IK,
-        exampleInput: { action: 'setup_retargeting', sourceSkeleton: '/Game/SK_A', targetSkeleton: '/Game/SK_B', assets: ['/Game/A_Run'], savePath: '/Game/Retargeted', suffix: '_Retargeted', overwrite: true },
-        exampleOutput: { success: true, message: 'Retargeting completed' } }),
-    buildRecord({ parentTool: T, id: `${T}.skin_mesh_to_skeleton`, action: 'skin_mesh_to_skeleton', topics: ['rig static mesh', 'bind mesh to skeleton'], family: F,
-        summary: 'Skin a static mesh to a skeleton so it deforms with the animation, producing a SkeletalMesh.', whenToUse: ['Clothing, armour or a prop must move with the body instead of holding its shape.', 'A garment downloaded as a static mesh needs to be worn.'], whenNotToUse: ['The mesh is already a SkeletalMesh on the right skeleton.'],
-        inputProps: { staticMeshPath: { type: 'string', description: 'StaticMesh to skin, e.g. a coat downloaded as a rigid mesh.' }, skeletalMeshPath: { type: 'string', description: 'SkeletalMesh whose geometry to re-skin, for a dressed character whose own rig will not retarget. Its materials carry over. Use instead of staticMeshPath.' }, skeletonPath: P.skeletonPath, outputPath: { type: 'string', description: 'Canonical /Game path for the SkeletalMesh this writes.' },
-            sourceSkeletalMesh: { type: 'string', description: 'An already-skinned mesh on the same skeleton to copy weights from, such as the body the garment is worn over. Beats computing weights fresh wherever the garment hugs the body. Falls back to smooth binding when omitted.' }, save: A.save }, required: ['skeletonPath', 'outputPath'], requiredOneOf: ['staticMeshPath', 'skeletalMeshPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'medium', plugins: ESU,
-        outputProps: { assetPath: P.assetPath, weights: { type: 'string', description: "Which binding ran: 'transferred' from sourceSkeletalMesh, or 'smooth'." } }, outputRequired: [],
-        exampleInput: { action: 'skin_mesh_to_skeleton', staticMeshPath: '/Game/Fab/coat', skeletonPath: '/Game/Chars/SK_Hero_Skeleton', outputPath: '/Game/Chars/SKM_Coat', sourceSkeletalMesh: '/Game/Chars/SKM_Hero' },
-        exampleOutput: { success: true, message: 'Mesh skinned to skeleton' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_layered_blend_per_bone`, action: 'add_layered_blend_per_bone', family: F,
-        summary: 'Add a Layered Blend Per Bone node with its branch filters.', whenToUse: ['Partial-skeleton layering needed.'], whenNotToUse: ['Use add_blend_node.'],
-        inputProps: { blueprintPath: A.graphBlueprintPath, layerSetup: A.layerSetup, boneName: str('Shorthand for one layer filtering this bone and its children; ignored when layerSetup is sent.'), positionX: A.positionX, positionY: A.positionY, save: A.save }, required: ['blueprintPath'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_layered_blend_per_bone', blueprintPath: '/Game/ABP_Char', layerSetup: [{ branchFilters: [{ boneName: 'spine_01', blendDepth: 1 }] }] } }),
-    buildRecord({ parentTool: T, id: `${T}.set_anim_graph_node_value`, action: 'set_anim_graph_node_value', family: F,
-        summary: 'Set a value on an AnimGraph node: a setting of the node (Alpha, PlayRate, bLoopAnimation, NodeComment), or the animation an asset player plays (Sequence on a Sequence Player, BlendSpace on a Blend Space Player) by its asset path; the reply reads the stored value back.',
-        whenToUse: ['A graph node property must change.', 'A Sequence Player or Blend Space Player must play a different animation.'], whenNotToUse: ['Use add_blend_node.'],
-        inputProps: {
-            blueprintPath: A.graphBlueprintPath,
-            nodeName: str('The node: its object name (AnimGraphNode_SequencePlayer_0), its GUID (the nodeId create_node, add_state and inspect_graph report), or a custom name set in its NodeComment or its title when one node has it. Looks in the AnimGraph and in the state machines and states under it; a name that matches nothing answers NODE_NOT_FOUND listing every node (nodes), and one that matches several AMBIGUOUS_NODE listing them (candidates).'),
-            nodeId: str('The node GUID; an alternative to nodeName.'),
-            propertyName: str('The property: a member of the node\'s settings struct (Alpha, PlayRate, bLoopAnimation, Sequence) or of the graph node (NodeComment), with dots for a nested one (Node.PlayRate). On an asset player the asset property (Sequence, BlendSpace) is written through the node\'s own setter and read back, and fails when the node did not take it; any other property is written by reflection and its stored value read back.'),
-            value: { description: 'The value: a number, boolean or string, an {x,y,z} or {r,g,b,a} object for a struct, or for an asset property the asset path (/Game/Anims/A_Idle).' },
-            save: A.save,
-        },
-        required: ['blueprintPath', 'propertyName', 'value'], requiredOneOf: ['nodeName', 'nodeId'],
-        outputProps: {
-            nodeName: str('Object name of the node that was set.'),
-            nodeId: str('GUID of the node that was set.'),
-            propertyName: str('Echoes propertyName.'),
-            value: str('The value now stored, read back from the node: the asset path for an asset property.'),
-        }, outputRequired: [],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'set_anim_graph_node_value', blueprintPath: '/Game/ABP_Char', nodeName: 'Blend', propertyName: 'NodeComment', value: 'Updated' } }),
-    buildRecord({ parentTool: T, id: `${T}.get_animation_info`, action: 'get_animation_info', family: F,
-        topics: ['length and frame rate', 'notifies and curves', 'list montage sections', 'blend space axes'],
-        summary: 'Read an animation asset: sequence or montage length, frame rate, notifies, curves, root motion and additive flags; montage sections and slots; blend space axes; anim Blueprint skeleton and parent class.',
-        whenToUse: ['The length, notifies or curves of an animation sequence or montage must be read.', 'A montage\'s sections and slots, or a blend space\'s axes, must be checked before editing.'], whenNotToUse: ['Mutate assets.'],
-        inputProps: { assetPath: P.assetPath }, required: ['assetPath'],
-        effect: 'read', latency: 'instant', resources: 'low', plugins: ESU,
-        outputProps: { length: P.num_, frameRate: P.num_ }, outputRequired: [],
-        exampleInput: { action: 'get_animation_info', assetPath: '/Game/A_Run' }, exampleOutput: { success: true, message: 'Animation info', length: 1.0, frameRate: 30 } }),
-    buildRecord({ parentTool: T, id: `${T}.cleanup`, action: 'cleanup', topics: ['clean up test animation assets'], family: F,
-        summary: 'Delete the listed transient animation authoring assets.', whenToUse: ['Reset authoring session.'], whenNotToUse: ['Persist work.'],
-        inputProps: { artifacts: A.artifacts }, required: ['artifacts'],
-        effect: 'destructive', behavior: { safeToRetry: true }, latency: 'instant', resources: 'low',
-        plugins: ESU, exampleInput: { action: 'cleanup', artifacts: ['/Game/MCPTest/ABP_Temp'] } }),
-];
-//# sourceMappingURL=authoring-3.data.js.map

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

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

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

@@ -1,14 +0,0 @@
-import { ANIM_AUTHORED_1 } from './authoring-1.data.js';
-import { ANIM_AUTHORED_2 } from './authoring-2.data.js';
-import { ANIM_AUTHORED_3 } from './authoring-3.data.js';
-import { SKELETON_RECORDS } from './skeleton.data.js';
-import { applyFolds } from '../../shared/fold.js';
-import { ANIMATION_PHYSICS_FOLDS } from '../../folds/animation-physics.folds.js';
-export const ANIMATION_PHYSICS_UNFOLDED_SOURCES = [
-    ...ANIM_AUTHORED_1,
-    ...ANIM_AUTHORED_2,
-    ...ANIM_AUTHORED_3,
-    ...SKELETON_RECORDS,
-];
-export const ANIMATION_PHYSICS_SOURCES = applyFolds(ANIMATION_PHYSICS_UNFOLDED_SOURCES, ANIMATION_PHYSICS_FOLDS, 'animation_physics');
-//# sourceMappingURL=index.js.map

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

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

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

@@ -1,52 +0,0 @@
-import { buildRecord } from '../helpers.js';
-import { P } from '../properties.js';
-import { A } from './animation-properties.js';
-const T = 'animation_physics';
-const F = 'skeleton';
-const W = ['A skeleton, bone, socket, physics body or morph target must be authored.'];
-const ESU = ['EditorScriptingUtilities'];
-const SKEL_BONE_REQUIRED = ['skeletonPath', 'boneName'];
-export const SKELETON_BONE_RECORDS = [
-    buildRecord({ parentTool: T, id: `${T}.create_skeleton`, action: 'create_skeleton', topics: ['new skeleton asset'], family: F,
-        summary: 'Create a new Skeleton asset.', whenToUse: W, whenNotToUse: ['A SkeletalMesh already exists.'],
-        inputProps: { name: P.name, path: P.path, rootBoneName: A.rootBoneName, save: A.save }, required: [],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: ESU,
-        exampleInput: { action: 'create_skeleton', path: '/Game/SK_Char', rootBoneName: 'Root', save: true } }),
-    buildRecord({ parentTool: T, id: `${T}.add_bone`, action: 'add_bone', family: F,
-        summary: 'Add a bone to a skeleton.', whenToUse: W, whenNotToUse: ['Bone already exists.'],
-        inputProps: { skeletonPath: P.skeletonPath, boneName: P.boneName, parentBoneName: P.parentBoneName, location: P.location, rotation: P.rotation, scale: A.scale, save: A.save },
-        required: SKEL_BONE_REQUIRED, effect: 'write', latency: 'interactive', resources: 'low',
-        plugins: ESU, exampleInput: { action: 'add_bone', skeletonPath: '/Game/SK_Char', boneName: 'spine_01', parentBoneName: 'Root', location: [10, 0, 0], save: true },
-        exampleOutput: { success: true, message: 'Bone added' } }),
-    buildRecord({ parentTool: T, id: `${T}.remove_bone`, action: 'remove_bone', family: F,
-        summary: 'Remove a bone from a skeleton.', whenToUse: ['A bone must be removed.'], whenNotToUse: ['Keep the bone.'],
-        inputProps: { skeletonPath: P.skeletonPath, boneName: P.boneName, removeChildren: A.removeChildren, save: A.save }, required: SKEL_BONE_REQUIRED,
-        effect: 'destructive', behavior: { safeToRetry: false }, latency: 'interactive', resources: 'low',
-        plugins: ESU, exampleInput: { action: 'remove_bone', skeletonPath: '/Game/SK_Char', boneName: 'tail_01', removeChildren: true, save: true },
-        exampleOutput: { success: true, message: 'Bone removed' } }),
-    buildRecord({ parentTool: T, id: `${T}.rename_bone`, action: 'rename_bone', family: F,
-        summary: 'Rename a virtual bone on a skeleton (real skeleton bones cannot be renamed and answer OPERATION_NOT_SUPPORTED).', whenToUse: ['A virtual bone needs renaming.'], whenNotToUse: ['Name is correct.', 'The bone is a real skeleton bone.'],
-        inputProps: { skeletonPath: P.skeletonPath, boneName: P.boneName, newBoneName: P.newBoneName, save: A.save },
-        required: SKEL_BONE_REQUIRED, effect: 'write', latency: 'interactive', resources: 'low',
-        plugins: ESU, exampleInput: { action: 'rename_bone', skeletonPath: '/Game/SK_Char', boneName: 'old', newBoneName: 'new', save: true },
-        exampleOutput: { success: true, message: 'Bone renamed' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_bone_transform`, action: 'set_bone_transform', family: F,
-        summary: 'Set the rest transform of a bone.', whenToUse: ['A bone rest pose must change.'], whenNotToUse: ['Use runtime animation.'],
-        inputProps: { skeletonPath: P.skeletonPath, skeletalMeshPath: P.skeletalMeshPath, boneName: P.boneName, location: P.location, rotation: P.rotation, scale: A.scale, save: A.save },
-        required: ['boneName'], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        plugins: ESU, exampleInput: { action: 'set_bone_transform', skeletalMeshPath: '/Game/SM_Char', boneName: 'spine_01', location: [0, 0, 0], scale: [1, 1, 1] },
-        exampleOutput: { success: true, message: 'Bone transform set' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_bone_parent`, action: 'set_bone_parent', family: F,
-        summary: 'Reparent a bone under a new parent.', whenToUse: ['Bone hierarchy must change.'], whenNotToUse: ['Hierarchy is correct.'],
-        inputProps: { skeletonPath: P.skeletonPath, boneName: P.boneName, parentBoneName: { type: 'string', description: 'Existing bone to become the new parent.' }, save: A.save },
-        required: [...SKEL_BONE_REQUIRED, 'parentBoneName'], effect: 'write', latency: 'interactive', resources: 'low',
-        plugins: ESU, exampleInput: { action: 'set_bone_parent', skeletonPath: '/Game/SK_Char', boneName: 'tail_01', parentBoneName: 'spine_03', save: true },
-        exampleOutput: { success: true, message: 'Bone parent set' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_virtual_bone`, action: 'create_virtual_bone', family: F,
-        summary: 'Create a virtual bone between two bones.', whenToUse: ['A virtual bone is needed for IK.'], whenNotToUse: ['Use a real bone.'],
-        inputProps: { skeletonPath: P.skeletonPath, boneName: P.boneName, sourceBoneName: P.sourceBoneName, targetBoneName: P.targetBoneName, save: A.save },
-        required: ['skeletonPath', 'sourceBoneName'], effect: 'write', latency: 'interactive', resources: 'low',
-        plugins: ESU, exampleInput: { action: 'create_virtual_bone', skeletonPath: '/Game/SK_Char', sourceBoneName: 'hand_l', targetBoneName: 'hand_r', boneName: 'VB_Hands', save: true },
-        exampleOutput: { success: true, message: 'Virtual bone created' } }),
-];
-//# sourceMappingURL=skeleton-bone.data.js.map

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

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

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

@@ -1,97 +0,0 @@
-import { buildRecord } from '../helpers.js';
-import { P } from '../properties.js';
-import { A } from './animation-properties.js';
-import { num, vec3 } from '../../shared/schema-props.js';
-const T = 'animation_physics';
-const F = 'skeleton';
-const ESU = ['EditorScriptingUtilities'];
-const MESH_REQUIRED = ['skeletalMeshPath'];
-const MESH_SKELETON = { type: 'string', description: 'A skeletal mesh whose skeleton to read, instead of skeletonPath.' };
-export const SKELETON_PHYSICS_MORPH_RECORDS = [
-    buildRecord({ parentTool: T, id: `${T}.add_physics_body`, action: 'add_physics_body', family: F,
-        summary: 'Add a physics body to a PhysicsAsset.', whenToUse: ['A bone needs a collision body.'], whenNotToUse: ['Body exists.'],
-        inputProps: { physicsAssetPath: P.physicsAssetPath, boneName: P.boneName, bodyType: A.bodyType, radius: num('Sphere or capsule radius (default 10).'), length: num('Capsule length between the end caps (default 20).'), width: num('Box extent along X (default 10).'), depth: num('Box extent along Y (default 10).'), height: num('Box extent along Z (default 10).'), center: A.center, rotation: vec3('Box or capsule rotation relative to the bone as [pitch, yaw, roll].'), save: A.save }, required: ['physicsAssetPath', 'boneName'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_physics_body', physicsAssetPath: '/Game/PA_Char', boneName: 'spine_01', bodyType: 'Sphere', radius: 12, center: [0, 0, 0] },
-        exampleOutput: { success: true, message: 'Physics body added' } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_physics_body`, action: 'configure_physics_body', family: F,
-        summary: 'Configure a physics body mass/damping/collision.', whenToUse: ['Body parameters must change.'], whenNotToUse: ['Use add_physics_body.'],
-        inputProps: { physicsAssetPath: P.physicsAssetPath, boneName: P.boneName, mass: P.mass, linearDamping: P.linearDamping, angularDamping: P.angularDamping, collisionEnabled: P.collisionEnabled, simulatePhysics: P.simulatePhysics, save: A.save },
-        required: ['physicsAssetPath', 'boneName'], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        plugins: ESU, exampleInput: { action: 'configure_physics_body', physicsAssetPath: '/Game/PA_Char', boneName: 'spine_01', mass: 5, linearDamping: 0.25, collisionEnabled: true },
-        exampleOutput: { success: true, message: 'Physics body configured' } }),
-    buildRecord({ parentTool: T, id: `${T}.add_physics_constraint`, action: 'add_physics_constraint', family: F,
-        summary: 'Add a physics constraint between two bodies; refuses a pair that already has one.', whenToUse: ['Bodies must be jointed.'], whenNotToUse: ['Rigid bodies suffice.'],
-        inputProps: { physicsAssetPath: P.physicsAssetPath, bodyA: P.bodyA, bodyB: P.bodyB, constraintName: A.constraintName, limits: A.limits, save: A.save }, required: ['physicsAssetPath', 'bodyA', 'bodyB'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'add_physics_constraint', physicsAssetPath: '/Game/PA_Char', bodyA: 'spine_01', bodyB: 'spine_02', constraintName: 'Spine' },
-        exampleOutput: { success: true, message: 'Constraint added' } }),
-    buildRecord({ parentTool: T, id: `${T}.configure_constraint_limits`, action: 'configure_constraint_limits', family: F,
-        summary: 'Configure constraint angular/linear limits.', whenToUse: ['Joint limits must change.'], whenNotToUse: ['Use add_physics_constraint.'],
-        inputProps: { physicsAssetPath: P.physicsAssetPath, bodyA: P.bodyA, bodyB: P.bodyB, limits: A.limits, save: A.save }, required: ['physicsAssetPath', 'bodyA', 'bodyB'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'configure_constraint_limits', physicsAssetPath: '/Game/PA_Char', bodyA: 'spine_01', bodyB: 'spine_02', limits: { swing1LimitAngle: 30 } },
-        exampleOutput: { success: true, message: 'Constraint limits configured' } }),
-    buildRecord({ parentTool: T, id: `${T}.bind_cloth_to_skeletal_mesh`, action: 'bind_cloth_to_skeletal_mesh', family: F,
-        summary: 'Bind a cloth asset to a skeletal mesh.', whenToUse: ['Cloth simulation is needed (Chaos Cloth).'], whenNotToUse: ['No cloth.'],
-        inputProps: { skeletalMeshPath: P.skeletalMeshPath, clothAssetName: { type: 'string', description: 'Name of a clothing asset already registered on the mesh.' }, clothAssetPath: { type: 'string', description: 'Clothing asset to load and register before binding.' }, meshLodIndex: { type: 'number', description: 'Mesh LOD to bind (default 0).' }, sectionIndex: { type: 'number', description: 'Mesh section to bind (default 0).' }, assetLodIndex: { type: 'number', description: 'Clothing asset LOD to use (default 0).' }, save: A.save }, required: MESH_REQUIRED,
-        effect: 'write', behavior: { longRunning: true }, latency: 'long-running', resources: 'high', plugins: ['ChaosCloth', 'EditorScriptingUtilities'],
-        exampleInput: { action: 'bind_cloth_to_skeletal_mesh', skeletalMeshPath: '/Game/SM_Char', save: false },
-        exampleOutput: { success: true, message: 'Cloth bound' } }),
-    buildRecord({ parentTool: T, id: `${T}.assign_cloth_asset_to_mesh`, action: 'assign_cloth_asset_to_mesh', family: F,
-        summary: 'Assign a cloth asset to a skeletal mesh section.', whenToUse: ['A cloth asset must be assigned.'], whenNotToUse: ['Use bind_cloth_to_skeletal_mesh.'],
-        inputProps: { skeletalMeshPath: P.skeletalMeshPath, clothAssetName: { type: 'string', description: 'Name of a clothing asset already registered on the mesh.' }, clothAssetPath: { type: 'string', description: 'Clothing asset to load and register before binding.' }, meshLodIndex: { type: 'number', description: 'Mesh LOD to bind (default 0).' }, sectionIndex: { type: 'number', description: 'Mesh section to bind (default 0).' }, assetLodIndex: { type: 'number', description: 'Clothing asset LOD to use (default 0).' }, save: A.save }, required: MESH_REQUIRED,
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: ['ChaosCloth', 'EditorScriptingUtilities'],
-        exampleInput: { action: 'assign_cloth_asset_to_mesh', skeletalMeshPath: '/Game/SM_Char', save: false },
-        exampleOutput: { success: true, message: 'Cloth asset assigned' } }),
-    buildRecord({ parentTool: T, id: `${T}.create_morph_target`, action: 'create_morph_target', family: F,
-        summary: 'Create a morph target on a skeletal mesh.', whenToUse: ['Facial/shape blending needed.'], whenNotToUse: ['No morph targets.'],
-        inputProps: { skeletalMeshPath: P.skeletalMeshPath, morphTargetName: P.morphTargetName, deltas: A.deltas, lodIndex: A.lodIndex, save: A.save }, required: ['skeletalMeshPath', 'morphTargetName'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: ESU,
-        exampleInput: { action: 'create_morph_target', skeletalMeshPath: '/Game/SM_Char', morphTargetName: 'smile', deltas: [{ vertexIndex: 0, positionDelta: { x: 0, y: 0, z: 1 } }] },
-        exampleOutput: { success: true, message: 'Morph target created' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_morph_target_deltas`, action: 'set_morph_target_deltas', family: F,
-        summary: 'Set vertex deltas for a morph target.', whenToUse: ['Morph shape must be authored.'], whenNotToUse: ['Use create_morph_target.'],
-        inputProps: { skeletalMeshPath: P.skeletalMeshPath, morphTargetName: P.morphTargetName, deltas: A.deltas, lodIndex: A.lodIndex, save: A.save },
-        required: ['skeletalMeshPath', 'morphTargetName'], effect: 'write', behavior: { longRunning: true }, latency: 'long-running', resources: 'high',
-        plugins: ESU, exampleInput: { action: 'set_morph_target_deltas', skeletalMeshPath: '/Game/SM_Char', morphTargetName: 'smile', deltas: [{ vertexIndex: 0, positionDelta: { x: 0, y: 0, z: 2 } }] },
-        exampleOutput: { success: true, message: 'Morph deltas set' } }),
-    buildRecord({ parentTool: T, id: `${T}.import_morph_targets`, action: 'import_morph_targets', family: F,
-        topics: ['import morph targets', 'transfer blend shapes', 'copy morph targets'],
-        summary: 'Copy morph targets (blend shapes) from another skeletal mesh into this mesh\'s source data, each vertex taking the delta of the nearest source vertex, so they survive every rebuild.',
-        whenToUse: ['A mesh must get the blend shapes of a sculpted or imported variant.'], whenNotToUse: ['The morph is authored by hand on this mesh (edit create or set_deltas).'],
-        inputProps: {
-            skeletalMeshPath: P.skeletalMeshPath,
-            sourceMeshPath: { type: 'string', description: 'Skeletal mesh that owns the morph targets (its LOD 0 source data).' },
-            morphTargets: { type: 'array', items: { type: 'string' }, description: 'Names to import (default all the source mesh has in its source data).' },
-            lodIndex: A.lodIndex, dropRenderOnlyMorphs: A.dropRenderOnlyMorphs, save: A.save,
-        },
-        required: ['skeletalMeshPath', 'sourceMeshPath'], effect: 'write', behavior: { longRunning: true }, latency: 'long-running', resources: 'high', plugins: ESU,
-        outputProps: {
-            imported: { type: 'array', items: { type: 'object', properties: { name: { type: 'string', description: 'Morph target.' }, verticesAffected: { type: 'number', description: 'Vertices it moves on this mesh.' } }, additionalProperties: false }, description: 'Each imported morph target.' },
-            replaced: { type: 'array', items: { type: 'string' }, description: 'Morph targets the mesh already had and were replaced.' },
-            builtMorphTargets: { type: 'array', items: { type: 'string' }, description: 'Imported names that exist as morph targets after the rebuild.' },
-            unmatchedVertices: { type: 'number', description: 'Vertices farther than 2% of the source size from any source vertex.' },
-            morphTargetsDropped: { type: 'array', items: { type: 'string' }, description: 'Render-only morph targets the rebuild removed, only with dropRenderOnlyMorphs true.' },
-            saved: { type: 'boolean', description: 'Whether the mesh was saved.' },
-        },
-        exampleInput: { action: 'import_morph_targets', skeletalMeshPath: '/Game/Characters/SK_Head', sourceMeshPath: '/Game/Characters/SK_Head_Sculpt', morphTargets: ['Smile'] } }),
-    buildRecord({ parentTool: T, id: `${T}.get_skeleton_info`, action: 'get_skeleton_info', family: F,
-        summary: 'Read skeleton bone/socket info.', whenToUse: ['Inspect skeleton structure.'], whenNotToUse: ['Mutate the skeleton.'],
-        inputProps: { skeletonPath: P.skeletonPath, skeletalMeshPath: MESH_SKELETON }, required: [], requiredOneOf: ['skeletonPath', 'skeletalMeshPath'],
-        effect: 'read', latency: 'instant', resources: 'low', plugins: ESU,
-        outputProps: { boneCount: P.num_, virtualBoneCount: P.num_, socketCount: P.num_ }, outputRequired: [],
-        exampleInput: { action: 'get_skeleton_info', skeletonPath: '/Game/SK_Char' },
-        exampleOutput: { success: true, message: 'Skeleton info', boneCount: 50, socketCount: 2 } }),
-    buildRecord({ parentTool: T, id: `${T}.list_bones`, action: 'list_bones', family: F,
-        summary: 'List bones of a skeleton.', whenToUse: ['Enumerate bones.'], whenNotToUse: ['Mutate bones.'],
-        inputProps: { skeletonPath: P.skeletonPath, skeletalMeshPath: MESH_SKELETON }, required: [], requiredOneOf: ['skeletonPath', 'skeletalMeshPath'],
-        effect: 'read', latency: 'instant', resources: 'low', plugins: ESU,
-        outputProps: {
-            bones: { type: 'array', description: 'One entry per bone in reference-skeleton order.', items: { type: 'object', additionalProperties: false, properties: { name: { type: 'string' }, index: { type: 'number' }, parentIndex: { type: 'number', description: '-1 for the root bone.' }, parentName: { type: 'string' }, location: { type: 'object', additionalProperties: false, properties: { x: { type: 'number' }, y: { type: 'number' }, z: { type: 'number' } } } }, required: ['name', 'index', 'parentIndex'] } },
-            count: { type: 'number', description: 'Number of bones listed.' },
-        }, outputRequired: [],
-        exampleInput: { action: 'list_bones', skeletonPath: '/Game/SK_Char' },
-        exampleOutput: { success: true, message: 'Bones listed', bones: [{ name: 'root', index: 0, parentIndex: -1, location: { x: 0, y: 0, z: 0 } }, { name: 'spine_01', index: 1, parentIndex: 0, parentName: 'root', location: { x: 0, y: 0, z: 90 } }], count: 2 } }),
-];
-//# sourceMappingURL=skeleton-physics-morph.data.js.map

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

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

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

@@ -1,141 +0,0 @@
-import { buildRecord } from '../helpers.js';
-import { P } from '../properties.js';
-import { A } from './animation-properties.js';
-import { num } from '../../shared/schema-props.js';
-const T = 'animation_physics';
-const F = 'skeleton';
-const ESU = ['EditorScriptingUtilities'];
-const REMAINING = (what) => num(`Number of ${what} left on the asset after the call.`);
-export const SKELETON_READ_ALIAS_RECORDS = [
-    buildRecord({ parentTool: T, id: `${T}.list_sockets`, action: 'list_sockets', family: F,
-        summary: 'List sockets of a skeleton.', whenToUse: ['Enumerate sockets.'], whenNotToUse: ['Mutate sockets.'],
-        inputProps: { skeletonPath: P.skeletonPath, skeletalMeshPath: { type: 'string', description: 'A skeletal mesh whose skeleton to read, instead of skeletonPath.' } }, required: [], requiredOneOf: ['skeletonPath', 'skeletalMeshPath'],
-        effect: 'read', latency: 'instant', resources: 'low', plugins: ESU,
-        outputProps: { sockets: { type: 'array', description: 'Sockets on the skeleton.', items: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Socket: name, boneName, relative location/rotation/scale.' } } }, outputRequired: [],
-        exampleInput: { action: 'list_sockets', skeletonPath: '/Game/SK_Char' },
-        exampleOutput: { success: true, message: 'Sockets listed', sockets: [{ name: 'Weapon', boneName: 'hand_r' }] } }),
-    buildRecord({ parentTool: T, id: `${T}.list_physics_bodies`, action: 'list_physics_bodies', family: F,
-        summary: 'List physics bodies of a PhysicsAsset.', whenToUse: ['Enumerate physics bodies.'], whenNotToUse: ['Mutate bodies.'],
-        inputProps: { physicsAssetPath: P.physicsAssetPath, skeletalMeshPath: { type: 'string', description: 'A skeletal mesh whose assigned physics asset to list, instead of physicsAssetPath.' } }, required: [], requiredOneOf: ['physicsAssetPath', 'skeletalMeshPath'],
-        effect: 'read', latency: 'instant', resources: 'low', plugins: ESU,
-        outputProps: { bodies: P.arrayOfStrings }, outputRequired: [],
-        exampleInput: { action: 'list_physics_bodies', physicsAssetPath: '/Game/PA_Char' },
-        exampleOutput: { success: true, message: 'Bodies listed', bodies: ['spine_01'] } }),
-    buildRecord({ parentTool: T, id: `${T}.set_physics_asset`, action: 'set_physics_asset', family: F,
-        summary: 'Assign a Physics Asset to a Skeletal Mesh.', whenToUse: ['A Skeletal Mesh must reference a specific Physics Asset.'], whenNotToUse: ['The Physics Asset itself must be edited (use configure_physics_body).'],
-        inputProps: { skeletalMeshPath: P.skeletalMeshPath, meshPath: P.meshPath, physicsAssetPath: P.physicsAssetPath },
-        required: ['physicsAssetPath'], requiredOneOf: ['skeletalMeshPath', 'meshPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: ESU,
-        outputProps: { skeletalMeshPath: P.skeletalMeshPath, physicsAssetPath: P.physicsAssetPath, physicsAssetName: A.physicsAssetName }, outputRequired: [],
-        exampleInput: { action: 'set_physics_asset', skeletalMeshPath: '/Game/SKM_Char', physicsAssetPath: '/Game/PA_Char' },
-        exampleOutput: { success: true, message: 'Physics asset assigned', skeletalMeshPath: '/Game/SKM_Char', physicsAssetPath: '/Game/PA_Char', physicsAssetName: 'PA_Char' } }),
-    buildRecord({ parentTool: T, id: `${T}.remove_physics_body`, action: 'remove_physics_body', family: F,
-        summary: 'Remove a physics body from a Physics Asset.', whenToUse: ['A bone should no longer simulate.'], whenNotToUse: ['The body only needs different parameters (use configure_physics_body).'],
-        inputProps: { physicsAssetPath: P.physicsAssetPath, boneName: P.boneName },
-        required: ['physicsAssetPath', 'boneName'],
-        effect: 'destructive', behavior: { safeToRetry: false }, latency: 'interactive', resources: 'low', plugins: ESU,
-        outputProps: { physicsAssetPath: P.physicsAssetPath, boneName: P.boneName, remainingBodies: REMAINING('physics bodies') }, outputRequired: [],
-        exampleInput: { action: 'remove_physics_body', physicsAssetPath: '/Game/PA_Char', boneName: 'spine_01' },
-        exampleOutput: { success: true, message: 'Physics body removed', physicsAssetPath: '/Game/PA_Char', boneName: 'spine_01', remainingBodies: 8 } }),
-    buildRecord({ parentTool: T, id: `${T}.get_physics_asset_info`, action: 'get_physics_asset_info', family: F,
-        summary: 'Read the bodies and constraints declared by a Physics Asset.', whenToUse: ['The contents of a Physics Asset must be inspected before editing it.'], whenNotToUse: ['Only the body names are needed (use list_physics_bodies).'],
-        inputProps: { physicsAssetPath: P.physicsAssetPath, skeletalMeshPath: P.skeletalMeshPath },
-        required: [], requiredOneOf: ['physicsAssetPath', 'skeletalMeshPath'],
-        effect: 'read', behavior: { idempotency: 'idempotent', safeToRetry: true }, latency: 'instant', resources: 'low', plugins: ESU,
-        outputProps: {
-            physicsAssetPath: P.physicsAssetPath,
-            numBodies: { type: 'number', description: 'Number of physics bodies in the asset.' },
-            numConstraints: { type: 'number', description: 'Number of constraints in the asset.' },
-            bodies: { type: 'array', description: 'One entry per physics body.', items: { type: 'object', additionalProperties: false, properties: { boneName: { type: 'string' }, physicsType: { type: 'string' }, numSpheres: { type: 'number' }, numBoxes: { type: 'number' }, numCapsules: { type: 'number' }, numConvex: { type: 'number' } } } },
-            constraints: { type: 'array', description: 'One entry per constraint.', items: { type: 'object', additionalProperties: false, properties: { name: { type: 'string' }, bone1: { type: 'string' }, bone2: { type: 'string' } } } },
-        }, outputRequired: [],
-        exampleInput: { action: 'get_physics_asset_info', physicsAssetPath: '/Game/PA_Char' },
-        exampleOutput: { success: true, message: 'Physics asset read', physicsAssetPath: '/Game/PA_Char', numBodies: 9, numConstraints: 8, bodies: [{ boneName: 'spine_01', physicsType: 'Simulated', numSpheres: 0, numBoxes: 1, numCapsules: 0, numConvex: 0 }], constraints: [{ name: 'spine_01', bone1: 'spine_01', bone2: 'pelvis' }] } }),
-    buildRecord({ parentTool: T, id: `${T}.list_morph_targets`, action: 'list_morph_targets', family: F,
-        summary: 'List the morph targets declared on a Skeletal Mesh.', whenToUse: ['The available morph targets must be discovered before driving one.'], whenNotToUse: ['A morph target must be created (use create_morph_target).'],
-        inputProps: { skeletalMeshPath: P.skeletalMeshPath, meshPath: P.meshPath },
-        required: [], requiredOneOf: ['skeletalMeshPath', 'meshPath'],
-        effect: 'read', behavior: { idempotency: 'idempotent', safeToRetry: true }, latency: 'instant', resources: 'low', plugins: ESU,
-        outputProps: {
-            skeletalMeshPath: P.skeletalMeshPath,
-            count: { type: 'number', description: 'Number of morph targets found.' },
-            morphTargets: { type: 'array', description: 'One entry per morph target.', items: { type: 'object', additionalProperties: false, properties: { name: { type: 'string' }, numDeltas: { type: 'number' } } } },
-        }, outputRequired: [],
-        exampleInput: { action: 'list_morph_targets', skeletalMeshPath: '/Game/SKM_Char' },
-        exampleOutput: { success: true, message: 'Morph targets listed', skeletalMeshPath: '/Game/SKM_Char', count: 2, morphTargets: [{ name: 'Smile', numDeltas: 128 }] } }),
-    buildRecord({ parentTool: T, id: `${T}.set_morph_target_value`, action: 'set_morph_target_value', family: F,
-        summary: 'Drive a morph target weight on a Skeletal Mesh actor in the level.', whenToUse: ['A morph target weight must be previewed on a placed actor.'], whenNotToUse: ['The morph target asset itself must change (use set_morph_target_deltas).'],
-        inputProps: { actorName: P.actorName, morphTargetName: P.morphTargetName, value: P.value, addMissing: P.addMissing },
-        required: ['actorName', 'morphTargetName'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: ESU,
-        outputProps: {
-            actorName: P.actorName, morphTargetName: P.morphTargetName,
-            value: { type: 'number', description: 'Weight applied to the morph target.' },
-            activeMorphTargets: { type: 'array', description: 'Morph targets currently driven on the actor.', items: { type: 'object', additionalProperties: false, properties: { name: { type: 'string' }, weight: { type: 'number' } } } },
-        }, outputRequired: [],
-        exampleInput: { action: 'set_morph_target_value', actorName: 'SKM_Char_1', morphTargetName: 'Smile', value: 0.75 },
-        exampleOutput: { success: true, message: 'Morph target value set', actorName: 'SKM_Char_1', morphTargetName: 'Smile', value: 0.75, activeMorphTargets: [{ name: 'Smile', weight: 0.75 }] } }),
-    buildRecord({ parentTool: T, id: `${T}.get_bone_transform`, action: 'get_bone_transform', family: F,
-        summary: 'Read the reference-pose transform and parent of a bone.', whenToUse: ['A bone position must be read before placing a socket or constraint.'], whenNotToUse: ['The whole hierarchy is needed (use list_bones).'],
-        inputProps: { skeletonPath: P.skeletonPath, skeletalMeshPath: P.skeletalMeshPath, boneName: P.boneName },
-        required: ['boneName'], requiredOneOf: ['skeletonPath', 'skeletalMeshPath'],
-        effect: 'read', behavior: { idempotency: 'idempotent', safeToRetry: true }, latency: 'instant', resources: 'low', plugins: ESU,
-        outputProps: {
-            boneName: P.boneName,
-            boneIndex: { type: 'number', description: 'Index of the bone in the reference skeleton.' },
-            parentBone: { type: 'string', description: 'Name of the parent bone, empty for the root.' },
-            parentIndex: { type: 'number', description: 'Index of the parent bone, -1 for the root.' },
-            location: { type: 'object', additionalProperties: false, description: 'Reference-pose location.', properties: { x: { type: 'number' }, y: { type: 'number' }, z: { type: 'number' } } },
-            rotation: { type: 'object', additionalProperties: false, description: 'Reference-pose rotation.', properties: { pitch: { type: 'number' }, yaw: { type: 'number' }, roll: { type: 'number' } } },
-            scale: { type: 'object', additionalProperties: false, description: 'Reference-pose scale.', properties: { x: { type: 'number' }, y: { type: 'number' }, z: { type: 'number' } } },
-        }, outputRequired: [],
-        exampleInput: { action: 'get_bone_transform', skeletonPath: '/Game/SK_Char', boneName: 'hand_r' },
-        exampleOutput: { success: true, message: 'Bone transform read', boneName: 'hand_r', boneIndex: 12, parentBone: 'lowerarm_r', parentIndex: 11, location: { x: 10, y: 0, z: 0 }, rotation: { pitch: 0, yaw: 0, roll: 0 }, scale: { x: 1, y: 1, z: 1 } } }),
-    buildRecord({ parentTool: T, id: `${T}.list_virtual_bones`, action: 'list_virtual_bones', family: F,
-        summary: 'List the virtual bones declared on a skeleton.', whenToUse: ['Existing virtual bones must be discovered before adding another.'], whenNotToUse: ['A virtual bone must be created (use create_virtual_bone).'],
-        inputProps: { skeletonPath: P.skeletonPath, skeletalMeshPath: P.skeletalMeshPath },
-        required: [], requiredOneOf: ['skeletonPath', 'skeletalMeshPath'],
-        effect: 'read', behavior: { idempotency: 'idempotent', safeToRetry: true }, latency: 'instant', resources: 'low', plugins: ESU,
-        outputProps: {
-            skeletonPath: P.skeletonPath,
-            count: { type: 'number', description: 'Number of virtual bones found.' },
-            virtualBones: { type: 'array', description: 'One entry per virtual bone.', items: { type: 'object', additionalProperties: false, properties: { name: { type: 'string' }, sourceBone: { type: 'string' }, targetBone: { type: 'string' } } } },
-        }, outputRequired: [],
-        exampleInput: { action: 'list_virtual_bones', skeletonPath: '/Game/SK_Char' },
-        exampleOutput: { success: true, message: 'Virtual bones listed', skeletonPath: '/Game/SK_Char', count: 1, virtualBones: [{ name: 'VB_hand_r', sourceBone: 'spine_03', targetBone: 'hand_r' }] } }),
-    buildRecord({ parentTool: T, id: `${T}.add_socket`, action: 'add_socket', family: F,
-        summary: 'Add a socket to a bone under the add_socket spelling of create_socket.', 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: 'add_socket', skeletonPath: '/Game/SK_Char', socketName: 'Weapon', attachBoneName: 'hand_r', relativeLocation: [1, 2, 3], save: true },
-        exampleOutput: { success: true, message: 'Socket created', socketName: 'Weapon', boneName: 'hand_r', skeletonPath: '/Game/SK_Char' } }),
-    buildRecord({ parentTool: T, id: `${T}.modify_socket`, action: 'modify_socket', family: F,
-        summary: 'Modify an existing socket transform under the modify_socket spelling of configure_socket.', whenToUse: ['Socket offset must change.'], whenNotToUse: ['Use add_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: 'modify_socket', skeletonPath: '/Game/SK_Char', socketName: 'Weapon', relativeLocation: [4, 5, 6], save: true },
-        exampleOutput: { success: true, message: 'Socket configured', socketName: 'Weapon', skeletonPath: '/Game/SK_Char' } }),
-    buildRecord({ parentTool: T, id: `${T}.modify_physics_body`, action: 'modify_physics_body', family: F,
-        summary: 'Modify a physics body mass, damping, or collision under the modify_physics_body spelling of configure_physics_body.', whenToUse: ['Body parameters must change.'], whenNotToUse: ['Use add_physics_body.'],
-        inputProps: { physicsAssetPath: P.physicsAssetPath, boneName: P.boneName, mass: P.mass, linearDamping: P.linearDamping, angularDamping: P.angularDamping, collisionEnabled: P.collisionEnabled, simulatePhysics: P.simulatePhysics, save: A.save },
-        required: ['physicsAssetPath', 'boneName'], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'modify_physics_body', physicsAssetPath: '/Game/PA_Char', boneName: 'spine_01', mass: 5, linearDamping: 0.25, collisionEnabled: true },
-        exampleOutput: { success: true, message: 'Physics body configured' } }),
-    buildRecord({ parentTool: T, id: `${T}.set_physics_constraint`, action: 'set_physics_constraint', family: F,
-        summary: 'Create or update the constraint between two physics bodies: an existing pair is edited in place, not duplicated.', whenToUse: ['Bodies must be jointed.', 'An existing joint needs a new name or limits.'], whenNotToUse: ['Rigid bodies suffice.'],
-        inputProps: { physicsAssetPath: P.physicsAssetPath, bodyA: P.bodyA, bodyB: P.bodyB, constraintName: A.constraintName, limits: A.limits, save: A.save },
-        required: ['physicsAssetPath', 'bodyA', 'bodyB'], effect: 'write', latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'set_physics_constraint', physicsAssetPath: '/Game/PA_Char', bodyA: 'spine_01', bodyB: 'spine_02', constraintName: 'Spine' },
-        exampleOutput: { success: true, message: 'Constraint added' } }),
-    buildRecord({ parentTool: T, id: `${T}.remove_socket`, action: 'remove_socket', family: F,
-        summary: 'Remove a socket from a skeleton or skeletal mesh.', whenToUse: ['An attach point must be taken off a skeleton.'], whenNotToUse: ['The socket transform should change; use configure_socket.'],
-        inputProps: { socketName: P.socketName, skeletonPath: P.skeletonPath, skeletalMeshPath: P.skeletalMeshPath },
-        required: ['socketName'], requiredOneOf: ['skeletonPath', 'skeletalMeshPath'],
-        outputProps: { socketName: P.socketName, skeletonPath: P.skeletonPath, remainingSockets: REMAINING('sockets') }, outputRequired: [],
-        effect: 'destructive', behavior: { safeToRetry: false }, latency: 'interactive', resources: 'low', plugins: ESU,
-        exampleInput: { action: 'remove_socket', skeletonPath: '/Game/SK_Char', socketName: 'Weapon' },
-        exampleOutput: { success: true, message: 'Socket removed', socketName: 'Weapon', skeletonPath: '/Game/SK_Char', remainingSockets: 2 } }),
-];
-//# sourceMappingURL=skeleton-read-alias.data.js.map

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

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