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

package/dist/tools/catalog/capabilities/records/build-environment/spline.data.js

@@ -1,200 +0,0 @@
-import { buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const F = 'spline';
-const WU = ['A spline actor or spline mesh must be created or modified.'];
-const ACTOR_PATH = { ...P.actorPath, description: 'Object path of the spline actor; used when actorName is omitted.' };
-const SPLINE_POSITION = { ...P.position, description: 'Point position relative to the spline actor {x, y, z}: its local space, the location get_splines_info with actorName reports (worldLocation is where the point lies in the level).' };
-const TEMPLATE = {
-    name: P.name, location: P.location, meshPath: P.meshPath, points: P.points,
-    materialPath: P.materialPath, width: { ...P.width, description: 'Width of the deformed mesh ribbon in world units (default 400).' }, closedLoop: P.closedLoop,
-};
-export const SPLINE_RECORDS = [
-    buildRecord({
-        id: 'build_environment.create_spline_actor', action: 'create_spline_actor', family: F,
-        summary: 'Create a spline actor in the level.',
-        whenToUse: WU, whenNotToUse: ['A static mesh path should be used instead.'],
-        inputProps: { initialPoints: P.initialPoints, name: P.name, location: P.location, rotation: P.rotation, points: P.points, bClosedLoop: P.bClosedLoop,
-            splineType: { ...P.splineType, description: 'Point type for every point: Linear, Curve (default), Constant, CurveClamped or CurveCustomTangent.' } },
-        required: [], effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'create_spline_actor', name: 'Spline_1', location: { x: 0, y: 0, z: 0 } },
-    }),
-    buildRecord({
-        id: 'build_environment.add_spline_point', action: 'add_spline_point', family: F,
-        summary: 'Add a point to an existing spline.',
-        whenToUse: WU, whenNotToUse: ['The spline should be recreated with all points.'],
-        inputProps: { actorName: P.actorName, actorPath: ACTOR_PATH, position: SPLINE_POSITION, index: P.index,
-            arriveTangent: P.arriveTangent, leaveTangent: P.leaveTangent, pointType: P.pointType },
-        required: [], effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'add_spline_point', actorName: 'Spline_1', position: { x: 100, y: 0, z: 0 } },
-    }),
-    buildRecord({
-        id: 'build_environment.remove_spline_point', action: 'remove_spline_point', family: F,
-        summary: 'Remove a point from a spline by index.',
-        whenToUse: WU, whenNotToUse: ['The spline should be recreated without the point.'],
-        inputProps: { actorName: P.actorName, actorPath: ACTOR_PATH, pointIndex: P.pointIndex },
-        required: [], effect: 'destructive', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'remove_spline_point', actorName: 'Spline_1', pointIndex: 2 },
-    }),
-    buildRecord({
-        id: 'build_environment.set_spline_point_position', action: 'set_spline_point_position', family: F,
-        summary: 'Set the position of a spline point by index.',
-        whenToUse: WU, whenNotToUse: ['The point should be moved interactively.'],
-        inputProps: { actorName: P.actorName, actorPath: ACTOR_PATH, pointIndex: P.pointIndex, position: SPLINE_POSITION },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'set_spline_point_position', actorName: 'Spline_1', pointIndex: 0, position: { x: 0, y: 0, z: 100 } },
-    }),
-    buildRecord({
-        id: 'build_environment.set_spline_point_tangents', action: 'set_spline_point_tangents', family: F,
-        summary: 'Set the arrive and leave tangents of a spline point (a lone arriveTangent sets both).',
-        whenToUse: WU, whenNotToUse: ['Default tangents are sufficient.'],
-        inputProps: { actorName: P.actorName, actorPath: ACTOR_PATH, pointIndex: P.pointIndex,
-            arriveTangent: P.arriveTangent, leaveTangent: P.leaveTangent },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'set_spline_point_tangents', actorName: 'Spline_1', pointIndex: 0, arriveTangent: { x: 50, y: 0, z: 0 } },
-    }),
-    buildRecord({
-        id: 'build_environment.set_spline_point_rotation', action: 'set_spline_point_rotation', family: F,
-        summary: 'Set the rotation of a spline point.',
-        whenToUse: WU, whenNotToUse: ['Default rotation is sufficient.'],
-        inputProps: { actorName: P.actorName, actorPath: ACTOR_PATH, pointIndex: P.pointIndex, pointRotation: P.pointRotation },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'set_spline_point_rotation', actorName: 'Spline_1', pointIndex: 0, pointRotation: { pitch: 0, yaw: 45, roll: 0 } },
-    }),
-    buildRecord({
-        id: 'build_environment.set_spline_point_scale', action: 'set_spline_point_scale', family: F,
-        summary: 'Set the scale of a spline point.',
-        whenToUse: WU, whenNotToUse: ['Default scale is sufficient.'],
-        inputProps: { actorName: P.actorName, actorPath: ACTOR_PATH, pointIndex: P.pointIndex, pointScale: P.pointScale },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'set_spline_point_scale', actorName: 'Spline_1', pointIndex: 0, pointScale: { x: 1, y: 1, z: 1 } },
-    }),
-    buildRecord({
-        id: 'build_environment.set_spline_type', action: 'set_spline_type', family: F,
-        summary: 'Set the spline point type (Linear, Curve, Constant, etc.).',
-        whenToUse: WU, whenNotToUse: ['Default curve type is sufficient.'],
-        inputProps: { actorName: P.actorName, actorPath: ACTOR_PATH, pointIndex: P.pointIndex, splineType: P.splineType },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'set_spline_type', actorName: 'Spline_1', pointIndex: 0, splineType: 'Curve' },
-    }),
-    buildRecord({
-        id: 'build_environment.create_spline_mesh_component', action: 'create_spline_mesh_component', family: F,
-        summary: 'Create a spline mesh component on an actor.',
-        whenToUse: WU, whenNotToUse: ['A static mesh should be used instead.'],
-        inputProps: { blueprintPath: P.blueprintPath, save: P.save, actorName: P.actorName, actorPath: ACTOR_PATH, componentName: P.componentName, meshPath: P.meshPath, forwardAxis: P.forwardAxis },
-        required: [], effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'create_spline_mesh_component', actorName: 'Spline_1', meshPath: '/Game/Meshes/SM_Road' },
-    }),
-    buildRecord({
-        id: 'build_environment.set_spline_mesh_asset', action: 'set_spline_mesh_asset', family: F,
-        summary: 'Set the static mesh asset for a spline mesh component.',
-        whenToUse: WU, whenNotToUse: ['The mesh should be recreated.'],
-        inputProps: { actorName: P.actorName, actorPath: ACTOR_PATH, componentName: P.componentName, meshPath: P.meshPath },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'set_spline_mesh_asset', actorName: 'Spline_1', meshPath: '/Game/Meshes/SM_Road_v2' },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_spline_mesh_axis', action: 'configure_spline_mesh_axis', family: F,
-        summary: 'Set the forward axis of a spline mesh component.',
-        whenToUse: WU, whenNotToUse: ['Default axis is sufficient.'],
-        inputProps: { actorName: P.actorName, actorPath: ACTOR_PATH, componentName: P.componentName, forwardAxis: P.forwardAxis },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_spline_mesh_axis', actorName: 'Spline_1', forwardAxis: 'X' },
-    }),
-    buildRecord({
-        id: 'build_environment.set_spline_mesh_material', action: 'set_spline_mesh_material', family: F,
-        summary: 'Set the material on a spline mesh component.',
-        whenToUse: WU, whenNotToUse: ['Default material is sufficient.'],
-        inputProps: { actorName: P.actorName, actorPath: ACTOR_PATH, componentName: P.componentName, materialPath: P.materialPath, materialIndex: P.materialIndex },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'set_spline_mesh_material', actorName: 'Spline_1', materialPath: '/Game/Materials/M_Road' },
-    }),
-    buildRecord({
-        id: 'build_environment.scatter_meshes_along_spline', action: 'scatter_meshes_along_spline', family: F,
-        summary: 'Scatter static meshes along a spline path.',
-        whenToUse: WU, whenNotToUse: ['Manual placement is sufficient.'],
-        inputProps: { actorName: P.actorName, actorPath: ACTOR_PATH, meshPath: P.meshPath,
-            spacing: P.spacing, alignToSpline: P.alignToSpline, randomizeRotation: P.randomizeRotation, randomizeScale: P.randomizeScale,
-            useRandomOffset: P.useRandomOffset, randomOffsetRange: P.randomOffsetRange, minScale: P.minScale, maxScale: P.maxScale, rotationRange: P.rotationRange },
-        required: [], effect: 'write', latency: 'interactive', resources: 'medium',
-        exampleInput: { action: 'scatter_meshes_along_spline', actorName: 'Spline_1', meshPath: '/Game/Meshes/SM_Tree', spacing: 200 },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_mesh_spacing', action: 'configure_mesh_spacing', family: F,
-        summary: 'Configure mesh spacing along a spline.',
-        whenToUse: WU, whenNotToUse: ['Default spacing is sufficient.'],
-        inputProps: { useRandomOffset: P.useRandomOffset, randomOffsetRange: P.randomOffsetRange, actorName: P.actorName, actorPath: ACTOR_PATH, spacing: P.spacing },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_mesh_spacing', actorName: 'Spline_1', spacing: 150 },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_mesh_randomization', action: 'configure_mesh_randomization', family: F,
-        summary: 'Configure randomization for meshes scattered along a spline.',
-        whenToUse: WU, whenNotToUse: ['Uniform placement is desired.'],
-        inputProps: { rotationRange: P.rotationRange, actorName: P.actorName, actorPath: ACTOR_PATH,
-            randomizeRotation: P.randomizeRotation, randomizeScale: P.randomizeScale, minScale: P.minScale, maxScale: P.maxScale },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_mesh_randomization', actorName: 'Spline_1', randomizeRotation: true },
-    }),
-    buildRecord({
-        id: 'build_environment.create_road_spline', action: 'create_road_spline', family: F,
-        summary: 'Create a road spline with mesh and width.',
-        whenToUse: WU, whenNotToUse: ['A generic spline should be used.'],
-        inputProps: TEMPLATE,
-        required: [], effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'create_road_spline', name: 'Road_1', meshPath: '/Game/Meshes/SM_Road', materialPath: '/Game/Materials/M_Road', width: 500, closedLoop: true },
-    }),
-    buildRecord({
-        id: 'build_environment.create_river_spline', action: 'create_river_spline', family: F,
-        summary: 'Create a river spline with mesh and width.',
-        whenToUse: WU, whenNotToUse: ['A water body actor should be used instead.'],
-        inputProps: TEMPLATE,
-        required: [], effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'create_river_spline', name: 'River_1', width: 800 },
-    }),
-    buildRecord({
-        id: 'build_environment.create_fence_spline', action: 'create_fence_spline', family: F,
-        summary: 'Create a fence spline: a mesh deformed along the route (place posts with scatter_meshes_along_spline).',
-        whenToUse: WU, whenNotToUse: ['Manual fence placement is sufficient.'],
-        inputProps: TEMPLATE,
-        required: [], effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'create_fence_spline', name: 'Fence_1', meshPath: '/Game/Meshes/SM_FenceRail' },
-    }),
-    buildRecord({
-        id: 'build_environment.create_wall_spline', action: 'create_wall_spline', family: F,
-        summary: 'Create a wall spline with mesh and height.',
-        whenToUse: WU, whenNotToUse: ['Manual wall placement is sufficient.'],
-        inputProps: TEMPLATE,
-        required: [], effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'create_wall_spline', name: 'Wall_1', meshPath: '/Game/Meshes/SM_Wall', width: 300 },
-    }),
-    buildRecord({
-        id: 'build_environment.create_cable_spline', action: 'create_cable_spline', family: F,
-        summary: 'Create a cable spline between two points.',
-        whenToUse: WU, whenNotToUse: ['A physics cable component should be used.'],
-        inputProps: TEMPLATE,
-        required: [], effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'create_cable_spline', name: 'Cable_1' },
-    }),
-    buildRecord({
-        id: 'build_environment.create_pipe_spline', action: 'create_pipe_spline', family: F,
-        summary: 'Create a pipe spline with mesh and radius.',
-        whenToUse: WU, whenNotToUse: ['Manual pipe placement is sufficient.'],
-        inputProps: TEMPLATE,
-        required: [], effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'create_pipe_spline', name: 'Pipe_1', meshPath: '/Game/Meshes/SM_Pipe', width: 50 },
-    }),
-    buildRecord({
-        id: 'build_environment.get_splines_info', action: 'get_splines_info', family: F,
-        topics: ['point count and length', 'closed loop', 'world points'],
-        summary: 'List the spline actors in the level with each one\'s point count, length and world points (first 64); with actorName, one spline\'s points (location relative to the actor, the space spline edits take, and worldLocation), types, length and closed-loop flag.',
-        whenToUse: ['Spline actors must be enumerated.'],
-        whenNotToUse: ['A specific spline path is already known.'],
-        inputProps: { actorName: P.actorName },
-        outputProps: { splines: { type: 'array', description: 'Spline info.', items: { type: 'object', description: 'Spline actor info.', additionalProperties: true, 'x-unreal-reflection-boundary': true } } },
-        outputRequired: ['splines'],
-        effect: 'read', latency: 'instant', resources: 'low',
-        exampleInput: { action: 'get_splines_info' },
-        exampleOutput: { success: true, splines: [] },
-    }),
-];
-//# sourceMappingURL=spline.data.js.map

