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

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

@@ -1,280 +0,0 @@
-import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
-import { DOMAIN, P } from './properties.js';
-const FAMILY_TRANSFORM = 'transform';
-const FAMILY_PHYSICS = 'physics';
-const OFFSET = {
-    type: 'array', items: { type: 'number' }, minItems: 3, maxItems: 3,
-    description: 'Move by [dx, dy, dz] from where the actor stands now, instead of to an absolute location; give one or the other.',
-};
-const TRANSFORM_INPUT = {
-    actorName: P.pieActorName,
-    location: P.location,
-    offset: OFFSET,
-    rotation: P.rotation,
-    scale: P.scale,
-    actors: {
-        type: 'array',
-        items: {
-            type: 'object',
-            properties: { actorName: P.actorName, location: P.location, offset: OFFSET, rotation: P.rotation, scale: P.scale },
-            required: ['actorName'],
-            additionalProperties: false,
-        },
-        description: 'Many actors in one call, each {actorName, location? or offset?, rotation?, scale?} with its own values (an omitted part keeps its current value); every actor is reported, and the call fails naming any that did not move.',
-    },
-};
-const TRANSFORM_OUTPUT = {
-    success: true,
-    message: 'Actor transform updated',
-    actorName: 'Cube1',
-    location: [10, 20, 30],
-    rotation: [0, 90, 0],
-    scale: [1, 1, 1],
-};
-const TRANSFORM_OUTPUT_PROPS = {
-    actorName: { type: 'string', description: 'Label of the actor whose transform was written.' },
-    location: {
-        type: 'array', items: { type: 'number' },
-        description: 'World location [x, y, z] read back off the actor after the write.',
-    },
-    rotation: {
-        type: 'array', items: { type: 'number' },
-        description: 'World rotation [pitch, yaw, roll] read back off the actor after the write.',
-    },
-    scale: {
-        type: 'array', items: { type: 'number' },
-        description: 'World scale [x, y, z] read back off the actor after the write.',
-    },
-    results: {
-        type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-        description: 'actors: one entry per actor (actorName, success, read-back location/rotation/scale, placementWarning, error).',
-    },
-    movedActors: { type: 'number', description: 'actors: how many actors took their transform.' },
-    affectedActors: {
-        type: 'array', items: { type: 'string' },
-        description: 'actors: the actors that took their transform, each by name and once; the receipt lists them as changes, with an actor handle each.',
-    },
-};
-export const TRANSFORM_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'set_transform',
-        editorStates: ANY_EDITOR_STATE,
-        domain: DOMAIN,
-        family: FAMILY_TRANSFORM,
-        topics: ['move actor', 'set actor location', 'set position', 'rotate actor', 'set rotation', 'scale actor', 'teleport actor', 'translate'],
-        aliases: ['control_actor.move', 'control_actor.move_actor'],
-        summary: 'Move, rotate or scale an actor by setting its world transform (location, rotation, scale) or moving it by an offset, or many actors in one call with actors.',
-        whenToUse: ['An actor must be moved, rotated, or rescaled in one call.', 'Several actors each need their own new location, rotation or scale (actors).', 'A group of actors must shift by the same amount (actors, each with offset).'],
-        whenNotToUse: ['Only the transform needs to be read (use get_transform).'],
-        inputProps: TRANSFORM_INPUT,
-        required: [],
-        requiredOneOf: ['actorName', 'actors'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'set_transform', actorName: 'Cube1', location: [10, 20, 30], rotation: [0, 90, 0], scale: [1, 1, 1] },
-        outputProps: TRANSFORM_OUTPUT_PROPS,
-        exampleOutput: TRANSFORM_OUTPUT,
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'teleport_actor',
-        editorStates: ANY_EDITOR_STATE,
-        domain: DOMAIN,
-        family: FAMILY_TRANSFORM,
-        summary: 'Alias of set_transform. The bridge dispatches both names to the same handler.',
-        whenToUse: ['Preferred when callers use the teleport_actor verb.'],
-        whenNotToUse: ['Use set_transform to avoid alias normalization.'],
-        inputProps: TRANSFORM_INPUT,
-        required: [],
-        requiredOneOf: ['actorName', 'actors'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'teleport_actor', actorName: 'Cube1', location: [5, 5, 5] },
-        outputProps: TRANSFORM_OUTPUT_PROPS,
-        exampleOutput: TRANSFORM_OUTPUT,
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'set_actor_location',
-        editorStates: ANY_EDITOR_STATE,
-        domain: DOMAIN,
-        family: FAMILY_TRANSFORM,
-        summary: 'Alias of set_transform (location-only intent); normalizes to set_transform.',
-        whenToUse: ['An actor must be moved to a new location.'],
-        whenNotToUse: ['Use set_transform for the full transform verb.'],
-        inputProps: TRANSFORM_INPUT,
-        required: [],
-        requiredOneOf: ['actorName', 'actors'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'set_actor_location', actorName: 'Cube1', location: [100, 0, 0] },
-        outputProps: TRANSFORM_OUTPUT_PROPS,
-        exampleOutput: TRANSFORM_OUTPUT,
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'set_actor_rotation',
-        editorStates: ANY_EDITOR_STATE,
-        domain: DOMAIN,
-        family: FAMILY_TRANSFORM,
-        summary: 'Alias of set_transform (rotation-only intent); normalizes to set_transform.',
-        whenToUse: ['An actor must be rotated.'],
-        whenNotToUse: ['Use set_transform for the full transform verb.'],
-        inputProps: TRANSFORM_INPUT,
-        required: [],
-        requiredOneOf: ['actorName', 'actors'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'set_actor_rotation', actorName: 'Cube1', rotation: [0, 45, 0] },
-        outputProps: TRANSFORM_OUTPUT_PROPS,
-        exampleOutput: TRANSFORM_OUTPUT,
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'set_actor_scale',
-        editorStates: ANY_EDITOR_STATE,
-        domain: DOMAIN,
-        family: FAMILY_TRANSFORM,
-        summary: 'Alias of set_transform (scale-only intent); normalizes to set_transform.',
-        whenToUse: ['An actor must be rescaled.'],
-        whenNotToUse: ['Use set_transform for the full transform verb.'],
-        inputProps: TRANSFORM_INPUT,
-        required: [],
-        requiredOneOf: ['actorName', 'actors'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'set_actor_scale', actorName: 'Cube1', scale: [2, 2, 2] },
-        outputProps: TRANSFORM_OUTPUT_PROPS,
-        exampleOutput: TRANSFORM_OUTPUT,
-    }),
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'get_transform',
-        editorStates: ANY_EDITOR_STATE,
-        domain: DOMAIN,
-        family: FAMILY_TRANSFORM,
-        topics: ['actor location', 'actor position', 'actor rotation', 'where is the actor'],
-        summary: 'Read the world transform (location, rotation, scale) of an actor.',
-        whenToUse: ['The current transform of an actor must be inspected.'],
-        whenNotToUse: ['The transform should be changed (use set_transform).'],
-        inputProps: { actorName: P.pieActorName },
-        required: ['actorName'],
-        outputProps: { location: P.location, rotation: P.rotation, scale: P.scale },
-        outputRequired: [],
-        effect: 'read',
-        exampleInput: { action: 'get_transform', actorName: 'Cube1' },
-        exampleOutput: { success: true, message: 'Transform for Cube1', location: [0, 0, 0], rotation: [0, 0, 0], scale: [1, 1, 1] },
-    }),
-    {
-        ...buildCoreRecord({
-            parentTool: 'control_actor',
-            action: 'sample_motion',
-            editorStates: ANY_EDITOR_STATE,
-            domain: DOMAIN,
-            family: FAMILY_TRANSFORM,
-            topics: ['sample motion', 'record trajectory', 'track actor over time', 'watch actor move', 'jump height', 'foot sliding', 'bone position over time'],
-            summary: 'Watch an actor over game time in Play-In-Editor and return its location, velocity, rotation and chosen properties at every interval, plus start/end and min/max extents, in one call; it can also follow points on the actor (bones, sockets, components) with their height over the ground, press keys at exact game times (inputs) and wait for another actor\'s property to change before it starts (startWhen).',
-            whenToUse: [
-                'A jump, spring launch, moving platform, enemy patrol or fall must be proven in PIE without a sleep-and-poll loop.',
-                'The peak height, landing point or path of a moving actor is needed.',
-                'An input must land at an exact moment (jump when a platform appears): inputs and startWhen run the whole timeline inside one call, so the caller\'s own delay between calls cannot shift it.',
-                'Feet must be proven to plant without sliding, sinking or floating, or a hand or muzzle must be followed: points with groundTrace measure it per point.',
-            ],
-            whenNotToUse: ['Only the current transform is needed (use get_transform).', 'Nothing is playing: the editor world does not simulate (start PIE with control_editor.play).'],
-            inputProps: {
-                actorName: P.pieActorName,
-                durationSeconds: { type: 'number', description: 'Game seconds to watch (default 2, at most 30). Game time, so a clock slowed with set_game_speed still covers the same span of play; a run that needs more wall-clock time than maxRealSeconds stops there (endedBecause realTimeCap).' },
-                intervalSeconds: { type: 'number', description: 'Game seconds between samples (default 0.05; 0 samples every frame). At most 400 samples are kept.' },
-                propertyNames: { type: 'array', items: { type: 'string' }, description: 'Actor properties read at every sample, e.g. ["bDead", "HP"], or a component\'s as "Component.Property" ("Visual.RelativeScale3D" catches a squash on landing), the component by its name or by the actor property that holds it ("CharacterMovement.MaxWalkSpeed"); a name that resolves to nothing is listed under missingProperties.' },
-                maxRealSeconds: { type: 'number', description: 'Wall-clock cap (default 25, at most 50): the run stops here and reports how much game time it covered, so a long run or an editor throttled to 3 fps still answers before a client that gives up at 30 s. Raise it only for a client that waits longer.' },
-                inputs: {
-                    type: 'array',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            key: { type: 'string', description: 'Key name as simulate_input takes it: SpaceBar, D, A, Left, Enter.' },
-                            atSeconds: { type: 'number', description: 'Game seconds after the run starts to press it (default 0).' },
-                            holdSeconds: { type: 'number', description: 'Game seconds to hold it (default 0.1).' },
-                        },
-                        required: ['key'],
-                        additionalProperties: false,
-                    },
-                    description: 'Keys pressed and released at exact game times during the run (at most 32), e.g. [{"key":"D","atSeconds":0,"holdSeconds":2},{"key":"SpaceBar","atSeconds":0.6,"holdSeconds":0.2}]. A key still held when the run ends is released.',
-                },
-                points: {
-                    type: 'array', items: { type: 'string' }, maxItems: 8,
-                    description: 'Places on the actor sampled with it (at most 8): a component by its name (LegL), a bone or socket of any of its components (foot_l, hand_r), or a component\'s own socket as Component.Socket (Weapon.Muzzle). Each sample\'s points gives each one\'s world location [x, y, z]; a name the actor lacks is refused with the names it has. Fewer samples are kept with points: 400 x 2 / (2 + points).',
-                },
-                groundTrace: { type: 'boolean', description: 'With points: each sample\'s aboveGround gives each point\'s height over the first surface below it that blocks Visibility (the actor and what is attached to it ignored), negative when the point is inside that surface, and pointStats sums up its contact.' },
-                contactCm: { type: 'number', description: 'With groundTrace: how far above its own lowest height a point still counts as planted (default 2 cm), so an ankle bone that never reaches the floor still counts as down when the foot is.' },
-                startWhen: {
-                    type: 'object',
-                    properties: {
-                        actorName: { type: 'string', description: 'Actor whose property starts the run.' },
-                        propertyName: { type: 'string', description: 'That actor\'s property, as propertyNames reads it: bActorEnableCollision, or a component\'s as Component.Property (CharacterMovement.MovementMode starts the run on a landing when equals is MOVE_Walking).' },
-                        equals: { description: 'Value that starts the run, as samples show it ("True", "False", 3).' },
-                        waitForChange: { type: 'boolean', description: 'Default true: start only when the value BECOMES equals (a platform appearing), not while it already is.' },
-                        maxWaitSeconds: { type: 'number', description: 'Game seconds to wait before giving up with endedBecause startWhenTimeout (default 10, at most 30).' },
-                    },
-                    required: ['actorName', 'propertyName', 'equals'],
-                    additionalProperties: false,
-                    description: 'Hold the run (samples and inputs) until another actor\'s property takes a value, so the timeline starts on a game event instead of whenever the call arrived.',
-                },
-            },
-            required: ['actorName'],
-            outputProps: {
-                actorName: { type: 'string', description: 'The actor watched.' },
-                samples: {
-                    type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-                    description: 'One entry per sample: t (game seconds since the start), location [x, y, z], velocity [x, y, z], rotation [pitch, yaw, roll] in degrees (on the first sample and on each one where it changed, so a sample without it still has the last one written), properties, and with points their world locations (points) and heights over the ground (aboveGround, with groundTrace; a point with nothing below it within 10 m is left out).',
-                },
-                sampleCount: { type: 'number', description: 'How many samples were taken.' },
-                gameSeconds: { type: 'number', description: 'Game time covered.' },
-                realSeconds: { type: 'number', description: 'Wall-clock time the run took.' },
-                endedBecause: { type: 'string', description: 'duration, realTimeCap, sampleCap, actorDestroyed (a PIE death that reloads the level ends here), worldEnded (PIE stopped), startWhenTimeout (startWhen never happened within maxWaitSeconds) or gamePaused (game time stood still for 3 s: a title or pause menu holds the game; the warning says how to get past it).' },
-                inputsApplied: {
-                    type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-                    description: 'One entry per input: key, at, hold, and down/up, the game seconds since the start when it was pressed and released (up is when the run ended for a key still held).',
-                },
-                waitedSeconds: { type: 'number', description: 'Game seconds spent waiting for startWhen before the run began.' },
-                start: { type: 'array', items: { type: 'number' }, description: 'First sampled location.' },
-                end: { type: 'array', items: { type: 'number' }, description: 'Last sampled location.' },
-                min: { type: 'array', items: { type: 'number' }, description: 'Smallest x, y and z sampled (the lowest point is min[2]).' },
-                max: { type: 'array', items: { type: 'number' }, description: 'Largest x, y and z sampled (the peak height is max[2]).' },
-                missingProperties: { type: 'array', items: { type: 'string' }, description: 'propertyNames the actor\'s class does not have.' },
-                pointStats: {
-                    type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true,
-                    description: 'Per point: min and max [x, y, z] over the run; with groundTrace also minAboveGround and maxAboveGround (a negative minimum means it sank into the surface, a large one that it never touched it), contactSeconds (time spent planted) and contactSlip (cm it moved across the ground while planted: a planted foot that slides shows here).',
-                },
-                windowRestored: { type: 'boolean', description: 'True when the editor window was minimized: a minimized editor runs PIE at about 3 fps, so it was put back on screen, without taking focus, before the run and is minimized again when the run ends. The background CPU throttle (Use Less CPU when in Background) is off for the run only, whatever the window did.' },
-            },
-            outputRequired: [],
-            effect: 'read',
-            costLatency: 'interactive',
-            exampleInput: { action: 'sample_motion', actorName: 'PlayerPawn', durationSeconds: 1.5, propertyNames: ['bDead'] },
-            exampleOutput: {
-                success: true, message: '31 samples of BP_Hero_C_0 over 1.50 game seconds (duration)',
-                actorName: 'BP_Hero_C_0', sampleCount: 31, gameSeconds: 1.5, realSeconds: 3.2, endedBecause: 'duration',
-                samples: [{ t: 0, location: [8500, 0, 56.1], velocity: [0, 0, 0], rotation: [0, 90, 0], properties: { bDead: 'False' } }],
-                start: [8500, 0, 56.1], end: [9310, 0, 130.2], min: [8500, 0, 56.1], max: [9310, 0, 302.4],
-            },
-        }),
-    },
-    buildCoreRecord({
-        parentTool: 'control_actor',
-        action: 'apply_force',
-        topics: ['push actor', 'apply impulse'],
-        domain: DOMAIN,
-        family: FAMILY_PHYSICS,
-        summary: 'Apply a physics force vector to an actor, auto-enabling simulation on failure.',
-        whenToUse: ['A physical impulse must be applied to a simulated actor.'],
-        whenNotToUse: ['The actor is not physics-enabled and physics cannot be auto-enabled.'],
-        inputProps: { actorName: P.actorName, force: P.force },
-        required: ['actorName', 'force'],
-        effect: 'write',
-        costLatency: 'interactive',
-        exampleInput: { action: 'apply_force', actorName: 'Cube1', force: [0, 0, 500] },
-    }),
-];
-//# sourceMappingURL=transform-records.js.map

