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

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

@@ -1,305 +0,0 @@
-import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
-import { bool, num, str } from '../shared/schema-props.js';
-import { DOMAIN, P } from './properties.js';
-const FAMILY_SPAWN = 'spawn';
-const FAMILY_LIFECYCLE = 'lifecycle';
-const SPAWN_UNDO = {
-    type: 'object',
-    additionalProperties: true,
-    'x-unreal-reflection-boundary': true,
-    description: 'Whether editor undo takes the spawn back: {undoable: true, transactionScope: "Spawn Actors"} (control_editor undo removes every actor the call made), or {undoable: false, reasonCode, reason}.',
-};
-const SPAWN_PLACEMENT = {
-    groundZ: num('Z of the solid surface under the actor; absent when nothing is below it.'),
-    groundClearance: num('How far the bottom of the actor\'s bounds sits above that surface; negative means it is sunk into it.'),
-    placementWarning: str('Present when the placement looks wrong: it intersects other actors, is sunk below the surface under it (the bottom of its bounds is under it, wherever its pivot is; suggestedLocation rests it), floats more than 50 units above it, or has nothing below it (an actor held up from the side is mounted, never floating: see mountedOn). A water body is a surface, not a solid: an actor partly under water (a buoy, a hull, a wading pawn) is neither intersecting nor sunk, and groundZ is the water level. Tag the actor mcp.placement.ok when that is deliberate and it is never reported.'),
-    mountedOn: str('The actor this one hangs on from the side (a window band flush on a hall, an awning on a facade): its bounds touch or overlap that actor\'s vertical face, so it is held up and is not reported floating or without a surface below. Present only then.'),
-    overlappingActors: {
-        type: 'array',
-        items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-        'x-unreal-reflection-boundary': true,
-        description: 'The actors it intersects (up to 8): actorName, actorClass, penetrationDepth.',
-    },
-    suggestedLocation: {
-        type: 'object',
-        additionalProperties: true,
-        'x-unreal-reflection-boundary': true,
-        description: 'The actor location (x, y, z) that rests the actor on the surface under it: its own location raised by the depth it is sunk, whatever its pivot. Present only when it is sunk.',
-    },
-};
-export const SPAWN_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'spawn',
-        editorStates: ANY_EDITOR_STATE,
-        domain: DOMAIN,
-        family: FAMILY_SPAWN,
-        topics: ['spawn actor', 'place actor', 'add actor to level', 'create actor', 'spawn cube', 'spawn static mesh', 'instantiate class'],
-        summary: 'Spawn a new actor instance from a class path into the current level, or a mesh actor from a mesh path alone.',
-        whenToUse: [
-            'A new actor of a known Unreal class must be created in the scene.',
-            'A static or skeletal mesh must be placed as its own actor (meshPath alone; the actor class follows the mesh).',
-        ],
-        whenNotToUse: ['A Blueprint instance is needed (use spawn_blueprint).'],
-        inputProps: {
-            classPath: P.classPath,
-            actorClass: P.actorClass,
-            actorName: P.actorName,
-            meshPath: P.meshPath,
-            location: P.location,
-            rotation: P.rotation,
-            scale: P.scale,
-        },
-        required: [],
-        requiredOneOf: ['classPath', 'actorClass', 'meshPath'],
-        outputProps: { name: P.actorName, undo: SPAWN_UNDO, ...SPAWN_PLACEMENT },
-        outputRequired: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        exampleInput: {
-            action: 'spawn',
-            classPath: '/Script/Engine.PointLight',
-            actorName: 'MyLight',
-            location: [0, 0, 100],
-        },
-        exampleOutput: {
-            success: true,
-            message: 'Spawned actor: MyLight',
-            name: 'MyLight',
-        },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'spawn_blueprint',
-        editorStates: ANY_EDITOR_STATE,
-        domain: DOMAIN,
-        family: FAMILY_SPAWN,
-        topics: ['spawn blueprint actor', 'place blueprint in level', 'instantiate blueprint'],
-        summary: 'Spawn an actor instance from a Blueprint asset path into the current level.',
-        whenToUse: ['A Blueprint instance must be placed in the scene.'],
-        whenNotToUse: ['A native class instance is needed (use spawn).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath,
-            actorName: P.actorName,
-            location: P.location,
-            rotation: P.rotation,
-            scale: P.scale,
-        },
-        required: ['blueprintPath'],
-        requiredOneOf: ['blueprintPath'],
-        outputProps: { name: P.actorName, undo: SPAWN_UNDO, ...SPAWN_PLACEMENT },
-        outputRequired: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        exampleInput: {
-            action: 'spawn_blueprint',
-            blueprintPath: '/Game/Blueprints/BP_Lamp',
-            actorName: 'Lamp1',
-        },
-        exampleOutput: {
-            success: true,
-            message: 'Spawned blueprint: Lamp1',
-            name: 'Lamp1',
-        },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'spawn_batch',
-        editorStates: ANY_EDITOR_STATE,
-        domain: DOMAIN,
-        family: FAMILY_SPAWN,
-        topics: ['spawn many actors', 'batch spawn', 'place many actors', 'lay out level', 'build level layout'],
-        summary: 'Spawn many actors in one call; each item is a spawn payload, optionally with a material, Blueprint variables, outliner folder and tags.',
-        whenToUse: ['More than a couple of actors must be placed, such as laying out a level.'],
-        whenNotToUse: ['A single actor is needed (use spawn).'],
-        inputProps: {
-            actors: {
-                type: 'array',
-                items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-                'x-unreal-reflection-boundary': true,
-                description: 'Actors to spawn, 1-500. Each is a spawn payload: classPath, blueprintPath or meshPath, plus '
-                    + 'actorName, location, rotation, scale ([x, y, z] arrays). Optional per item: materialPath (applied like '
-                    + 'set_material; componentName/materialSlot/allComponents narrow it), variables ({name: value} Blueprint '
-                    + 'variables set on the new instance, like set_blueprint_variables; in a running game they are set before its '
-                    + 'BeginPlay, so it starts with them), folder (outliner folder path), tags '
-                    + '(actor tags; delete_by_tag removes the batch again). Items that fail are reported; the rest still spawn.',
-            },
-            defaults: {
-                type: 'object',
-                additionalProperties: true,
-                'x-unreal-reflection-boundary': true,
-                description: 'Fields shared by every item (e.g. meshPath, materialPath, folder, tags); an item\'s own fields win.',
-            },
-            report: {
-                type: 'string',
-                enum: ['all', 'failures'],
-                description: 'Which items results lists: all (default), or failures only (items that failed to spawn or to take '
-                    + 'their material or variables, and items with a placementWarning); spawned and failed still count every item. '
-                    + 'Use failures for big layouts.',
-            },
-        },
-        required: ['actors'],
-        requiredOneOf: ['actors'],
-        outputProps: {
-            spawned: num('Actors spawned.'),
-            failed: num('Items that failed to spawn or to take their material.'),
-            placementWarnings: num('Items that spawned but look misplaced (sunk into the surface under them, floating, intersecting other actors or with nothing below); each carries its placementWarning in results. A warning is not a failure: it changes neither failed nor success.'),
-            results: {
-                type: 'array',
-                items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-                'x-unreal-reflection-boundary': true,
-                description: 'Per item (only the failed ones and those with a placementWarning or ignoredKeys under report: failures): '
-                    + 'index, success, name, path, error, errorCode, variablesSet, variablesError, materialApplied, materialError, '
-                    + 'ignoredKeys (the item\'s keys no spawn reads, such as a "label" meant as actorName), and the placement '
-                    + 'facts set_transform reports (groundZ, groundClearance, placementWarning, overlappingActors, suggestedLocation), '
-                    + 'measured after the item took its tags, variables and material, so an item tagged mcp.placement.ok is never '
-                    + 'reported. name is the label the item asked for, or the unique actor name when it gave no actorName.',
-            },
-            unnamedActors: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'The unique name of every item that gave no actorName, in batch order ("" where it failed), under '
-                    + 'either report mode. Their labels repeat (every cube is "Cube"), so these are the names later calls must use.',
-            },
-            affectedActors: {
-                type: 'array',
-                items: { type: 'string' },
-                description: 'The actors that spawned, by the name each result carries, in batch order and under either report mode; '
-                    + 'the receipt lists them as changes, with an actor handle each (the first 20).',
-            },
-            report: { type: 'string', description: 'Echoes report when it narrowed results.' },
-            undo: SPAWN_UNDO,
-        },
-        outputRequired: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        costResources: 'medium',
-        exampleInput: {
-            action: 'spawn_batch',
-            defaults: { meshPath: '/Engine/BasicShapes/Cube', folder: 'Level/Blocks', tags: ['LevelBlocks'] },
-            actors: [
-                { actorName: 'Block_1', location: [0, 0, 50] },
-                { actorName: 'Block_2', location: [100, 0, 50], materialPath: '/Game/Materials/M_Brick' },
-            ],
-        },
-        exampleOutput: { success: true, message: 'Spawned 2 actors', spawned: 2, failed: 0, affectedActors: ['Block_1', 'Block_2'] },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'duplicate',
-        domain: DOMAIN,
-        family: FAMILY_LIFECYCLE,
-        topics: ['clone actor', 'copy actor', 'make actor copy'],
-        summary: 'Duplicate an existing actor, optionally with a new name and offset.',
-        whenToUse: ['An actor must be copied within the current level.'],
-        whenNotToUse: ['A distinct class instance is needed (use spawn).'],
-        inputProps: {
-            actorName: P.actorName,
-            newName: P.newName,
-            offset: P.offset,
-        },
-        required: ['actorName'],
-        effect: 'write',
-        costLatency: 'interactive',
-        exampleInput: {
-            action: 'duplicate',
-            actorName: 'Cube1',
-            newName: 'Cube2',
-            offset: [100, 0, 0],
-        },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'rename',
-        domain: DOMAIN,
-        family: FAMILY_LIFECYCLE,
-        topics: ['rename actor', 'actor label', 'relabel actor', 'outliner name', 'actor object name', 'give actor a new name', 'change actor name'],
-        summary: 'Rename an actor: its label (the name the Outliner and every other call use), and with renameObject its object name too, which is the name a cooked level ships.',
-        whenToUse: [
-            'An actor should go by a different name.',
-            'A Blueprint class was renamed and its placed actors still carry the old class in their object names (BP_OldName_C_3): rename each with renameObject, then save the level.',
-        ],
-        whenNotToUse: ['A copy under a new name is wanted (use duplicate with newName).'],
-        inputProps: {
-            actorName: P.actorName,
-            newName: str('The new label; letters, digits, spaces and underscores are safe.'),
-            renameObject: bool('Also rename the object itself to newName, made valid and unique (default false: the label only). The label is editor-only; the object name ships in the cooked level. References from inside the same level follow the rename, a Level Sequence binding or a soft reference by the old path does not. An actor saved in its own package (World Partition) keeps its object name, with a note.'),
-        },
-        required: ['actorName', 'newName'],
-        outputProps: {
-            actorName: str('The actor as later calls should name it.'),
-            label: str('The label now.'),
-            oldLabel: str('The label before.'),
-            objectName: str('The object name now.'),
-            oldObjectName: str('The object name before.'),
-            actorPath: str('Full object path of the actor.'),
-            note: str('Why the object name was kept, when renameObject could not rename it.'),
-        },
-        outputRequired: [],
-        effect: 'write',
-        costLatency: 'instant',
-        exampleInput: { action: 'rename', actorName: 'BP_OldEnemy_C_6', newName: 'Enemy_01', renameObject: true },
-        exampleOutput: { success: true, message: 'Actor renamed', actorName: 'Enemy_01', label: 'Enemy_01', oldLabel: 'Enemy_01', objectName: 'Enemy_01', oldObjectName: 'BP_OldEnemy_C_6' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'delete',
-        editorStates: ANY_EDITOR_STATE,
-        domain: DOMAIN,
-        family: FAMILY_LIFECYCLE,
-        topics: ['delete actor', 'destroy actor', 'remove actor from level', 'delete selected actor', 'delete spawned actor', 'delete object'],
-        aliases: ['control_actor.delete_actor'],
-        summary: 'Permanently delete one actor or a batch of actors by name.',
-        whenToUse: ['An actor must be permanently removed from the level.'],
-        whenNotToUse: ['The actor should only be hidden (use set_visibility).'],
-        inputProps: { actorName: P.actorName, actorNames: P.actorNames },
-        required: [],
-        requiredOneOf: ['actorName', 'actorNames'],
-        effect: 'destructive',
-        behavior: { safeToRetry: false },
-        costLatency: 'interactive',
-        exampleInput: { action: 'delete', actorName: 'Cube1' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'destroy_actor',
-        editorStates: ANY_EDITOR_STATE,
-        domain: DOMAIN,
-        family: FAMILY_LIFECYCLE,
-        summary: 'Long-form alias for delete. The bridge dispatches both names to the same handler.',
-        whenToUse: ['Preferred when callers use the explicit destroy_actor verb.'],
-        whenNotToUse: ['Use the shorter delete form to avoid alias normalization.'],
-        inputProps: { actorName: P.actorName, actorNames: P.actorNames },
-        required: [],
-        requiredOneOf: ['actorName', 'actorNames'],
-        effect: 'destructive',
-        behavior: { safeToRetry: false },
-        costLatency: 'interactive',
-        exampleInput: { action: 'destroy_actor', actorName: 'Cube1' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'delete_by_tag',
-        editorStates: ANY_EDITOR_STATE,
-        domain: DOMAIN,
-        family: FAMILY_LIFECYCLE,
-        summary: 'Permanently delete every actor matching a gameplay tag, or any of several tags in one call.',
-        whenToUse: ['All actors sharing a tag must be removed in one operation.', 'Actors under several tags must go at once (tags, one consent).'],
-        whenNotToUse: ['A single named actor should be removed (use delete).'],
-        inputProps: {
-            tag: P.tag,
-            tags: { type: 'array', items: { type: 'string' }, description: 'Several actor tags at once, in place of tag: every actor carrying any of them is deleted under one consent.' },
-        },
-        required: [],
-        requiredOneOf: ['tag', 'tags'],
-        effect: 'destructive',
-        behavior: { safeToRetry: false },
-        costLatency: 'interactive',
-        exampleInput: { action: 'delete_by_tag', tag: 'Disposable' },
-        exampleOutput: {
-            success: true,
-            message: 'Deleted actors by tag: Disposable',
-        },
-    }),
-];
-//# sourceMappingURL=spawn-records.js.map

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

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

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

