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

package/dist/tools/catalog/capabilities/records/manage-sequence/timeline-playback.js

@@ -1,81 +0,0 @@
-import { buildRecord, P, SEQ_PLUGINS } from './helpers.js';
-const F = 'timeline';
-const D = 'sequence';
-const START_TIME = {
-    type: 'number', minimum: 0,
-    description: 'Sequence time in seconds. play starts there; pause jumps the playhead there and holds that frame, so the viewport and screenshots show the scene at that moment. A time past the end of the playback range is refused: frame N at 24 fps is N / 24 seconds.',
-};
-export const TIMELINE_PLAYBACK_RECORDS = [
-    buildRecord({
-        id: 'sequence.play', action: 'play', family: F, domain: D,
-        topics: ['play sequence', 'play cinematic', 'preview sequence', 'play cutscene', 'preview cutscene'],
-        summary: 'Start playing the currently open Level Sequence.',
-        whenToUse: ['Sequence playback must be started for preview or PIE.'],
-        whenNotToUse: ['The sequence is already playing.'],
-        inputProps: { path: P.path, startTime: START_TIME, loopMode: { type: 'string', enum: ['once', 'loop'], description: 'Sequencer loop mode for the preview: once or loop.' } },
-        required: ['path'],
-        effect: 'write', latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'play', path: '/Game/Cinematics/SEQ_Master' },
-    }),
-    buildRecord({
-        id: 'sequence.pause', action: 'pause', family: F, domain: D,
-        summary: 'Pause playback of the currently open Level Sequence, or hold it at one moment to inspect it.',
-        whenToUse: ['Sequence playback must be paused.', 'A pose, camera or effect must be checked at one moment of the sequence: pause with startTime, then take a screenshot.'],
-        whenNotToUse: ['The sequence is not open in Sequencer (play opens it).'],
-        inputProps: { path: P.path, startTime: START_TIME },
-        required: ['path'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'pause', path: '/Game/Cinematics/SEQ_Master' },
-    }),
-    buildRecord({
-        id: 'sequence.stop', action: 'stop', family: F, domain: D,
-        summary: 'Stop playback and reset the playhead of the open Level Sequence.',
-        whenToUse: ['Sequence playback must be stopped and the playhead reset.'],
-        whenNotToUse: ['The sequence should only be paused.'],
-        inputProps: { path: P.path },
-        required: ['path'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'stop', path: '/Game/Cinematics/SEQ_Master' },
-    }),
-    buildRecord({
-        id: 'sequence.set_playback_speed', action: 'set_playback_speed', family: F, domain: D,
-        summary: 'Set the playback speed of a Level Sequence on the level sequence actors that play it, and on Sequencer when it is open.',
-        whenToUse: ['Playback speed must be changed for preview.'],
-        whenNotToUse: ['The speed value is not a positive number.'],
-        inputProps: { path: P.path, speed: P.speed },
-        required: ['path', 'speed'],
-        effect: 'write', latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'set_playback_speed', path: '/Game/Cinematics/SEQ_Master', speed: 0.5 },
-    }),
-    buildRecord({
-        id: 'sequence.get_properties', action: 'get_properties', family: F, domain: D,
-        summary: 'Read playback properties (frame rate, length, range) of a Level Sequence.',
-        whenToUse: ['Sequence timing properties must be inspected.'],
-        whenNotToUse: ['Properties are being set rather than read.'],
-        inputProps: { path: P.path },
-        required: ['path'],
-        outputProps: {
-            frameRate: P.frameRate, lengthInFrames: { type: 'integer', description: 'Sequence length in frames.' },
-            playbackStart: { type: 'integer', description: 'Playback start frame.' },
-            playbackEnd: { type: 'integer', description: 'Playback end frame.' },
-        },
-        outputRequired: ['frameRate'],
-        effect: 'read', latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'get_properties', path: '/Game/Cinematics/SEQ_Master' },
-        exampleOutput: { success: true, frameRate: 24, lengthInFrames: 120 },
-    }),
-    buildRecord({
-        id: 'sequence.set_properties', action: 'set_properties', family: F, domain: D,
-        summary: 'Set playback properties (frame rate, length, range) of a Level Sequence.',
-        whenToUse: ['Sequence timing properties must be configured.'],
-        whenNotToUse: ['Properties are being read rather than set.'],
-        inputProps: { path: P.path, frameRate: P.frameRate,
-            lengthInFrames: { type: 'integer', description: 'Sequence length in frames.' },
-            playbackStart: { type: 'integer', description: 'Playback start frame.' },
-            playbackEnd: { type: 'integer', description: 'Playback end frame.' } },
-        required: ['path'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'set_properties', path: '/Game/Cinematics/SEQ_Master', frameRate: 30 },
-    }),
-];
-//# sourceMappingURL=timeline-playback.js.map