package/dist/tools/catalog/capabilities/records/build-environment/water.data.d.ts

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

package/dist/tools/catalog/capabilities/records/build-environment/water.data.js

@@ -1,83 +0,0 @@
-import { buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const F = 'water';
-const WU = ['A water body or water simulation must be created or configured.'];
-const BODY = {
-    name: P.name, waterBodyName: P.waterBodyName, location: P.location,
-    rotation: { ...P.rotation, description: 'Water body rotation, applied on every call.' },
-    materialPath: P.materialPath, materialIndex: P.materialIndex,
-    collisionEnabled: { ...P.collisionEnabled, description: 'Collision on the body\'s primitive components: true = query and physics, false = none.' },
-    settings: P.actorSettings,
-};
-const TARGET = { waterBodyName: { ...P.waterBodyName, description: 'Water body to configure; the first ocean, lake, river or custom body when omitted.' } };
-export const WATER_RECORDS = [
-    buildRecord({
-        id: 'build_environment.create_water_body_ocean', action: 'create_water_body_ocean', family: F,
-        summary: 'Create an ocean water body actor with the editor\'s default ocean material and waves.',
-        whenToUse: WU, whenNotToUse: ['A lake or river water body is needed.'],
-        inputProps: BODY,
-        required: [], effect: 'write', latency: 'interactive', resources: 'medium',
-        exampleInput: { action: 'create_water_body_ocean', name: 'Ocean_1', location: { x: 0, y: 0, z: 0 } },
-    }),
-    buildRecord({
-        id: 'build_environment.create_water_body_lake', action: 'create_water_body_lake', family: F,
-        summary: 'Create a lake water body actor.',
-        whenToUse: WU, whenNotToUse: ['An ocean or river water body is needed.'],
-        inputProps: BODY,
-        required: [], effect: 'write', latency: 'interactive', resources: 'medium',
-        exampleInput: { action: 'create_water_body_lake', name: 'Lake_1', location: { x: 0, y: 0, z: 100 } },
-    }),
-    buildRecord({
-        id: 'build_environment.create_water_body_river', action: 'create_water_body_river', family: F,
-        summary: 'Create a river water body actor.',
-        whenToUse: WU, whenNotToUse: ['An ocean or lake water body is needed.'],
-        inputProps: BODY,
-        required: [], effect: 'write', latency: 'interactive', resources: 'medium',
-        exampleInput: { action: 'create_water_body_river', name: 'River_1', location: { x: 0, y: 0, z: 50 } },
-    }),
-    buildRecord({
-        id: 'build_environment.create_water_body_custom', action: 'create_water_body_custom', family: F,
-        summary: 'Create a custom water body actor.',
-        whenToUse: WU, whenNotToUse: ['A standard ocean/lake/river body is sufficient.'],
-        inputProps: BODY,
-        required: [], effect: 'write', latency: 'interactive', resources: 'medium',
-        exampleInput: { action: 'create_water_body_custom', name: 'CustomWater_1' },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_water_waves', action: 'configure_water_waves', family: F,
-        summary: 'Give a water body Gerstner waves, the swell its surface and anything floating on it follow: height, wavelength, steepness and wind direction. The call fails when the body does not end up holding the waves.',
-        whenToUse: WU, whenNotToUse: ['Default waves are sufficient.'],
-        inputProps: { waveHeight: { ...P.waveHeight, description: 'Height (amplitude) of the largest wave in cm; the body\'s other waves shrink to 15% of it, as a real sea\'s do. A calm harbour is about 5-10, open sea 50 or more.' },
-            waveLength: { ...P.waveLength, description: 'Wavelength of the longest wave in cm, crest to crest; the shortest waves are 13% of it (a harbour is about 1500-2500).' },
-            amplitude: { ...P.amplitude, description: 'Same as waveHeight; waveHeight wins when both are given.' },
-            steepness: { ...P.steepness, description: 'Crest sharpness of the short waves, 0 (smooth swell) to 1 (peaked); the long waves take about half. Keep it under about 0.3: steep crests from many waves fold the surface over itself.' },
-            direction: { ...P.direction, description: 'Wind direction: its yaw sets where the waves travel.' }, ...TARGET },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_water_waves', waveHeight: 1.0, waveLength: 10 },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_water_material', action: 'configure_water_material', family: F,
-        summary: 'Configure the material applied to a water body.',
-        whenToUse: WU, whenNotToUse: ['Default water material is sufficient.'],
-        inputProps: { materialPath: P.materialPath, materialIndex: P.materialIndex, settings: P.settings, ...TARGET },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_water_material', materialPath: '/Game/Materials/M_Water' },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_water_collision', action: 'configure_water_collision', family: F,
-        summary: 'Configure water collision settings.',
-        whenToUse: WU, whenNotToUse: ['Default collision is sufficient.'],
-        inputProps: { collisionEnabled: P.collisionEnabled, settings: P.settings, ...TARGET },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_water_collision', collisionEnabled: true },
-    }),
-    buildRecord({
-        id: 'build_environment.create_buoyancy_component', action: 'create_buoyancy_component', topics: ['make a boat float'], family: F,
-        summary: 'Make an actor float: add a buoyancy component (pontoons in settings.BuoyancyData) to an actor whose root is a physics-simulating mesh, and let it take the water body\'s overlap at level load, so one placed already in the water floats instead of sinking. In a Blueprint, add /Script/Water.BuoyancyComponent with edit_scs and set the class default bGenerateOverlapEventsDuringLevelStreaming to true.',
-        whenToUse: WU, whenNotToUse: ['Buoyancy is not needed.'],
-        inputProps: { actorPath: P.actorPath, actorName: P.actorName, targetActor: P.targetActor, settings: P.settings },
-        required: [], effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'create_buoyancy_component', actorName: 'Boat_1' },
-    }),
-];
-//# sourceMappingURL=water.data.js.map

