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

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

@@ -1,162 +0,0 @@
-import { buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const F = 'foliage';
-const WU = ['Foliage must be added, configured, or removed in the level.'];
-const AREAS = {
-    type: 'array', items: P.area,
-    description: 'Several area boxes at once, each {min, max}: every instance inside any of them is removed under one consent (every type unless foliageType names one).',
-};
-export const FOLIAGE_RECORDS = [
-    buildRecord({
-        id: 'build_environment.add_foliage', action: 'add_foliage', family: F,
-        topics: ['foliage', 'vegetation', 'grass', 'trees', 'scatter foliage', 'plants'],
-        summary: 'Add foliage: with only meshPath (+ name) create or update a foliage type asset; with a foliage type or a placement (locations, position, location + radius + count) scatter instances onto the ground, a bare meshPath standing in for its auto foliage type.',
-        whenToUse: WU, whenNotToUse: ['A procedural foliage volume should be used for large areas.'],
-        inputProps: { count: P.count, name: P.name, foliageType: P.foliageType, foliageTypePath: P.foliageTypePath,
-            meshPath: P.meshPath, path: { ...P.path, description: 'Folder the new foliage type asset goes in (type creation only; default /Game/Foliage).' },
-            density: { ...P.density, description: 'Type creation: instances per 1000x1000 units. Scatter: brush fill 0-1 (count overrides it).' },
-            minScale: P.minScale, maxScale: P.maxScale,
-            alignToNormal: P.alignToNormal, randomYaw: P.randomYaw, cullDistance: P.cullDistance,
-            locations: P.locations, location: P.location, radius: P.radius, position: P.position },
-        effect: 'write', latency: 'interactive', resources: 'medium',
-        dispatchAction: 'add_foliage',
-        exampleInput: { action: 'add_foliage', meshPath: '/Game/Meshes/SM_Bush', name: 'Bush_Type' },
-    }),
-    buildRecord({
-        id: 'build_environment.add_foliage_instances', action: 'add_foliage_instances', family: F,
-        summary: 'Add explicit foliage instances: full transforms, or bare locations varied by minScale/maxScale/randomYaw.',
-        whenToUse: WU, whenNotToUse: ['Random scatter via paint_foliage is sufficient.'],
-        inputProps: { foliageType: P.foliageType, foliageTypePath: P.foliageTypePath,
-            meshPath: { ...P.meshPath, description: 'StaticMesh to place when no foliage type is named; its /Game/Foliage/Auto_<mesh> type is made once and reused.' },
-            locations: P.locations, transforms: P.transforms,
-            minScale: P.minScale, maxScale: P.maxScale, randomYaw: P.randomYaw },
-        effect: 'write', latency: 'interactive', resources: 'medium',
-        dispatchAction: 'add_foliage_instances',
-        exampleInput: { action: 'add_foliage_instances', foliageType: 'Bush_Type', transforms: [{ location: { x: 0, y: 0, z: 0 } }] },
-    }),
-    buildRecord({
-        id: 'build_environment.get_foliage_instances', action: 'get_foliage_instances', family: F,
-        topics: ['count per type', 'vegetation count', 'positions and scale', 'count trees', 'how many trees'],
-        summary: 'Count foliage instances in the level, in total and per foliage type (byType), and list their positions; one type also returns rotation and scale ({x, y, z}: the whole scale, so a non-uniform one shows). The summary flag drops the list; limit caps it.',
-        whenToUse: ['Existing foliage instances must be inspected.', 'What foliage a level holds must be counted before removing it (summary).'],
-        whenNotToUse: ['Foliage should be removed rather than inspected.'],
-        inputProps: {
-            foliageType: P.foliageType, foliageTypePath: P.foliageTypePath,
-            summary: { type: 'boolean', description: 'Count only: byType and count, no instance list. A level-wide listing runs to tens of KB.' },
-            limit: { type: 'number', minimum: 0, description: 'Return at most this many instances; truncated says when more exist (count stays the total).' },
-        },
-        effect: 'read', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'get_foliage_instances', foliageType: 'Bush_Type' },
-    }),
-    buildRecord({
-        id: 'build_environment.remove_foliage', action: 'remove_foliage', family: F,
-        summary: 'Remove foliage: every instance of a type, all foliage, or only the instances inside an area box (or several boxes with areas).',
-        whenToUse: WU, whenNotToUse: ['Foliage should be hidden rather than removed.'],
-        inputProps: { foliageType: P.foliageType, foliageTypePath: P.foliageTypePath, removeAll: P.removeAll, area: P.area, areas: AREAS },
-        effect: 'destructive', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'remove_foliage', foliageType: 'Bush_Type' },
-    }),
-    buildRecord({
-        id: 'build_environment.paint_foliage', action: 'paint_foliage', family: F,
-        summary: 'Paint foliage over a brush disc (location + radius) or a box area: count instances dropped onto the ground, each with a random scale and yaw.',
-        whenToUse: WU, whenNotToUse: ['Explicit transforms should be used via add_foliage_instances.'],
-        inputProps: { foliageType: P.foliageType, foliageTypePath: P.foliageTypePath,
-            locations: P.locations, position: P.position, location: P.location, radius: P.radius,
-            density: P.density, area: P.area, count: P.count, snapToSurface: P.snapToSurface,
-            minScale: P.minScale, maxScale: P.maxScale, randomYaw: P.randomYaw, alignToNormal: P.alignToNormal },
-        effect: 'write', latency: 'interactive', resources: 'low',
-        dispatchAction: 'paint_foliage',
-        exampleInput: { action: 'paint_foliage', foliageType: '/Game/Foliage/FT_Grass', area: { min: { x: 0, y: -150, z: 0 }, max: { x: 5000, y: -100, z: 0 } }, count: 40, minScale: 0.8, maxScale: 1.4, randomYaw: true },
-    }),
-    buildRecord({
-        id: 'build_environment.paint_foliage_instances', action: 'paint_foliage_instances', family: F,
-        summary: 'Paint foliage instances with brush-based placement: a disc or a box area, dropped onto the ground.',
-        whenToUse: WU, whenNotToUse: ['Explicit locations should be used via add_foliage_instances.'],
-        inputProps: { foliageType: P.foliageType, foliageTypePath: P.foliageTypePath,
-            locations: P.locations, position: P.position, radius: P.radius, density: P.density,
-            area: P.area, count: P.count, snapToSurface: P.snapToSurface,
-            minScale: P.minScale, maxScale: P.maxScale, randomYaw: P.randomYaw, alignToNormal: P.alignToNormal },
-        effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'paint_foliage_instances', foliageType: 'Bush_Type', position: { x: 0, y: 0, z: 0 } },
-    }),
-    buildRecord({
-        id: 'build_environment.create_foliage_type', action: 'create_foliage_type', family: F,
-        summary: 'Create a foliage type asset from a static mesh.',
-        whenToUse: ['A new foliage type asset is needed.'],
-        whenNotToUse: ['An existing foliage type should be reused.'],
-        inputProps: { name: P.name, meshPath: P.meshPath, path: P.path, density: P.density, minScale: P.minScale, maxScale: P.maxScale,
-            alignToNormal: P.alignToNormal, randomYaw: P.randomYaw, cullDistance: P.cullDistance },
-        effect: 'write', latency: 'interactive', resources: 'low',
-        dispatchAction: 'add_foliage_type',
-        exampleInput: { action: 'create_foliage_type', name: 'Bush_Type', meshPath: '/Game/Meshes/SM_Bush' },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_foliage_mesh', action: 'configure_foliage_mesh', family: F,
-        summary: 'Configure the mesh assignment for a foliage type.',
-        whenToUse: ['A foliage type needs a different mesh.'],
-        whenNotToUse: ['A new foliage type should be created instead.'],
-        inputProps: { foliageType: P.foliageType, foliageTypePath: P.foliageTypePath,
-            meshPath: P.meshPath, staticMesh: P.staticMesh },
-        outputProps: {
-            configuredProperties: { type: 'array', items: { type: 'string' }, description: 'Every setting this call wrote, by UFoliageType property name (Mesh, Density, ScaleX, CullDistance, ...), the reflected settings entries included.' },
-            configuredPropertyCount: { type: 'number', description: 'How many properties configuredProperties lists.' },
-            previousMesh: { type: 'string', description: 'Mesh assignment: the mesh the type used before this call (empty when it had none).' },
-            placedInstances: { type: 'number', description: 'Mesh assignment: instances of this type placed in the level (its foliage actor).' },
-            instancesShowingNewMesh: { type: 'number', description: 'Mesh assignment: how many of the placed instances now draw the new mesh, read back off their component; below placedInstances means some did not follow.' },
-        },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_foliage_mesh', foliageType: 'Bush_Type', meshPath: '/Game/Meshes/SM_Bush_v2' },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_foliage_placement', action: 'configure_foliage_placement', family: F,
-        summary: 'Configure placement parameters for a foliage type.',
-        whenToUse: ['Foliage placement density or scale must be tuned.'],
-        whenNotToUse: ['Foliage should be placed manually.'],
-        inputProps: { foliageType: P.foliageType, foliageTypePath: P.foliageTypePath,
-            density: P.density, minScale: P.minScale, maxScale: P.maxScale, alignToNormal: P.alignToNormal, randomYaw: P.randomYaw },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_foliage_placement', foliageType: 'Bush_Type', density: 0.5 },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_foliage_lod', action: 'configure_foliage_lod', family: F,
-        summary: 'Configure LOD settings for a foliage type.',
-        whenToUse: ['Foliage LOD distances must be tuned.'],
-        whenNotToUse: ['LODs should be generated rather than configured.'],
-        inputProps: { foliageType: P.foliageType, foliageTypePath: P.foliageTypePath, settings: P.settings },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_foliage_lod', foliageType: 'Bush_Type' },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_foliage_collision', action: 'configure_foliage_collision', family: F,
-        summary: 'Configure collision settings for a foliage type.',
-        whenToUse: ['Foliage collision must be enabled or disabled.'],
-        whenNotToUse: ['Collision is not needed for decorative foliage.'],
-        inputProps: { foliageType: P.foliageType, foliageTypePath: P.foliageTypePath,
-            collisionEnabled: { ...P.collisionEnabled, description: 'Collision of placed instances: true = query and physics, false = none.' } },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_foliage_collision', foliageType: 'Bush_Type', collisionEnabled: true },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_foliage_culling', action: 'configure_foliage_culling', family: F,
-        summary: 'Configure culling distance for a foliage type.',
-        whenToUse: ['Foliage cull distance must be tuned.'],
-        whenNotToUse: ['All foliage should remain visible at all distances.'],
-        inputProps: { foliageType: P.foliageType, foliageTypePath: P.foliageTypePath,
-            cullDistance: { ...P.cullDistance, description: 'Distance at which instances are culled (CullDistance max); the fade start is lowered to it if it was further.' } },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_foliage_culling', foliageType: 'Bush_Type', cullDistance: 5000 },
-    }),
-    buildRecord({
-        id: 'build_environment.create_procedural_foliage', action: 'create_procedural_foliage', family: F,
-        summary: 'Create a procedural foliage volume with seeded scatter; fails when the simulation places nothing.',
-        whenToUse: ['Large-area procedural foliage scatter is needed.'],
-        whenNotToUse: ['Manual foliage placement is sufficient.'],
-        inputProps: { name: P.name, volumeName: { ...P.volumeName, description: 'Label of the procedural foliage volume (name is accepted too).' },
-            path: { ...P.path, description: 'Folder for the spawner and its foliage type assets (default /Game/ProceduralFoliage).' },
-            foliageTypes: P.foliageTypes, bounds: P.bounds, seed: P.seed, tileSize: P.tileSize },
-        effect: 'write', latency: 'interactive', resources: 'medium',
-        dispatchAction: 'create_procedural_foliage',
-        exampleInput: { action: 'create_procedural_foliage', name: 'PFV_1', foliageTypes: [{ meshPath: '/Game/Meshes/SM_Bush', density: 0.5 }] },
-    }),
-];
-//# sourceMappingURL=foliage.data.js.map

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

