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

package/dist/tools/catalog/capabilities/records/world/manage-geometry.dynamicmesh.data.js

@@ -1,260 +0,0 @@
-import { buildWorldRecord } from './builder.js';
-import { P } from './properties.js';
-import { str } from '../shared/schema-props.js';
-const F = 'dynamicmesh';
-const PLUGIN = ['GeometryScripting'];
-const int = (d) => ({ type: 'integer', description: d });
-const OUT_VERTEX_COUNT = int('Vertex count of the mesh after the call.');
-const OUT_TRIANGLE_COUNT = int('Triangle count of the mesh after the call.');
-const POINT = {
-    type: 'object',
-    properties: { x: { type: 'number', description: 'X' }, y: { type: 'number', description: 'Y' }, z: { type: 'number', description: 'Z' } },
-    required: ['x', 'y', 'z'],
-    additionalProperties: false,
-};
-const POLYGON_VERTICES = {
-    type: 'array',
-    items: POINT,
-    minItems: 1,
-    maxItems: 20000,
-    description: 'New points {x, y, z} in the mesh\'s local space, at most 20000. The faces of this call index into this list, so its first point is index 0. Points are never merged with the mesh\'s existing ones, and a point no face uses is left out.',
-};
-const POLYGON_FACES = {
-    type: 'array',
-    items: { type: 'array', items: { type: 'integer', minimum: 0 }, minItems: 3, maxItems: 256 },
-    minItems: 1,
-    maxItems: 20000,
-    description: 'Faces, each a list of three or more vertex indices into vertices (at most 20000 faces). List a face\'s corners so that (v1 - v0) x (v2 - v0) points outward, and let two faces that share an edge run along it in opposite directions; the call refuses a face wound the other way, or an edge shared by more than two faces, and names the face. A face with more than three corners is triangulated (it may be concave) and all its triangles keep the face\'s polygroup.',
-};
-const FACE_GROUPS = {
-    type: 'array',
-    items: { type: 'integer', minimum: 0 },
-    maxItems: 20000,
-    description: 'Polygroup id of each face, one entry per face, 0 to 1000000 (default: a new unique group per face). Subdivision with catmull_clark treats every polygroup as one face of the cage, so leave this out for a cage of separate faces; give several faces one id to make one flat region.',
-};
-const FACE_MATERIALS = {
-    type: 'array',
-    items: { type: 'integer', minimum: 0, maximum: 255 },
-    maxItems: 20000,
-    description: 'Material id of each face, one entry per face, 0 to 255 (default 0). A material id becomes a static-mesh material slot when the mesh is baked with convert_to_static_mesh or convert_to_nanite.',
-};
-export const GEOMETRY_DYNAMICMESH_RECORDS = [
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_procedural_mesh', plugins: PLUGIN,
-        family: F, summary: 'Spawn an empty DynamicMesh actor to author geometry into.',
-        whenToUse: ['A mesh must be built vertex by vertex rather than from a primitive.'],
-        whenNotToUse: ['A parametric shape is enough; use a create_* primitive.'],
-        inputProps: { name: P.name, actorName: P.actorName, enableCollision: P.enableCollision },
-        required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        outputProps: { name: P.name, class: str('Class of the spawned actor.'), enableCollision: P.enableCollision },
-        outputRequired: ['name'],
-        exampleInput: { action: 'create_procedural_mesh', name: 'DM_Authored', enableCollision: true },
-        exampleOutput: { success: true, name: 'DM_Authored', class: 'DynamicMeshActor', enableCollision: true },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'append_vertex', plugins: PLUGIN,
-        family: F, summary: 'Append one vertex to a DynamicMesh actor and return its index.',
-        whenToUse: ['A mesh is being authored point by point.'],
-        whenNotToUse: ['A whole triangle is being added; use append_triangle.'],
-        inputProps: { actorName: P.actorName, position: P.position },
-        required: ['actorName'], effect: 'write', costLatency: 'instant', costResources: 'low',
-        outputProps: { actorName: P.actorName, vertexIndex: P.vertexIndex, vertexCount: OUT_VERTEX_COUNT },
-        outputRequired: ['actorName', 'vertexIndex', 'vertexCount'],
-        exampleInput: { action: 'append_vertex', actorName: 'DM_Authored', position: { x: 100, y: 0, z: 0 } },
-        exampleOutput: { success: true, actorName: 'DM_Authored', vertexIndex: 3, vertexCount: 4 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'append_triangle', plugins: PLUGIN,
-        family: F, summary: 'Append a triangle to a DynamicMesh actor from three corner positions.',
-        whenToUse: ['A face must be added to an authored mesh in one call.'],
-        whenNotToUse: ['Only a point is needed; use append_vertex.'],
-        inputProps: { actorName: P.actorName, v0: P.v0, v1: P.v1, v2: P.v2, groupID: P.groupID },
-        required: ['actorName'], effect: 'write', costLatency: 'instant', costResources: 'low',
-        outputProps: {
-            actorName: P.actorName, triangleIndex: P.triangleIndex,
-            vertexIndex0: int('Index of the first appended corner.'),
-            vertexIndex1: int('Index of the second appended corner.'),
-            vertexIndex2: int('Index of the third appended corner.'),
-            triangleCount: OUT_TRIANGLE_COUNT,
-        },
-        outputRequired: ['actorName', 'triangleIndex', 'triangleCount'],
-        exampleInput: { action: 'append_triangle', actorName: 'DM_Authored', v0: { x: 0, y: 0, z: 0 }, v1: { x: 100, y: 0, z: 0 }, v2: { x: 50, y: 100, z: 0 } },
-        exampleOutput: { success: true, actorName: 'DM_Authored', triangleIndex: 0, vertexIndex0: 0, vertexIndex1: 1, vertexIndex2: 2, triangleCount: 1 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'get_vertex_position', plugins: PLUGIN,
-        family: F, summary: 'Read the x, y, z position of one vertex, by vertexIndex, of a procedural DynamicMesh actor.',
-        whenToUse: ['An authored vertex must be inspected before it is moved.'],
-        whenNotToUse: ['Whole-mesh counts are wanted; use get_mesh_info.'],
-        inputProps: { actorName: P.actorName, vertexIndex: P.vertexIndex },
-        required: ['actorName', 'vertexIndex'], effect: 'read',
-        costLatency: 'instant', costResources: 'low',
-        outputProps: { actorName: P.actorName, vertexIndex: P.vertexIndex, position: P.position },
-        outputRequired: ['actorName', 'vertexIndex', 'position'],
-        exampleInput: { action: 'get_vertex_position', actorName: 'DM_Authored', vertexIndex: 1 },
-        exampleOutput: { success: true, actorName: 'DM_Authored', vertexIndex: 1, position: { x: 100, y: 0, z: 0 } },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'set_vertex_position', plugins: PLUGIN,
-        family: F, summary: 'Move one vertex of a DynamicMesh actor to a new position.',
-        whenToUse: ['An authored vertex must be nudged without rebuilding the mesh.'],
-        whenNotToUse: ['The whole mesh must move; use translate_mesh.'],
-        inputProps: { actorName: P.actorName, vertexIndex: P.vertexIndex, position: P.position },
-        required: ['actorName', 'vertexIndex'], effect: 'write',
-        behavior: { idempotency: 'idempotent' }, costLatency: 'instant', costResources: 'low',
-        outputProps: { actorName: P.actorName, vertexIndex: P.vertexIndex, position: P.position },
-        outputRequired: ['actorName', 'vertexIndex', 'position'],
-        exampleInput: { action: 'set_vertex_position', actorName: 'DM_Authored', vertexIndex: 1, position: { x: 120, y: 0, z: 0 } },
-        exampleOutput: { success: true, actorName: 'DM_Authored', vertexIndex: 1, position: { x: 120, y: 0, z: 0 } },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'set_vertex_color', plugins: PLUGIN,
-        family: F, summary: 'Set the vertex colour on one vertex, or on every vertex, of a DynamicMesh actor.',
-        whenToUse: ['Authored geometry must carry colour the material reads.'],
-        whenNotToUse: ['A material parameter is the right place for the colour.'],
-        inputProps: { actorName: P.actorName, vertexIndex: P.vertexIndex, r: P.r, g: P.g, b: P.b, a: P.a, setAll: P.setAll },
-        required: ['actorName'], effect: 'write',
-        behavior: { idempotency: 'idempotent' }, costLatency: 'instant', costResources: 'low',
-        outputProps: {
-            actorName: P.actorName,
-            verticesModified: int('Number of vertices whose colour changed.'),
-            r: P.r, g: P.g, b: P.b, a: P.a,
-        },
-        outputRequired: ['actorName', 'verticesModified'],
-        exampleInput: { action: 'set_vertex_color', actorName: 'DM_Authored', r: 1, g: 0, b: 0, a: 1, setAll: true },
-        exampleOutput: { success: true, actorName: 'DM_Authored', verticesModified: 4, r: 1, g: 0, b: 0, a: 1 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'set_uvs', plugins: PLUGIN,
-        family: F, summary: 'Set the UV coordinate of one vertex on a UV channel of a DynamicMesh actor.',
-        whenToUse: ['An authored vertex needs an exact UV rather than a generated one.'],
-        whenNotToUse: ['The whole mesh needs unwrapping; use auto_uv or unwrap_uv.'],
-        inputProps: { actorName: P.actorName, vertexIndex: P.vertexIndex, u: P.u, v: P.v, uvChannel: P.uvChannel },
-        required: ['actorName'], effect: 'write',
-        behavior: { idempotency: 'idempotent' }, costLatency: 'instant', costResources: 'low',
-        outputProps: {
-            actorName: P.actorName, vertexIndex: P.vertexIndex, u: P.u, v: P.v, uvChannel: P.uvChannel,
-            elementsModified: int('Number of UV elements written.'),
-        },
-        outputRequired: ['actorName', 'elementsModified'],
-        exampleInput: { action: 'set_uvs', actorName: 'DM_Authored', vertexIndex: 1, u: 0.5, v: 0.25, uvChannel: 0 },
-        exampleOutput: { success: true, actorName: 'DM_Authored', vertexIndex: 1, u: 0.5, v: 0.25, uvChannel: 0, elementsModified: 1 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'split_normals', plugins: PLUGIN,
-        family: F, summary: 'Split the normals of a DynamicMesh actor above an angle threshold to harden edges.',
-        whenToUse: ['Authored geometry shades too soft across its creases.'],
-        whenNotToUse: ['Normals only need recomputing; use recalculate_normals.'],
-        inputProps: { actorName: P.actorName, splitAngle: P.splitAngle },
-        required: ['actorName'], effect: 'write',
-        behavior: { idempotency: 'idempotent' }, costLatency: 'interactive', costResources: 'low',
-        outputProps: { actorName: P.actorName, splitAngle: P.splitAngle },
-        outputRequired: ['actorName', 'splitAngle'],
-        exampleInput: { action: 'split_normals', actorName: 'DM_Authored', splitAngle: 45 },
-        exampleOutput: { success: true, actorName: 'DM_Authored', splitAngle: 45 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'translate_mesh', plugins: PLUGIN,
-        family: F, summary: 'Translate every vertex of a DynamicMesh actor, leaving the actor transform alone.',
-        whenToUse: ['Authored geometry must shift inside its own local space.'],
-        whenNotToUse: ['The actor itself should move; set its transform instead.'],
-        inputProps: { actorName: P.actorName, translation: P.translation },
-        required: ['actorName'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        outputProps: { actorName: P.actorName, translation: P.translation },
-        outputRequired: ['actorName', 'translation'],
-        exampleInput: { action: 'translate_mesh', actorName: 'DM_Authored', translation: { x: 0, y: 0, z: 50 } },
-        exampleOutput: { success: true, actorName: 'DM_Authored', translation: { x: 0, y: 0, z: 50 } },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'append_polygons', plugins: PLUGIN,
-        topics: ['polygon cage', 'author a mesh from vertices and faces', 'quad mesh', 'hard surface cage', 'low poly blockout mesh', 'subdivision cage'],
-        family: F, summary: 'Author a polygon cage on a DynamicMesh actor in one call: new vertices and faces of three or more corners, each with its own polygroup and material id.',
-        whenToUse: ['A smooth, rounded model starts as a coarse cage: append its vertices and faces here (one polygroup per face), then optimize_mesh subdivide with scheme catmull_clark and iterations 2 or 3.',
-            'Faces must be built from an explicit vertex list, quads and larger polygons included, with polygroups or material ids set up front.'],
-        whenNotToUse: ['One triangle or one point is enough; use append_triangle or append_vertex.', 'A parametric shape is enough; use a create_* primitive.'],
-        inputProps: { actorName: P.actorName, vertices: POLYGON_VERTICES, faces: POLYGON_FACES, faceGroups: FACE_GROUPS, faceMaterials: FACE_MATERIALS },
-        required: ['actorName', 'vertices', 'faces'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        outputProps: {
-            actorName: P.actorName,
-            verticesAdded: int('Points appended: those some face uses.'),
-            facesAdded: int('Faces appended.'),
-            trianglesAdded: int('Triangles the faces came to once larger polygons were triangulated.'),
-            vertexCount: OUT_VERTEX_COUNT,
-            triangleCount: OUT_TRIANGLE_COUNT,
-            groupCount: int('Distinct polygroups the mesh holds after the call.'),
-        },
-        outputRequired: ['actorName', 'verticesAdded', 'facesAdded', 'trianglesAdded', 'vertexCount', 'triangleCount', 'groupCount'],
-        exampleInput: {
-            action: 'append_polygons', actorName: 'DM_Cage',
-            vertices: [
-                { x: -50, y: -50, z: -50 }, { x: 50, y: -50, z: -50 }, { x: 50, y: 50, z: -50 }, { x: -50, y: 50, z: -50 },
-                { x: -50, y: -50, z: 50 }, { x: 50, y: -50, z: 50 }, { x: 50, y: 50, z: 50 }, { x: -50, y: 50, z: 50 },
-            ],
-            faces: [[0, 3, 2, 1], [4, 5, 6, 7], [0, 1, 5, 4], [1, 2, 6, 5], [2, 3, 7, 6], [3, 0, 4, 7]],
-        },
-        exampleOutput: { success: true, actorName: 'DM_Cage', verticesAdded: 8, facesAdded: 6, trianglesAdded: 12, vertexCount: 8, triangleCount: 12, groupCount: 6 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'set_material_id', plugins: PLUGIN,
-        topics: ['assign a material to faces', 'material slots on a mesh', 'multi material mesh', 'material per face', 'paint faces with a material'],
-        family: F, summary: 'Set the material id (the static-mesh material slot) of triangles of a DynamicMesh actor: every triangle, the triangleIndices you list, or a region.',
-        whenToUse: ['One mesh needs several materials: give each part an id (0 is the default), then bake with convert_to_static_mesh or convert_to_nanite and list one material per id in materials; entry i is the material of id i.',
-            'Triangles must be picked by where they are: region.box, region.normal (the top faces are {x:0,y:0,z:1}), region.groupIds or region.materialIds.'],
-        whenNotToUse: ['A smooth mask for a material to read is needed rather than a slot; use bake_vertex_colors.'],
-        inputProps: { actorName: P.actorName, materialId: { type: 'integer', minimum: 0, maximum: 255, description: 'Material id to set, 0 to 255. The baked asset gets the highest id used + 1 slots.' }, triangleIndices: P.triangleIndices, region: P.region },
-        required: ['actorName', 'materialId'], effect: 'write',
-        behavior: { idempotency: 'idempotent' }, costLatency: 'interactive', costResources: 'low',
-        outputProps: {
-            actorName: P.actorName,
-            materialId: int('Material id that was set.'),
-            trianglesSelected: int('Triangles that received the id.'),
-            triangleCount: OUT_TRIANGLE_COUNT,
-            materialIdsInUse: { type: 'array', items: { type: 'integer' }, description: 'Every material id the mesh carries now, ascending.' },
-        },
-        outputRequired: ['actorName', 'materialId', 'trianglesSelected', 'triangleCount', 'materialIdsInUse'],
-        exampleInput: { action: 'set_material_id', actorName: 'DM_Cage', materialId: 1, region: { normal: { x: 0, y: 0, z: 1 }, normalAngle: 30 } },
-        exampleOutput: { success: true, actorName: 'DM_Cage', materialId: 1, trianglesSelected: 2, triangleCount: 12, materialIdsInUse: [0, 1] },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'bake_vertex_colors', plugins: PLUGIN,
-        topics: ['ambient occlusion mask', 'edge wear mask', 'cavity mask', 'height gradient mask', 'bake masks for materials'],
-        family: F,
-        summary: 'Bake ambient occlusion, convex-edge, concave-cavity and height masks into the vertex colours of a DynamicMesh actor, for a material to read through its VertexColor node.',
-        whenToUse: ['A material needs masks (dirt in crevices, wear on edges, a height gradient) without textures: bake once the shape is final, then convert_to_static_mesh or convert_to_nanite.',
-            'Channels: R is ambient occlusion (1 open, 0 occluded); G is 1 minus the convex edge (1 on flat or concave surface, lower along an outward fold such as a rim); B is 1 minus the concave cavity (1 on flat or convex surface, lower in a crease); A is height (0 at the bottom of the bounds, 1 at the top, along local Z).',
-            'White means no effect for every channel except height, so a mesh that was never baked, which reads (1, 1, 1, 1), behaves like one whose masks are all quiet.',
-            'The values reach the static mesh unchanged: the conversion cancels the sRGB encoding the static-mesh build applies (UE 5.1 and later), so a material\'s VertexColor node reads the baked value and a stored byte is the value times 255.'],
-        whenNotToUse: ['One flat colour on every vertex is wanted; use set_vertex_color.', 'The mesh will be rebuilt afterwards by morphology or remesh_voxel, which drop vertex colours; bake after them.'],
-        inputProps: {
-            actorName: P.actorName,
-            aoRays: { type: 'integer', description: 'Hemisphere rays per vertex for occlusion (default 32, clamped to 8-256); the bake cuts them on a very dense mesh to keep the call short, and the reply says how many it used.' },
-            aoDistance: { type: 'number', description: 'How far an occluder can be, in cm (default 15% of the bounds diagonal); nearer geometry darkens R, farther geometry is ignored.' },
-            curvatureScale: { type: 'number', description: 'Strength of the G and B masks (default 1): a fold of a quarter turn (90 degrees) is a full edge or cavity at 1; use 2 to make a 45 degree fold full, 0 to switch both masks off.' },
-            blurIterations: { type: 'integer', description: 'Neighbour-averaging passes over R, G and B (default 1, 0 to 16); 0 keeps the masks per vertex and noisy.' },
-        },
-        required: ['actorName'], effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive', costResources: 'medium',
-        outputProps: {
-            actorName: P.actorName,
-            vertexCount: OUT_VERTEX_COUNT,
-            aoRays: int('Rays per vertex that were traced.'),
-            aoDistance: { type: 'number', description: 'Occlusion distance used, in cm.' },
-            curvatureScale: { type: 'number', description: 'Curvature scale used.' },
-            blurIterations: int('Blur passes that ran.'),
-            averages: { type: 'object', description: 'Mean of each channel over the vertices, {r, g, b, a}, to see at a glance whether a mask did anything.', properties: { r: { type: 'number' }, g: { type: 'number' }, b: { type: 'number' }, a: { type: 'number' } }, additionalProperties: false },
-            channels: { type: 'string', description: 'What each channel holds.' },
-        },
-        outputRequired: ['actorName', 'vertexCount', 'aoRays', 'aoDistance'],
-        exampleInput: { action: 'bake_vertex_colors', actorName: 'DM_Cage', aoRays: 64, blurIterations: 2 },
-        exampleOutput: { success: true, actorName: 'DM_Cage', vertexCount: 386, aoRays: 64, aoDistance: 25.4, curvatureScale: 1, blurIterations: 2 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'difference', plugins: PLUGIN,
-        family: F, summary: 'Subtract a tool mesh from a target mesh under the difference spelling of boolean_subtract.',
-        whenToUse: ['A caller reaches for the CSG name for a subtraction.'],
-        whenNotToUse: ['The canonical spelling is available; use boolean_subtract.'],
-        inputProps: { targetActor: P.targetActor, toolActor: P.toolActor, keepTool: P.keepTool },
-        required: ['targetActor', 'toolActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'difference', targetActor: 'DM_A', toolActor: 'DM_B' },
-    }),
-];
-//# sourceMappingURL=manage-geometry.dynamicmesh.data.js.map

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

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

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

@@ -1,16 +0,0 @@
-import { GEOMETRY_PRIMITIVES_RECORDS } from './manage-geometry.primitives.data.js';
-import { GEOMETRY_OPERATIONS_RECORDS } from './manage-geometry.operations.data.js';
-import { GEOMETRY_DEFORM_RECORDS } from './manage-geometry.deform.data.js';
-import { GEOMETRY_OPTIMIZE_RECORDS } from './manage-geometry.optimize.data.js';
-import { GEOMETRY_DYNAMICMESH_RECORDS } from './manage-geometry.dynamicmesh.data.js';
-import { applyFolds } from '../shared/fold.js';
-import { MANAGE_GEOMETRY_FOLDS } from '../folds/manage-geometry.folds.js';
-export const MANAGE_GEOMETRY_UNFOLDED_SOURCES = [
-    ...GEOMETRY_PRIMITIVES_RECORDS,
-    ...GEOMETRY_OPERATIONS_RECORDS,
-    ...GEOMETRY_DEFORM_RECORDS,
-    ...GEOMETRY_OPTIMIZE_RECORDS,
-    ...GEOMETRY_DYNAMICMESH_RECORDS,
-];
-export const MANAGE_GEOMETRY_SOURCES = applyFolds(MANAGE_GEOMETRY_UNFOLDED_SOURCES, MANAGE_GEOMETRY_FOLDS, 'manage_geometry');
-//# sourceMappingURL=manage-geometry.index.js.map

package/dist/tools/catalog/capabilities/records/world/manage-geometry.operations.data.d.ts

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

package/dist/tools/catalog/capabilities/records/world/manage-geometry.operations.data.js

@@ -1,191 +0,0 @@
-import { buildWorldRecord } from './builder.js';
-import { P } from './properties.js';
-const F = 'operations';
-const PLUGIN = ['GeometryScripting'];
-const BEVEL_DISTANCE = { type: 'number', description: 'Bevel width in world units (default 5).' };
-const BEVEL_SEGMENTS = { type: 'integer', description: 'Subdivisions for a rounded bevel (UE 5.4 or later); omit or 0 for a flat bevel.' };
-const SWEEP_STEPS = { type: 'integer', description: 'Path steps along the sweep (default 16); the profile uses half as many sides.' };
-const STEPS = { type: 'integer', description: 'Path steps along a sweep (default 16; the profile uses half as many sides), or segments around the axis for a revolve (default 16, 3 to 512; 48 or more reads as round).' };
-const CAP = { type: 'boolean', description: 'Close open ends: the tube ends of a loft, sweep or extrude along a spline, or for a revolve flat discs from the first and last profile points to the axis (revolve default true).' };
-const TRIANGLES_SELECTED = { type: 'integer', description: 'Triangles the operation worked on: the triangleIndices or region selection, else every triangle of the mesh.' };
-const SELECTION_OUTPUT = { trianglesSelected: TRIANGLES_SELECTED };
-export const GEOMETRY_OPERATIONS_RECORDS = [
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'boolean_union', plugins: PLUGIN,
-        family: F, summary: 'Boolean union of two dynamic mesh actors.', whenToUse: ['Two meshes must be merged via union.'], whenNotToUse: ['A subtraction is needed; use boolean_subtract.'],
-        inputProps: { targetActor: P.targetActor, toolActor: P.toolActor, keepTool: P.keepTool }, required: ['targetActor', 'toolActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'boolean_union', targetActor: 'DM_A', toolActor: 'DM_B' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'boolean_subtract', plugins: PLUGIN,
-        family: F, summary: 'Boolean subtract a tool mesh from a target mesh.', whenToUse: ['A tool mesh must be cut out of a target.'], whenNotToUse: ['A union is needed; use boolean_union.'],
-        inputProps: { targetActor: P.targetActor, toolActor: P.toolActor, keepTool: P.keepTool }, required: ['targetActor', 'toolActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'boolean_subtract', targetActor: 'DM_A', toolActor: 'DM_B' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'boolean_intersection', plugins: PLUGIN,
-        family: F, summary: 'Boolean intersection of two dynamic mesh actors.', whenToUse: ['The overlapping volume of two meshes is needed.'], whenNotToUse: ['A union is needed; use boolean_union.'],
-        inputProps: { targetActor: P.targetActor, toolActor: P.toolActor, keepTool: P.keepTool }, required: ['targetActor', 'toolActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'boolean_intersection', targetActor: 'DM_A', toolActor: 'DM_B' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'boolean_trim', plugins: PLUGIN,
-        family: F, summary: 'Trim a target mesh by a trim actor (keep inside/outside).', whenToUse: ['A mesh must be trimmed against a volume.'], whenNotToUse: ['A full boolean is needed; use boolean_subtract.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, trimActorName: P.trimActorName, keepInside: P.keepInside }, required: ['trimActorName'], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'boolean_trim', targetActor: 'DM_A', trimActorName: 'Trim_01' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'self_union', plugins: PLUGIN,
-        family: F, summary: 'Self-union overlapping triangles of a dynamic mesh.', whenToUse: ['A self-intersecting mesh must be resolved.'], whenNotToUse: ['A boolean against another mesh is needed.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'self_union', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'extrude', plugins: PLUGIN,
-        family: F, summary: 'Extrude selected faces of a dynamic mesh.', whenToUse: ['Faces must be extruded along a direction; pick them with triangleIndices or a region (the top faces are region.normal {x:0,y:0,z:1}).'], whenNotToUse: ['A sweep along a spline is needed; use extrude_along_spline.'],
-        inputProps: { actorName: P.actorName, amount: P.amount, targetActor: P.targetActor, offset: P.offset, triangleIndices: P.triangleIndices, region: P.region }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        outputProps: SELECTION_OUTPUT,
-        exampleInput: { action: 'extrude', targetActor: 'DM_A', offset: { x: 0, y: 0, z: 50 } },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'inset', plugins: PLUGIN,
-        family: F, summary: 'Inset selected faces of a dynamic mesh.', whenToUse: ['Faces must be inset; pick them with triangleIndices or a region.'], whenNotToUse: ['Faces must be outset; use outset.'],
-        inputProps: { actorName: P.actorName, distance: P.distance, targetActor: P.targetActor, triangleIndices: P.triangleIndices, region: P.region }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        outputProps: SELECTION_OUTPUT,
-        exampleInput: { action: 'inset', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'outset', plugins: PLUGIN,
-        family: F, summary: 'Outset selected faces of a dynamic mesh.', whenToUse: ['Faces must be outset; pick them with triangleIndices or a region.'], whenNotToUse: ['Faces must be inset; use inset.'],
-        inputProps: { actorName: P.actorName, distance: P.distance, targetActor: P.targetActor, triangleIndices: P.triangleIndices, region: P.region }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        outputProps: SELECTION_OUTPUT,
-        exampleInput: { action: 'outset', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'bevel', plugins: PLUGIN,
-        family: F, summary: 'Bevel selected edges of a dynamic mesh.', whenToUse: ['Edges must be beveled; pick the faces whose edges bevel with triangleIndices or a region.'], whenNotToUse: ['Edges must be split; use edge_split.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, triangleIndices: P.triangleIndices, region: P.region, distance: BEVEL_DISTANCE, segments: BEVEL_SEGMENTS }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        outputProps: SELECTION_OUTPUT,
-        exampleInput: { action: 'bevel', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'offset_faces', plugins: PLUGIN,
-        family: F, summary: 'Offset selected faces of a dynamic mesh.', whenToUse: ['Faces must be offset; pick them with triangleIndices or a region.'], whenNotToUse: ['Faces must be extruded; use extrude.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, distance: P.distance, triangleIndices: P.triangleIndices, region: P.region }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        outputProps: SELECTION_OUTPUT,
-        exampleInput: { action: 'offset_faces', targetActor: 'DM_A', distance: 10 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'shell', plugins: PLUGIN,
-        family: F, summary: 'Create a shell (inner offset) of a dynamic mesh.', whenToUse: ['A hollow shell must be generated.'], whenNotToUse: ['A simple offset is needed; use offset_faces.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, thickness: P.thickness }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'shell', targetActor: 'DM_A', thickness: 5 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'revolve', plugins: PLUGIN,
-        family: F, summary: 'Turn a profile of {radius, height} points around the vertical axis into a new dynamic mesh actor: a vase, column, bottle, tower or dome.', whenToUse: ['A lathe/revolve solid must be created.'], whenNotToUse: ['A sweep along a spline is needed; use sweep.'],
-        inputProps: {
-            name: P.name, location: P.location, rotation: P.rotation, scale: P.scale,
-            profile: {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    properties: { radius: { type: 'number', description: 'Distance from the axis in cm, 0 or more.' }, height: { type: 'number', description: 'Height above the base in cm.' } },
-                    required: ['radius', 'height'], additionalProperties: false,
-                },
-                description: 'Points from bottom to top, at least 2. For a hollow shape with walls, go up the outside and back down the inside. Omit for a small built-in vase.',
-            },
-            angle: { type: 'number', description: 'Degrees to turn the profile, 1 to 360 (default 360); less leaves an open wedge.' },
-            steps: STEPS, cap: CAP,
-        },
-        required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'revolve', name: 'Column', profile: [{ radius: 40, height: 0 }, { radius: 30, height: 300 }, { radius: 45, height: 320 }], steps: 32 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'chamfer', plugins: PLUGIN,
-        family: F, summary: 'Chamfer selected edges of a dynamic mesh.', whenToUse: ['Edges must be chamfered; pick the faces whose edges chamfer with triangleIndices or a region.'], whenNotToUse: ['Edges must be beveled; use bevel.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, triangleIndices: P.triangleIndices, region: P.region, distance: BEVEL_DISTANCE, segments: BEVEL_SEGMENTS }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        outputProps: SELECTION_OUTPUT,
-        exampleInput: { action: 'chamfer', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'extrude_along_spline', plugins: PLUGIN,
-        family: F, summary: 'Extrude a profile along a spline actor.', whenToUse: ['A mesh must be swept along a spline path.'], whenNotToUse: ['A straight extrude is needed; use extrude.'],
-        inputProps: { actorName: P.actorName, cap: CAP, segments: P.segments, targetActor: P.targetActor, splineActorName: P.splineActorName }, required: ['splineActorName'], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'extrude_along_spline', targetActor: 'DM_A', splineActorName: 'Spline_01' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'bridge', plugins: PLUGIN,
-        family: F, summary: 'Bridge two edge loops of a dynamic mesh.', whenToUse: ['Two edge loops must be bridged.'], whenNotToUse: ['A loft between profiles is needed; use loft.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'bridge', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'loft', plugins: PLUGIN,
-        family: F, summary: 'Loft between two or more profile curves.', whenToUse: ['A lofted surface between profiles must be created.'], whenNotToUse: ['A sweep along a spline is needed; use sweep.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, splineActorName: P.splineActorName, segments: SWEEP_STEPS, cap: CAP }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'loft', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'sweep', plugins: PLUGIN,
-        family: F, summary: 'Sweep a profile along a path of a dynamic mesh.', whenToUse: ['A swept solid must be created.'], whenNotToUse: ['A revolve is needed; use revolve.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, splineActorName: P.splineActorName, steps: STEPS, cap: CAP }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'sweep', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'duplicate_along_spline', plugins: PLUGIN,
-        family: F, summary: 'Duplicate a mesh along a spline actor.', whenToUse: ['Copies of a mesh must be distributed along a spline.'], whenNotToUse: ['A single extrude is needed; use extrude_along_spline.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, splineActorName: P.splineActorName, count: P.count }, required: ['splineActorName'], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'duplicate_along_spline', targetActor: 'DM_A', splineActorName: 'Spline_01', count: 10 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'loop_cut', plugins: PLUGIN,
-        family: F, summary: 'Insert evenly spaced edge loops across a dynamic mesh, perpendicular to an axis.', whenToUse: ['An edge loop must be inserted.'], whenNotToUse: ['An edge must be split; use edge_split.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, axis: P.axis, numCuts: P.numCuts }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'loop_cut', targetActor: 'DM_A', axis: 'Z', numCuts: 2 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'edge_split', plugins: PLUGIN,
-        family: F, summary: 'Split edges of a dynamic mesh at their midpoints.', whenToUse: ['Specific edges must be subdivided.'], whenNotToUse: ['An edge loop must be inserted; use loop_cut.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, edges: P.edges }, required: ['edges'], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'edge_split', targetActor: 'DM_A', edges: [0, 1] },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'poke', plugins: PLUGIN,
-        family: F, summary: 'Poke faces of a dynamic mesh: add a centre vertex to each triangle (optionally pushed out along its normal) and fan it into three triangles.',
-        whenToUse: ['Faces must be split from their centre, or pushed out into pyramids or spikes; pick them with triangleIndices or a region.'], whenNotToUse: ['The whole mesh should be refined evenly; use subdivide.'],
-        inputProps: {
-            actorName: P.actorName, targetActor: P.targetActor, triangleIndices: P.triangleIndices, region: P.region,
-            distance: { type: 'number', description: 'Distance in cm to push each new centre vertex along its face normal (default 0; negative pushes inward).' },
-        },
-        required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        outputProps: {
-            ...SELECTION_OUTPUT,
-            trianglesPoked: { type: 'number', description: 'Triangles that were poked.' },
-            trianglesBefore: { type: 'number', description: 'Triangle count before.' },
-            trianglesAfter: { type: 'number', description: 'Triangle count after (before + 2 per poked triangle).' },
-            verticesAdded: { type: 'number', description: 'New centre vertices.' },
-            skipped: { type: 'number', description: 'Degenerate or missing triangles that were left alone.' },
-        },
-        exampleInput: { action: 'poke', targetActor: 'DM_A', distance: 10 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'quadrangulate', plugins: PLUGIN,
-        family: F, summary: 'Group pairs of adjacent triangles of a dynamic mesh into quad PolyGroups, so PolyGroup edits (extrude, inset, bevel by group) act on quads. The mesh itself stays triangles.',
-        whenToUse: ['A triangulated mesh must be edited as quads.'], whenNotToUse: ['Real quad topology is needed in an exported asset; meshes in Unreal are always triangles.'],
-        inputProps: {
-            actorName: P.actorName, targetActor: P.targetActor,
-            respectUVSeams: { type: 'boolean', description: 'Never pair two triangles across a UV seam (default true).' },
-            respectHardNormals: { type: 'boolean', description: 'Never pair two triangles across a hard edge (default false).' },
-        },
-        required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        outputProps: {
-            quadsFormed: { type: 'number', description: 'Triangle pairs grouped as quads.' },
-            singleTriangleGroups: { type: 'number', description: 'Triangles left in a group of their own.' },
-            largerGroups: { type: 'number', description: 'Groups of more than two triangles.' },
-            triangleCount: { type: 'number', description: 'Triangles in the mesh (unchanged).' },
-        },
-        exampleInput: { action: 'quadrangulate', targetActor: 'DM_A' },
-    }),
-];
-//# sourceMappingURL=manage-geometry.operations.data.js.map

package/dist/tools/catalog/capabilities/records/world/manage-geometry.optimize.data.d.ts

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