package/dist/tools/catalog/capabilities/records/build-environment/weather.data.d.ts

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

package/dist/tools/catalog/capabilities/records/build-environment/weather.data.js

@@ -1,52 +0,0 @@
-import { buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const F = 'weather';
-const WU = ['A weather system or weather particle effect must be configured.'];
-const TARGET = {
-    actorName: { ...P.actorName, description: 'Label of the weather actor to configure; spawned with this label when the level has none.' },
-    location: { ...P.location, description: 'Where the actor is spawned when it does not exist yet; an existing actor is not moved.' },
-};
-const ROTATION = { ...P.rotation, description: 'Actor rotation, applied on every call.' };
-export const WEATHER_RECORDS = [
-    buildRecord({
-        id: 'build_environment.create_weather_system', action: 'create_weather_system', family: F,
-        summary: 'Create a weather system actor with particle effects.',
-        whenToUse: WU, whenNotToUse: ['Individual particle systems should be used.'],
-        inputProps: { name: P.name, location: P.location, rotation: ROTATION, particleSystemPath: P.particleSystemPath },
-        required: [], effect: 'write', latency: 'interactive', resources: 'medium',
-        exampleInput: { action: 'create_weather_system', name: 'Weather_1' },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_rain_particles', action: 'configure_rain_particles', family: F,
-        summary: 'Configure rain particle settings.',
-        whenToUse: WU, whenNotToUse: ['Rain is not needed.'],
-        inputProps: { particleSystemPath: P.particleSystemPath, settings: P.settings, rotation: ROTATION, ...TARGET },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_rain_particles', particleSystemPath: '/Game/Weather/P_Rain' },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_snow_particles', action: 'configure_snow_particles', family: F,
-        summary: 'Configure snow particle settings.',
-        whenToUse: WU, whenNotToUse: ['Snow is not needed.'],
-        inputProps: { particleSystemPath: P.particleSystemPath, settings: P.settings, rotation: ROTATION, ...TARGET },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_snow_particles', particleSystemPath: '/Game/Weather/P_Snow' },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_wind', action: 'configure_wind', family: F,
-        summary: 'Configure wind settings for foliage and particles.',
-        whenToUse: WU, whenNotToUse: ['Wind is not needed.'],
-        inputProps: { settings: P.settings, speed: P.speed, direction: P.direction, ...TARGET },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_wind', speed: 10, direction: { pitch: 0, yaw: 90, roll: 0 } },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_lightning', action: 'configure_lightning', family: F,
-        summary: 'Configure lightning effect settings.',
-        whenToUse: WU, whenNotToUse: ['Lightning is not needed.'],
-        inputProps: { particleSystemPath: P.particleSystemPath, settings: P.settings, rotation: ROTATION, ...TARGET },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_lightning' },
-    }),
-];
-//# sourceMappingURL=weather.data.js.map

package/dist/tools/catalog/capabilities/records/compensation.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityCompensation } from '../model.js';
-export declare const COMPENSATION: ReadonlyMap<string, CapabilityCompensation>;
-//# sourceMappingURL=compensation.d.ts.map