package/dist/tools/catalog/capabilities/records/control-editor/asset.d.ts

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

package/dist/tools/catalog/capabilities/records/control-editor/asset.js

@@ -1,134 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-const F = 'asset';
-const D = 'editor';
-const COMPENSATION_STEP = {
-    type: 'object',
-    description: 'One step of the non-atomic save, naming what landed or why it did not.',
-    properties: {
-        step: { type: 'string', description: 'Machine-readable step id, e.g. save:/Game/Maps/Main.' },
-        detail: { type: 'string', description: 'What landed on disk, or the reason nothing did.' },
-    },
-    required: ['step', 'detail'],
-    additionalProperties: false,
-};
-const COMPENSATION = {
-    type: 'object',
-    description: 'Compensating-cleanup receipt. Present on every outcome including the all-succeeded one, because '
-        + 'each package lands independently and a completed save is already durable: non-atomic is a property '
-        + 'of the operation, not of one result.',
-    properties: {
-        operation: { type: 'string', description: 'Canonical capability this receipt describes.' },
-        atomic: {
-            type: 'boolean',
-            enum: [false],
-            description: 'Always false. Packages land one at a time and the ones that landed stay landed.',
-        },
-        rollback: {
-            type: 'string',
-            enum: ['unavailable'],
-            description: 'Always "unavailable". No editor transaction can reach a finished save, so this call was not and cannot be undone.',
-        },
-        rollbackReason: { type: 'string', description: 'Why no rollback exists for this class of work.' },
-        state: {
-            type: 'string',
-            enum: ['completed', 'partial', 'failed', 'noop'],
-            description: 'Outcome across all steps: everything landed, some did, none did, or there was nothing to do.',
-        },
-        completed: { type: 'array', items: COMPENSATION_STEP, description: 'Steps whose effect is now durable on disk.' },
-        notCompleted: { type: 'array', items: COMPENSATION_STEP, description: 'Steps that did not complete, each with its reason.' },
-        skipped: { type: 'array', items: COMPENSATION_STEP, description: 'Steps deliberately not attempted, such as transient packages.' },
-        compensatingCapabilities: {
-            type: 'array',
-            items: { type: 'string', description: 'Canonical capability id that reverses a durable effect.' },
-            description: 'Separate calls the caller may make to reverse a durable effect. Never a rollback of this call.',
-        },
-        callerAction: { type: 'string', description: 'Exact instruction for reaching a clean state; empty when nothing is outstanding.' },
-    },
-    required: ['atomic', 'rollback', 'state'],
-    additionalProperties: false,
-};
-export const ASSET_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'open_asset', domain: D, family: F,
-        topics: ['open blueprint editor', 'open asset editor', 'open in editor'],
-        summary: 'Open an asset in the appropriate editor by asset path.',
-        whenToUse: ['An asset must be opened for editing or inspection.'],
-        whenNotToUse: ['The asset is already open.'],
-        inputProps: { assetPath: P.assetPath },
-        required: ['assetPath'],
-        effect: 'read',
-        costLatency: 'interactive',
-        exampleInput: { action: 'open_asset', assetPath: '/Game/Materials/M_Base' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'close_asset', domain: D, family: F,
-        summary: 'Close every editor open on an asset, by asset path. Fails with EDITOR_NOT_OPEN when none is open; the asset is never loaded to do this.',
-        whenToUse: ['An open asset editor must be closed.'],
-        whenNotToUse: ['The asset is not open.', 'The Unreal Editor itself must close: that is restart_editor with relaunch false.'],
-        inputProps: { assetPath: P.assetPath },
-        required: ['assetPath'],
-        effect: 'write',
-        exampleInput: { action: 'close_asset', assetPath: '/Game/Materials/M_Base' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'open_level', domain: D, family: F,
-        topics: ['open map', 'open level asset'],
-        summary: 'Open a level by asset path, loading it as the current level.',
-        whenToUse: ['A different level must be loaded into the editor.'],
-        whenNotToUse: ['The level is already loaded.',
-            'Open levels have unsaved changes: opening another level would drop them, so the call is refused with DIRTY_PACKAGES, listing them in unsavedPackages. Save first (manage_level save), or use manage_level load, which takes saveDirtyPackages or discardUnsaved.'],
-        inputProps: { levelPath: P.levelPath, path: P.path, assetPath: P.assetPath },
-        required: ['levelPath'],
-        effect: 'write',
-        costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'open_level', levelPath: '/Game/Maps/EntryMap' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'focus_actor', domain: D, family: F,
-        aliases: ['control_editor.move_camera_to_actor'],
-        summary: 'Focus the viewport camera on a specific actor by name: the level viewport, or the free view of an ejected player.',
-        whenToUse: ['The viewport must frame a specific actor.'],
-        whenNotToUse: ['The actor does not exist in the current level.',
-            'Play In Editor runs and the player is not ejected: the level viewport is hidden behind the game, so this is refused with PIE_VIEW_NOT_EJECTED (eject first, or point the game camera with set_camera cameraOp=view_target).'],
-        inputProps: { actorName: P.actorName, name: P.name },
-        required: ['actorName'],
-        effect: 'read',
-        exampleInput: { action: 'focus_actor', actorName: 'BP_PlayerStart' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'save_all', domain: D, family: F,
-        topics: ['save all', 'save everything', 'save dirty packages', 'save project', 'save assets', 'save asset', 'save one asset'],
-        summary: 'Save all dirty assets and levels in the editor, or only the ones listed in assetPaths.',
-        whenToUse: ['All unsaved changes must be persisted.', 'Only the assets this task changed should be saved (assetPaths), leaving other unsaved work alone.'],
-        whenNotToUse: ['Nothing has changed since the last save.'],
-        inputProps: {
-            assetPaths: { type: 'array', items: { type: 'string' }, description: 'Save only these assets or levels, e.g. ["/Game/UI/WBP_Menu"], and leave every other dirty package as it is; omit to save everything dirty.' },
-        },
-        required: [],
-        outputProps: {
-            compensation: COMPENSATION,
-            leftDirtyPackages: { type: 'array', items: { type: 'string' }, description: 'With assetPaths: the other packages that still hold unsaved changes, left as they were.' },
-        },
-        effect: 'write',
-        costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'save_all' },
-        exampleOutput: {
-            success: true,
-            message: 'All assets saved',
-            compensation: {
-                operation: 'control_editor.save_all',
-                atomic: false,
-                rollback: 'unavailable',
-                rollbackReason: 'Completed steps are already durable on disk. No editor transaction can reach a finished save, build or render, so nothing here was or can be undone.',
-                state: 'completed',
-                completed: [{ step: 'save:/Game/Maps/EntryMap', detail: 'level package written to disk' }],
-                notCompleted: [],
-                skipped: [],
-                compensatingCapabilities: [],
-                callerAction: '',
-            },
-        },
-    }),
-];
-//# sourceMappingURL=asset.js.map