package/dist/tools/catalog/capabilities/records/manage-sequence/timeline-state-ranges.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-sequence/timeline-state-ranges.js

@@ -1,95 +0,0 @@
-import { buildRecord, P, SEQ_PLUGINS } from './helpers.js';
-const F = 'timeline';
-const D = 'sequence';
-export const TIMELINE_STATE_RANGE_RECORDS = [
-    buildRecord({
-        id: 'sequence.set_track_muted', action: 'set_track_muted', family: F, domain: D,
-        summary: 'Mute or unmute a track in a Level Sequence.',
-        whenToUse: ['A track must be temporarily silenced.'],
-        whenNotToUse: ['The track should be permanently removed.'],
-        inputProps: { path: P.path, trackName: P.trackName, muted: { type: 'boolean', description: 'Whether to mute.' } },
-        required: ['path', 'trackName'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'set_track_muted', path: '/Game/Cinematics/SEQ_Master', trackName: 'Audio', muted: true },
-    }),
-    buildRecord({
-        id: 'sequence.set_track_solo', action: 'set_track_solo', family: F, domain: D,
-        summary: 'Solo or unsolo a track in a Level Sequence.',
-        whenToUse: ['A single track must be isolated for preview.'],
-        whenNotToUse: ['Multiple tracks need to be audible simultaneously.'],
-        inputProps: { path: P.path, trackName: P.trackName, solo: { type: 'boolean', description: 'Whether to solo.' } },
-        required: ['path', 'trackName'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'set_track_solo', path: '/Game/Cinematics/SEQ_Master', trackName: 'Audio', solo: true },
-    }),
-    buildRecord({
-        id: 'sequence.set_track_locked', action: 'set_track_locked', family: F, domain: D,
-        summary: 'Lock or unlock a track in a Level Sequence.',
-        whenToUse: ['A track must be protected from accidental edits.'],
-        whenNotToUse: ['The track needs to be edited.'],
-        inputProps: { path: P.path, trackName: P.trackName, locked: { type: 'boolean', description: 'Whether to lock.' } },
-        required: ['path', 'trackName'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'set_track_locked', path: '/Game/Cinematics/SEQ_Master', trackName: 'Transform', locked: true },
-    }),
-    buildRecord({
-        id: 'sequence.set_section', action: 'set_section', family: F, domain: D,
-        summary: 'Move, trim or ease a section already on a track: its start and end frames, and the frames it eases in and out over.',
-        whenToUse: ['Two animation clips should crossfade: overlap their sections, ease the later one in and the earlier one out.', 'A section must start or end on another frame.'],
-        whenNotToUse: ['The section does not exist yet (use add_section, or add_cinematic_track for a clip).'],
-        inputProps: {
-            path: P.path,
-            trackName: { type: 'string', description: 'The track, by the trackName get_properties info=tracks or info=keys lists (MovieSceneSkeletalAnimationTrack_3).' },
-            sectionIndex: { type: 'integer', minimum: 0, description: 'Which section of the track, in the order info=keys lists them (default 0).' },
-            startFrame: { type: 'number', description: 'New start of the section in display-rate frames.' },
-            endFrame: { type: 'number', description: 'New end of the section in display-rate frames, after its start.' },
-            easeInFrames: { type: 'number', minimum: 0, description: 'Frames the section fades in over; 0 removes its ease in.' },
-            easeOutFrames: { type: 'number', minimum: 0, description: 'Frames the section fades out over; 0 removes its ease out.' },
-        },
-        required: ['path', 'trackName'],
-        outputProps: { trackName: { type: 'string', description: 'The track the section is on.' }, sectionIndex: { type: 'integer', description: 'The section that changed.' } },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'set_section', path: '/Game/Cinematics/SEQ_Master', trackName: 'MovieSceneSkeletalAnimationTrack_3', endFrame: 130, easeOutFrames: 10 },
-    }),
-    buildRecord({
-        id: 'sequence.set_display_rate', action: 'set_display_rate', family: F, domain: D,
-        summary: 'Set the display frame rate of a Level Sequence.',
-        whenToUse: ['The sequence display rate must be changed.'],
-        whenNotToUse: ['The tick resolution needs changing instead.'],
-        inputProps: { path: P.path, frameRate: P.frameRate },
-        required: ['path', 'frameRate'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'set_display_rate', path: '/Game/Cinematics/SEQ_Master', frameRate: 24 },
-    }),
-    buildRecord({
-        id: 'sequence.set_tick_resolution', action: 'set_tick_resolution', family: F, domain: D,
-        summary: 'Set the tick resolution of a Level Sequence.',
-        whenToUse: ['The sequence tick resolution must be changed.'],
-        whenNotToUse: ['The display rate needs changing instead.'],
-        inputProps: { path: P.path, resolution: P.resolution },
-        required: ['path', 'resolution'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'set_tick_resolution', path: '/Game/Cinematics/SEQ_Master', resolution: '24000/1001' },
-    }),
-    buildRecord({
-        id: 'sequence.set_work_range', action: 'set_work_range', family: F, domain: D,
-        summary: 'Set the work range (editable region) of a Level Sequence.',
-        whenToUse: ['The editable region must be bounded.'],
-        whenNotToUse: ['The view range needs changing instead.'],
-        inputProps: { path: P.path, start: P.start, end: P.end },
-        required: ['path', 'start', 'end'],
-        effect: 'write', latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'set_work_range', path: '/Game/Cinematics/SEQ_Master', start: 0, end: 120 },
-    }),
-    buildRecord({
-        id: 'sequence.set_view_range', action: 'set_view_range', family: F, domain: D,
-        summary: 'Set the view range (visible region) of a Level Sequence.',
-        whenToUse: ['The visible region in the Sequencer must be bounded.'],
-        whenNotToUse: ['The work range needs changing instead.'],
-        inputProps: { path: P.path, start: P.start, end: P.end },
-        required: ['path'],
-        effect: 'write', latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'set_view_range', path: '/Game/Cinematics/SEQ_Master', start: 0, end: 60 },
-    }),
-];
-//# sourceMappingURL=timeline-state-ranges.js.map

