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

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

@@ -1,280 +0,0 @@
-import { buildWorldRecord } from './builder.js';
-import { P } from './properties.js';
-const F = 'optimize';
-const PLUGIN = ['GeometryScripting'];
-const REMESH_TRIS = { type: 'number', description: 'Triangle budget when targetEdgeLength is omitted (remesh_uniform default 5000). remesh_voxel only approximates it, picking the grid cell from the surface area, and uses voxelCount first when that is given.' };
-const VOXEL_COUNT = { type: 'integer', description: 'Grid cells along the mesh\'s longest side for the voxel operations (default 128, clamped to 16-256): more cells keep thinner detail and cost more time and triangles. The reply\'s voxelSize is the resulting cell width in cm.' };
-const MORPH_OPERATION = { type: 'string', enum: ['dilate', 'contract', 'close', 'open'], description: 'dilate grows the surface outward by distance, contract shrinks it inward; close (the default) fills creases and rounds the seams where parts meet, a fillet up to about twice distance wide; open shaves off bumps and thin parts smaller than distance.' };
-const MORPH_DISTANCE = { type: 'number', description: 'Offset distance in cm (default 2% of the mesh\'s longest side). Keep it above one voxel (the longest side divided by voxelCount) or the effect barely registers.' };
-const SUBDIVIDE_SCHEME = { type: 'string', enum: ['pn', 'catmull_clark', 'loop', 'bilinear'], description: 'Subdivision scheme (default pn). pn: PN tessellation, which adds triangles and keeps the shape. catmull_clark: a smooth subdivision surface over a polygon cage, where every polygroup is one face (build the cage with edit_dynamic_mesh append_polygons, or start from create_box, which has one polygroup per face); the surface rounds toward the cage, and polygroups and material ids carry through. loop: smooths the triangles as they are and needs no cage. bilinear: cuts the cage into quads without smoothing. iterations is the level.' };
-const SUBDIVIDE_LEVEL = { type: 'integer', description: 'Subdivision level, 1 to 6 (default 1). Each level quadruples the face count, so 2 or 3 is enough for a smooth result; the call is refused past 500000 triangles.' };
-const CONVERT_MATERIALS = { type: 'array', items: { type: 'string' }, description: 'Materials for the baked asset\'s slots as asset paths (a material or material instance): entry i is the material of slot i, which holds every triangle with material id i (set ids with edit_dynamic_mesh set_material_id). The asset gets the mesh\'s highest material id + 1 slots; slots you do not list, or list as "", keep the default material. A path that is unsafe or does not load as a material is refused before anything is created, and so is a list longer than the slot count.' };
-const SLOT = {
-    type: 'object',
-    properties: {
-        slot: { type: 'integer', description: 'Slot index, equal to the material id it holds.' },
-        name: { type: 'string', description: 'Slot name.' },
-        material: { type: 'string', description: 'Material asset path; empty for the default material.' },
-    },
-    additionalProperties: false,
-};
-const MESH_USER_WARNINGS = { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, 'x-unreal-reflection-boundary': true, description: 'When outputPath replaced a mesh that loaded Blueprints already draw: the parts drawing it that now sink, worst first (at most 8, each also a warnings[] sentence): blueprintPath, componentName, kind (buried: inside otherComponent; sunk: below a Character\'s capsule bottom), depth in cm, insideShare and issue. Measured like edit_scs partWarnings; a part tagged mcp.placement.ok is left out, and mcp.placement.ok:<component> accepts the embed in that one part only.' };
-const CONVERT_COLLISION = { type: 'string', enum: ['box', 'complex', 'none'], description: 'Collision for the baked asset: box (default) is one box the size of the bounds, which pawns can stand on (on a converted-over asset too); complex uses the render triangles as simple collision too, exact but costly; none gives the asset no collision at all.' };
-const COLLISION_TYPE = { type: 'string', enum: ['box', 'sphere', 'capsule', 'convex', 'convex_decomposition'], description: 'Collision shapes to generate (default convex).' };
-export const GEOMETRY_OPTIMIZE_RECORDS = [
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'mirror', topics: ['mirror a mesh'], plugins: PLUGIN,
-        family: F, summary: 'Mirror a dynamic mesh across an axis.', whenToUse: ['A mesh must be mirrored.'], whenNotToUse: ['Instances must be arrayed; use array_linear.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, axis: P.axis, center: P.center }, required: ['axis'], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'mirror', targetActor: 'DM_A', axis: 'X' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'array_linear', plugins: PLUGIN,
-        family: F, summary: 'Create a linear array of a dynamic mesh.', whenToUse: ['Instances must be arrayed linearly.'], whenNotToUse: ['A radial array is needed; use array_radial.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, count: P.count, offset: P.offset }, required: ['count'], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'array_linear', targetActor: 'DM_A', count: 5, offset: { x: 200, y: 0, z: 0 } },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'array_radial', plugins: PLUGIN,
-        family: F, summary: 'Create a radial array of a dynamic mesh.', whenToUse: ['Instances must be arrayed radially.'], whenNotToUse: ['A linear array is needed; use array_linear.'],
-        inputProps: { actorName: P.actorName, angle: P.angle, targetActor: P.targetActor, count: P.count, center: P.center }, required: ['count'], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'array_radial', actorName: 'DM_A', count: 8, center: { x: 0, y: 0, z: 0 } },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'simplify_mesh', plugins: PLUGIN,
-        family: F, summary: 'Simplify a dynamic mesh to a target triangle count.', whenToUse: ['A mesh must be simplified.'], whenNotToUse: ['A mesh must be subdivided; use subdivide.'],
-        inputProps: { actorName: P.actorName, reductionPercent: P.reductionPercent, targetActor: P.targetActor, targetTriangleCount: P.targetTriangleCount }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'simplify_mesh', targetActor: 'DM_A', targetTriangleCount: 5000 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'subdivide', plugins: PLUGIN,
-        topics: ['catmull clark', 'loop subdivision', 'subdivision surface', 'smooth subdivision', 'round the edges of a cage'],
-        family: F, summary: 'Subdivide a dynamic mesh: pn tessellation (default), or a Catmull-Clark, Loop or bilinear subdivision surface.',
-        whenToUse: ['A mesh must be refined. For a smooth, rounded model, author a coarse polygon cage (edit_dynamic_mesh append_polygons, one polygroup per face, or create_box) and subdivide it with scheme catmull_clark, iterations 2 or 3.',
-            'The cage carries material ids and polygroups through the subdivision, so assign them with set_material_id first.'],
-        whenNotToUse: ['A mesh must be simplified; use simplify_mesh.', 'Edges must stay sharp; subdivision rounds every edge of the cage.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, iterations: SUBDIVIDE_LEVEL, scheme: SUBDIVIDE_SCHEME }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        outputProps: {
-            scheme: { type: 'string', description: 'Scheme that ran.' },
-            level: { type: 'integer', description: 'Subdivision level that ran.' },
-            trianglesBefore: { type: 'integer', description: 'Triangle count before.' },
-            trianglesAfter: { type: 'integer', description: 'Triangle count after.' },
-            cageFaces: { type: 'integer', description: 'Cage faces: polygroups for catmull_clark and bilinear, triangles for loop; absent for pn.' },
-        },
-        exampleInput: { action: 'subdivide', targetActor: 'DM_Cage', scheme: 'catmull_clark', iterations: 2 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'remesh_uniform', plugins: PLUGIN,
-        family: F, summary: 'Uniformly remesh a dynamic mesh to a target edge length.', whenToUse: ['A uniform remesh is needed.'], whenNotToUse: ['A voxel remesh is needed; use remesh_voxel.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, targetEdgeLength: P.targetEdgeLength, targetTriangleCount: REMESH_TRIS }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'remesh_uniform', targetActor: 'DM_A', targetEdgeLength: 10 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'merge_vertices', plugins: PLUGIN,
-        family: F, summary: 'Merge coincident vertices of a dynamic mesh.', whenToUse: ['Duplicate vertices must be welded/merged.'], whenNotToUse: ['A precise weld is needed; use weld_vertices.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, weldDistance: P.weldDistance }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'merge_vertices', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'remesh_voxel', plugins: PLUGIN,
-        family: F, summary: 'Voxel-wrap a dynamic mesh into one watertight, smooth-shaded surface (the engine\'s solidify): the mesh is sampled into a grid and rebuilt, closing holes and merging overlapping parts.',
-        whenToUse: ['A watertight voxel remesh is needed, for example to fuse unioned or overlapping parts into one skin. The grid cell is targetEdgeLength, or the longest side divided by voxelCount (default 128). The surface is rebuilt, so UVs, material ids, polygroups and vertex colours are dropped: run auto_uv, set_material_id and bake_vertex_colors afterwards.'],
-        whenNotToUse: ['A uniform remesh is needed; use remesh_uniform.', 'Seams between parts must be rounded rather than fused; use morphology close.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, targetEdgeLength: P.targetEdgeLength, targetTriangleCount: REMESH_TRIS, voxelCount: VOXEL_COUNT }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', behavior: { longRunning: true }, costLatency: 'long-running', costResources: 'high',
-        exampleInput: { action: 'remesh_voxel', targetActor: 'DM_A', voxelCount: 96 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'morphology', plugins: PLUGIN,
-        topics: ['fillet', 'blend parts together', 'round the seams', 'dilate', 'contract', 'offset a mesh', 'close gaps in a mesh'],
-        family: F, summary: 'Offset a dynamic mesh\'s surface through a voxel grid: dilate, contract, close (fillet the seams where unioned parts meet) or open.',
-        whenToUse: ['Joined parts need a smooth blend: boolean_union them, then morphology close with a distance about the fillet radius, then auto_uv, set_material_id and bake_vertex_colors.',
-            'A mesh must grow or shrink evenly (dilate, contract), or small bumps must go (open).'],
-        whenNotToUse: ['Edges must stay crisp; the grid rounds every feature narrower than about twice distance.', 'UVs, material ids, polygroups or vertex colours must survive; the surface is rebuilt from the grid, so set them afterwards.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, operation: MORPH_OPERATION, distance: MORPH_DISTANCE, voxelCount: VOXEL_COUNT }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', behavior: { longRunning: true }, costLatency: 'long-running', costResources: 'high',
-        outputProps: {
-            operation: { type: 'string', description: 'Operation that ran.' },
-            distance: { type: 'number', description: 'Offset distance used, in cm.' },
-            voxelCount: { type: 'integer', description: 'Grid cells along the longest side after clamping.' },
-            voxelSize: { type: 'number', description: 'Width of one grid cell in cm.' },
-            trianglesBefore: { type: 'integer', description: 'Triangle count before.' },
-            trianglesAfter: { type: 'integer', description: 'Triangle count after.' },
-            note: { type: 'string', description: 'What the rebuild dropped, and a hint when distance is under one voxel.' },
-        },
-        exampleInput: { action: 'morphology', targetActor: 'DM_A', operation: 'close', distance: 4, voxelCount: 128 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'weld_vertices', plugins: PLUGIN,
-        family: F, summary: 'Weld vertices of a dynamic mesh within a distance.', whenToUse: ['Vertices must be welded by threshold.'], whenNotToUse: ['A merge is needed; use merge_vertices.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, weldDistance: P.weldDistance }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'weld_vertices', targetActor: 'DM_A', weldDistance: 0.1 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'fill_holes', plugins: PLUGIN,
-        family: F, summary: 'Fill boundary holes of a dynamic mesh.', whenToUse: ['Mesh holes must be capped.'], whenNotToUse: ['Degenerate triangles must be removed; use remove_degenerates.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'fill_holes', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'remove_degenerates', plugins: PLUGIN,
-        family: F, summary: 'Remove degenerate triangles from a dynamic mesh.', whenToUse: ['Degenerate triangles must be removed.'], whenNotToUse: ['Holes must be filled; use fill_holes.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'remove_degenerates', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'auto_uv', plugins: PLUGIN,
-        family: F, summary: 'Auto-generate UVs for a dynamic mesh.', whenToUse: ['UVs must be auto-generated.'], whenNotToUse: ['UVs must be unwrapped; use unwrap_uv.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, uvChannel: P.uvChannel }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'auto_uv', targetActor: 'DM_A', uvChannel: 0 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'project_uv', plugins: PLUGIN,
-        family: F, summary: 'Project UVs from a planar/box projection.', whenToUse: ['UVs must be projected.'], whenNotToUse: ['UVs must be transformed; use transform_uvs.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, uvChannel: P.uvChannel }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'project_uv', targetActor: 'DM_A', uvChannel: 0 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'transform_uvs', plugins: PLUGIN,
-        family: F, summary: 'Transform existing UVs (scale/offset) of a dynamic mesh.', whenToUse: ['UVs must be scaled/offset.'], whenNotToUse: ['UVs must be repacked; use pack_uv_islands.'],
-        inputProps: { actorName: P.actorName, rotation: P.uvRotation, targetActor: P.targetActor, uvChannel: P.uvChannel, uvScale: P.uvScale, uvOffset: P.uvOffset }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'transform_uvs', targetActor: 'DM_A', uvChannel: 0, uvScale: { u: 2, v: 2 } },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'unwrap_uv', plugins: PLUGIN,
-        family: F, summary: 'Unwrap UVs of a dynamic mesh.', whenToUse: ['UVs must be unwrapped.'], whenNotToUse: ['UVs must be auto-generated; use auto_uv.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, uvChannel: P.uvChannel }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'unwrap_uv', targetActor: 'DM_A', uvChannel: 0 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'pack_uv_islands', plugins: PLUGIN,
-        family: F, summary: 'Pack UV islands of a dynamic mesh into a 0-1 square.', whenToUse: ['UV islands must be packed.'], whenNotToUse: ['UVs must be transformed; use transform_uvs.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, uvChannel: P.uvChannel }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'pack_uv_islands', targetActor: 'DM_A', uvChannel: 0 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'recalculate_normals', plugins: PLUGIN,
-        family: F, summary: 'Recalculate normals of a dynamic mesh.', whenToUse: ['Normals must be recalculated.'], whenNotToUse: ['Normals must be flipped; use flip_normals.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, hardEdgeAngle: P.hardEdgeAngle, computeWeightedNormals: P.computeWeightedNormals }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'recalculate_normals', actorName: 'DM_A', hardEdgeAngle: 60 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'flip_normals', plugins: PLUGIN,
-        family: F, summary: 'Flip normals of a dynamic mesh.', whenToUse: ['Normals must be flipped (inside-out).'], whenNotToUse: ['Normals must be recomputed; use recalculate_normals.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'flip_normals', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'recompute_tangents', plugins: PLUGIN,
-        family: F, summary: 'Recompute tangents of a dynamic mesh.', whenToUse: ['Tangents must be recomputed for correct shading.'], whenNotToUse: ['Normals must be recomputed; use recalculate_normals.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'recompute_tangents', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'generate_collision', plugins: PLUGIN,
-        family: F, summary: 'Generate simple collision for a dynamic mesh.', whenToUse: ['Simple collision must be generated.'], whenNotToUse: ['Complex collision is needed; use generate_complex_collision.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor, collisionType: COLLISION_TYPE, maxHullCount: { type: 'integer', description: 'Hull budget (1 to 64, default 8) when collisionType is convex_decomposition.' } }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'generate_collision', targetActor: 'DM_A', collisionType: 'convex' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'generate_complex_collision', plugins: PLUGIN,
-        family: F, summary: 'Generate complex (convex decomposition) collision.', whenToUse: ['Complex collision must be generated.'], whenNotToUse: ['Simple collision is sufficient; use generate_collision.'],
-        inputProps: { actorName: P.actorName, hullCount: P.hullCount, maxHullCount: P.maxHullCount, targetActor: P.targetActor }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'generate_complex_collision', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'simplify_collision', plugins: PLUGIN,
-        family: F, summary: 'Simplify an existing collision hull.', whenToUse: ['A collision hull must be simplified.'], whenNotToUse: ['Collision must be generated; use generate_collision.'],
-        inputProps: { actorName: P.actorName, simplificationFactor: P.simplificationFactor, targetHullCount: P.targetHullCount, targetActor: P.targetActor }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'simplify_collision', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'generate_lods', plugins: PLUGIN,
-        family: F, summary: 'Generate LODs for a dynamic mesh.', whenToUse: ['LODs must be generated for a mesh.'], whenNotToUse: ['LOD screen sizes must be set; use set_lod_screen_sizes.'],
-        inputProps: { actorName: P.actorName, lodCount: P.lodCount, targetActor: P.targetActor, outputPath: { ...P.outputPath, description: 'Where the baked static mesh (the LODs need one) is saved: a folder or a full asset path; default /Game/GeneratedMeshes/<actorName>_LOD.' } }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', behavior: { longRunning: true }, costLatency: 'long-running', costResources: 'high',
-        exampleInput: { action: 'generate_lods', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'set_lod_settings', plugins: PLUGIN,
-        family: F, summary: 'Set LOD settings for a dynamic mesh.', whenToUse: ['LOD build settings must be configured.'], whenNotToUse: ['LODs must be generated; use generate_lods.'],
-        inputProps: { actorName: P.actorName, lodIndex: P.lodIndex, trianglePercent: P.trianglePercent, reductionPercent: P.reductionPercent, recomputeNormals: P.recomputeNormals, recomputeTangents: P.recomputeTangents, targetActor: P.targetActor }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'set_lod_settings', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'set_lod_screen_sizes', plugins: PLUGIN,
-        family: F, summary: 'Set LOD screen-size thresholds for a dynamic mesh.', whenToUse: ['LOD screen-size transitions must be tuned.'], whenNotToUse: ['LOD settings must be configured; use set_lod_settings.'],
-        inputProps: { actorName: P.actorName, screenSizes: P.screenSizes, targetActor: P.targetActor }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'set_lod_screen_sizes', targetActor: 'DM_A' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'convert_to_nanite', plugins: PLUGIN,
-        family: F, summary: 'Bake a dynamic mesh into a Nanite-enabled static mesh asset, with a material per slot and a collision choice; the reply reads naniteEnabled back from the saved mesh. An asset already at outputPath is replaced, and its material slots come back empty unless materials fills them (asset.process_asset process=mesh_materials sets them later).',
-        whenToUse: ['A baked static mesh must use Nanite for virtualized geometry. The end of the subdivision-surface workflow: append_polygons a cage, subdivide with catmull_clark, set_material_id per part, bake_vertex_colors, then convert here with materials (entry i is the material of id i).'],
-        whenNotToUse: ['The baked mesh must not use Nanite; use convert_to_static_mesh.'],
-        inputProps: { actorName: P.actorName, outputPath: P.outputPath, targetActor: P.targetActor, materials: CONVERT_MATERIALS, collision: CONVERT_COLLISION }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive', costResources: 'medium',
-        outputProps: {
-            assetPath: { type: 'string', description: 'Path of the new static mesh asset.' },
-            naniteEnabled: { type: 'boolean', description: 'Whether Nanite is on for the asset.' },
-            collision: { type: 'string', description: 'Collision the asset got.' },
-            slots: { type: 'array', description: 'The asset\'s material slots; an empty material is the default material.', items: SLOT },
-            partWarnings: MESH_USER_WARNINGS,
-        },
-        exampleInput: { action: 'convert_to_nanite', targetActor: 'DM_Cage', materials: ['/Engine/BasicShapes/BasicShapeMaterial'], collision: 'complex' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'convert_to_static_mesh', plugins: PLUGIN,
-        topics: ['static mesh from geometry', 'bake to static mesh', 'convert mesh', 'dynamic mesh to static'],
-        family: F, summary: 'Bake a dynamic mesh actor into a static mesh asset, with a material per slot and a collision choice.',
-        whenToUse: ['A dynamic mesh must be persisted as a static mesh. Give the triangles material ids with edit_dynamic_mesh set_material_id first, then list one material per id in materials (entry i is the material of id i).',
-            'Colours baked with bake_vertex_colors come through to the material\'s VertexColor node unchanged.'],
-        whenNotToUse: ['A static mesh must use Nanite; use convert_to_nanite.'],
-        inputProps: { actorName: P.actorName, outputPath: P.outputPath, targetActor: P.targetActor, materials: CONVERT_MATERIALS, collision: CONVERT_COLLISION }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        outputProps: {
-            assetPath: { type: 'string', description: 'Path of the new static mesh asset.' },
-            naniteEnabled: { type: 'boolean', description: 'Whether Nanite is on for the asset.' },
-            collision: { type: 'string', description: 'Collision the asset got.' },
-            slots: { type: 'array', description: 'The asset\'s material slots; an empty material is the default material.', items: SLOT },
-            partWarnings: MESH_USER_WARNINGS,
-        },
-        exampleInput: { action: 'convert_to_static_mesh', targetActor: 'DM_A', outputPath: '/Game/Meshes/SM_Baked', materials: ['/Engine/BasicShapes/BasicShapeMaterial'] },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'split_mesh', plugins: PLUGIN,
-        topics: ['split mesh', 'separate mesh parts', 'break a mesh apart', 'mesh pack into separate props', 'split mesh by material'],
-        family: F, summary: 'Split a static mesh asset into one static mesh per connected part (or per material slot), each with its own pivot, the materials it uses and a collision choice.',
-        whenToUse: ['A library pack or kit came in as one static mesh and its props must be placed one by one: split it, then place each new mesh (offset says where its pivot stood in the source, so the original layout can be rebuilt).',
-            'A mesh must be separated by material slot (by material).'],
-        whenNotToUse: ['A dynamic mesh actor being modelled must become an asset (use convert_to_static_mesh).'],
-        inputProps: {
-            meshPath: { type: 'string', description: 'The static mesh asset to split; it is not changed.' },
-            by: { type: 'string', enum: ['parts', 'material'], description: 'parts (default): one mesh per separate object, where connected pieces whose bounds touch or come within gap cm are one object (a crate\'s planks stay one crate); material: one per material slot.' },
-            gap: { type: 'number', description: 'With by parts: pieces whose bounds come within this many cm of each other are one object (default 2).' },
-            outputPath: { type: 'string', description: 'Folder for the new meshes (default: the folder of the source mesh).' },
-            namePrefix: { type: 'string', description: 'Names are <namePrefix>01, <namePrefix>02 ..., largest part first (default <source name>_Part); a name already taken refuses the split before anything is made.' },
-            pivot: { type: 'string', enum: ['bottom', 'center', 'source'], description: 'Each new mesh\'s pivot: bottom (default), the bottom centre of its bounds, so it stands on what it is placed on; center; or source, the source\'s own origin.' },
-            minTriangles: { type: 'number', description: 'Objects with fewer triangles are left out (default 12): loose bits, decal cards.' },
-            maxParts: { type: 'number', description: 'More parts than this (default 64) refuses the split with nothing made.' },
-            dropRepeats: { type: 'boolean', description: 'Leave out an object that only repeats a larger one where it stands, such as an LOD copy an importer merged into the mesh (default true).' },
-            dryRun: { type: 'boolean', description: 'Answer the meshes the split would make (size, triangles, offset, and exists when the name is taken) and create nothing, to tune gap and minTriangles first. A large pack can take longer than one call waits.' },
-            collision: CONVERT_COLLISION,
-        },
-        required: ['meshPath'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        outputProps: {
-            meshPath: { type: 'string', description: 'The source mesh.' },
-            meshes: { type: 'array', description: 'One entry per new mesh, largest first: assetPath, triangles, size [x, y, z], offset [x, y, z] (its pivot in the source\'s space), slots; saved: false when it could not be written to disk.', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true } },
-            skippedSmall: { type: 'number', description: 'Objects left out for having fewer than minTriangles triangles.' },
-            droppedRepeats: { type: 'number', description: 'Objects left out as repeats of a larger one.' },
-        },
-        exampleInput: { action: 'split_mesh', meshPath: '/Game/Imports/SM_CratePack', outputPath: '/Game/Props/Crates', namePrefix: 'SM_Crate' },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'get_mesh_info', plugins: PLUGIN,
-        topics: ['vertex count', 'triangle count', 'has uvs and normals', 'how many vertices does a mesh have'],
-        family: F, summary: 'Read a procedural DynamicMesh actor: vertex count and triangle count, and whether it has normals, UV sets, vertex colors and polygroups.', whenToUse: ['Mesh stats must be inspected.'], whenNotToUse: ['The mesh must be modified.'],
-        inputProps: { actorName: P.actorName, targetActor: P.targetActor }, required: [], requiredOneOf: ['actorName', 'targetActor'], effect: 'read', costLatency: 'instant', costResources: 'low',
-        exampleInput: { action: 'get_mesh_info', targetActor: 'DM_A' }, exampleOutput: { success: true, message: 'Mesh info', vertexCount: 1200, triangleCount: 2400 },
-        outputProps: {
-            vertexCount: { type: 'number', description: 'Vertex count.' },
-            triangleCount: { type: 'number', description: 'Triangle count.' },
-        },
-    }),
-];
-//# sourceMappingURL=manage-geometry.optimize.data.js.map

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

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

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

@@ -1,166 +0,0 @@
-import { buildWorldRecord } from './builder.js';
-import { P } from './properties.js';
-const F = 'primitives';
-const PLUGIN = ['GeometryScripting'];
-const IDENT = { name: P.name };
-const XFORM = { location: P.location, rotation: P.rotation, scale: P.scale };
-const cm = (d) => ({ type: 'number', description: d });
-const vec = (d) => ({ type: 'object', description: d, properties: { x: cm('X'), y: cm('Y'), z: cm('Z') }, additionalProperties: false });
-const SDF_SHAPES = {
-    type: 'array', minItems: 1, maxItems: 64,
-    description: 'Shapes combined in order onto shapes[0] (which must be a union) as one signed distance field, then meshed. ' +
-        'Sizes are cm in the mesh\'s local space. Each joined shape takes a blend: the radius of the soft fillet where it meets what came before. ' +
-        'An entry with mirror or repeat stands for all its copies (at most 1024 shapes in all), applied in its place in the order.',
-    items: {
-        type: 'object', required: ['type'], additionalProperties: false,
-        properties: {
-            type: { type: 'string', enum: ['sphere', 'ellipsoid', 'box', 'capsule', 'cylinder', 'torus', 'cone'], description: 'sphere (radius), ellipsoid (radii), box (extent = half size, rounding), capsule (radius, length of the straight part, along local Z), cylinder (radius, length, rounding, along local Z), torus (radius to the tube centre, thickness = tube radius, in local XY), cone (radius at the bottom, topRadius, length, along local Z, rounded ends).' },
-            operation: { type: 'string', enum: ['union', 'subtract', 'intersect'], description: 'union adds the shape (default), subtract carves it out of what came before (a recess, socket or groove), intersect keeps only the overlap.' },
-            center: vec('Shape centre in the mesh\'s local space, cm (default 0,0,0).'),
-            rotation: { type: 'object', description: 'Shape rotation {pitch, yaw, roll} in degrees; turns the shape\'s local Z axis for capsule, cylinder, cone and torus.', properties: { pitch: cm('Pitch'), yaw: cm('Yaw'), roll: cm('Roll') }, additionalProperties: false },
-            radius: cm('Radius in cm (sphere, capsule, cylinder, cone base; torus: distance to the tube centre). Default 50.'),
-            radii: vec('Ellipsoid radii along local X, Y, Z in cm.'),
-            extent: vec('Box half size along local X, Y, Z in cm.'),
-            rounding: cm('Box or cylinder edge rounding radius in cm (0 = sharp).'),
-            length: cm('Capsule straight length, cylinder or cone height, in cm (default 100).'),
-            topRadius: cm('Cone radius at the top in cm (0 = point; larger than radius widens upward).'),
-            thickness: cm('Torus tube radius in cm (default 10).'),
-            blend: cm('Smooth-join radius in cm with the shapes before it: 0 is a hard edge; a few cm reads as a soft fillet on a union and as a rounded rim on a subtract.'),
-            materialId: { type: 'integer', minimum: 0, maximum: 63, description: 'Material slot of the surface this shape forms (default 0). A subtract shape owns the surface it carves, so a carved visor can take its own slot.' },
-            mirror: {
-                type: 'array', minItems: 1, maxItems: 3, items: { type: 'string', enum: ['x', 'y', 'z'] },
-                description: 'Also add this shape reflected across the mesh\'s own plane through the origin normal to each listed axis ("y" mirrors y to -y): both eyes, both ears or a pair of legs from one entry. Each axis doubles the copies so far, so ["x","y"] gives four; repeat copies are mirrored too.',
-            },
-            repeat: {
-                type: 'object', additionalProperties: false, required: ['count'],
-                description: 'Copies of this shape with the same size, blend, operation and materialId: a row with offset, or a ring with axis. A row of stitches, rivets round a rim or curls round a head is one entry. The reply\'s parts[] still lists one entry per shapes[] item, with copies.',
-                properties: {
-                    count: { type: 'integer', minimum: 2, maximum: 256, description: 'How many, the shape itself included.' },
-                    offset: vec('Row: each copy moves this much further from the previous one, cm.'),
-                    axis: { type: 'string', enum: ['x', 'y', 'z'], description: 'Ring: turn the copies about this mesh axis through pivot (each copy turns with it).' },
-                    angle: cm('Ring: total sweep in degrees (default 360, evenly spaced all round; a smaller arc puts the last copy at its end).'),
-                    pivot: vec('Ring: a point on the turning axis, cm (default 0,0,0).'),
-                },
-            },
-        },
-    },
-};
-export const GEOMETRY_PRIMITIVES_RECORDS = [
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_box', plugins: PLUGIN,
-        topics: ['box mesh', 'cube mesh', 'procedural box', 'geometry cube'],
-        family: F, summary: 'Create a box dynamic mesh actor.', whenToUse: ['A box primitive must be created.'], whenNotToUse: ['A sphere is needed; use create_sphere.'],
-        inputProps: { ...IDENT, ...XFORM, dimensions: P.dimensions, width: P.width, height: P.boxHeight, depth: P.depth, widthSegments: P.widthSegments, heightSegments: P.heightSegments, depthSegments: P.depthSegments }, required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_box', dimensions: { x: 100, y: 100, z: 100 } },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_sphere', plugins: PLUGIN,
-        family: F, summary: 'Create a sphere dynamic mesh actor.', whenToUse: ['A sphere primitive must be created.'], whenNotToUse: ['A box is needed; use create_box.'],
-        inputProps: { ...IDENT, ...XFORM, radius: P.radius, radialSegments: P.radialSegments, numRings: P.numRings }, required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_sphere', radius: 50 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_cylinder', plugins: PLUGIN,
-        family: F, summary: 'Create a cylinder dynamic mesh actor.', whenToUse: ['A cylinder primitive must be created.'], whenNotToUse: ['A cone is needed; use create_cone.'],
-        inputProps: { ...IDENT, ...XFORM, radius: P.radius, height: P.height, numSides: P.numSides }, required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_cylinder', radius: 50, height: 200 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_cone', plugins: PLUGIN,
-        family: F, summary: 'Create a cone dynamic mesh actor.', whenToUse: ['A cone primitive must be created.'], whenNotToUse: ['A cylinder is needed; use create_cylinder.'],
-        inputProps: { ...IDENT, ...XFORM, radius: P.radius, baseRadius: P.baseRadius, topRadius: P.topRadius, height: P.height, numSides: P.numSides }, required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_cone', radius: 50, height: 200 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_capsule', plugins: PLUGIN,
-        family: F, summary: 'Create a capsule dynamic mesh actor.', whenToUse: ['A capsule primitive must be created.'], whenNotToUse: ['A sphere is needed; use create_sphere.'],
-        inputProps: { ...IDENT, ...XFORM, radius: P.radius, length: P.length, height: P.height, radialSegments: P.radialSegments, numRings: P.numRings, heightSegments: P.heightSegments }, required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_capsule', radius: 50, height: 200 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_torus', plugins: PLUGIN,
-        family: F, summary: 'Create a torus dynamic mesh actor.', whenToUse: ['A torus primitive must be created.'], whenNotToUse: ['A ring is needed; use create_ring.'],
-        inputProps: { ...IDENT, ...XFORM, radius: P.radius, innerRadius: P.innerRadius, angle: { type: 'number', description: 'Sweep angle in degrees (default 360, a full torus; less makes an open segment).' }, numSides: P.numSides, radialSegments: P.radialSegments, numRings: P.numRings }, required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_torus', radius: 100, innerRadius: 20 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_plane', plugins: PLUGIN,
-        family: F, summary: 'Create a plane dynamic mesh actor: flat in XY, centred on its origin, facing +Z.', whenToUse: ['A flat plane primitive must be created.', 'A sign, banner or flag needs a subdivided sheet: stand the plane up with a 90 degree roll on the component that draws it.'], whenNotToUse: ['A box is needed; use create_box.'],
-        inputProps: { ...IDENT, ...XFORM, width: P.width, depth: P.depth, widthSegments: P.widthSegments, heightSegments: P.heightSegments }, required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_plane', width: 500, depth: 500 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_disc', plugins: PLUGIN,
-        family: F, summary: 'Create a disc dynamic mesh actor.', whenToUse: ['A circular disc primitive must be created.'], whenNotToUse: ['A plane is needed; use create_plane.'],
-        inputProps: { ...IDENT, ...XFORM, radius: P.radius, innerRadius: { type: 'number', description: 'Radius of a centred hole (default 0, a solid disc).' }, numSides: P.numSides }, required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_disc', radius: 100 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_stairs', plugins: PLUGIN,
-        family: F, summary: 'Create a stairs dynamic mesh actor.', whenToUse: ['A stair primitive must be created.'], whenNotToUse: ['A ramp is needed; use create_ramp.'],
-        inputProps: { ...IDENT, ...XFORM, steps: P.steps, numSteps: P.numSteps, stepWidth: P.stepWidth, stepHeight: P.stepHeight, stepDepth: P.stepDepth, floating: P.floating }, required: ['steps'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_stairs', steps: 10, stepWidth: 200, stepHeight: 20, stepDepth: 30 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_spiral_stairs', plugins: PLUGIN,
-        family: F, summary: 'Create a spiral stairs dynamic mesh actor.', whenToUse: ['A spiral stair primitive must be created.'], whenNotToUse: ['A straight stair is needed; use create_stairs.'],
-        inputProps: { ...IDENT, ...XFORM, steps: P.steps, numSteps: P.numSteps, radius: P.radius, innerRadius: P.innerRadius, numTurns: P.numTurns, stepWidth: P.stepWidth, stepHeight: P.stepHeight, floating: P.floating }, required: ['steps'], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_spiral_stairs', steps: 20, radius: 200 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_ring', plugins: PLUGIN,
-        family: F, summary: 'Create a ring dynamic mesh actor.', whenToUse: ['A ring/annulus primitive must be created.'], whenNotToUse: ['A torus is needed; use create_torus.'],
-        inputProps: { ...IDENT, ...XFORM, innerRadius: P.innerRadius, outerRadius: P.outerRadius, numSides: P.numSides }, required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_ring', innerRadius: 80, outerRadius: 100 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_arch', plugins: PLUGIN,
-        family: F, summary: 'Create an arch dynamic mesh actor.', whenToUse: ['An arch primitive must be created.'], whenNotToUse: ['A pipe is needed; use create_pipe.'],
-        inputProps: { ...IDENT, ...XFORM, radius: P.radius, innerRadius: P.innerRadius, angle: P.angle, numSides: P.numSides, radialSegments: P.radialSegments, numRings: P.numRings }, required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_arch', radius: 300, innerRadius: 50, angle: 180 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_pipe', plugins: PLUGIN,
-        family: F, summary: 'Create a pipe dynamic mesh actor.', whenToUse: ['A pipe/tube primitive must be created.'], whenNotToUse: ['A cylinder is needed; use create_cylinder.'],
-        inputProps: { ...IDENT, ...XFORM, radius: P.radius, innerRadius: P.innerRadius, outerRadius: P.outerRadius, height: P.height, numSides: P.numSides, heightSegments: P.heightSegments }, required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_pipe', radius: 30, height: 400 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_ramp', plugins: PLUGIN,
-        family: F, summary: 'Create a ramp dynamic mesh actor.', whenToUse: ['A ramp primitive must be created.'], whenNotToUse: ['A stair is needed; use create_stairs.'],
-        inputProps: { ...IDENT, ...XFORM, width: P.width, length: P.length, height: P.height }, required: [], effect: 'write', costLatency: 'interactive', costResources: 'low',
-        exampleInput: { action: 'create_ramp', width: 100, length: 200, height: 50 },
-    }),
-    buildWorldRecord({
-        parentTool: 'manage_geometry', action: 'create_sdf', plugins: PLUGIN,
-        topics: ['sdf', 'signed distance field', 'smooth union', 'blend shapes', 'organic mesh', 'fillet', 'metaball', 'rounded character part'],
-        family: F,
-        summary: 'Create one smooth organic mesh actor from blended shapes (a signed distance field): spheres, ellipsoids, rounded boxes, capsules, cylinders, tori and cones joined with soft fillets, carved with rounded recesses, or intersected, each shape with its own material slot.',
-        whenToUse: ['A smooth organic or toy-like form must be modelled from several parts that flow into each other: a helmet, a hand, a shoe, a character body, a rounded prop.', 'A recess, socket or groove with a soft rim must be carved into a rounded form (subtract with blend), for example a visor.'],
-        whenNotToUse: ['One plain primitive is enough; use that primitive.', 'Hard mechanical parts with exact flat faces; use primitives with bevel and booleans.'],
-        inputProps: { ...IDENT, ...XFORM, shapes: SDF_SHAPES, resolution: { type: 'integer', minimum: 16, maximum: 256, description: 'Grid cells along the longest side of the shapes\' bounds (default 128, 16-256): higher is finer and slower; 160-200 suits a hero part.' } },
-        outputProps: {
-            parts: {
-                type: 'array', description: 'One entry per shape, saying which surface it formed.',
-                items: {
-                    type: 'object', additionalProperties: false,
-                    properties: {
-                        shape: { type: 'integer', description: 'Index into shapes.' },
-                        groupId: { type: 'integer', description: 'Polygroup of the surface this shape formed (index+1).' },
-                        materialId: { type: 'integer', description: 'Material slot of that surface.' },
-                        triangles: { type: 'integer', description: 'Triangles of that surface; 0 when another shape covered it entirely.' },
-                        copies: { type: 'integer', description: 'How many shapes this entry became with its repeat and mirror (the shape itself included); absent for a single shape.' },
-                        warning: { type: 'string', description: 'Present when a union shape is under two grid cells across: its surface can come out ragged, or as almost nothing when it formed under 24 triangles; raise resolution or thicken it.' },
-                    },
-                },
-            },
-            resolution: { type: 'integer', description: 'Grid cells along the longest side, as used.' },
-            cellSize: cm('Grid cell size in cm.'),
-            vertexCount: { type: 'integer', description: 'Vertices in the mesh.' },
-            triangleCount: { type: 'integer', description: 'Triangles in the mesh.' },
-        },
-        required: ['shapes'], effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'create_sdf', name: 'Mitten', resolution: 160, shapes: [{ type: 'ellipsoid', radii: { x: 9, y: 4, z: 10 } }, { type: 'capsule', center: { x: 7, y: 0, z: -2 }, rotation: { pitch: 60, yaw: 0, roll: 0 }, radius: 3, length: 6, blend: 3 }] },
-    }),
-];
-//# sourceMappingURL=manage-geometry.primitives.data.js.map

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

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

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

@@ -1,10 +0,0 @@
-import { LEVEL_STRUCTURE_RECORDS } from './manage-level-structure.structure.data.js';
-import { LEVEL_VOLUME_RECORDS } from './manage-level-structure.volume.data.js';
-import { applyFolds } from '../shared/fold.js';
-import { MANAGE_LEVEL_STRUCTURE_FOLDS } from '../folds/manage-level-structure.folds.js';
-export const MANAGE_LEVEL_STRUCTURE_UNFOLDED_SOURCES = [
-    ...LEVEL_STRUCTURE_RECORDS,
-    ...LEVEL_VOLUME_RECORDS,
-];
-export const MANAGE_LEVEL_STRUCTURE_SOURCES = applyFolds(MANAGE_LEVEL_STRUCTURE_UNFOLDED_SOURCES, MANAGE_LEVEL_STRUCTURE_FOLDS, 'manage_level_structure');
-//# sourceMappingURL=manage-level-structure.index.js.map

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

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