@@ -1,9 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-import { type CoreRecordSpec } from '../core/builder.js';
-export type RecordSpec = Omit<CoreRecordSpec, 'parentTool' | 'domain' | 'bareInput' | 'costLatency' | 'costResources' | 'id'> & {
-    readonly id: string;
-    readonly latency: NonNullable<CoreRecordSpec['costLatency']>;
-    readonly resources: NonNullable<CoreRecordSpec['costResources']>;
-};
-export declare const buildRecord: ({ latency, resources, ...spec }: RecordSpec) => CapabilityRecordSource;
-//# sourceMappingURL=helpers.d.ts.map

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

@@ -1,3 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-export const buildRecord = ({ latency, resources, ...spec }) => buildCoreRecord({ ...spec, parentTool: 'build_environment', domain: 'environment', costLatency: latency, costResources: resources });
-//# sourceMappingURL=helpers.js.map

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

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

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

@@ -1,28 +0,0 @@
-import { ATMOSPHERE_RECORDS } from './atmosphere.data.js';
-import { FOLIAGE_RECORDS } from './foliage.data.js';
-import { LANDSCAPE_RECORDS } from './landscape.data.js';
-import { LIGHTING_RECORDS } from './lighting.data.js';
-import { PROCEDURAL_RECORDS } from './procedural.data.js';
-import { RENDER_POSTPROCESS_RECORDS } from './render-postprocess.data.js';
-import { RENDER_RAYTRACE_RECORDS } from './render-raytrace.data.js';
-import { RENDER_SCREEN_RECORDS } from './render-screen.data.js';
-import { SPLINE_RECORDS } from './spline.data.js';
-import { WATER_RECORDS } from './water.data.js';
-import { WEATHER_RECORDS } from './weather.data.js';
-import { applyFolds } from '../shared/fold.js';
-import { BUILD_ENVIRONMENT_FOLDS } from '../folds/build-environment.folds.js';
-export const BUILD_ENVIRONMENT_UNFOLDED_SOURCES = [
-    ...LANDSCAPE_RECORDS,
-    ...FOLIAGE_RECORDS,
-    ...PROCEDURAL_RECORDS,
-    ...LIGHTING_RECORDS,
-    ...RENDER_RAYTRACE_RECORDS,
-    ...RENDER_POSTPROCESS_RECORDS,
-    ...RENDER_SCREEN_RECORDS,
-    ...SPLINE_RECORDS,
-    ...ATMOSPHERE_RECORDS,
-    ...WEATHER_RECORDS,
-    ...WATER_RECORDS,
-];
-export const BUILD_ENVIRONMENT_SOURCES = applyFolds(BUILD_ENVIRONMENT_UNFOLDED_SOURCES, BUILD_ENVIRONMENT_FOLDS, 'build_environment');
-//# sourceMappingURL=index.js.map

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

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

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