package/dist/tools/catalog/capabilities/records/manage-sequence/timeline-tracks.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-sequence/timeline-tracks.js

@@ -1,147 +0,0 @@
-import { buildRecord, P, SEQ_PLUGINS } from './helpers.js';
-const F = 'timeline';
-const D = 'sequence';
-export const TIMELINE_TRACKS_RECORDS = [
-    buildRecord({
-        id: 'sequence.add_track', action: 'add_track', family: F, domain: D,
-        summary: 'Add a track of a specific type to a Level Sequence or binding.',
-        whenToUse: ['A new track (transform, float, event, etc.) must be added.'],
-        whenNotToUse: ['The track type is not supported by the sequence.'],
-        inputProps: { path: P.path, trackType: P.trackType, trackName: P.trackName, actorName: P.actorName },
-        required: ['path', 'trackType'],
-        outputProps: { trackType: P.trackType, trackName: P.trackName, trackId: { type: 'string', description: 'Object name of the created track (addressable by later track actions).' }, trackClass: { type: 'string', description: 'UMovieSceneTrack subclass that was created.' }, trackPath: { type: 'string', description: 'Full object path of the created track.' }, actorName: P.actorName, bindingGuid: { type: 'string', description: 'Sequencer binding GUID the track was added to (bound tracks only).' } },
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'add_track', path: '/Game/Cinematics/SEQ_Master', trackType: 'transform', actorName: 'Cube' },
-    }),
-    buildRecord({
-        id: 'sequence.add_section', action: 'add_section', family: F, domain: D,
-        summary: 'Add a section to an existing track in a Level Sequence; on an Audio track, soundPath puts music or a sound in it.',
-        topics: ['add music to sequence', 'add sound to cutscene', 'sequence audio'],
-        whenToUse: ['A section must be added to animate a sub-range of a track.',
-            'Music or a sound must play in a cutscene: add an Audio track, then a section with soundPath.'],
-        whenNotToUse: ['The track does not exist.', 'A sound must play in the running game, not inside a sequence.'],
-        inputProps: { path: P.path, trackName: P.trackName, actorName: { type: 'string', description: 'Only search the tracks of this bound actor.' }, bindingId: { type: 'string', description: 'Camera binding GUID for a camera cut section (required on a camera cut track).' }, soundPath: { type: 'string', description: 'Audio track only: /Game path of the SoundWave, SoundCue or MetaSound the section plays. Without end the section is as long as the sound (one second for a looping one).' }, start: { type: 'number', description: 'Section start in display-rate frames (default 0).' }, end: { type: 'number', description: 'Section end in display-rate frames, after start (default 100; with soundPath, the length of the sound).' } },
-        required: ['path'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'add_section', path: '/Game/Cinematics/SEQ_Master', trackName: 'Transform', start: 0, end: 60 },
-    }),
-    buildRecord({
-        id: 'sequence.remove_track', action: 'remove_track', family: F, domain: D,
-        summary: 'Remove a track by name from a Level Sequence.',
-        whenToUse: ['A track must be permanently removed from the sequence.'],
-        whenNotToUse: ['The track should be muted instead.'],
-        inputProps: { path: P.path, trackName: P.trackName },
-        required: ['path', 'trackName'],
-        effect: 'destructive', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'remove_track', path: '/Game/Cinematics/SEQ_Master', trackName: 'Fade' },
-    }),
-    buildRecord({
-        id: 'sequence.list_tracks', action: 'list_tracks', family: F, domain: D,
-        summary: 'List all tracks in a Level Sequence.',
-        whenToUse: ['The tracks in a sequence must be enumerated.'],
-        whenNotToUse: ['A specific track name is already known.'],
-        inputProps: { path: P.path },
-        required: ['path'],
-        outputProps: {
-            tracks: { type: 'array', items: { type: 'object', description: 'Track info.', additionalProperties: false, properties: {
-                        trackName: { type: 'string', description: 'Track name.' },
-                        trackType: { type: 'string', description: 'MovieScene track class name.' },
-                        displayName: { type: 'string', description: 'Track display name.' },
-                        isMasterTrack: { type: 'boolean', description: 'Whether the track belongs to the master (unbound) row.' },
-                        isCameraCut: { type: 'boolean', description: 'Whether the track is a camera-cut track.' },
-                        bindingName: { type: 'string', description: 'Bound actor name, or Actor/Component for a component bound under its actor (binding tracks only).' },
-                        bindingGuid: { type: 'string', description: 'Bound object guid string (binding tracks only).' },
-                        sectionCount: { type: 'integer', description: 'Number of sections on the track.' },
-                    }, required: ['trackName', 'trackType', 'displayName', 'isMasterTrack', 'sectionCount'] }, description: 'Sequence tracks.' },
-            trackCount: { type: 'integer', description: 'Total number of tracks reported.' },
-            sequencePath: { type: 'string', description: 'Resolved sequence asset path.' },
-        },
-        outputRequired: ['tracks'],
-        effect: 'read', latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'list_tracks', path: '/Game/Cinematics/SEQ_Master' },
-        exampleOutput: { success: true, tracks: [{ trackName: 'CameraCut', trackType: 'MovieSceneCameraCutTrack', displayName: 'CameraCut', isMasterTrack: true, sectionCount: 1 }], trackCount: 1 },
-    }),
-    buildRecord({
-        id: 'sequence.list_track_types', action: 'list_track_types', family: F, domain: D,
-        summary: 'List all available MovieScene track types registered in the engine.',
-        whenToUse: ['Available track types must be discovered before adding a track.'],
-        whenNotToUse: ['The track type is already known.'],
-        inputProps: {},
-        outputProps: { types: { type: 'array', items: { type: 'string', description: 'Track type name.' }, description: 'Available track types.' } },
-        outputRequired: ['types'],
-        effect: 'read', latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'list_track_types' },
-        exampleOutput: { success: true, types: ['transform', 'float', 'event', 'camera_cut'] },
-    }),
-    buildRecord({
-        id: 'sequence.list_track_keys', action: 'list_track_keys', family: F, domain: D,
-        summary: 'Read the sections and keyframes already on a sequence track.',
-        whenToUse: ['Existing keys must be inspected before re-authoring a track.',
-            'A keyframe appeared to do nothing and the section range needs checking.'],
-        whenNotToUse: ['Only track names are needed; list_tracks is cheaper.'],
-        inputProps: { path: P.path, trackName: P.trackName },
-        required: ['path'],
-        outputProps: {
-            trackKeys: { type: 'array', description: 'Tracks with their sections and keys.', items: {
-                    type: 'object', additionalProperties: false, description: 'Track keys.', properties: {
-                        trackName: { type: 'string', description: 'Track name.' },
-                        trackType: { type: 'string', description: 'MovieScene track class name.' },
-                        bindingName: { type: 'string', description: 'The bound actor the track animates, or Actor/Component for a component bound under its actor; absent on a master track.' },
-                        sections: { type: 'array', description: 'Sections on the track.', items: {
-                                type: 'object', additionalProperties: false, description: 'Section keys.', properties: {
-                                    sectionName: { type: 'string', description: 'Section object name.' },
-                                    rangeIsEmpty: { type: 'boolean', description: 'True when the section covers no time, so its keys never evaluate.' },
-                                    startFrame: { type: 'number', description: 'Section start in display frames.' },
-                                    endFrame: { type: 'number', description: 'Section end in display frames.' },
-                                    rowIndex: { type: 'integer', description: 'Row of the section within its track.' },
-                                    easeInFrames: { type: 'number', description: 'Frames the section fades in over; absent when it does not ease in.' },
-                                    easeOutFrames: { type: 'number', description: 'Frames the section fades out over; absent when it does not ease out.' },
-                                    animation: { type: 'string', description: 'The clip an animation section plays.' },
-                                    channels: { type: 'array', description: 'Channels and their keys.', items: {
-                                            type: 'object', additionalProperties: false, description: 'Channel keys.', properties: {
-                                                channelIndex: { type: 'integer', description: 'Index within the channel family.' },
-                                                channelType: { type: 'string', description: 'double, float, bool, byte, integer or particle.' },
-                                                channelName: { type: 'string', description: 'Channel name, when the section publishes metadata.' },
-                                                keyCount: { type: 'integer', description: 'Number of keys on the channel.' },
-                                                keys: { type: 'array', description: 'Keys on the channel.', items: {
-                                                        type: 'object', additionalProperties: false, description: 'One key.', properties: {
-                                                            frame: { type: 'number', description: 'Key time in display frames.' },
-                                                            value: { type: 'number', description: 'Key value; a bool key (a Visibility track) reads 1 for true and 0 for false, a particle key 0 activate, 1 deactivate, 2 trigger.' },
-                                                        }
-                                                    } },
-                                            }
-                                        } },
-                                }
-                            } },
-                    }
-                } },
-            trackCount: { type: 'integer', description: 'Tracks reported.' },
-            keyCount: { type: 'integer', description: 'Total keys across every reported channel.' },
-            sequencePath: { type: 'string', description: 'Resolved sequence asset path.' },
-        },
-        outputRequired: ['trackKeys'],
-        effect: 'read', latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'list_track_keys', path: '/Game/Cinematics/SEQ_Master', trackName: 'MovieScene3DTransformTrack_0' },
-        exampleOutput: { success: true, trackKeys: [{ trackName: 'MovieScene3DTransformTrack_0', trackType: 'MovieScene3DTransformTrack', sections: [{ sectionName: 'MovieScene3DTransformSection_0', rangeIsEmpty: false, startFrame: 0, endFrame: 120, channels: [] }] }], trackCount: 1, keyCount: 15 },
-    }),
-    buildRecord({
-        id: 'sequence.remove_keyframe', action: 'remove_keyframe', family: F, domain: D,
-        summary: 'Remove keyframes from a sequence track: the keys on one frame or on several, or every key on the track.',
-        whenToUse: ['A track must be cleanly re-authored rather than added to.',
-            'A single bad key must be deleted.'],
-        whenNotToUse: ['The whole track should go; use delete with deleteScope track.'],
-        inputProps: { path: P.path, trackName: P.trackName, bindingId: P.bindingId, frame: P.frame, frames: { type: 'array', minItems: 1, maxItems: 500, items: { type: 'integer', description: 'Frame number.' }, description: 'Remove the keys on each of these frames in one call, of every key type (transform, float, Visibility, particle). Without frame and frames every key on the track goes.' } },
-        required: ['path'],
-        outputProps: {
-            matchedTracks: { type: 'integer', description: 'Tracks the filter matched.' },
-            removedKeys: { type: 'integer', description: 'Keys actually removed.' },
-            clearedAllFrames: { type: 'boolean', description: 'True when no frame was supplied and the whole track was cleared.' },
-            sequencePath: { type: 'string', description: 'Resolved sequence asset path.' },
-        },
-        outputRequired: ['removedKeys'],
-        effect: 'destructive', latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'remove_keyframe', path: '/Game/Cinematics/SEQ_Master', trackName: 'MovieScene3DTransformTrack_0' },
-        exampleOutput: { success: true, message: 'Removed 15 key(s) from 1 track(s)', matchedTracks: 1, removedKeys: 15, clearedAllFrames: true },
-    }),
-];
-//# sourceMappingURL=timeline-tracks.js.map

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

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

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

