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

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

@@ -1,146 +0,0 @@
-import { A } from './alias-props.js';
-import { buildRecord, MRQ_PLUGINS, P } from './helpers.js';
-const F = 'mrq';
-const D = 'movie_render';
-const OUTPUT_SETTINGS = {
-    outputDirectory: P.outputDirectory,
-    fileNameFormat: P.fileNameFormat, resolution: P.mrqResolution,
-    width: P.width, height: P.height, frameRate: P.frameRate,
-    startFrame: P.startFrame,
-    endFrame: { type: 'integer', minimum: 1, description: 'Custom playback range end frame, EXCLUSIVE: must be strictly greater than startFrame. 0..1 renders exactly one frame; 0..0 renders nothing and is refused as INVALID_FRAME_RANGE.' },
-    audioOutput: { type: 'boolean', description: 'true also writes a .wav of everything the world played during the render (music, effects, gameplay sounds) beside the frames; false removes it. MRQ records audio only when the editor runs with -DeterministicAudio, and the reply warns when it does not.' },
-    gameModeOverride: { type: 'string', description: 'The game mode the render plays. Unset, MRQ uses its cinematic game mode, which spawns no player pawn and no HUD: right for a cinematic, empty for gameplay. "level" plays the level\'s own game mode (its pawn, HUD and rules); a class path (/Game/X/BP_Mode or /Script/Module.Class) plays that one.' },
-};
-const JOB_SELECTOR = ['jobId', 'renderJobName'];
-const OUTPUT_ONLY_SETTINGS = {
-    type: 'object',
-    description: 'Nested output settings.',
-    additionalProperties: false,
-    properties: {
-        handleFrameCount: P.mrqSettings.properties.handleFrameCount,
-        zeroPadFrameNumbers: P.mrqSettings.properties.zeroPadFrameNumbers,
-    },
-};
-export const MRQ_RECORDS = [
-    buildRecord({
-        id: 'sequence.mrq.create_render_job', action: 'create_render_job', family: F, domain: D,
-        summary: 'Create a new Movie Render Queue job for a sequence.',
-        whenToUse: ['A new render job must be created for a cinematic sequence.'],
-        whenNotToUse: ['A render job already exists for the sequence.'],
-        inputProps: { sequencePath: P.sequencePath, mapPath: P.mapPath, renderJobName: P.renderJobName, jobName: A.jobName, ...OUTPUT_SETTINGS, settings: OUTPUT_ONLY_SETTINGS },
-        required: ['sequencePath'],
-        outputProps: { jobId: P.jobId },
-        outputRequired: ['jobId'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: MRQ_PLUGINS,
-        exampleInput: { action: 'create_render_job', sequencePath: '/Game/Cinematics/SEQ_Master', mapPath: '/Game/Maps/M_Cinematics' },
-        exampleOutput: { success: true, jobId: 'render-job-1' },
-    }),
-    buildRecord({
-        id: 'sequence.mrq.configure_output_settings', action: 'configure_output_settings', family: F, domain: D,
-        summary: 'Configure output resolution, format, and directory for an MRQ job.',
-        whenToUse: ['Render output settings must be specified.'],
-        whenNotToUse: ['The job does not exist.'],
-        inputProps: {
-            jobId: P.jobId, ...OUTPUT_SETTINGS,
-            settings: P.mrqSettings,
-            renderJobName: P.renderJobName,
-        },
-        requiredOneOf: JOB_SELECTOR,
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: MRQ_PLUGINS,
-        exampleInput: { action: 'configure_output_settings', jobId: 'render-job-1', outputDirectory: '/tmp/renders', resolution: '1920x1080' },
-    }),
-    buildRecord({
-        id: 'sequence.mrq.add_render_pass', action: 'add_render_pass', family: F, domain: D,
-        summary: 'Add a render pass (beauty, depth, object ID, the game UI layer, etc.) to an MRQ job.',
-        whenToUse: ['An additional render pass must be added to the job.', 'A render of gameplay must show the HUD and menus (renderPass ui).'],
-        whenNotToUse: ['The pass is not supported by the MRQ configuration.'],
-        inputProps: {
-            jobId: P.jobId, renderJobName: P.renderJobName, renderPass: P.renderPass,
-            renderPasses: P.renderPasses, materialPath: P.materialPath,
-            includeTranslucentObjects: P.includeTranslucentObjects,
-            compositeOntoFinalImage: { type: 'boolean', description: 'For the ui pass: draw the UI over the final image (default true); false writes it as its own ViewportUI layer.' },
-        },
-        requiredOneOf: JOB_SELECTOR,
-        effect: 'write', latency: 'instant', resources: 'low', plugins: MRQ_PLUGINS,
-        exampleInput: { action: 'add_render_pass', jobId: 'render-job-1', renderPass: 'beauty' },
-    }),
-    buildRecord({
-        id: 'sequence.mrq.configure_anti_aliasing', action: 'configure_anti_aliasing', family: F, domain: D,
-        summary: 'Configure anti-aliasing method and sample counts for an MRQ job.',
-        whenToUse: ['Anti-aliasing settings must be specified for render quality.'],
-        whenNotToUse: ['Default anti-aliasing is acceptable.'],
-        inputProps: { jobId: P.jobId, renderJobName: P.renderJobName, antiAliasingMethod: P.antiAliasingMethod, method: A.method, spatialSampleCount: P.sampleCount, temporalSampleCount: P.sampleCount, settings: P.mrqSettings },
-        requiredOneOf: JOB_SELECTOR,
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: MRQ_PLUGINS,
-        exampleInput: { action: 'configure_anti_aliasing', jobId: 'render-job-1', antiAliasingMethod: 'TSAA', spatialSampleCount: 4, temporalSampleCount: 4 },
-    }),
-    buildRecord({
-        id: 'sequence.mrq.configure_console_variables', action: 'configure_console_variables', family: F, domain: D,
-        summary: 'Set console variables for an MRQ job render.',
-        whenToUse: ['CVars must be set for render-specific behavior.'],
-        whenNotToUse: ['Default CVars are acceptable.'],
-        inputProps: { jobId: P.jobId, renderJobName: P.renderJobName, consoleVariables: { type: 'object', description: 'CVar name-value pairs.', additionalProperties: true, 'x-unreal-reflection-boundary': true } },
-        required: ['consoleVariables'],
-        requiredOneOf: JOB_SELECTOR,
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: MRQ_PLUGINS,
-        exampleInput: { action: 'configure_console_variables', jobId: 'render-job-1', consoleVariables: { 'r.AntiAliasingMethod': 2 } },
-    }),
-    buildRecord({
-        id: 'sequence.mrq.configure_burn_ins', action: 'configure_burn_ins', family: F, domain: D,
-        summary: 'Configure burn-in overlay settings for an MRQ job.',
-        whenToUse: ['Burn-in overlays must be composited onto rendered frames.'],
-        whenNotToUse: ['Burn-ins are not needed for the render.'],
-        inputProps: { jobId: P.jobId, renderJobName: P.renderJobName, burnIn: { type: 'object', description: 'Burn-in settings.', additionalProperties: false, properties: { enabled: { type: 'boolean', description: 'Whether burn-ins are enabled.' }, compositeOntoFinalImage: { type: 'boolean', description: 'Whether to composite onto the final image.' }, classPath: P.burnInClassPath }, required: ['enabled'] } },
-        requiredOneOf: JOB_SELECTOR,
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: MRQ_PLUGINS,
-        exampleInput: { action: 'configure_burn_ins', jobId: 'render-job-1', burnIn: { enabled: true, compositeOntoFinalImage: true, classPath: '/Script/MovieRenderPipelineCore.MoviePipelineBurnInWidget' } },
-    }),
-    buildRecord({
-        id: 'sequence.mrq.queue_render', action: 'queue_render', family: F, domain: D,
-        summary: 'Enable a render job in the MRQ queue without starting execution. Enqueue does NOT mean render completion.',
-        whenToUse: ['A job must be added to the render queue for later execution.'],
-        whenNotToUse: ['The render should start immediately. Use start_render instead.'],
-        inputProps: { jobId: P.jobId, renderJobId: A.renderJobId, renderJobName: P.renderJobName, onlyJob: { type: 'boolean', description: 'Whether to queue only this job.' }, useCurrentLevel: P.useCurrentLevel },
-        requiredOneOf: JOB_SELECTOR,
-        outputProps: { message: P.message },
-        outputRequired: [],
-        effect: 'write', latency: 'instant', resources: 'low', plugins: MRQ_PLUGINS,
-        exampleInput: { action: 'queue_render', jobId: 'render-job-1' },
-    }),
-    buildRecord({
-        id: 'sequence.mrq.start_render', action: 'start_render', family: F, domain: D,
-        summary: 'Start MRQ render execution. Blocks until completion, fatal error, or timeout. Supports advisory cancellation. renderTimeoutMs (how long the render may run before it is cancelled) defaults to and is capped at 300000 (5 minutes); the transport waits 35000ms longer for the reply.',
-        whenToUse: ['The MRQ queue must be executed to produce rendered output files.'],
-        whenNotToUse: ['A render is already in progress (MRQ_ALREADY_RENDERING).'],
-        inputProps: { jobId: P.jobId, renderJobName: P.renderJobName, onlyJob: { type: 'boolean', description: 'Render only this job; every other queued job is disabled for this render.' }, renderTimeoutMs: { type: 'integer', minimum: 1, maximum: 300000, description: 'How long the render may run before it is cancelled, in milliseconds (default and maximum 300000). options.timeoutMs is the gateway deadline for the call and never reaches the render.' }, executorClass: P.executorClass, useCurrentLevel: P.useCurrentLevel },
-        requiredOneOf: JOB_SELECTOR,
-        outputProps: {
-            outputDirectory: P.outputDirectory,
-            renderContinuesAsynchronously: { type: 'boolean', description: 'Whether render continued asynchronously after timeout.' },
-            bCancellationDeadlineExpired: { type: 'boolean', description: 'Whether the cancellation deadline expired.' },
-        },
-        outputRequired: [],
-        effect: 'write',
-        behavior: { longRunning: true, safeToRetry: false },
-        latency: 'long-running', resources: 'high', plugins: MRQ_PLUGINS,
-        exampleInput: { action: 'start_render', jobId: 'render-job-1' },
-        exampleOutput: { success: true, outputDirectory: '/tmp/renders', renderContinuesAsynchronously: false, bCancellationDeadlineExpired: false },
-    }),
-    buildRecord({
-        id: 'sequence.mrq.remove_render_job', action: 'remove_render_job', family: F, domain: D,
-        summary: 'Remove a render job from the Movie Render Queue, or every job (allJobs). Rendered files stay on disk. The queue holds a limited number of jobs, and a finished job stays queued (an unrestricted start renders it again), so remove finished ones before creating more.',
-        whenToUse: ['create_render_job answered MRQ_RESOURCE_LIMIT_EXCEEDED: the queue is full.', 'Finished jobs would render again with the next start.'],
-        whenNotToUse: ['A render is running (MRQ_ALREADY_RENDERING).'],
-        inputProps: { jobId: P.jobId, renderJobName: P.renderJobName, allJobs: { type: 'boolean', description: 'Remove every job in the queue instead of one.' } },
-        requiredOneOf: ['jobId', 'renderJobName', 'allJobs'],
-        outputProps: {
-            removedCount: { type: 'integer', description: 'Jobs removed.' },
-            queueJobCount: { type: 'integer', description: 'Jobs left in the queue.' },
-        },
-        outputRequired: [],
-        effect: 'write', latency: 'instant', resources: 'low', plugins: MRQ_PLUGINS,
-        exampleInput: { action: 'remove_render_job', allJobs: true },
-        exampleOutput: { success: true, removedCount: 3, queueJobCount: 0 },
-    }),
-];
-//# sourceMappingURL=mrq.js.map

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

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

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

@@ -1,103 +0,0 @@
-import { buildRecord, P } from './helpers.js';
-const F = 'replay';
-const D = 'replay';
-const REPLAY_PLUGINS = ['LevelSequenceEditor', 'OnlineSubsystem'];
-export const REPLAY_RECORDS = [
-    buildRecord({
-        id: 'sequence.replay.start_demo_recording', action: 'start_demo_recording', family: F, domain: D,
-        summary: 'Start recording a demo replay to disk. Recording runs until stop_demo_recording. No interrupt/cancel.',
-        whenToUse: ['A demo replay must be recorded.'],
-        whenNotToUse: ['A recording is already in progress (ALREADY_RECORDING).'],
-        inputProps: { replayName: P.replayName, demoName: P.demoName, friendlyName: P.friendlyName, additionalOptions: P.additionalOptions },
-        effect: 'write',
-        behavior: { longRunning: true, safeToRetry: false },
-        latency: 'long-running', resources: 'medium', plugins: REPLAY_PLUGINS,
-        editorStates: ['edit', 'pie'],
-        exampleInput: { action: 'start_demo_recording', replayName: 'Demo_01' },
-    }),
-    buildRecord({
-        id: 'sequence.replay.stop_demo_recording', action: 'stop_demo_recording', family: F, domain: D,
-        summary: 'Stop demo recording and return the replay name.',
-        whenToUse: ['An in-progress demo recording must be stopped.'],
-        whenNotToUse: ['No recording is in progress (NOT_RECORDING).'],
-        inputProps: {},
-        outputProps: { replayName: P.replayName },
-        outputRequired: ['replayName'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: REPLAY_PLUGINS,
-        editorStates: ['edit', 'pie'],
-        exampleInput: { action: 'stop_demo_recording' },
-        exampleOutput: { success: true, replayName: 'Demo_01' },
-    }),
-    buildRecord({
-        id: 'sequence.replay.configure_demo_settings', action: 'configure_demo_settings', family: F, domain: D,
-        summary: 'Configure replay settings (max record time, checkpoint interval, speed, actor priority).',
-        whenToUse: ['Replay recording settings must be configured before recording.'],
-        whenNotToUse: ['Default replay settings are acceptable.'],
-        inputProps: { replayName: { type: 'string', description: 'Default replay name for recordings that do not name one.' }, maxRecordTimeSeconds: { type: 'number', description: 'Max record time (<=86400).' }, checkpointSaveMaxMSPerFrame: { type: 'number', description: 'Max checkpoint save MS per frame (<=1000).' }, playbackSpeed: P.speed, prioritizeActors: P.prioritizeActors, loadDefaultMapOnStop: { type: 'boolean', description: 'Whether to load the default map on stop.' }, friendlyName: P.friendlyName, additionalOptions: P.additionalOptions },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: REPLAY_PLUGINS,
-        exampleInput: { action: 'configure_demo_settings', maxRecordTimeSeconds: 300, checkpointSaveMaxMSPerFrame: 100 },
-    }),
-    buildRecord({
-        id: 'sequence.replay.play_demo', action: 'play_demo', family: F, domain: D,
-        summary: 'Start playing a recorded demo replay.',
-        whenToUse: ['A recorded demo replay must be played back.'],
-        whenNotToUse: ['A recording is in progress (ALREADY_PLAYING).'],
-        inputProps: { demoName: P.demoName, replayName: P.replayName, additionalOptions: P.additionalOptions },
-        effect: 'write', latency: 'instant', resources: 'medium', plugins: REPLAY_PLUGINS,
-        editorStates: ['edit', 'pie'],
-        exampleInput: { action: 'play_demo', demoName: 'Demo_01' },
-    }),
-    buildRecord({
-        id: 'sequence.replay.pause_demo', action: 'pause_demo', family: F, domain: D,
-        summary: 'Pause demo replay playback.',
-        whenToUse: ['Demo playback must be paused.'],
-        whenNotToUse: ['Demo is not playing.'],
-        inputProps: { paused: P.paused },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: REPLAY_PLUGINS,
-        editorStates: ['edit', 'pie'],
-        exampleInput: { action: 'pause_demo' },
-    }),
-    buildRecord({
-        id: 'sequence.replay.seek_demo', action: 'seek_demo', family: F, domain: D,
-        summary: 'Seek to a specific time in demo replay playback.',
-        whenToUse: ['Demo playback must be seeked to a specific time.'],
-        whenNotToUse: ['Demo is not playing.'],
-        inputProps: { timeSeconds: { type: 'number', description: 'Seek time in seconds (<=86400).' }, seconds: { type: 'number', description: 'Seek time in seconds (alias of timeSeconds).' } },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: REPLAY_PLUGINS,
-        editorStates: ['edit', 'pie'],
-        exampleInput: { action: 'seek_demo', timeSeconds: 10.0 },
-    }),
-    buildRecord({
-        id: 'sequence.replay.set_demo_playback_speed', action: 'set_demo_playback_speed', family: F, domain: D,
-        summary: 'Set demo replay playback speed (max 16x).',
-        whenToUse: ['Demo playback speed must be changed.'],
-        whenNotToUse: ['Demo is not playing.'],
-        inputProps: { speed: P.speed, playbackSpeed: P.speed },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: REPLAY_PLUGINS,
-        editorStates: ['edit', 'pie'],
-        exampleInput: { action: 'set_demo_playback_speed', speed: 2.0 },
-    }),
-    buildRecord({
-        id: 'sequence.replay.configure_killcam_duration', action: 'configure_killcam_duration', family: F, domain: D,
-        summary: 'Configure killcam replay duration (max 600 seconds).',
-        whenToUse: ['Killcam duration must be set for replay-based kill cameras.'],
-        whenNotToUse: ['No killcam is needed.'],
-        inputProps: { durationSeconds: { type: 'number', description: 'Killcam duration in seconds (<=600).' } },
-        required: ['durationSeconds'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: REPLAY_PLUGINS,
-        exampleInput: { action: 'configure_killcam_duration', durationSeconds: 5.0 },
-    }),
-    buildRecord({
-        id: 'sequence.replay.start_killcam', action: 'start_killcam', family: F, domain: D,
-        summary: 'Start a killcam replay playback for a specific duration.',
-        whenToUse: ['A killcam replay must be triggered.'],
-        whenNotToUse: ['No killcam is needed.'],
-        inputProps: { demoName: P.demoName, replayName: P.replayName, durationSeconds: { type: 'number', description: 'Killcam duration in seconds (<=600).' }, additionalOptions: P.additionalOptions },
-        effect: 'write',
-        behavior: { longRunning: true, safeToRetry: false },
-        latency: 'long-running', resources: 'medium', plugins: REPLAY_PLUGINS,
-        editorStates: ['edit', 'pie'],
-        exampleInput: { action: 'start_killcam', demoName: 'Demo_01', durationSeconds: 3.0 },
-    }),
-];
-//# sourceMappingURL=replay.js.map

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

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

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

@@ -1,59 +0,0 @@
-import { A } from './alias-props.js';
-import { buildRecord, P, TAKE_PLUGINS } from './helpers.js';
-const F = 'take';
-const D = 'take_recorder';
-const REDUCE_KEYS = { type: 'boolean', description: 'Whether to reduce keyframes.' };
-export const TAKE_RECORDS = [
-    buildRecord({
-        id: 'sequence.take.create_take_recorder_panel', action: 'create_take_recorder_panel', family: F, domain: D,
-        summary: 'Open or focus the Take Recorder panel in the editor.',
-        whenToUse: ['The Take Recorder panel must be opened for recording.'],
-        whenNotToUse: ['The panel is already open.'],
-        inputProps: {},
-        effect: 'write', latency: 'instant', resources: 'low', plugins: TAKE_PLUGINS,
-        exampleInput: { action: 'create_take_recorder_panel' },
-    }),
-    buildRecord({
-        id: 'sequence.take.configure_take_sources', action: 'configure_take_sources', family: F, domain: D,
-        summary: 'Configure Take Recorder sources (actors, components) for recording.',
-        whenToUse: ['Recording sources must be specified before starting a take.'],
-        whenNotToUse: ['Sources are already configured.'],
-        inputProps: { sourceActors: P.actorNames, actorNames: P.actorNames, actorName: P.actorName, sourceClasses: P.sourceClasses, clearSources: P.clearSources, takePresetPath: P.takePresetPath, recordType: P.recordType, actors: A.actors, recordParentHierarchy: A.recordParentHierarchy, reduceKeys: REDUCE_KEYS, recordingSequencePath: P.recordingSequencePath, takeSequencePath: P.takeSequencePath, sequencePath: P.sequencePath, frameRate: P.frameRate, recordInto: P.recordInto },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: TAKE_PLUGINS,
-        exampleInput: { action: 'configure_take_sources', sourceActors: ['Actor1', 'Actor2'] },
-    }),
-    buildRecord({
-        id: 'sequence.take.start_recording', action: 'start_recording', family: F, domain: D,
-        summary: 'Start a Take Recorder recording into a Level Sequence. It runs for duration seconds when given, otherwise until stop_recording. No interrupt/cancel available.',
-        whenToUse: ['A take recording must be started.'],
-        whenNotToUse: ['A recording is already in progress (ALREADY_RECORDING).'],
-        inputProps: { sequencePath: P.sequencePath, recordingSequencePath: P.recordingSequencePath, takeSequencePath: P.takeSequencePath, recordInto: P.recordInto, frameRate: P.frameRate, duration: { type: 'number', minimum: 0, maximum: 86400, description: 'Seconds (above 0) to record after the countdown before the take stops by itself.' }, sourceActors: P.actorNames, actorNames: P.actorNames, actorName: P.actorName, sourceClasses: P.sourceClasses, clearSources: P.clearSources, recordType: P.recordType, recordParentHierarchy: A.recordParentHierarchy, reduceKeys: REDUCE_KEYS },
-        effect: 'write',
-        behavior: { longRunning: true, safeToRetry: false },
-        latency: 'long-running', resources: 'medium', plugins: TAKE_PLUGINS,
-        editorStates: ['edit'],
-        exampleInput: { action: 'start_recording', recordingSequencePath: '/Game/Takes/SEQ_Take01' },
-    }),
-    buildRecord({
-        id: 'sequence.take.stop_recording', action: 'stop_recording', family: F, domain: D,
-        summary: 'Stop a Take Recorder recording and finalize the recorded Level Sequence. Returns hasRecordedData.',
-        whenToUse: ['An in-progress take recording must be stopped and finalized.'],
-        whenNotToUse: ['No recording is in progress (NOT_RECORDING).'],
-        inputProps: {},
-        outputProps: { hasRecordedData: { type: 'boolean', description: 'Whether recorded data was captured.' }, sequencePath: P.sequencePath },
-        outputRequired: ['hasRecordedData'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: TAKE_PLUGINS,
-        exampleInput: { action: 'stop_recording' },
-        exampleOutput: { success: true, hasRecordedData: true, sequencePath: '/Game/Takes/SEQ_Take01' },
-    }),
-    buildRecord({
-        id: 'sequence.take.configure_recorded_tracks', action: 'configure_recorded_tracks', family: F, domain: D,
-        summary: 'Configure which tracks are recorded for each Take Recorder source.',
-        whenToUse: ['Specific tracks (transform, animation, etc.) must be recorded per source.'],
-        whenNotToUse: ['Default track recording is sufficient.'],
-        inputProps: { sourceActors: P.actorNames, actorNames: P.actorNames, actorName: P.actorName, tracks: P.recordedTracks, reduceKeys: REDUCE_KEYS, sequencePath: P.sequencePath, frameRate: P.frameRate, recordInto: P.recordInto, properties: A.properties, trackNames: A.trackNames, actors: A.actors, enabled: A.enabled, disableOthers: A.disableOthers, recordParentHierarchy: A.recordParentHierarchy, recordType: P.recordType },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: TAKE_PLUGINS,
-        exampleInput: { action: 'configure_recorded_tracks', sourceActors: ['Actor1'], tracks: ['transform', 'animation'] },
-    }),
-];
-//# sourceMappingURL=take.js.map

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

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

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

@@ -1,88 +0,0 @@
-import { buildRecord, P, SEQ_PLUGINS } from './helpers.js';
-const F = 'timeline';
-const D = 'sequence';
-export const TIMELINE_BINDINGS_RECORDS = [
-    buildRecord({
-        id: 'sequence.add_camera', action: 'add_camera', family: F, domain: D,
-        summary: 'Add a camera binding (possessable or spawnable) to a Level Sequence.',
-        whenToUse: ['A camera must be added to the sequence for cinematic shots.'],
-        whenNotToUse: ['The camera already exists as a binding.'],
-        inputProps: { path: P.path, actorName: P.actorName, spawnable: { type: 'boolean', description: 'Add a spawnable camera owned by the sequence instead of placing a camera actor in the level (default false).' } },
-        required: ['path'],
-        outputProps: { bindingGuid: { type: 'string', description: 'The binding GUID.' } },
-        outputRequired: [],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'add_camera', path: '/Game/Cinematics/SEQ_Master' },
-    }),
-    buildRecord({
-        id: 'sequence.add_actor', action: 'add_actor', family: F, domain: D,
-        summary: 'Bind an existing level actor to a Level Sequence as a possessable.',
-        whenToUse: ['An existing actor must be added to the sequence.'],
-        whenNotToUse: ['The actor does not exist in the current level.'],
-        inputProps: { path: P.path, actorName: P.actorName },
-        required: ['path', 'actorName'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'add_actor', path: '/Game/Cinematics/SEQ_Master', actorName: 'MyActor' },
-    }),
-    buildRecord({
-        id: 'sequence.add_actors', action: 'add_actors', family: F, domain: D,
-        summary: 'Bind multiple existing level actors to a Level Sequence.',
-        whenToUse: ['Multiple actors must be bound at once.'],
-        whenNotToUse: ['Only a single actor is needed.'],
-        inputProps: { path: P.path, actorNames: P.actorNames },
-        required: ['path', 'actorNames'],
-        outputProps: { results: { type: 'array', items: { type: 'object', description: 'Per-actor binding result.', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Per-actor result: actorName, success, bindingGuid or error.' }, total: { type: 'number', description: 'Actor names supplied.' }, successful: { type: 'number', description: 'Actors actually bound.' }, failed: { type: 'number', description: 'Actor names that could not be bound.' } },
-        outputRequired: ['results', 'total', 'successful', 'failed'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'add_actors', path: '/Game/Cinematics/SEQ_Master', actorNames: ['Actor1', 'Actor2'] },
-        exampleOutput: { success: true, message: 'Actors processed', total: 2, successful: 2, failed: 0, results: [{ actorName: 'Actor1', success: true, bindingGuid: 'ABC-123' }] },
-    }),
-    buildRecord({
-        id: 'sequence.remove_actors', action: 'remove_actors', family: F, domain: D,
-        summary: 'Remove actor bindings from a Level Sequence.',
-        whenToUse: ['Bound actors must be removed from the sequence.'],
-        whenNotToUse: ['The actors are not bound to the sequence.'],
-        inputProps: { path: P.path, actorNames: P.actorNames },
-        required: ['path', 'actorNames'],
-        outputProps: { results: { type: 'array', items: { type: 'object', description: 'Per-actor removal result.', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Per-actor result: actorName, success or error.' }, total: { type: 'number', description: 'Actor names supplied.' }, successful: { type: 'number', description: 'Bindings actually removed.' }, failed: { type: 'number', description: 'Actor names with no binding to remove.' } },
-        outputRequired: ['results', 'total', 'successful', 'failed'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'remove_actors', path: '/Game/Cinematics/SEQ_Master', actorNames: ['Actor1'] },
-        exampleOutput: { success: true, message: 'Actors processed', total: 1, successful: 1, failed: 0, results: [{ actorName: 'Actor1', success: true }] },
-    }),
-    buildRecord({
-        id: 'sequence.get_bindings', action: 'get_bindings', family: F, domain: D,
-        summary: 'List all bindings (possessables and spawnables) in a Level Sequence.',
-        whenToUse: ['Sequence bindings must be enumerated.'],
-        whenNotToUse: ['A specific binding GUID is already known.'],
-        inputProps: { path: P.path },
-        required: ['path'],
-        outputProps: { bindings: { type: 'array', items: { type: 'object', description: 'Binding info.', additionalProperties: false, properties: { id: { type: 'string', description: 'Binding GUID (object guid string).' }, name: P.actorName }, required: ['id', 'name'] }, description: 'Sequence bindings.' } },
-        outputRequired: ['bindings'],
-        effect: 'read', latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'get_bindings', path: '/Game/Cinematics/SEQ_Master' },
-        exampleOutput: { success: true, bindings: [{ id: 'ABC-123', name: 'Camera1' }] },
-    }),
-    buildRecord({
-        id: 'sequence.add_spawnable_from_class', action: 'add_spawnable_from_class', family: F, domain: D,
-        summary: 'Add a spawnable binding from a Unreal class path to a Level Sequence.',
-        whenToUse: ['A spawnable actor must be created from a class.'],
-        whenNotToUse: ['An existing level actor should be possessed instead.'],
-        inputProps: { path: P.path, className: P.className },
-        required: ['path', 'className'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'add_spawnable_from_class', path: '/Game/Cinematics/SEQ_Master', className: '/Script/Engine.PointLight' },
-    }),
-    buildRecord({
-        id: 'sequence.add_keyframe', action: 'add_keyframe', family: F, domain: D,
-        summary: 'Add a keyframe for a property at a specific frame on a bound actor.',
-        whenToUse: ['A property value must be animated at a specific frame.'],
-        whenNotToUse: ['The actor is not bound to the sequence.'],
-        inputProps: { path: P.path, actorName: P.actorName, bindingId: P.bindingId, property: { ...P.property, description: 'Property to key: Transform, Location, Rotation or Scale; Visibility, which shows (true) or hides (false) the bound actor in the editor and in renders; or a float or bool property by name.' }, frame: P.frame, value: { description: 'Keyframe value. For property "Transform" pass a composed object with any subset of {location:{x,y,z}, rotation:{pitch,yaw,roll}, scale:{x,y,z}}; each component supplied must carry all of its finite axes; a new Transform track starts from the current transform of the actor, so the parts a key leaves out keep their values. Add lookAt:{x,y,z} beside location to aim the key at that point (a camera at its subject): pitch and yaw are worked out, roll comes from rotation.roll or 0, and the yaw turns the short way from the key before, so an orbit of aimed keys never spins round. For "Location"/"Rotation"/"Scale" pass that component object alone. Visibility takes true or false; other properties take their own scalar value, so no type is declared here.' }, interpolation: { type: 'string', enum: ['auto', 'linear', 'constant'], description: 'How the curve leaves this key: auto (default) a smooth curve through the keys, linear a steady rate to the next key (a bullet, a constant pan), constant a hold that jumps at the next key.' }, keys: { type: 'array', minItems: 1, maxItems: 500, items: { type: 'object', properties: { frame: { type: 'integer', description: 'Frame number for this key.' }, value: { description: 'Key value, in the form value takes.' }, interpolation: { type: 'string', enum: ['auto', 'linear', 'constant'], description: 'How the curve leaves this key; default the interpolation of the call.' } }, required: ['frame', 'value'], additionalProperties: false }, description: 'Several keys on this property in one call, in place of frame and value: a whole curve, or a flash shown on one frame and hidden on the next. Each entry is {frame, value, interpolation}; they are written in order, so lookAt keys turn the short way from the entry before. Every frame is checked before any key is written.' } },
-        required: ['path'],
-        requiredOneOf: ['bindingId', 'actorName'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'add_keyframe', path: '/Game/Cinematics/SEQ_Master', actorName: 'Cube', property: 'Transform', frame: 0, value: { location: { x: 0, y: 0, z: 100 } } },
-    }),
-];
-//# sourceMappingURL=timeline-bindings.js.map

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

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

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

@@ -1,132 +0,0 @@
-import { buildRecord, P, SEQ_PLUGINS } from './helpers.js';
-import { str } from '../shared/schema-props.js';
-const FAMILY = 'timeline';
-const DOMAIN = 'sequence';
-export const TIMELINE_LIFECYCLE_RECORDS = [
-    buildRecord({
-        id: 'sequence.create',
-        action: 'create',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['level sequence', 'new sequence', 'cinematic', 'sequencer', 'create cinematic', 'cutscene', 'make a cutscene', 'level sequence asset', 'create level sequence'],
-        aliases: ['sequence.create_level_sequence', 'sequence.create_cinematic'],
-        summary: 'Create a new Level Sequence asset in the content browser.',
-        whenToUse: ['A new cinematic or animation sequence asset is needed.'],
-        whenNotToUse: ['An existing sequence should be opened instead.'],
-        inputProps: {
-            name: str('Name of the new sequence, made in the folder path names (default /Game). Leave it out when path names the sequence itself.'),
-            path: str('Sequence asset path, such as /Game/Cinematics/SEQ_Shot; with name, create reads it as the folder instead.'),
-        },
-        required: [],
-        requiredOneOf: ['name', 'path'],
-        outputProps: {
-            assetPath: { type: 'string', description: 'Created sequence asset path (verification).' },
-            assetName: { type: 'string', description: 'Created sequence asset name (verification).' },
-            assetClass: { type: 'string', description: 'Created sequence asset class (verification).' },
-            verifiedPath: { type: 'string', description: 'Verified existing asset path.' },
-            existsAfter: { type: 'boolean', description: 'Whether the asset existed after the call.' },
-        },
-        outputRequired: [],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'create', name: 'SEQ_Master', path: '/Game/Cinematics' },
-        exampleOutput: { success: true, assetPath: '/Game/Cinematics/SEQ_Master', assetName: 'SEQ_Master', existsAfter: true },
-    }),
-    buildRecord({
-        id: 'sequence.open',
-        action: 'open',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Open an existing Level Sequence in the Sequencer editor.',
-        whenToUse: ['An existing sequence must be opened for editing.'],
-        whenNotToUse: ['A new sequence should be created instead.'],
-        inputProps: { path: P.path },
-        required: ['path'],
-        effect: 'read',
-        latency: 'instant',
-        resources: 'low',
-        plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'open', path: '/Game/Cinematics/SEQ_Master' },
-    }),
-    buildRecord({
-        id: 'sequence.duplicate',
-        action: 'duplicate',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Duplicate a Level Sequence asset to a new destination.',
-        whenToUse: ['A sequence must be copied to a different folder or name.'],
-        whenNotToUse: ['The sequence should be renamed in place.'],
-        inputProps: { path: P.path, destinationPath: P.destinationPath, newName: P.newName },
-        required: ['path', 'destinationPath', 'newName'],
-        outputProps: { sequencePath: P.sequencePath },
-        outputRequired: ['sequencePath'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'duplicate', path: '/Game/Cinematics/SEQ_Master', destinationPath: '/Game/Cinematics/Copies', newName: 'SEQ_Copy' },
-        exampleOutput: { success: true, sequencePath: '/Game/Cinematics/Copies/SEQ_Copy' },
-    }),
-    buildRecord({
-        id: 'sequence.rename',
-        action: 'rename',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Rename a Level Sequence asset in place.',
-        whenToUse: ['A sequence asset needs a new name.'],
-        whenNotToUse: ['The sequence should be duplicated to preserve the original.'],
-        inputProps: { path: P.path, newName: P.newName },
-        required: ['path', 'newName'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        latency: 'interactive',
-        resources: 'low',
-        plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'rename', path: '/Game/Cinematics/SEQ_Master', newName: 'SEQ_Renamed' },
-    }),
-    buildRecord({
-        id: 'sequence.delete',
-        action: 'delete',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Permanently delete a Level Sequence asset.',
-        whenToUse: ['A sequence asset must be permanently removed.'],
-        whenNotToUse: ['The sequence should only be unloaded or hidden.'],
-        inputProps: { path: P.path },
-        required: ['path'],
-        effect: 'destructive',
-        outputProps: {
-            deletedPath: { type: 'string', description: 'Package path of the deleted sequence asset.' },
-            existsAfter: { type: 'boolean', description: 'Whether the asset still exists after the delete.' },
-        },
-        behavior: { safeToRetry: false },
-        latency: 'interactive',
-        resources: 'low',
-        plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'delete', path: '/Game/Cinematics/SEQ_Disposable' },
-    }),
-    buildRecord({
-        id: 'sequence.list',
-        action: 'list',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'List Level Sequence assets under a content folder (recursively; the whole Game folder when path is omitted).',
-        whenToUse: ['Available sequences under a folder must be enumerated.'],
-        whenNotToUse: ['A specific known sequence path is already available.'],
-        inputProps: { path: P.path },
-        outputProps: {
-            sequences: { type: 'array', description: 'Discovered sequences.', items: { type: 'object', description: 'Sequence asset.', additionalProperties: false, properties: { path: { type: 'string', description: 'Sequence object path.' }, name: { type: 'string', description: 'Asset name.' } } } },
-            count: { type: 'number', description: 'Number of sequences found.' },
-        },
-        outputRequired: ['sequences'],
-        effect: 'read',
-        latency: 'instant',
-        resources: 'low',
-        plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'list', path: '/Game/Cinematics' },
-        exampleOutput: { success: true, sequences: [{ path: '/Game/Cinematics/SEQ_Master.SEQ_Master', name: 'SEQ_Master' }], count: 1 },
-    }),
-];
-//# sourceMappingURL=timeline-lifecycle.js.map

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

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