package/dist/tools/catalog/capabilities/records/compensation.js

@@ -1,15 +0,0 @@
-import { CapabilityIdSchema } from '../identifiers.js';
-const inverse = (id) => ({ inverse: [CapabilityIdSchema.parse(id)] });
-export const COMPENSATION = new Map([
-    ['control_actor.spawn', inverse('control_actor.delete')],
-    ['control_actor.duplicate', inverse('control_actor.delete')],
-    ['build_environment.create_light', inverse('build_environment.delete')],
-    ['build_environment.create_landscape', inverse('build_environment.delete')],
-    ['control_editor.open_asset', inverse('control_editor.close_asset')],
-    ['manage_tools.enable_tools', inverse('manage_tools.disable_tools')],
-    ['manage_tools.enable_category', inverse('manage_tools.disable_category')],
-    ['sequence.mrq.create_render_job', {
-            guidance: 'Rendered frames are written to the configured MRQ output directory and are not removed by any capability; delete them from disk. The render itself only supports advisory cancellation while running.',
-        }],
-]);
-//# sourceMappingURL=compensation.js.map

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

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

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

@@ -1,135 +0,0 @@
-import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
-import { DOMAIN, P } from './properties.js';
-import { bool, str, vec3 } from '../shared/schema-props.js';
-const FAMILY_ATTACH = 'attachment';
-const FAMILY_BLUEPRINT = 'blueprint';
-const FAMILY_SNAPSHOT = 'snapshot';
-const FAMILY_COLLISION = 'collision';
-const FAMILY_FUNCTION = 'function';
-export const ADVANCED_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'attach',
-        domain: DOMAIN,
-        family: FAMILY_ATTACH,
-        topics: ['attach actor', 'parent actor', 'attach to actor', 'child actor', 'attach to socket', 'set actor parent'],
-        summary: 'Attach a child actor to a parent actor in the scene hierarchy, or to a bone or socket of one of its components (a weapon or a case to a hand).',
-        whenToUse: ['An actor must follow another actor transform.', 'A prop must ride a character\'s hand, head or other bone: socketName with snapToTarget, then tune the grip with relativeLocation/relativeRotation.'],
-        whenNotToUse: ['The actor should remain independent (use detach).'],
-        inputProps: {
-            childActor: P.childActor, parentActor: P.parentActor,
-            componentName: str('Component of the parent actor to attach to (default its root): on a character built from several meshes, the mesh that owns the bone.'),
-            socketName: str('Bone or socket on that component to attach to (hand_r, weapon_r, head). Refused with SOCKET_NOT_FOUND when the component has neither.'),
-            snapToTarget: bool('Snap the child onto the bone or socket instead of keeping its current world placement (default false).'),
-            relativeLocation: vec3('With snapToTarget: offset from the bone or socket in its own space, as [x, y, z].'),
-            relativeRotation: vec3('With snapToTarget: rotation relative to the bone or socket, as [pitch, yaw, roll] in degrees.'),
-        },
-        required: ['childActor', 'parentActor'],
-        effect: 'write',
-        costLatency: 'interactive',
-        exampleInput: { action: 'attach', childActor: 'Sword', parentActor: 'Knight' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'detach',
-        domain: DOMAIN,
-        family: FAMILY_ATTACH,
-        summary: 'Detach a child actor from its current parent.',
-        whenToUse: ['An actor must be released from attachment.'],
-        whenNotToUse: ['The actor is not attached (no-op).'],
-        inputProps: { actorName: P.actorName },
-        required: ['actorName'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        costLatency: 'interactive',
-        exampleInput: { action: 'detach', actorName: 'Sword' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'set_blueprint_variables',
-        topics: ['actor variable'],
-        domain: DOMAIN,
-        family: FAMILY_BLUEPRINT,
-        summary: 'Set one or more Blueprint instance variables on a spawned actor, or on many actors in one call with actors.',
-        whenToUse: ['Instance variables on a Blueprint actor must be configured.', 'Several actors each need their own variable values (actors).'],
-        whenNotToUse: ['The actor is not a Blueprint instance (variables are undefined).'],
-        inputProps: {
-            actorName: P.actorName, variables: P.variables,
-            actors: {
-                type: 'array',
-                items: { type: 'object', properties: { actorName: P.actorName, variables: P.variables }, required: ['actorName', 'variables'], additionalProperties: false },
-                description: 'Many actors in one call, each {actorName, variables} with its own values; every actor is reported, the actors that took a variable come back under affectedActors (which the receipt lists as changes, with an actor handle each), and the call fails naming any that did not take all of its variables.',
-            },
-        },
-        required: [],
-        requiredOneOf: ['actorName', 'actors'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        costLatency: 'interactive',
-        exampleInput: { action: 'set_blueprint_variables', actorName: 'Lamp1', variables: { Brightness: 2.0 } },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'create_snapshot',
-        domain: DOMAIN,
-        family: FAMILY_SNAPSHOT,
-        summary: 'Capture a named snapshot of actor state for later comparison.',
-        whenToUse: ['Actor state must be recorded before a mutation.'],
-        whenNotToUse: ['No later comparison or restore is planned.'],
-        inputProps: { actorName: P.actorName, snapshotName: P.snapshotName },
-        required: ['actorName', 'snapshotName'],
-        effect: 'read',
-        exampleInput: { action: 'create_snapshot', actorName: 'Cube1', snapshotName: 'before_move' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'set_actor_collision',
-        domain: DOMAIN,
-        family: FAMILY_COLLISION,
-        summary: 'Enable or disable collision on an actor, or on many actors at once with actorNames, as one undoable step; normalizes to set_collision.',
-        whenToUse: ['Actor collision must be toggled.', 'Many actors must have collision toggled together (actorNames does them in one call).'],
-        whenNotToUse: ['One component only, or a mode other than on and off (QueryOnly, PhysicsOnly): use edit_component (edit set_properties) with CollisionEnabled, which takes the ECollisionEnabled names.'],
-        inputProps: {
-            actorName: P.actorName,
-            actorNames: { type: 'array', items: { type: 'string' }, description: 'Several actors to toggle in one call and one undo step, in place of actorName; names not found are listed back under missing, and the actors changed under affectedActors (which the receipt lists as changes, with an actor handle each).' },
-            collisionEnabled: P.collisionEnabled,
-        },
-        required: [],
-        requiredOneOf: ['actorName', 'actorNames'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'set_actor_collision', actorName: 'Cube1', collisionEnabled: true },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'call_actor_function',
-        editorStates: ANY_EDITOR_STATE,
-        domain: DOMAIN,
-        family: FAMILY_FUNCTION,
-        summary: 'Call a named function on an actor, or while Play In Editor runs on the game\'s GameInstance, GameMode or another framework object, with optional arguments; normalizes to call_function.',
-        whenToUse: [
-            'A Blueprint or native function on an actor must be invoked.',
-            'A function of the running game\'s GameInstance (save, score, reset) must be called during Play In Editor: actorName GameInstance.',
-            'A function of one of the actor\'s components must be called (a body\'s GetCenterOfMass, a movement component\'s StopMovementImmediately): componentName.',
-        ],
-        whenNotToUse: ['The function has side effects that cannot be undone.'],
-        inputProps: {
-            actorName: {
-                ...P.actorName,
-                description: 'Target actor name in the current level; while Play In Editor runs, GameInstance, GameMode, GameState, PlayerController, PlayerPawn, PlayerState or HUD names that object of the running game (the GameInstance is no actor).',
-            },
-            componentName: str('Call the function on this component of the actor instead of on the actor itself (refused with COMPONENT_NOT_FOUND when the actor has none of that name).'),
-            functionName: P.functionName,
-            arguments: P.arguments,
-        },
-        required: ['actorName', 'functionName'],
-        outputProps: { value: P.value },
-        outputRequired: [],
-        effect: 'destructive',
-        policyOverride: { consent: 'elevated' },
-        costLatency: 'interactive',
-        exampleInput: { action: 'call_actor_function', actorName: 'Lamp1', functionName: 'ToggleLight' },
-        exampleOutput: { success: true, message: 'Called ToggleLight on Lamp1', value: true },
-    }),
-];
-//# sourceMappingURL=advanced-records.js.map

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

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

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

@@ -1,107 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-import { DOMAIN, P } from './properties.js';
-const FAMILY_COMPONENT = 'component';
-const FAMILY_MATERIAL = 'material';
-const MATERIAL_INPUT = {
-    inputProps: {
-        actorName: P.actorName,
-        actorNames: { type: 'array', items: { type: 'string' }, description: 'Several actors to give the same material in one call and one undo step, in place of actorName; each is reported under results, and the actors changed under affectedActors (which the receipt lists as changes, with an actor handle each); the call fails naming any that did not take it.' },
-        materialPath: P.materialPath, componentName: P.componentName, materialSlot: P.materialSlot, materialIndex: P.materialIndex, allComponents: P.allComponents,
-        materials: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 64, description: 'One material per slot in place of materialPath and materialSlot: entry i goes into slot i, "" leaves that slot as it is. Every slot is reported under slots, in one undo step; the call fails naming any slot that did not take its material. A mesh made with several material ids (an SDF part) needs this once instead of one call per slot.' },
-    },
-    requiredOneOf: ['actorName', 'actorNames'],
-};
-export const COMPONENT_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'add_component',
-        domain: DOMAIN,
-        family: FAMILY_COMPONENT,
-        topics: ['add component to actor', 'actor component', 'attach component to actor'],
-        summary: 'Add a new component of a given type to an actor. If any requested property (or meshPath) does not apply, the call fails naming what did not, although the component was added.',
-        whenToUse: ['A component must be attached to an existing actor.'],
-        whenNotToUse: ['An existing component should be configured (use set_component_property).'],
-        inputProps: {
-            actorName: P.actorName, componentType: P.componentType, componentName: P.componentName, properties: P.properties,
-            meshPath: { type: 'string', description: 'Static mesh asset (/Game path) to show on the new component; only a StaticMeshComponent takes one. A mesh that does not load fails the call, naming the component that was still added.' },
-        },
-        required: ['actorName', 'componentType'],
-        effect: 'write',
-        costLatency: 'interactive',
-        exampleInput: { action: 'add_component', actorName: 'Cube1', componentType: 'PointLightComponent', componentName: 'Light1' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'remove_component',
-        domain: DOMAIN,
-        family: FAMILY_COMPONENT,
-        summary: 'Remove a named component from an actor.',
-        whenToUse: ['A component must be permanently detached and removed from an actor.'],
-        whenNotToUse: ['The component should only be reconfigured (use set_component_property).'],
-        inputProps: { actorName: P.actorName, componentName: P.componentName },
-        required: ['actorName', 'componentName'],
-        effect: 'write',
-        costLatency: 'interactive',
-        exampleInput: { action: 'remove_component', actorName: 'Cube1', componentName: 'Light1' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'set_component_property',
-        domain: DOMAIN,
-        family: FAMILY_COMPONENT,
-        summary: 'Set one or more properties on a named actor component. For RelativeScale3D/RelativeLocation, note that a child inherits its parent\'s scale: Unreal multiplies parent and child scale COMPONENT-WISE in the child\'s own local axes, and rotation does NOT permute which axis each factor lands on. World size = ParentScale * ChildScale * MeshExtent per local axis, and world offset = ParentScale * RelativeLocation. Under a parent scaled non-uniformly, divide the offset you want by the parent scale on that axis.',
-        whenToUse: ['Component properties must be changed via a properties object or propertyName/value pair.'],
-        whenNotToUse: ['The property should only be read (use get_component_property).'],
-        inputProps: { actorName: P.actorName, componentName: P.componentName, properties: P.properties, propertyName: P.propertyName, value: P.value },
-        required: ['actorName', 'componentName'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'set_component_property', actorName: 'Cube1', componentName: 'Light1', properties: { Intensity: 5.0 } },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'set_component_properties',
-        domain: DOMAIN,
-        family: FAMILY_COMPONENT,
-        summary: 'Alias of set_component_property. The bridge dispatches both names to the same handler.',
-        whenToUse: ['Preferred when callers use the plural set_component_properties verb.'],
-        whenNotToUse: ['Use set_component_property to avoid alias normalization.'],
-        inputProps: { actorName: P.actorName, componentName: P.componentName, properties: P.properties, propertyName: P.propertyName, value: P.value },
-        required: ['actorName', 'componentName'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'set_component_properties', actorName: 'Cube1', componentName: 'Light1', properties: { Intensity: 5.0 } },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'get_component_property',
-        domain: DOMAIN,
-        family: FAMILY_COMPONENT,
-        topics: ['value of a setting', 'nested struct member', 'no instance needed', 'blueprint component property'],
-        summary: 'Read one property\'s value and type from a named component on a live actor, or from a Blueprint\'s own component (blueprintPath, no instance needed); dotted paths reach into structs.',
-        whenToUse: ['A component property value must be inspected.', 'A component template on a Blueprint with no instance in the level must be read.'],
-        whenNotToUse: ['The property should be changed (use set_component_property).'],
-        inputProps: { actorName: P.actorName, blueprintPath: P.templateBlueprintPath, componentName: P.componentName, propertyName: P.propertyName, propertyPath: P.propertyPath },
-        required: ['componentName'],
-        outputProps: { value: P.value },
-        outputRequired: [],
-        effect: 'read',
-        exampleInput: { action: 'get_component_property', actorName: 'Cube1', componentName: 'Light1', propertyName: 'Intensity' },
-        exampleOutput: { success: true, message: 'Intensity = 5.0', value: 5.0 },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'set_material',
-        domain: DOMAIN,
-        family: FAMILY_MATERIAL,
-        topics: ['assign material to mesh', 'apply material to actor', 'change actor material', 'put material on mesh', 'replace mesh material', 'set material slot'],
-        summary: 'Apply a material asset to a mesh component on an actor, optionally per slot, or a material to every slot in one call (materials).',
-        whenToUse: ['A material must be assigned to an actor mesh component.', 'A mesh with several material slots (an SDF part) needs a material in each: materials sets them all in one call.'],
-        whenNotToUse: ['The mesh has no material slots (the assignment is a no-op).'],
-        ...MATERIAL_INPUT,
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'set_material', actorName: 'Cube1', materialPath: '/Game/Materials/M_Glow', materialSlot: 0 },
-    }),
-];
-//# sourceMappingURL=component-records.js.map