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

package/dist/tools/catalog/capabilities/records/world/manage-level-structure.structure.data.js

@@ -1,180 +0,0 @@
-import { buildWorldRecord } from './builder.js';
-import { P } from './properties.js';
-const F = 'structure';
-const BP_LEVEL = { type: 'string', description: 'Loaded level (persistent or streaming sublevel) whose level blueprint to edit; defaults to the persistent level.' };
-const LEVEL_ASSET = { type: 'string', description: 'Saved level asset to instance or pack, e.g. /Game/Maps/Room01 (not the open level).' };
-const SAVE_LEVEL = { type: 'boolean', description: 'Save the open level (default true unless it was never saved).' };
-export const LEVEL_STRUCTURE_RECORDS = [
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'create_level', dispatchAction: 'create_level',
-        family: F, summary: 'Create a new level asset; loadAfterCreate opens it in the editor.',
-        whenToUse: ['A brand-new level must be created and opened.'], whenNotToUse: ['An existing level should be loaded instead.'],
-        inputProps: { levelName: P.levelName, levelPath: P.levelPath, bCreateWorldPartition: P.bCreateWorldPartition, bUseExternalActors: P.bUseExternalActors, save: P.save, loadAfterCreate: { type: 'boolean', description: 'Open the new level in the editor after creating it (default false). When open levels have unsaved changes the load would drop, the call is refused with DIRTY_PACKAGES (listing them in unsavedPackages) before anything is created.' } },
-        required: ['levelName'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'create_level', levelName: 'NewMap', bCreateWorldPartition: false },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'create_sublevel', dispatchAction: 'create_sublevel',
-        topics: ['sublevel', 'sub level', 'streaming level', 'child level'],
-        family: F, summary: 'Create a sub-level asset as a streaming child of a parent level.',
-        whenToUse: ['A streaming child level must be created.'], whenNotToUse: ['The level should be loaded as the main level; use create_level.'],
-        inputProps: { sublevelName: P.sublevelName, sublevelPath: P.sublevelPath, parentLevel: P.parentLevel, streamingMethod: P.streamingMethod, save: P.save },
-        required: ['sublevelName'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_sublevel', sublevelName: 'Sub01', parentLevel: '/Game/Maps/Demo' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'configure_level_streaming', dispatchAction: 'configure_level_streaming',
-        family: F, summary: 'Configure streaming settings for a sub-level (method, visibility, blocking).',
-        whenToUse: ['A sub-level streaming method or load behavior must be set.'], whenNotToUse: ['A streaming volume should be created; use create_*_volume.'],
-        inputProps: { levelName: P.levelName, streamingMethod: P.streamingMethod, bShouldBeVisible: P.bShouldBeVisible, bShouldBlockOnLoad: P.bShouldBlockOnLoad, bDisableDistanceStreaming: P.bDisableDistanceStreaming, save: P.levelEditSave },
-        required: ['levelName'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'configure_level_streaming', levelName: 'Sub01', streamingMethod: 'Blueprint' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'set_streaming_distance', dispatchAction: 'set_streaming_distance',
-        family: F, summary: 'Set the distance-based streaming radius for a sub-level via a streaming volume.',
-        whenToUse: ['Distance-based streaming must be tuned for a sub-level.'], whenNotToUse: ['The streaming method should be changed; use configure_level_streaming.'],
-        inputProps: { volumeLocation: P.volumeLocation, levelName: P.levelName, streamingDistance: P.streamingDistance, streamingUsage: P.streamingUsage, createVolume: P.createVolume, save: P.levelEditSave },
-        required: ['levelName', 'streamingDistance'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'set_streaming_distance', levelName: 'Sub01', streamingDistance: 5000 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'enable_world_partition', dispatchAction: 'enable_world_partition',
-        family: F, summary: 'Enable World Partition for a level (requires editor, one-time conversion).',
-        whenToUse: ['A level must be converted to use World Partition.'], whenNotToUse: ['World Partition is already enabled for the level.'],
-        inputProps: { bEnableWorldPartition: P.bEnableWorldPartition, bUseExternalActors: { type: 'boolean', description: 'Also move the level actors into one-file-per-actor packages (default false).' }, save: P.levelEditSave },
-        required: [], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'enable_world_partition', bEnableWorldPartition: true },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'configure_grid_size', dispatchAction: 'configure_grid_size',
-        family: F, summary: 'Configure the World Partition grid cell size and loading range.',
-        whenToUse: ['World Partition grid resolution must be tuned.'], whenNotToUse: ['World Partition is not enabled for the level.'],
-        inputProps: { gridName: P.gridName, createIfMissing: P.createIfMissing, bBlockOnSlowStreaming: P.bBlockOnSlowStreaming, gridCellSize: P.gridCellSize, loadingRange: P.loadingRange, priority: P.gridPriority, save: P.levelEditSave },
-        required: [], effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'configure_grid_size', gridCellSize: 12800 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'create_data_layer', dispatchAction: 'create_data_layer',
-        family: F, summary: 'Create a World Partition data layer asset.',
-        whenToUse: ['A Runtime or Editor data layer must be created.'], whenNotToUse: ['The level does not use World Partition.'],
-        inputProps: { dataLayerName: P.dataLayerName, dataLayerType: P.dataLayerType, bIsInitiallyVisible: P.bIsInitiallyVisible, bIsInitiallyLoaded: P.bIsInitiallyLoaded, dataLayerAssetPath: { type: 'string', description: 'Folder for the new DataLayerAsset (default /Game/DataLayers).' }, bIsPrivate: { type: 'boolean', description: 'Make the data layer private to this world (UE 5.3 or later).' }, save: { type: 'boolean', description: 'Save the level that holds the new data layer instance (the data layer asset itself is always saved).' } },
-        required: ['dataLayerName'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_data_layer', dataLayerName: 'DL_Vegetation', dataLayerType: 'Runtime' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'assign_actor_to_data_layer', dispatchAction: 'assign_actor_to_data_layer',
-        family: F, summary: 'Assign an actor to a World Partition data layer.',
-        whenToUse: ['An actor must be organized under a data layer.'], whenNotToUse: ['The actor should remain in the default layer.'],
-        inputProps: { actorName: P.actorName, actorPath: P.actorPath, dataLayerName: P.dataLayerName, save: P.levelEditSave },
-        required: ['dataLayerName'], requiredOneOf: ['actorName', 'actorPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'assign_actor_to_data_layer', actorName: 'Tree_01', dataLayerName: 'DL_Vegetation' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'configure_hlod_layer', dispatchAction: 'configure_hlod_layer',
-        family: F, summary: 'Configure an HLOD layer (spatial loading, cell size, loading distance).',
-        whenToUse: ['An HLOD layer must be configured for the level.'], whenNotToUse: ['HLOD is not used for the level.'],
-        inputProps: { layerType: P.layerType, hlodLayerName: P.hlodLayerName, hlodLayerPath: P.hlodLayerPath, bIsSpatiallyLoaded: P.bIsSpatiallyLoaded, cellSize: P.cellSize, loadingDistance: P.loadingDistance, save: { type: 'boolean', description: 'Save the new HLOD layer asset (default true).' } },
-        required: ['hlodLayerName'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'configure_hlod_layer', hlodLayerName: 'HLOD_01' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'create_minimap_volume', dispatchAction: 'create_minimap_volume',
-        family: F, summary: 'Create a minimap capture volume for the level.',
-        whenToUse: ['A minimap capture volume must be placed.'], whenNotToUse: ['A generic volume is needed; use create_*_volume.'],
-        inputProps: { volumeLocation: P.volumeLocation, volumeExtent: P.volumeExtent, volumeName: P.volumeName, location: P.location, extent: P.extent, save: P.levelEditSave },
-        required: ['location'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_minimap_volume', location: { x: 0, y: 0, z: 0 } },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'create_level_instance', dispatchAction: 'create_level_instance',
-        topics: ['level instance', 'instance a level', 'place level in level', 'reuse room level'],
-        family: F, summary: 'Place a Level Instance actor that loads an existing level asset at a location, so one saved level (a room, a building) can be reused inside another.',
-        whenToUse: ['A saved level must appear inside the open level as one movable actor.'], whenNotToUse: ['The level should stream as a sublevel; use create_sublevel or configure_level_streaming.'],
-        inputProps: {
-            levelAssetPath: LEVEL_ASSET,
-            location: P.location,
-            rotation: P.rotation,
-            label: { type: 'string', description: 'Actor label of the new instance (default LI_<LevelName>).' },
-            save: SAVE_LEVEL,
-        },
-        required: ['levelAssetPath'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        outputProps: {
-            actorName: { type: 'string', description: 'Object name of the placed Level Instance actor.' },
-            actorLabel: { type: 'string', description: 'Its label in the outliner.' },
-            worldAsset: { type: 'string', description: 'The level the instance loads.' },
-            loaded: { type: 'boolean', description: 'Whether the instanced level is loaded in the editor now.' },
-            childActorCount: { type: 'number', description: 'Actors in the loaded instance level.' },
-            saved: { type: 'boolean', description: 'Whether the open level was saved.' },
-        },
-        exampleInput: { action: 'create_level_instance', levelAssetPath: '/Game/Maps/Room01', location: { x: 1000, y: 0, z: 0 } },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'create_packed_level_actor', dispatchAction: 'create_packed_level_actor',
-        topics: ['packed level actor', 'packed level blueprint', 'bake level into instanced meshes'],
-        family: F, summary: 'Bake the static meshes of a level into a Packed Level Blueprint (instanced static mesh components) and optionally place it (UE 5.3 or later).',
-        whenToUse: ['A level of repeated static meshes must become one cheap, reusable Blueprint actor.'], whenNotToUse: ['The level has gameplay actors that must stay live; use create_level_instance.'],
-        inputProps: {
-            levelAssetPath: LEVEL_ASSET,
-            blueprintPath: { type: 'string', description: 'Packed Level Blueprint to create or update (default <level folder>/BPP_<LevelName>).' },
-            spawn: { type: 'boolean', description: 'Place the Blueprint in the open level (default true).' },
-            location: P.location,
-            save: { type: 'boolean', description: 'Save the Blueprint (default true) and, when it is placed, the open level (default true unless the level was never saved).' },
-        },
-        required: ['levelAssetPath'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        outputProps: {
-            blueprintPath: { type: 'string', description: 'The Packed Level Blueprint that was created or updated.' },
-            blueprintCreated: { type: 'boolean', description: 'True when the Blueprint was new.' },
-            ismComponentCount: { type: 'number', description: 'Instanced static mesh components on the Blueprint.' },
-            instanceCount: { type: 'number', description: 'Mesh instances across those components.' },
-            blueprintSaved: { type: 'boolean', description: 'Whether the Blueprint was saved.' },
-            actorName: { type: 'string', description: 'The placed actor, when spawn is true.' },
-            saved: { type: 'boolean', description: 'Whether the open level was saved.' },
-        },
-        exampleInput: { action: 'create_packed_level_actor', levelAssetPath: '/Game/Maps/Room01', location: { x: 0, y: 2000, z: 0 } },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'open_level_blueprint', dispatchAction: 'open_level_blueprint',
-        family: F, summary: 'Open the level blueprint (level scripting) editor.',
-        whenToUse: ['The level blueprint graph must be edited.'], whenNotToUse: ['A sub-level blueprint is needed; use the asset path directly.'],
-        inputProps: { levelPath: P.levelPath },
-        required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'open_level_blueprint', levelPath: '/Game/Maps/Demo' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'add_level_blueprint_node', dispatchAction: 'add_level_blueprint_node',
-        family: F, summary: 'Add a node to the level blueprint graph.',
-        whenToUse: ['A new node must be added to level scripting.'], whenNotToUse: ['An existing node should be connected; use connect_level_blueprint_nodes.'],
-        inputProps: { nodeClass: P.nodeClass, nodeName: P.nodeName, nodePosition: P.nodePosition, levelPath: BP_LEVEL, save: P.levelEditSave, functionName: { type: 'string', description: 'Function to bind when nodeClass is K2Node_CallFunction (e.g. PrintString); short function names may also be passed as nodeClass.' } },
-        required: ['nodeClass'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_level_blueprint_node', nodeClass: 'K2Node_CallFunction', nodeName: 'Print' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'remove_level_blueprint_node', dispatchAction: 'remove_level_blueprint_node',
-        family: F, summary: 'Remove nodes from the level blueprint graph by id or name, or purge unbound call nodes.',
-        whenToUse: ['A level blueprint node must be deleted, or an unbound K2Node_CallFunction ("Could not find a function named None") must be repaired.'], whenNotToUse: ['The node only needs re-wiring; use connect_level_blueprint_nodes.'],
-        inputProps: { nodeId: { type: 'string', description: 'Node GUID returned by add_level_blueprint_node.' }, nodeName: P.nodeName, unboundOnly: { type: 'boolean', description: 'Remove every call-function node that has no bound function instead of a named node.' }, levelPath: BP_LEVEL, save: P.levelEditSave },
-        required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'remove_level_blueprint_node', unboundOnly: true },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'connect_level_blueprint_nodes', dispatchAction: 'connect_level_blueprint_nodes',
-        family: F, summary: 'Connect two level blueprint graph nodes by pin names.',
-        whenToUse: ['Two level blueprint nodes must be wired together.'], whenNotToUse: ['A node must be created first; use add_level_blueprint_node.', 'The nodes are in a Blueprint asset, not the level Blueprint; use blueprint.edit_graph (edit=connect_pins).'],
-        inputProps: { sourceNodeName: P.sourceNodeName, sourcePinName: P.sourcePinName, targetNodeName: P.targetNodeName, targetPinName: P.targetPinName, levelPath: BP_LEVEL, save: P.levelEditSave },
-        required: ['sourceNodeName', 'targetNodeName'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'connect_level_blueprint_nodes', sourceNodeName: 'EventBegin', targetNodeName: 'Print' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'get_level_structure_info', dispatchAction: 'get_level_structure_info',
-        topics: ['list streaming sublevels', 'world partition enabled', 'list data layers', 'hlod layers'],
-        family: F, summary: 'Read the open level\'s structure: streaming sub-levels (loaded, visible, actor counts), whether World Partition is on, its data layers, level instances and HLOD layers.',
-        whenToUse: ['The level structure must be inspected.'], whenNotToUse: ['A specific volume list is needed; use get_volumes_info.'],
-        inputProps: {},
-        required: [], effect: 'read', costLatency: 'instant', costResources: 'low',
-        exampleInput: { action: 'get_level_structure_info' },
-        exampleOutput: { success: true, message: 'Retrieved level structure information', levelStructureInfo: { currentLevel: 'L_Stage01', persistentLevel: '/Game/Maps/L_Stage01', actorCount: 412, sublevelCount: 0, sublevels: [], streamingLevels: [], worldPartitionEnabled: false, levelInstances: [], hlodLayers: [] } },
-        outputProps: { levelStructureInfo: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'currentLevel, persistentLevel, actorCount, sublevelCount, sublevels (package names), streamingLevels (name, packageName, isLoaded, isVisible, shouldBeLoaded, shouldBeVisible, streamingClass, alwaysLoaded, actorCount), worldPartitionEnabled, dataLayers when World Partition is on (name, fullName, isRuntime, runtimeState, initialRuntimeState), levelInstances (labels) and hlodLayers (name, type and the layer settings).' } },
-    }),
-];
-//# sourceMappingURL=manage-level-structure.structure.data.js.map

package/dist/tools/catalog/capabilities/records/world/manage-level-structure.volume.data.d.ts

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

package/dist/tools/catalog/capabilities/records/world/manage-level-structure.volume.data.js

@@ -1,141 +0,0 @@
-import { buildWorldRecord } from './builder.js';
-import { P } from './properties.js';
-const F = 'volume';
-const VOLUME_PRIORITY = { type: 'number', description: 'Priority where volumes overlap (PhysicsVolume, PostProcessVolume).' };
-const T = 'manage_level_structure';
-const VOLUME_CLASS_ACTIONS = {
-    TriggerVolume: 'add_trigger_volume',
-    TriggerBox: 'create_trigger_box',
-    TriggerSphere: 'create_trigger_sphere',
-    TriggerCapsule: 'create_trigger_capsule',
-    BlockingVolume: 'add_blocking_volume',
-    KillZVolume: 'add_kill_z_volume',
-    PainCausingVolume: 'create_pain_causing_volume',
-    PhysicsVolume: 'add_physics_volume',
-    AudioVolume: 'create_audio_volume',
-    ReverbVolume: 'create_reverb_volume',
-    CullDistanceVolume: 'add_cull_distance_volume',
-    PrecomputedVisibilityVolume: 'create_precomputed_visibility_volume',
-    LightmassImportanceVolume: 'create_lightmass_importance_volume',
-    NavMeshBoundsVolume: 'create_nav_mesh_bounds_volume',
-    NavModifierVolume: 'create_nav_modifier_volume',
-    CameraBlockingVolume: 'create_camera_blocking_volume',
-    PostProcessVolume: 'add_post_process_volume',
-};
-const FOLDED = [
-    { action: 'create_trigger_volume', pins: { volumeClass: 'TriggerVolume' } },
-    { action: 'add_trigger_volume', pins: { volumeClass: 'TriggerVolume' } },
-    { action: 'create_trigger_box', pins: { volumeClass: 'TriggerBox' } },
-    { action: 'create_trigger_sphere', pins: { volumeClass: 'TriggerSphere' } },
-    { action: 'create_trigger_capsule', pins: { volumeClass: 'TriggerCapsule' } },
-    { action: 'create_blocking_volume', pins: { volumeClass: 'BlockingVolume' } },
-    { action: 'add_blocking_volume', pins: { volumeClass: 'BlockingVolume' } },
-    { action: 'create_kill_z_volume', pins: { volumeClass: 'KillZVolume' } },
-    { action: 'add_kill_z_volume', pins: { volumeClass: 'KillZVolume' } },
-    { action: 'create_pain_causing_volume', pins: { volumeClass: 'PainCausingVolume' } },
-    { action: 'create_physics_volume', pins: { volumeClass: 'PhysicsVolume' } },
-    { action: 'add_physics_volume', pins: { volumeClass: 'PhysicsVolume' } },
-    { action: 'create_audio_volume', pins: { volumeClass: 'AudioVolume' } },
-    { action: 'create_reverb_volume', pins: { volumeClass: 'ReverbVolume' } },
-    { action: 'create_cull_distance_volume', pins: { volumeClass: 'CullDistanceVolume' } },
-    { action: 'add_cull_distance_volume', pins: { volumeClass: 'CullDistanceVolume' } },
-    { action: 'create_precomputed_visibility_volume', pins: { volumeClass: 'PrecomputedVisibilityVolume' } },
-    { action: 'create_lightmass_importance_volume', pins: { volumeClass: 'LightmassImportanceVolume' } },
-    { action: 'create_nav_mesh_bounds_volume', pins: { volumeClass: 'NavMeshBoundsVolume' } },
-    { action: 'create_nav_modifier_volume', pins: { volumeClass: 'NavModifierVolume' } },
-    { action: 'create_camera_blocking_volume', pins: { volumeClass: 'CameraBlockingVolume' } },
-    { action: 'create_post_process_volume', pins: { volumeClass: 'PostProcessVolume' } },
-    { action: 'add_post_process_volume', pins: { volumeClass: 'PostProcessVolume' } },
-];
-const SHAPE_NAMES = new Set(['create_trigger_box', 'create_trigger_sphere', 'create_trigger_capsule']);
-const ADVERTISED_ALIASES = FOLDED.filter((entry) => !SHAPE_NAMES.has(entry.action)).map((entry) => `${T}.${entry.action}`);
-const volumeClass = {
-    type: 'string',
-    enum: Object.keys(VOLUME_CLASS_ACTIONS),
-    description: 'Volume class to spawn. Each class takes only its own parameters; one it would ignore is refused.',
-};
-const actorPath = {
-    type: 'string',
-    description: 'Attach the new volume to this actor instead of placing it standalone. Honoured for TriggerVolume, '
-        + 'BlockingVolume, KillZVolume, PhysicsVolume, CullDistanceVolume and PostProcessVolume.',
-};
-export const LEVEL_VOLUME_RECORDS = [
-    buildWorldRecord({
-        parentTool: T, action: 'create_volume', dispatchAction: 'create_volume',
-        folded: FOLDED,
-        dispatchBy: { param: 'volumeClass', actions: VOLUME_CLASS_ACTIONS },
-        aliases: ADVERTISED_ALIASES,
-        topics: ['create volume', 'trigger volume', 'trigger box', 'trigger sphere', 'trigger capsule', 'blocking volume', 'kill z volume', 'post process volume'],
-        family: F,
-        summary: 'Create a volume actor of the chosen class in the level, or attach it to an actor when actorPath is given.',
-        whenToUse: [
-            'Any volume actor must be placed: trigger, blocking, kill-Z, pain, physics, audio, reverb, cull distance, '
-                + 'precomputed visibility, Lightmass importance, nav bounds, nav modifier, camera blocking or post-process.',
-        ],
-        whenNotToUse: ['An existing volume must be resized or reconfigured; use set_volume_extent or set_volume_properties.'],
-        inputProps: {
-            volumeClass,
-            volumeName: P.volumeName, location: P.location, rotation: P.rotation, extent: P.extent, actorPath,
-            boxExtent: P.boxExtent, sphereRadius: P.sphereRadius, capsuleRadius: P.capsuleRadius, capsuleHalfHeight: P.capsuleHalfHeight,
-            bPainCausing: P.bPainCausing, damagePerSec: P.damagePerSec,
-            fluidFriction: P.fluidFriction, terminalVelocity: P.terminalVelocity, bWaterVolume: P.bWaterVolume,
-            bEnabled: P.bEnabled, reverbVolume: P.reverbVolume, fadeTime: P.fadeTime,
-            cullDistances: P.cullDistances,
-            bUnbound: P.bUnbound, blendRadius: P.blendRadius, blendWeight: P.blendWeight,
-            priority: VOLUME_PRIORITY,
-            killZHeight: { type: 'number', description: 'World Z of the kill plane (KillZVolume); sets the volume height.' },
-            postProcessSettings: {
-                type: 'object', additionalProperties: false,
-                description: 'PostProcessVolume overrides: bloomEnabled, exposureBias, vignetteIntensity, saturation, contrast, gamma.',
-                properties: { bloomEnabled: { type: 'boolean' }, exposureBias: { type: 'number' }, vignetteIntensity: { type: 'number' }, saturation: { type: 'number' }, contrast: { type: 'number' }, gamma: { type: 'number' } },
-            },
-            save: P.levelEditSave,
-        },
-        required: ['volumeClass', 'location'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_volume', volumeClass: 'TriggerVolume', location: { x: 0, y: 0, z: 0 }, extent: { x: 500, y: 500, z: 200 } },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'set_volume_extent', dispatchAction: 'set_volume_extent',
-        family: F, summary: 'Set the extent (half-size) of an existing volume.',
-        whenToUse: ['A volume must be resized.'], whenNotToUse: ['A new volume must be created; use create_volume.'],
-        inputProps: { volumeName: P.volumeName, extent: P.extent, save: P.levelEditSave },
-        required: ['volumeName', 'extent'], effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'set_volume_extent', volumeName: 'PP_01', extent: { x: 1000, y: 1000, z: 500 } },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'set_volume_bounds', dispatchAction: 'set_volume_bounds',
-        family: F, summary: 'Set the bounds (min/max) of an existing volume.',
-        whenToUse: ['A volume must be repositioned/resized via min/max bounds.'], whenNotToUse: ['Only the extent must change; use set_volume_extent.'],
-        inputProps: { volumeName: P.volumeName, bounds: P.boundsArray, save: P.levelEditSave },
-        required: ['volumeName', 'bounds'], effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'set_volume_bounds', volumeName: 'PP_01', bounds: [-1000, -1000, -500, 1000, 1000, 500] },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'set_volume_properties', dispatchAction: 'set_volume_properties',
-        family: F, summary: 'Set generic properties (enabled, blend, priority) on an existing volume.',
-        whenToUse: ['Volume properties must be updated without recreating it.'], whenNotToUse: ['The volume extent must change; use set_volume_extent.'],
-        inputProps: { volumeName: P.volumeName, bEnabled: P.bEnabled, priority: VOLUME_PRIORITY, blendWeight: P.blendWeight, bWaterVolume: P.bWaterVolume, fluidFriction: P.fluidFriction, terminalVelocity: P.terminalVelocity, bPainCausing: P.bPainCausing, damagePerSec: P.damagePerSec, reverbVolume: P.reverbVolume, fadeTime: P.fadeTime, save: P.levelEditSave },
-        required: ['volumeName'], effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'set_volume_properties', volumeName: 'PP_01', bEnabled: true },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'remove_volume', topics: ['remove trigger volume'], dispatchAction: 'remove_volume',
-        family: F, summary: 'Remove a volume actor from the level.',
-        whenToUse: ['A volume actor must be permanently removed.'], whenNotToUse: ['The volume should be disabled; use set_volume_properties.'],
-        inputProps: { volumeName: P.volumeName, save: P.levelEditSave },
-        required: ['volumeName'], effect: 'destructive', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'remove_volume', volumeName: 'PP_01' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_level_structure', action: 'get_volumes_info', dispatchAction: 'get_volumes_info',
-        topics: ['box extents', 'trigger actors'],
-        family: F, summary: 'List the volumes and trigger actors in the level with name, class, location and box extent, and a total count; filter by label or volumeType (a class name part such as Trigger or PostProcess).',
-        whenToUse: ['The set of volumes must be enumerated or inspected.'], whenNotToUse: ['A single volume must be resized; use set_volume_extent.'],
-        inputProps: { filter: P.filter, volumeType: P.volumeType },
-        required: [], effect: 'read', costLatency: 'instant', costResources: 'low',
-        exampleInput: { action: 'get_volumes_info', volumeType: 'Trigger' },
-        exampleOutput: { success: true, message: 'Found 1 volumes/triggers', volumesInfo: { totalCount: 1, volumes: [{ name: 'Trigger_01', class: 'TriggerBox', location: { x: 0, y: 0, z: 100 }, extent: { x: 64, y: 64, z: 64 } }] } },
-        outputProps: { volumesInfo: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'totalCount and volumes: each volume or trigger actor with name (its label), class, location and extent (the bounds half-size), as {x,y,z}.' } },
-    }),
-];
-//# sourceMappingURL=manage-level-structure.volume.data.js.map

package/dist/tools/catalog/capabilities/records/world/manage-pcg.async.data.d.ts

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

package/dist/tools/catalog/capabilities/records/world/manage-pcg.async.data.js

@@ -1,21 +0,0 @@
-import { buildWorldRecord } from './builder.js';
-import { P } from './properties.js';
-const F = 'pcg-execution';
-const PLUGIN = ['PCG'];
-export const PCG_ASYNC_RECORDS = [
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'execute_pcg_graph', topics: ['run pcg graph', 'generate pcg'], plugins: PLUGIN,
-        family: F, summary: 'Execute a PCG graph asynchronously, returning a numeric task identifier.', whenToUse: ['A PCG graph must be generated and the caller needs the scheduling task id.'], whenNotToUse: ['Graph authoring is needed; use add_pcg_node or connect_pcg_pins.'],
-        inputProps: {
-            graphPath: P.graphPath, actorName: P.actorName, componentName: P.componentName,
-            componentPath: P.componentPath, createComponent: P.createComponent, force: P.force, save: P.save,
-        }, required: ['graphPath'], effect: 'write',
-        behavior: { longRunning: true, safeToRetry: false }, costLatency: 'long-running', costResources: 'high',
-        exampleInput: { action: 'execute_pcg_graph', graphPath: '/Game/PCG/PCG_MyGraph', createComponent: true, save: true },
-        exampleOutput: { success: true, message: 'PCG graph execution started', taskId: 5231 },
-        outputProps: {
-            taskId: { type: 'number', description: 'Opaque numeric scheduling receipt for the PCG task.' },
-        },
-    }),
-];
-//# sourceMappingURL=manage-pcg.async.data.js.map

package/dist/tools/catalog/capabilities/records/world/manage-pcg.graph.data.d.ts

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

package/dist/tools/catalog/capabilities/records/world/manage-pcg.graph.data.js

@@ -1,196 +0,0 @@
-import { buildWorldRecord } from './builder.js';
-import { P } from './properties.js';
-const F = 'pcg';
-const PLUGIN = ['PCG'];
-const PCG_SAVE = { type: 'boolean', description: 'Save the PCG graph asset after the edit (default true).' };
-export const PCG_GRAPH_RECORDS = [
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'create_pcg_graph', plugins: PLUGIN,
-        topics: ['pcg graph', 'procedural generation', 'pcg asset', 'new pcg graph'],
-        family: F, summary: 'Create a new PCG graph asset.', whenToUse: ['A PCG graph asset must be created.'], whenNotToUse: ['A subgraph is needed; use create_pcg_subgraph.'],
-        inputProps: { assetPath: P.assetPath, path: P.path, overwrite: P.overwrite, graphPath: P.graphPath, name: P.name, save: PCG_SAVE }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'create_pcg_graph', graphPath: '/Game/PCG/PCG_MyGraph' }, exampleOutput: { success: true, message: 'PCG graph created', graphPath: '/Game/PCG/PCG_MyGraph' },
-        outputProps: { graphPath: { type: 'string', description: 'Created PCG graph asset path.' } },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'create_pcg_subgraph', plugins: PLUGIN,
-        family: F, summary: 'Create a PCG subgraph asset for reuse.', whenToUse: ['A reusable PCG subgraph must be created.'], whenNotToUse: ['A top-level graph is needed; use create_pcg_graph.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, overwrite: P.overwrite, subgraphPath: P.subgraphPath, parentGraphPath: P.parentGraphPath, name: P.name, save: PCG_SAVE }, required: ['subgraphPath'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'create_pcg_subgraph', subgraphPath: '/Game/PCG/PCG_Sub' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_pcg_node', plugins: PLUGIN,
-        family: F, summary: 'Add a node to a PCG graph by settings class or alias.', whenToUse: ['A node must be added to a PCG graph.'], whenNotToUse: ['Pins must be connected; use connect_pcg_pins.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, posX: P.posX, posY: P.posY, settings: P.settings, graphPath: P.graphPath, nodeType: P.nodeType, settingsClass: P.settingsClass, name: P.name, save: PCG_SAVE }, required: ['graphPath', 'nodeType'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_pcg_node', graphPath: '/Game/PCG/PCG_MyGraph', nodeType: 'PCGStaticMeshSpawner' }, exampleOutput: { success: true, message: 'PCG node added', nodeId: 'Node_3' },
-        outputProps: { nodeId: { type: 'string', description: 'Created PCG node identifier.' } },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'connect_pcg_pins', plugins: PLUGIN,
-        family: F, summary: 'Connect an output pin of one PCG node to an input pin of another.', whenToUse: ['Two PCG nodes must be wired together.'], whenNotToUse: ['A node must be added; use add_pcg_node.'],
-        inputProps: { inputName: P.inputName, outputName: P.outputName, graphPath: P.graphPath, sourceNodeId: P.sourceNodeId, sourcePin: P.sourcePin, targetNodeId: P.targetNodeId, targetPin: P.targetPin, save: PCG_SAVE }, required: ['graphPath', 'sourceNodeId', 'targetNodeId'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'connect_pcg_pins', graphPath: '/Game/PCG/PCG_MyGraph', sourceNodeId: 'Node_1', targetNodeId: 'Node_2' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'set_pcg_node_settings', plugins: PLUGIN,
-        family: F, summary: 'Set settings on an existing PCG node.', whenToUse: ['A PCG node settings must be updated.'], whenNotToUse: ['The node must be created; use add_pcg_node.'],
-        inputProps: { nodeName: P.nodeName, title: P.title, classPath: P.classPath, texturePath: P.texturePath, meshPath: P.meshPath, actorClass: P.actorClass, x: P.x, y: P.y, settings: P.settings, graphPath: P.graphPath, nodeId: P.nodeId, save: PCG_SAVE }, required: ['graphPath', 'nodeId'], effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'set_pcg_node_settings', graphPath: '/Game/PCG/PCG_MyGraph', nodeId: 'Node_3' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_landscape_data_node', plugins: PLUGIN,
-        family: F, summary: 'Add a Landscape data source node to a PCG graph.', whenToUse: ['A PCG graph must sample landscape data.'], whenNotToUse: ['A spline data node is needed; use add_spline_data_node.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_landscape_data_node', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_spline_data_node', plugins: PLUGIN,
-        family: F, summary: 'Add a Spline data source node to a PCG graph.', whenToUse: ['A PCG graph must sample a spline.'], whenNotToUse: ['A landscape data node is needed; use add_landscape_data_node.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_spline_data_node', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_volume_data_node', plugins: PLUGIN,
-        family: F, summary: 'Add a Volume data source node to a PCG graph.', whenToUse: ['A PCG graph must sample a volume.'], whenNotToUse: ['A texture data node is needed; use add_texture_data_node.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_volume_data_node', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_actor_data_node', plugins: PLUGIN,
-        family: F, summary: 'Add an Actor data source node to a PCG graph.', whenToUse: ['A PCG graph must sample existing actors.'], whenNotToUse: ['A mesh sampler is needed; use add_mesh_sampler.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_actor_data_node', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_texture_data_node', plugins: PLUGIN,
-        family: F, summary: 'Add a Texture data source node to a PCG graph.', whenToUse: ['A PCG graph must sample a texture.'], whenNotToUse: ['A volume data node is needed; use add_volume_data_node.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, texturePath: P.texturePath, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_texture_data_node', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_surface_sampler', plugins: PLUGIN,
-        family: F, summary: 'Add a Surface sampler node to a PCG graph.', whenToUse: ['Points must be sampled on surfaces.'], whenNotToUse: ['A mesh sampler is needed; use add_mesh_sampler.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_surface_sampler', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_mesh_sampler', plugins: PLUGIN,
-        family: F, summary: 'Add a Mesh sampler node to a PCG graph.', whenToUse: ['Points must be sampled on a mesh.'], whenNotToUse: ['A surface sampler is needed; use add_surface_sampler.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name, meshPath: P.meshPath }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_mesh_sampler', graphPath: '/Game/PCG/PCG_MyGraph', meshPath: '/Game/Meshes/SM_Rock' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_spline_sampler', plugins: PLUGIN,
-        family: F, summary: 'Add a Spline sampler node to a PCG graph.', whenToUse: ['Points must be sampled along a spline.'], whenNotToUse: ['A volume sampler is needed; use add_volume_sampler.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_spline_sampler', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_volume_sampler', plugins: PLUGIN,
-        family: F, summary: 'Add a Volume sampler node to a PCG graph.', whenToUse: ['Points must be sampled within a volume.'], whenNotToUse: ['A spline sampler is needed; use add_spline_sampler.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_volume_sampler', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_bounds_modifier', plugins: PLUGIN,
-        family: F, summary: 'Add a Bounds modifier node to a PCG graph.', whenToUse: ['Point bounds must be modified.'], whenNotToUse: ['A density filter is needed; use add_density_filter.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_bounds_modifier', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_density_filter', plugins: PLUGIN,
-        family: F, summary: 'Add a Density filter node to a PCG graph.', whenToUse: ['Points must be filtered by density.'], whenNotToUse: ['A height filter is needed; use add_height_filter.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_density_filter', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_height_filter', plugins: PLUGIN,
-        family: F, summary: 'Add a Height filter node to a PCG graph.', whenToUse: ['Points must be filtered by height.'], whenNotToUse: ['A slope filter is needed; use add_slope_filter.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_height_filter', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_slope_filter', plugins: PLUGIN,
-        family: F, summary: 'Add a Slope filter node to a PCG graph.', whenToUse: ['Points must be filtered by slope.'], whenNotToUse: ['A distance filter is needed; use add_distance_filter.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_slope_filter', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_distance_filter', plugins: PLUGIN,
-        family: F, summary: 'Add a Distance filter node to a PCG graph.', whenToUse: ['Points must be filtered by distance.'], whenNotToUse: ['A bounds filter is needed; use add_bounds_filter.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_distance_filter', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_bounds_filter', plugins: PLUGIN,
-        family: F, summary: 'Add a Bounds filter node to a PCG graph.', whenToUse: ['Points must be filtered by bounds.'], whenNotToUse: ['A self-pruning node is needed; use add_self_pruning.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_bounds_filter', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_self_pruning', plugins: PLUGIN,
-        family: F, summary: 'Add a Self-pruning node to a PCG graph.', whenToUse: ['Overlapping points must be pruned.'], whenNotToUse: ['Points must be transformed; use add_transform_points.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_self_pruning', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_transform_points', plugins: PLUGIN,
-        family: F, summary: 'Add a Transform Points node to a PCG graph.', whenToUse: ['Points must be transformed.'], whenNotToUse: ['Points must be projected to a surface; use add_project_to_surface.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_transform_points', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_project_to_surface', plugins: PLUGIN,
-        family: F, summary: 'Add a Project to Surface node to a PCG graph.', whenToUse: ['Points must be projected onto a surface.'], whenNotToUse: ['Points must be copied; use add_copy_points.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_project_to_surface', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_copy_points', plugins: PLUGIN,
-        family: F, summary: 'Add a Copy Points node to a PCG graph.', whenToUse: ['Points must be copied from one set to another.'], whenNotToUse: ['Points must be merged; use add_merge_points.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_copy_points', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_merge_points', plugins: PLUGIN,
-        family: F, summary: 'Add a Merge Points node to a PCG graph.', whenToUse: ['Multiple point sets must be merged.'], whenNotToUse: ['A static mesh spawner is needed; use add_static_mesh_spawner.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_merge_points', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_static_mesh_spawner', plugins: PLUGIN,
-        family: F, summary: 'Add a Static Mesh spawner node to a PCG graph.', whenToUse: ['Static meshes must be spawned at points.'], whenNotToUse: ['An actor spawner is needed; use add_actor_spawner.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name, meshPath: P.meshPath }, required: ['graphPath', 'meshPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_static_mesh_spawner', graphPath: '/Game/PCG/PCG_MyGraph', meshPath: '/Game/Meshes/SM_Rock' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_actor_spawner', plugins: PLUGIN,
-        family: F, summary: 'Add an Actor spawner node to a PCG graph.', whenToUse: ['Actors must be spawned at points.'], whenNotToUse: ['A static mesh spawner is needed; use add_static_mesh_spawner.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, classPath: P.classPath, graphPath: P.graphPath, name: P.name, actorClass: P.actorClass }, required: ['graphPath', 'actorClass'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_actor_spawner', graphPath: '/Game/PCG/PCG_MyGraph', actorClass: '/Game/Blueprints/BP_Tree' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'add_spline_spawner', plugins: PLUGIN,
-        family: F, summary: 'Add a Spline spawner node to a PCG graph.', whenToUse: ['Actors/meshes must be spawned along a spline.'], whenNotToUse: ['A static mesh spawner is needed; use add_static_mesh_spawner.'],
-        inputProps: { nodeName: P.nodeName, x: P.x, y: P.y, settings: P.settings, save: PCG_SAVE, graphPath: P.graphPath, name: P.name }, required: ['graphPath'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'add_spline_spawner', graphPath: '/Game/PCG/PCG_MyGraph' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_pcg', action: 'set_pcg_partition_grid_size', plugins: PLUGIN,
-        family: F, summary: 'Set the PCG partition grid cell size for a graph or component.',
-        whenToUse: ['PCG partition resolution must be tuned.'], whenNotToUse: ['A node must be added; use add_pcg_node.'],
-        inputProps: {
-            scope: P.pcgScope, gridSize: P.pcgGridSize,
-            actorName: P.actorName, componentName: P.componentName, componentPath: P.componentPath, save: P.save,
-        }, required: ['gridSize'], effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'set_pcg_partition_grid_size', scope: 'world', gridSize: 12800, save: true },
-        exampleOutput: { success: true, message: 'PCG partition grid size set', scope: 'world', previousGridSize: 6400, gridSize: 12800, saved: true },
-        outputProps: {
-            scope: { type: 'string', description: "Resolved scope: 'world' or 'component'." },
-            previousGridSize: { type: 'number', description: 'Previous partition grid cell size.' },
-            gridSize: { type: 'number', description: 'New partition grid cell size.' },
-            saved: { type: 'boolean', description: 'Whether the level/asset was saved.' },
-        },
-    }),
-];
-//# sourceMappingURL=manage-pcg.graph.data.js.map

package/dist/tools/catalog/capabilities/records/world/manage-pcg.index.d.ts

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

package/dist/tools/catalog/capabilities/records/world/manage-pcg.index.js

@@ -1,10 +0,0 @@
-import { PCG_GRAPH_RECORDS } from './manage-pcg.graph.data.js';
-import { PCG_ASYNC_RECORDS } from './manage-pcg.async.data.js';
-import { applyFolds } from '../shared/fold.js';
-import { MANAGE_PCG_FOLDS } from '../folds/manage-pcg.folds.js';
-export const MANAGE_PCG_UNFOLDED_SOURCES = [
-    ...PCG_GRAPH_RECORDS,
-    ...PCG_ASYNC_RECORDS,
-];
-export const MANAGE_PCG_SOURCES = applyFolds(MANAGE_PCG_UNFOLDED_SOURCES, MANAGE_PCG_FOLDS, 'manage_pcg');
-//# sourceMappingURL=manage-pcg.index.js.map