package/dist/tools/catalog/capabilities/records/control-editor/bookmark.d.ts

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

package/dist/tools/catalog/capabilities/records/control-editor/bookmark.js

@@ -1,27 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-const F = 'bookmark';
-const D = 'editor';
-export const BOOKMARK_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'create_bookmark', topics: ['bookmark camera view'], domain: D, family: F,
-        summary: 'Store the level viewport camera in a numbered bookmark slot (id).',
-        whenToUse: ['The current viewport camera state must be saved for later recall.'],
-        whenNotToUse: ['A bookmark already exists at the desired index.'],
-        inputProps: { id: P.id },
-        required: ['id'],
-        effect: 'write',
-        exampleInput: { action: 'create_bookmark', id: 1 },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'jump_to_bookmark', topics: ['go to bookmark'], domain: D, family: F,
-        summary: 'Move the level viewport camera to a bookmark slot (id); fails with BOOKMARK_NOT_FOUND when that slot is empty.',
-        whenToUse: ['The viewport must navigate to a saved bookmark position.'],
-        whenNotToUse: ['The bookmark does not exist.'],
-        inputProps: { id: P.id },
-        required: ['id'],
-        effect: 'read',
-        exampleInput: { action: 'jump_to_bookmark', id: 1 },
-    }),
-];
-//# sourceMappingURL=bookmark.js.map