@@ -1,276 +0,0 @@
-import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
-const CATEGORY_ENUM = {
-    type: 'string',
-    enum: ['core', 'world', 'gameplay', 'utility', 'all'],
-    description: 'Category name to enable/disable.',
-};
-const TOOLS_ARRAY = {
-    type: 'array',
-    items: { type: 'string' },
-    description: 'Tool names to enable or disable.',
-};
-const SPECS = [
-    {
-        action: 'list_tools',
-        family: 'tool-catalog',
-        topics: ['list tools', 'available tools', 'all tools', 'which tools', 'tool list', 'capabilities'],
-        summary: 'List all canonical tools with their enabled state and category.',
-        whenToUse: ['Enumerate every registered tool and its current visibility.'],
-        whenNotToUse: ['When only aggregate counts are needed (use get_status).'],
-        inputProps: {},
-        required: [],
-        outputProps: {
-            tools: {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    properties: {
-                        name: { type: 'string' },
-                        enabled: { type: 'boolean' },
-                        category: { type: 'string' },
-                    },
-                    additionalProperties: false,
-                },
-            },
-            totalTools: { type: 'number' },
-            enabledCount: { type: 'number' },
-            disabledCount: { type: 'number' },
-        },
-        outputRequired: ['tools', 'totalTools', 'enabledCount', 'disabledCount'],
-        effect: 'read',
-        exampleInput: { action: 'list_tools' },
-        exampleOutput: {
-            success: true,
-            message: 'Listed 23 tools (23 enabled, 0 disabled).',
-            tools: [{ name: 'manage_asset', enabled: true, category: 'core' }],
-            totalTools: 23,
-            enabledCount: 23,
-            disabledCount: 0,
-        },
-    },
-    {
-        action: 'list_categories',
-        family: 'tool-catalog',
-        topics: ['tool groups', 'core world gameplay utility'],
-        summary: 'List the four tool categories (core, world, gameplay, utility), each with its enabled flag, tool count and enabled tool count.',
-        whenToUse: ['Inspect the four categories (core, world, gameplay, utility).'],
-        whenNotToUse: ['When individual tool states are needed (use list_tools).'],
-        inputProps: {},
-        required: [],
-        outputProps: {
-            categories: {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    properties: {
-                        name: { type: 'string' },
-                        enabled: { type: 'boolean' },
-                        toolCount: { type: 'number' },
-                        enabledCount: { type: 'number' },
-                    },
-                    additionalProperties: false,
-                },
-            },
-            totalCategories: { type: 'number' },
-        },
-        outputRequired: ['categories', 'totalCategories'],
-        effect: 'read',
-        exampleInput: { action: 'list_categories' },
-        exampleOutput: {
-            success: true,
-            message: 'Listed 4 categories.',
-            categories: [{ name: 'core', enabled: true, toolCount: 8, enabledCount: 8 }],
-            totalCategories: 4,
-        },
-    },
-    {
-        action: 'enable_tools',
-        family: 'tool-visibility',
-        summary: 'Enable specific tools by name.',
-        whenToUse: ['Re-enable tools that were previously disabled.'],
-        whenNotToUse: ['When the tools are already enabled.'],
-        inputProps: { tools: TOOLS_ARRAY },
-        required: ['tools'],
-        outputProps: {
-            enabled: { type: 'array', items: { type: 'string' } },
-            notFound: { type: 'array', items: { type: 'string' } },
-        },
-        outputRequired: ['enabled'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        exampleInput: { action: 'enable_tools', tools: ['manage_asset'] },
-        exampleOutput: {
-            success: true,
-            message: 'Enabled 1 tools.',
-            enabled: ['manage_asset'],
-            notFound: [],
-        },
-    },
-    {
-        action: 'disable_tools',
-        family: 'tool-visibility',
-        summary: 'Disable specific tools by name.',
-        whenToUse: ['Hide non-essential tools from the MCP tool list.'],
-        whenNotToUse: [
-            'To disable protected tools (manage_tools, inspect) - they are protected and always enabled.',
-        ],
-        inputProps: { tools: TOOLS_ARRAY },
-        required: ['tools'],
-        outputProps: {
-            disabled: { type: 'array', items: { type: 'string' } },
-            notFound: { type: 'array', items: { type: 'string' } },
-            protected: { type: 'array', items: { type: 'string' } },
-        },
-        outputRequired: ['disabled', 'protected'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        exampleInput: { action: 'disable_tools', tools: ['manage_audio'] },
-        exampleOutput: {
-            success: true,
-            message: 'Disabled 1 tools.',
-            disabled: ['manage_audio'],
-            notFound: [],
-            protected: [],
-        },
-    },
-    {
-        action: 'enable_category',
-        family: 'tool-visibility',
-        summary: 'Enable all tools in a category.',
-        whenToUse: ['Re-enable an entire category or all categories at once.'],
-        whenNotToUse: ['When only specific tools need re-enabling (use enable_tools).'],
-        inputProps: { category: CATEGORY_ENUM },
-        required: ['category'],
-        outputProps: {
-            category: { type: 'string' },
-            enabled: { type: 'array', items: { type: 'string' } },
-        },
-        outputRequired: ['category', 'enabled'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        exampleInput: { action: 'enable_category', category: 'world' },
-        exampleOutput: {
-            success: true,
-            message: "Enabled category 'world' (4 tools).",
-            category: 'world',
-            enabled: ['build_environment', 'manage_geometry', 'manage_pcg', 'manage_level_structure'],
-        },
-    },
-    {
-        action: 'disable_category',
-        family: 'tool-visibility',
-        summary: 'Disable all tools in a category.',
-        whenToUse: ['Hide an entire non-essential category from the tool list.'],
-        whenNotToUse: [
-            'To disable the core category - it is protected and remains enabled.',
-        ],
-        inputProps: { category: CATEGORY_ENUM },
-        required: ['category'],
-        outputProps: {
-            category: { type: 'string' },
-            disabled: { type: 'array', items: { type: 'string' } },
-            protected: { type: 'array', items: { type: 'string' } },
-        },
-        outputRequired: ['category', 'disabled', 'protected'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        exampleInput: { action: 'disable_category', category: 'utility' },
-        exampleOutput: {
-            success: true,
-            message: "Disabled category 'utility' (3 tools disabled).",
-            category: 'utility',
-            disabled: ['manage_sequence', 'manage_audio', 'manage_networking'],
-            protected: [],
-        },
-    },
-    {
-        action: 'get_status',
-        family: 'tool-status',
-        topics: ['how many tools are enabled', 'catalog revision', 'enabled and disabled counts'],
-        summary: 'Read how many tools are enabled and disabled, the per-category breakdown, and the catalog revision numbers.',
-        whenToUse: ['Check aggregate tool visibility and per-category counts.'],
-        whenNotToUse: ['When individual tool detail is needed (use list_tools).'],
-        inputProps: {},
-        required: [],
-        outputProps: {
-            totalTools: { type: 'number' },
-            enabledTools: { type: 'number' },
-            disabledTools: { type: 'number' },
-            categories: {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    properties: {
-                        name: { type: 'string' },
-                        enabled: { type: 'boolean' },
-                        toolCount: { type: 'number' },
-                        enabledCount: { type: 'number' },
-                    },
-                    additionalProperties: false,
-                },
-            },
-        },
-        outputRequired: ['totalTools', 'enabledTools', 'disabledTools', 'categories'],
-        effect: 'read',
-        exampleInput: { action: 'get_status' },
-        exampleOutput: {
-            success: true,
-            message: '23/23 tools enabled.',
-            totalTools: 23,
-            enabledTools: 23,
-            disabledTools: 0,
-            categories: [{ name: 'core', enabled: true, toolCount: 8, enabledCount: 8 }],
-        },
-    },
-    {
-        action: 'get_task_result',
-        family: 'tool-status',
-        topics: ['task result', 'still running result', 'long call result', 'read finished call', 'task state'],
-        summary: 'Read a call that answered "still running": whether it is queued, running or done, and once done the reply it would have given.',
-        whenToUse: ['A call answered task.state running or queued, and its result is wanted without sending the call again.'],
-        whenNotToUse: ['The call answered with its result.'],
-        inputProps: {
-            taskId: { type: 'string', description: 'The task.taskId the still-running answer gave. Only the last 32 such calls of this server or editor session are kept.' },
-        },
-        required: ['taskId'],
-        outputProps: {
-            taskId: { type: 'string', description: 'The task read.' },
-            state: { type: 'string', enum: ['queued', 'running', 'done'], description: 'queued (waiting for the editor), running, or done.' },
-            progress: { type: 'number', description: 'While running, the share done (0-1) when the call reports progress.' },
-            outcome: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Once done: the call\'s own reply as it would have answered (success, message, errorCode, data, and its receipt with what changed).' },
-        },
-        outputRequired: ['taskId', 'state'],
-        effect: 'read',
-        exampleInput: { action: 'get_task_result', taskId: 'num:12' },
-        exampleOutput: {
-            success: true,
-            message: 'Task num:12 is done.',
-            taskId: 'num:12',
-            state: 'done',
-            outcome: { success: true, message: 'Render finished' },
-        },
-    },
-    {
-        action: 'reset',
-        family: 'tool-visibility',
-        summary: 'Reset all tools and categories to their default enabled state.',
-        whenToUse: ['Restore the full default tool set after disabling tools or categories.'],
-        whenNotToUse: ['When only a subset needs re-enabling (use enable_tools or enable_category).'],
-        inputProps: {},
-        required: [],
-        outputProps: {
-            enabled: { type: 'number' },
-        },
-        outputRequired: ['enabled'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        exampleInput: { action: 'reset' },
-        exampleOutput: {
-            success: true,
-            message: 'Reset complete. 0 tools re-enabled.',
-            enabled: 0,
-        },
-    },
-];
-export const MANAGE_TOOLS_SOURCES = SPECS.map((spec) => buildCoreRecord({ parentTool: 'manage_tools', domain: 'tools', editorStates: ANY_EDITOR_STATE, ...spec }));
-//# sourceMappingURL=index.js.map

package/dist/tools/catalog/capabilities/records/parent-metadata.d.ts

@@ -1,8 +0,0 @@
-import type { LegacyToolName } from '../identifiers.js';
-export type ParentToolMetadata = {
-    readonly parent: LegacyToolName;
-    readonly description: string;
-    readonly category: 'core' | 'world' | 'gameplay' | 'utility';
-};
-export declare function getParentToolMetadata(parentTool: string): ParentToolMetadata;
-//# sourceMappingURL=parent-metadata.d.ts.map