@@ -1,166 +0,0 @@
-import { buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const F = 'landscape';
-const WU = ['A landscape must be created or modified in the current level.'];
-const LANDSCAPE = { landscapeName: P.landscapeName, landscapePath: P.landscapePath, landscapeActorPath: P.landscapeActorPath };
-const PAINT = { region: P.region, strength: P.strength, skipFlush: P.skipFlush };
-export const LANDSCAPE_RECORDS = [
-    buildRecord({
-        id: 'build_environment.create_landscape', action: 'create_landscape', family: F,
-        topics: ['landscape', 'terrain', 'new landscape', 'heightfield', 'add a landscape'],
-        summary: 'Create a new Landscape actor in the current level.',
-        whenToUse: WU, whenNotToUse: ['A landscape already exists and should be modified.'],
-        inputProps: { name: P.name, landscapeName: P.landscapeName, location: P.location, sizeX: P.sizeX,
-            sizeY: P.sizeY, quadsPerSection: P.quadsPerSection, sectionSize: P.sectionSize,
-            sectionsPerComponent: P.sectionsPerComponent, componentCount: P.componentCount, materialPath: P.materialPath },
-        requiredOneOf: ['name', 'landscapeName'],
-        effect: 'write', latency: 'interactive', resources: 'medium',
-        dispatchAction: 'create_landscape',
-        exampleInput: { action: 'create_landscape', name: 'Landscape_1', sizeX: 1009, sizeY: 1009 },
-    }),
-    buildRecord({
-        id: 'build_environment.sculpt', action: 'sculpt', family: F,
-        summary: 'Sculpt the landscape heightmap at a location with a brush.',
-        whenToUse: WU, whenNotToUse: ['The landscape should be modified via raw heightmap data.'],
-        inputProps: { ...LANDSCAPE,
-            tool: P.tool, location: P.location, radius: P.radius, strength: P.strength,
-            falloff: P.falloff, skipFlush: P.skipFlush },
-        effect: 'write', latency: 'interactive', resources: 'low',
-        dispatchAction: 'sculpt_landscape',
-        exampleInput: { action: 'sculpt', landscapeName: 'Landscape_1', location: { x: 0, y: 0, z: 0 }, radius: 500 },
-        aliases: ['build_environment.sculpt_heightmap'],
-    }),
-    buildRecord({
-        id: 'build_environment.modify_heightmap', action: 'modify_heightmap', family: F,
-        summary: 'Modify landscape heightmap data in a region.',
-        whenToUse: WU, whenNotToUse: ['The landscape should be sculpted interactively.'],
-        inputProps: { ...LANDSCAPE,
-            operation: P.operation, heightData: P.heightData, minX: P.minX, minY: P.minY,
-            maxX: P.maxX, maxY: P.maxY, region: P.region, updateNormals: P.updateNormals, skipFlush: P.skipFlush },
-        effect: 'write', latency: 'interactive', resources: 'medium',
-        dispatchAction: 'modify_heightmap',
-        exampleInput: { action: 'modify_heightmap', landscapeName: 'Landscape_1', operation: 'set', heightData: [100, 200] },
-    }),
-    buildRecord({
-        id: 'build_environment.set_landscape_material', action: 'set_landscape_material', family: F,
-        summary: 'Set the material applied to a landscape.',
-        whenToUse: ['A landscape needs a different material assignment.'],
-        whenNotToUse: ['The material should be configured with layer blends.'],
-        inputProps: { ...LANDSCAPE, materialPath: P.materialPath },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        dispatchAction: 'set_landscape_material',
-        exampleInput: { action: 'set_landscape_material', landscapeName: 'Landscape_1', materialPath: '/Game/Materials/M_Landscape' },
-    }),
-    buildRecord({
-        id: 'build_environment.paint_landscape', action: 'paint_landscape', family: F,
-        summary: 'Paint a landscape layer over a brush disc (location + radius), a vertex region, or the whole landscape.',
-        whenToUse: WU, whenNotToUse: ['The landscape layer weight should be set via raw data.'],
-        inputProps: { ...LANDSCAPE, layerName: P.layerName,
-            location: { ...P.location, description: 'Brush centre in world space; paints the disc of radius around it (radius required).' },
-            radius: { ...P.radius, description: 'Brush radius in world units (with location).' }, ...PAINT },
-        effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'paint_landscape', landscapeName: 'Landscape_1', layerName: 'Grass', location: { x: 0, y: 0, z: 0 }, radius: 500 },
-    }),
-    buildRecord({
-        id: 'build_environment.paint_landscape_layer', action: 'paint_landscape_layer', family: F,
-        summary: 'Paint a landscape layer at a uniform weight over a vertex region, or the whole landscape.',
-        whenToUse: WU, whenNotToUse: ['The landscape should be painted interactively.'],
-        inputProps: { ...LANDSCAPE, layerName: P.layerName,
-            layerInfoPath: { ...P.layerInfoPath, description: 'Layer info asset to use when the landscape has no layer of that name yet (else one lives only inside the landscape).' },
-            ...PAINT },
-        effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'paint_landscape_layer', landscapeName: 'Landscape_1', layerName: 'Grass' },
-    }),
-    buildRecord({
-        id: 'build_environment.import_heightmap', action: 'import_heightmap', family: F,
-        summary: 'Import a heightmap file into a landscape.',
-        whenToUse: ['A heightmap file must be imported to create or update a landscape.'],
-        whenNotToUse: ['The heightmap should be generated procedurally.'],
-        inputProps: { ...LANDSCAPE, heightmapPath: { type: 'string', description: 'Raw 16-bit heightmap file, project-relative.' },
-            region: P.region, updateNormals: P.updateNormals, skipFlush: P.skipFlush },
-        effect: 'write', latency: 'interactive', resources: 'medium',
-        exampleInput: { action: 'import_heightmap', landscapeName: 'Landscape_1', heightmapPath: 'Saved/Heightmaps/terrain.raw' },
-    }),
-    buildRecord({
-        id: 'build_environment.export_heightmap', action: 'export_heightmap', family: F,
-        summary: 'Export a landscape heightmap to a file.',
-        whenToUse: ['A landscape heightmap must be exported for external editing.'],
-        whenNotToUse: ['The heightmap should be modified in the editor.'],
-        inputProps: { outputPath: P.outputPath, ...LANDSCAPE, path: P.path, region: P.region },
-        effect: 'read', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'export_heightmap', landscapeName: 'Landscape_1', path: '/Game/Heightmaps/export.raw' },
-    }),
-    buildRecord({
-        id: 'build_environment.create_landscape_layer_info', action: 'create_landscape_layer_info', family: F,
-        summary: 'Create a landscape layer info asset.',
-        whenToUse: ['A new landscape layer info asset is needed for painting.'],
-        whenNotToUse: ['An existing layer info asset should be reused.'],
-        inputProps: { hardness: P.hardness, noWeightBlend: P.noWeightBlend, name: P.name, path: P.path, layerName: P.layerName, physicalMaterialPath: P.physicalMaterialPath },
-        effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'create_landscape_layer_info', name: 'LI_Grass', path: '/Game/Landscape' },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_landscape_material', action: 'configure_landscape_material', family: F,
-        summary: 'Assign the material a landscape renders with (its layer blends come from the material).',
-        whenToUse: ['A landscape needs a different material assignment.'],
-        whenNotToUse: ['Layers should be painted: use paint_landscape_layer.'],
-        inputProps: { ...LANDSCAPE, materialPath: P.materialPath },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_landscape_material', landscapeName: 'Landscape_1', materialPath: '/Game/M_Landscape' },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_landscape_splines', action: 'configure_landscape_splines', family: F,
-        summary: 'Replace a landscape\'s splines with one through the given points (width, loop, terrain deform, painted layer).',
-        whenToUse: ['Landscape splines need to be added or modified.'],
-        whenNotToUse: ['Standalone spline actors should be used instead.'],
-        inputProps: { ...LANDSCAPE, points: P.points,
-            width: { ...P.width, description: 'Spline width in world units (default 256); side falloff is half of it.' },
-            closedLoop: P.closedLoop, layerName: { ...P.layerName, description: 'Landscape layer the spline paints.' },
-            raiseTerrain: P.raiseTerrain, lowerTerrain: P.lowerTerrain },
-        effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_landscape_splines', landscapeName: 'Landscape_1' },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_landscape_lod', action: 'configure_landscape_lod', family: F,
-        summary: 'Configure LOD settings for a landscape; fails when nothing applied.',
-        whenToUse: ['Landscape LOD distance or screen-size must be tuned.'],
-        whenNotToUse: ['LODs should be generated rather than configured.'],
-        inputProps: { ...LANDSCAPE,
-            settings: { ...P.settings, description: 'Landscape properties by name, e.g. {"MaxLODLevel": 2, "LODDistributionSetting": 1.5}.' } },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_landscape_lod', landscapeName: 'Landscape_1' },
-    }),
-    buildRecord({
-        id: 'build_environment.create_landscape_streaming_proxy', action: 'create_landscape_streaming_proxy', family: F,
-        summary: 'Create a landscape streaming proxy for World Partition.',
-        whenToUse: ['A landscape streaming proxy is needed for World Partition tiles.'],
-        whenNotToUse: ['The level does not use World Partition.'],
-        inputProps: { ...LANDSCAPE,
-            actorName: { ...P.actorName, description: 'Label of the proxy (found and reused when it exists; default LandscapeStreamingProxy).' },
-            location: { ...P.location, description: 'Proxy location (default the landscape\'s).' },
-            rotation: { ...P.rotation, description: 'Proxy rotation (default the landscape\'s).' } },
-        effect: 'write', latency: 'interactive', resources: 'medium',
-        exampleInput: { action: 'create_landscape_streaming_proxy', landscapeName: 'Landscape_1' },
-    }),
-    buildRecord({
-        id: 'build_environment.create_landscape_grass_type', action: 'create_landscape_grass_type', family: F,
-        summary: 'Create a landscape grass type asset.',
-        whenToUse: ['A grass type asset is needed for landscape grass rendering.'],
-        whenNotToUse: ['Foliage instances should be placed manually.'],
-        inputProps: { name: P.name, meshPath: P.meshPath, staticMesh: P.staticMesh, path: P.path },
-        effect: 'write', latency: 'interactive', resources: 'low',
-        dispatchAction: 'create_landscape_grass_type',
-        exampleInput: { action: 'create_landscape_grass_type', name: 'GT_Grass', meshPath: '/Game/Meshes/SM_Grass' },
-    }),
-    buildRecord({
-        id: 'build_environment.generate_lods', action: 'generate_lods', family: F,
-        summary: 'Generate LODs for static mesh assets (foliage meshes included).',
-        whenToUse: ['LODs must be generated for one or more assets.'],
-        whenNotToUse: ['LODs have already been generated.'],
-        inputProps: { assetPath: P.assetPath, assetPaths: P.assetPaths, assets: P.assets, numLODs: P.numLODs },
-        effect: 'write', latency: 'long-running', resources: 'high',
-        behavior: { longRunning: true },
-        exampleInput: { action: 'generate_lods', assetPaths: ['/Game/Meshes/SM_Rock'], numLODs: 3 },
-    }),
-];
-//# sourceMappingURL=landscape.data.js.map

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

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

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