@@ -1,129 +0,0 @@
-import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
-import { DOMAIN, P } from './properties.js';
-const FAMILY_VISIBILITY = 'visibility';
-const FAMILY_QUERY = 'query';
-const COMPONENT_NAMES = { type: 'array', items: { type: 'string' }, description: 'Return only these components, by name (case-insensitive); a name that matches none is listed under missingComponents.' };
-const MISSING_COMPONENTS = { type: 'array', items: { type: 'string' }, description: 'componentNames that matched no component.' };
-const VISIBILITY_ACTOR_NAMES = { type: 'array', items: { type: 'string' }, description: 'Several actors to show or hide in one call and one undo step, in place of actorName; names not found are listed back under missing, and the actors changed under affectedActors (which the receipt lists as changes, with an actor handle each).' };
-const LISTED_ACTORS = {
-    ...P.actors,
-    items: {
-        ...P.actors.items,
-        properties: {
-            ...P.actors.items.properties,
-            distance: { type: 'number', description: 'With near: world units from the point to the actor\'s bounding box, 0 when the box contains it. Rows are sorted by it, nearest first; of equally near actors the smaller box comes first, so the level-wide foliage actor, which contains every point, trails.' },
-        },
-    },
-    description: 'Matched actors; with near, nearest first, each with its distance.',
-};
-const COUNT_ROW = {
-    type: 'object',
-    properties: { name: { type: 'string', description: 'Class, tag or folder.' }, count: { type: 'number', description: 'Matching actors.' } },
-    required: ['name', 'count'],
-    additionalProperties: false,
-};
-export const STATE_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'set_visibility',
-        domain: DOMAIN,
-        family: FAMILY_VISIBILITY,
-        topics: ['hide actor', 'show actor', 'toggle visibility', 'hidden in game', 'make actor invisible', 'unhide actor'],
-        aliases: ['control_actor.hide_actor', 'control_actor.show_actor'],
-        summary: 'Toggle the visibility of an actor in the level, or of many actors at once with actorNames.',
-        whenToUse: ['An actor must be shown or hidden without being deleted.', 'Many actors must be shown or hidden together (actorNames does them in one call).'],
-        whenNotToUse: ['The actor should be removed (use delete).'],
-        inputProps: { actorName: P.actorName, actorNames: VISIBILITY_ACTOR_NAMES, visible: P.visible },
-        required: [],
-        requiredOneOf: ['actorName', 'actorNames'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'set_visibility', actorName: 'Cube1', visible: false },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'set_actor_visible',
-        domain: DOMAIN,
-        family: FAMILY_VISIBILITY,
-        summary: 'Alias of set_visibility. The bridge dispatches both names to the same handler.',
-        whenToUse: ['Preferred when callers use the explicit set_actor_visible verb.'],
-        whenNotToUse: ['Use set_visibility to avoid alias normalization.'],
-        inputProps: { actorName: P.actorName, actorNames: VISIBILITY_ACTOR_NAMES, visible: P.visible },
-        required: [],
-        requiredOneOf: ['actorName', 'actorNames'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'set_actor_visible', actorName: 'Cube1', visible: true },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'get_components',
-        domain: DOMAIN,
-        family: FAMILY_QUERY,
-        summary: 'List all components attached to an actor with their relative transforms.',
-        whenToUse: ['The component composition of an actor must be inspected.'],
-        whenNotToUse: ['A single component property is needed (use get_component_property).'],
-        inputProps: { actorName: P.actorName, componentNames: COMPONENT_NAMES },
-        required: ['actorName'],
-        outputProps: { components: P.components, missingComponents: MISSING_COMPONENTS },
-        outputRequired: [],
-        effect: 'read',
-        exampleInput: { action: 'get_components', actorName: 'Cube1' },
-        exampleOutput: { success: true, message: 'Components for Cube1', components: [{ name: 'StaticMesh', class: 'StaticMeshComponent' }] },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'get_actor_bounds',
-        domain: DOMAIN,
-        family: FAMILY_QUERY,
-        summary: 'Read the world-space bounding box of an actor; normalizes to get_bounding_box.',
-        whenToUse: ['The spatial extent of an actor must be measured.'],
-        whenNotToUse: ['The actor has no renderable components (bounds are undefined).'],
-        inputProps: { actorName: P.actorName },
-        required: ['actorName'],
-        outputProps: {
-            origin: { type: 'array', items: { type: 'number' }, minItems: 3, maxItems: 3, description: 'World-space centre of the bounding box as [x, y, z].' },
-            extent: { type: 'array', items: { type: 'number' }, minItems: 3, maxItems: 3, description: 'Half-size of the bounding box along each axis as [x, y, z].' },
-        },
-        outputRequired: [],
-        effect: 'read',
-        exampleInput: { action: 'get_actor_bounds', actorName: 'Cube1' },
-        exampleOutput: { success: true, message: 'Bounds for Cube1', origin: [0, 0, 50], extent: [50, 50, 50] },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'list',
-        editorStates: ANY_EDITOR_STATE,
-        domain: DOMAIN,
-        family: FAMILY_QUERY,
-        topics: ['list actors', 'all actors in level', 'actors in scene', 'enumerate actors', 'world outliner', 'actors in level', 'level actors', 'actor positions', 'actor locations', 'actor transforms', 'level layout', 'variable values of many actors', 'how many actors', 'count actors', 'actors in the level', 'actors near point', 'count enemies'],
-        aliases: ['control_actor.list_actors'],
-        summary: 'List actors in the current level with their label, class, location, rotation and scale, plus any propertyNames values, narrowed by name filter, tag, class or outliner folder; page on with offset. near (a world point) with radius is how to find what is near a point, nearest first, each with its distance. summary counts the level by class, tag and folder instead.',
-        whenToUse: ['The actors present in the level must be enumerated.', 'Every actor with one tag, of one class or in one outliner folder must be found, for example to see what a delete_by_tag would remove.', 'Something seen in a screenshot or at a coordinate must be identified: list the actors near that point, nearest first.'],
-        whenNotToUse: ['A specific known actor name is already available (use find_by_name).'],
-        inputProps: {
-            limit: P.limit, filter: P.filter, offset: { type: 'number', description: 'Skip this many matching actors; the next page starts at nextOffset from the previous reply.' },
-            tag: { type: 'string', description: 'Only actors carrying this actor tag. With summary, shows what the tag covers before a delete_by_tag removes it.' },
-            className: { type: 'string', description: 'Only actors of this class or a subclass, by name or path: TextRenderActor, Light (every light type), or a Blueprint such as BP_Sign, with or without _C.' },
-            folder: { type: 'string', description: 'Only actors in this outliner folder or a folder under it (Level/Stage matches Level/Stage/Signs); "(none)" for the actors at the root.' },
-            propertyNames: { type: 'array', items: { type: 'string' }, description: 'Property or Blueprint variable names to read on every listed actor, returned per actor under properties, e.g. Kind and Content, or a component\'s as "Component.Property" (StaticMeshComponent.LDMaxDrawDistance, Visual.RelativeScale3D; the component by its name, or by the actor property that holds it, as CharacterMovement.MaxWalkSpeed), keyed as asked. A name that an actor lacks, or whose component it lacks, is listed under missingProperties for that actor.' },
-            near: { ...P.location, description: 'A world point as [x, y, z] (an {x, y, z} object works too): list what is close to it, nearest first, each row with its distance. With radius, only actors whose bounds come within radius of the point; without it, every matching actor sorted by distance. Combines with filter, tag, className and folder.' },
-            radius: { type: 'number', minimum: 0, description: 'World units from near: an actor is listed when its bounding box comes within this distance of the point (the distance is 0 for a box that contains the point, such as a floor slab under it). Needs near.' },
-            summary: { type: 'boolean', description: 'Count the matching actors by class, actor tag and outliner folder (byClass, byTag, byFolder) instead of listing them; limit and offset do not apply. The cheap first look at an unfamiliar level.' },
-        },
-        required: [],
-        outputProps: {
-            actors: LISTED_ACTORS, count: P.count, totalCount: P.totalCount, excludedCount: P.excludedCount, isPieWorld: P.isPieWorld, worldName: P.worldName, filter: P.filter,
-            hasMore: { type: 'boolean', description: 'More matching actors exist past this page.' },
-            nextOffset: { type: 'number', description: 'The offset of the next page; present only when hasMore.' },
-            byClass: { type: 'array', items: COUNT_ROW, description: 'summary: matching actors per class, as {name, count} rows sorted by name.' },
-            byTag: { type: 'array', items: COUNT_ROW, description: 'summary: matching actors per actor tag, as {name, count} rows sorted by name.' },
-            byFolder: { type: 'array', items: COUNT_ROW, description: 'summary: matching actors per outliner folder, as {name, count} rows sorted by name ("(none)" for the root).' },
-        },
-        outputRequired: [],
-        effect: 'read',
-        exampleInput: { action: 'list', limit: 50, filter: 'Cube' },
-        exampleOutput: { success: true, message: 'Found 1 actors: Cube1', actors: [{ label: 'Cube1', name: 'Cube1', location: { x: 0, y: 0, z: 50 }, rotation: { pitch: 0, yaw: 0, roll: 0 }, scale: { x: 1, y: 1, z: 1 } }], count: 1, totalCount: 1, excludedCount: 9 },
-    }),
-];
-//# sourceMappingURL=state-records.js.map

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

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