package/dist/tools/catalog/capabilities/records/control-editor/camera.d.ts

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

package/dist/tools/catalog/capabilities/records/control-editor/camera.js

@@ -1,65 +0,0 @@
-import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-const F = 'camera';
-const D = 'editor';
-export const CAMERA_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'set_view_target', domain: D, family: F,
-        editorStates: ANY_EDITOR_STATE,
-        summary: 'Set the PIE view target to a specific actor by name.',
-        whenToUse: ['The camera must follow or focus on a specific actor in PIE.'],
-        whenNotToUse: ['A fixed camera position is preferred (use set_camera).'],
-        inputProps: { actorName: P.actorName, name: P.name, objectPath: P.objectPath, location: P.location, rotation: P.rotation, blendTime: P.blendTime },
-        required: ['actorName'],
-        effect: 'read',
-        exampleInput: { action: 'set_view_target', actorName: 'BP_CameraTarget' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'set_game_view_target', dispatchAction: 'set_view_target',
-        editorStates: ANY_EDITOR_STATE,
-        domain: D, family: F,
-        summary: 'Set the PIE view target (alias for set_view_target).',
-        whenToUse: ['The camera view target must be set using the set_game_view_target alias.'],
-        whenNotToUse: ['A fixed camera position is preferred (use set_camera).'],
-        inputProps: { actorName: P.actorName, name: P.name, objectPath: P.objectPath, location: P.location, rotation: P.rotation, blendTime: P.blendTime },
-        required: ['actorName'],
-        effect: 'read',
-        exampleInput: { action: 'set_game_view_target', actorName: 'BP_CameraTarget' },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'set_camera', domain: D, family: F,
-        editorStates: ANY_EDITOR_STATE,
-        summary: 'Set the viewport camera position and rotation: the level viewport, or, while Play In Editor runs with the player ejected (control_editor play control=eject), the free camera the game view is drawn from.',
-        whenToUse: [
-            'The viewport camera must be moved to a specific position and orientation.',
-            'The view of a running game must be placed, for a screenshot of it: eject the player first, then set the camera.',
-        ],
-        whenNotToUse: [
-            'The camera should follow an actor (use set_view_target).',
-            'Play In Editor runs and the player is not ejected: the game draws its view target\'s camera (the pawn, or an actor set with view_target), which has no free camera to move, so the call is refused with PIE_VIEW_NOT_EJECTED (eject first, or use cameraOp view_target).',
-        ],
-        inputProps: { location: P.location, rotation: P.rotation },
-        required: ['location', 'rotation'],
-        effect: 'read',
-        outputProps: {
-            view: { type: 'string', description: 'Which view moved: editor_viewport (the level viewport), or pie_ejected (the free camera of an ejected player while Play In Editor runs).' },
-            cameraLocation: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Where the camera is after the call, {x, y, z}.' },
-            cameraRotation: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'How the camera is turned after the call, {pitch, yaw, roll}.' },
-            locationApplied: { type: 'boolean', description: 'Whether the viewport took the requested location; false (with CAMERA_NOT_APPLIED) when it is locked to an actor, piloting or orthographic.' },
-            rotationApplied: { type: 'boolean', description: 'Whether the viewport took the requested rotation.' },
-        },
-        exampleInput: { action: 'set_camera', location: { x: 0, y: 0, z: 500 }, rotation: { pitch: -45, yaw: 0, roll: 0 } },
-    }),
-    buildCoreRecord({
-        parentTool: 'control_editor', action: 'set_camera_fov', domain: D, family: F,
-        editorStates: ANY_EDITOR_STATE,
-        summary: 'Set the camera field of view of the view on screen: the level viewport, the free view of an ejected player, or while the player plays the running game\'s camera (method player_camera_manager; locked to the value until play stops).',
-        whenToUse: ['The camera FOV must be adjusted for the viewport.'],
-        whenNotToUse: ['The default FOV is acceptable.'],
-        inputProps: { fov: P.fov },
-        required: ['fov'],
-        effect: 'read',
-        exampleInput: { action: 'set_camera_fov', fov: 90 },
-    }),
-];
-//# sourceMappingURL=camera.js.map

package/dist/tools/catalog/capabilities/records/control-editor/command.d.ts

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