@@ -1,183 +0,0 @@
-import { buildRecord } from './helpers.js';
-import { P } from './properties.js';
-import { str } from '../shared/schema-props.js';
-import { LIGHT_AIM_TEXT, LIGHT_CLASS_TEXT, LIGHT_COLOR_WITH_PROPERTIES_TEXT, LIGHT_INTENSITY_TEXT, LIGHT_LOCATION_TEXT, LIGHT_PROPERTIES_TEXT, LIGHT_SUMMARY, LIGHT_TYPE_TEXT, LIGHT_WHEN_NOT_TO_USE, LIGHT_WHEN_TO_USE, } from '../shared/light-text.js';
-const F = 'lighting';
-const WU = ['A light actor or lighting setting must be created or configured.'];
-export const LIGHTING_RECORDS = [
-    buildRecord({
-        id: 'build_environment.create_light', action: 'create_light', family: F,
-        summary: LIGHT_SUMMARY,
-        whenToUse: LIGHT_WHEN_TO_USE, whenNotToUse: LIGHT_WHEN_NOT_TO_USE,
-        inputProps: {
-            lightType: { ...P.lightType, description: LIGHT_TYPE_TEXT },
-            lightClass: { ...P.lightClass, description: LIGHT_CLASS_TEXT },
-            name: P.name,
-            location: { ...P.location, description: LIGHT_LOCATION_TEXT },
-            rotation: { ...P.rotation, description: `Rotation {pitch, yaw, roll} in degrees. ${LIGHT_AIM_TEXT}` },
-            intensity: { ...P.intensity, description: LIGHT_INTENSITY_TEXT },
-            color: { ...P.color, description: `Light color {r, g, b, a}. ${LIGHT_COLOR_WITH_PROPERTIES_TEXT}` },
-            properties: { ...P.properties, description: LIGHT_PROPERTIES_TEXT },
-        },
-        requiredOneOf: ['lightClass', 'lightType'],
-        effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: {
-            action: 'create_light', lightType: 'Spot', name: 'StreetLamp', location: { x: 0, y: 0, z: 400 },
-            rotation: { pitch: -90, yaw: 0, roll: 0 }, intensity: 5000, color: { r: 1, g: 0.7, b: 0.42 },
-            properties: { castShadows: true, outerConeAngle: 50, attenuationRadius: 1200 },
-        },
-        exampleOutput: {
-            success: true, message: 'Light spawned',
-            details: {
-                actorName: 'StreetLamp', actorLabel: 'StreetLamp', objectName: 'SpotLight_0',
-                applied: ['intensity', 'color', 'castShadows', 'outerConeAngle', 'attenuationRadius'],
-            },
-        },
-    }),
-    buildRecord({
-        id: 'build_environment.create_sky_light', action: 'create_sky_light', family: F,
-        summary: 'Create a sky light actor, capturing the scene or lighting from a cubemap.',
-        whenToUse: WU, whenNotToUse: ['A sky light already exists.'],
-        inputProps: { name: P.name, location: P.location, rotation: P.rotation, intensity: P.intensity,
-            cubemapPath: { ...P.cubemapPath, description: 'Cube texture to light from (sets the specified-cubemap source); a path that does not load fails before anything spawns.' },
-            recapture: P.recapture },
-        effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'create_sky_light', name: 'SkyLight_1' },
-    }),
-    buildRecord({
-        id: 'build_environment.ensure_single_sky_light', action: 'ensure_single_sky_light', family: F,
-        summary: 'Ensure exactly one sky light exists in the level.',
-        whenToUse: ['Duplicate sky lights must be consolidated.'],
-        whenNotToUse: ['Multiple sky lights are intentionally present.'],
-        inputProps: { name: { ...P.name, description: 'Label of the sky light to keep (default SkyLight); another is relabelled, or one spawned, when none has it.' }, recapture: P.recapture },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'ensure_single_sky_light' },
-    }),
-    buildRecord({
-        id: 'build_environment.create_lightmass_volume', action: 'create_lightmass_volume', family: F,
-        summary: 'Create a LightmassImportanceVolume actor.',
-        whenToUse: ['A lightmass importance volume is needed for baking.'],
-        whenNotToUse: ['Dynamic lighting is used exclusively.'],
-        inputProps: { name: P.name, location: P.location, size: P.size },
-        effect: 'write', latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'create_lightmass_volume', name: 'LIV_1' },
-    }),
-    buildRecord({
-        id: 'build_environment.create_lighting_enabled_level', action: 'create_lighting_enabled_level', family: F,
-        summary: 'Create a level with lighting enabled.',
-        whenToUse: ['A new level with lighting setup is needed.'],
-        whenNotToUse: ['An existing level should be modified.'],
-        inputProps: { name: P.name, path: P.path, levelName: str('Level name; appended when path is a folder.') },
-        effect: 'write', latency: 'interactive', resources: 'medium',
-        exampleInput: { action: 'create_lighting_enabled_level', name: 'LightingLevel' },
-    }),
-    buildRecord({
-        id: 'build_environment.setup_global_illumination', action: 'setup_global_illumination', family: F,
-        summary: 'Configure global illumination settings.',
-        whenToUse: ['GI must be enabled or tuned.'],
-        whenNotToUse: ['GI is not needed for the scene.'],
-        inputProps: {
-            method: {
-                type: 'string',
-                enum: ['LumenGI', 'ScreenSpace', 'None', 'RayTraced', 'Lightmass'],
-                description: 'Global illumination method. Matches the handler-enforced value set.',
-            },
-            quality: {
-                type: 'string',
-                enum: ['Low', 'Medium', 'High', 'Epic'],
-                description: 'Global illumination scalability level (sg.GlobalIlluminationQuality).',
-            },
-            indirectLightingIntensity: P.indirectLightingIntensity, bounces: P.bounces,
-        },
-        required: ['method'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'setup_global_illumination', method: 'LumenGI' },
-    }),
-    buildRecord({
-        id: 'build_environment.configure_shadows', action: 'configure_shadows', family: F,
-        summary: 'Configure shadow settings for lights.',
-        whenToUse: ['Shadow quality or method must be tuned.'],
-        whenNotToUse: ['Shadows are not needed.'],
-        inputProps: {
-            settings: { ...P.settings, description: 'The same shadow keys as the top level, nested; a value here wins.' },
-            actorName: { ...P.actorName, description: 'Light whose own shadow settings (castShadows, shadowBias, shadowSlopeBias, shadowResolutionScale) change.' },
-            shadowQuality: P.shadowQuality, shadowDistance: P.shadowDistance, contactShadows: P.contactShadows,
-            rayTracedShadows: P.rayTracedShadows, virtualShadowMaps: P.virtualShadowMaps,
-            castShadows: P.castShadows, shadowBias: P.shadowBias, shadowSlopeBias: P.shadowSlopeBias, shadowResolutionScale: P.shadowResolutionScale,
-        },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'configure_shadows', actorName: 'Light_1', shadowQuality: 'High' },
-    }),
-    buildRecord({
-        id: 'build_environment.set_exposure', action: 'set_exposure', family: F,
-        summary: 'Set exposure settings for the camera or auto-exposure.',
-        whenToUse: ['Exposure must be adjusted.'],
-        whenNotToUse: ['Default exposure is sufficient.'],
-        inputProps: {
-            actorName: P.actorName,
-            method: {
-                type: 'string',
-                enum: ['Manual', 'AutoExposureHistogram', 'AutoExposureBasic'],
-                description: 'Auto-exposure method written on the post-process volume.',
-            },
-            compensationValue: P.compensationValue, minBrightness: P.minBrightness, maxBrightness: P.maxBrightness,
-        },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low',
-        exampleInput: { action: 'set_exposure', compensationValue: 1.0 },
-    }),
-    buildRecord({
-        id: 'build_environment.set_ambient_occlusion', action: 'set_ambient_occlusion', family: F,
-        summary: 'Set ambient occlusion settings.',
-        whenToUse: ['AO intensity or method must be tuned.'],
-        whenNotToUse: ['AO is not needed.'],
-        inputProps: {
-            actorName: P.actorName, enabled: P.enabled,
-            intensity: { type: 'number', description: 'Ambient occlusion intensity.' },
-            radius: { type: 'number', description: 'Ambient occlusion radius in world units.' },
-            quality: {
-                type: 'string',
-                enum: ['Low', 'Medium', 'High'],
-                description: 'Ambient occlusion quality on the post-process volume (25, 50 or 100 of 100).',
-            },
-        },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low',
-        exampleInput: { action: 'set_ambient_occlusion', intensity: 0.5 },
-    }),
-    buildRecord({
-        id: 'build_environment.setup_volumetric_fog', action: 'setup_volumetric_fog', family: F,
-        summary: 'Configure volumetric fog settings.',
-        whenToUse: ['Volumetric fog must be enabled or tuned.'],
-        whenNotToUse: ['Standard exponential height fog is sufficient.'],
-        inputProps: { enabled: P.enabled, viewDistance: P.viewDistance },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low',
-        exampleInput: { action: 'setup_volumetric_fog', enabled: true, viewDistance: 6000 },
-    }),
-    buildRecord({
-        id: 'build_environment.build_lighting', action: 'build_lighting', family: F,
-        topics: ['bake lighting', 'lightmass', 'build lights', 'rebuild lighting', 'bake lightmaps'],
-        summary: 'Build static lighting for the current level.',
-        whenToUse: ['Static lighting must be built.'],
-        whenNotToUse: ['Dynamic lighting is used exclusively.'],
-        inputProps: { quality: P.quality },
-        effect: 'write', behavior: { longRunning: true, idempotency: 'idempotent' },
-        latency: 'long-running', resources: 'high',
-        exampleInput: { action: 'build_lighting', quality: 'Preview' },
-    }),
-    buildRecord({
-        id: 'build_environment.list_light_types', action: 'list_light_types', family: F,
-        topics: ['kinds available', 'light classes', 'class names'],
-        summary: 'List the light classes known to the editor: DirectionalLight, PointLight, SpotLight, RectLight and any other loaded light class, with a count.',
-        whenToUse: ['Available light types must be enumerated.'],
-        whenNotToUse: ['A specific light type is already known.'],
-        inputProps: {},
-        outputProps: {
-            types: { type: 'array', items: str('Light type.'), description: 'Available light types.' },
-            count: { type: 'number', description: 'Number of available light types.' },
-        },
-        outputRequired: ['types'],
-        effect: 'read', latency: 'instant', resources: 'low',
-        exampleInput: { action: 'list_light_types' },
-        exampleOutput: { success: true, types: ['PointLight', 'SpotLight', 'DirectionalLight'], count: 3 },
-    }),
-];
-//# sourceMappingURL=lighting.data.js.map

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

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