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

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

@@ -1,166 +0,0 @@
-import { A } from './alias-props.js';
-import { buildRecord, P, SEQ_PLUGINS } from './helpers.js';
-import { int } from '../shared/schema-props.js';
-const F = 'cinematic';
-const D = 'cinematics';
-const SECTION_RANGE = { startFrame: A.startFrame, durationFrames: A.durationFrames, endFrame: A.endFrame, rowIndex: A.rowIndex };
-const TRACK_COMPONENT = {
-    type: 'string',
-    description: 'Component of the actor the track works on. skeletal_animation: the skeletal mesh that plays the clip '
-        + '(default the actor\'s root when that is a skeletal mesh; it gets its own binding under the actor, because '
-        + 'Sequencer otherwise plays the clip on the first skeletal mesh it finds, which on a character built from several '
-        + 'meshes copies another\'s pose and shows nothing). material_parameter: the component owning the material.',
-};
-const masterPath = { type: 'string', description: 'Canonical /Game path of the master sequence that owns the shot track.' };
-const CAMERA_SETTINGS = {
-    currentFocalLength: A.currentFocalLength, currentAperture: A.currentAperture,
-    sensorWidth: { type: 'number', description: 'Sensor width in mm.' }, sensorHeight: { type: 'number', description: 'Sensor height in mm.' },
-    manualFocusDistance: A.manualFocusDistance, lens: A.lens, filmback: A.filmback, focus: A.focus,
-};
-const sectionNameOutput = {
-    type: 'string',
-    description: 'Name of the created section, assigned by Sequencer.',
-};
-function trackRecord(id, action, summary, extraProps = {}, spec = { required: ['path'], example: {} }) {
-    const { required, example, requiredOneOf, notFor } = spec;
-    return buildRecord({
-        id, action, family: F, domain: D,
-        summary,
-        whenToUse: [`${summary}`],
-        whenNotToUse: ['The track is not needed for this sequence.', ...(notFor === undefined ? [] : [notFor])],
-        inputProps: { path: P.path, save: A.save, ...extraProps },
-        required,
-        ...(requiredOneOf === undefined ? {} : { requiredOneOf }),
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action, path: '/Game/Cinematics/SEQ_Master', ...example },
-    });
-}
-export const CINEMATIC_RECORDS = [
-    buildRecord({
-        id: 'sequence.cinematic.create_master_sequence', action: 'create_master_sequence', family: F, domain: D,
-        summary: 'Create a master cinematic sequence with sub-sequence and shot track structure.',
-        whenToUse: ['A new cinematic with shots must be scaffolded.'],
-        whenNotToUse: ['A flat sequence without shots is sufficient.'],
-        inputProps: { name: P.name, sequencePath: P.sequencePath, path: P.path, assetPath: P.assetPath, frameRate: P.frameRate, startFrame: P.startFrame, durationFrames: A.durationFrames, endFrame: int('Playback range end frame (exclusive); used when durationFrames is absent.') },
-        required: ['name', 'sequencePath'],
-        outputProps: { sequencePath: P.sequencePath },
-        outputRequired: ['sequencePath'],
-        effect: 'write', latency: 'interactive', resources: 'medium', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'create_master_sequence', name: 'SEQ_Master', sequencePath: '/Game/Cinematics/SEQ_Master' },
-        exampleOutput: { success: true, sequencePath: '/Game/Cinematics/SEQ_Master' },
-    }),
-    buildRecord({
-        id: 'sequence.cinematic.add_subsequence', action: 'add_subsequence', family: F, domain: D,
-        summary: 'Add a sub-sequence to a master sequence shot track.',
-        whenToUse: ['A sub-sequence must be nested inside the master sequence.'],
-        whenNotToUse: ['The sequence should remain flat.'],
-        inputProps: { path: masterPath, subsequencePath: P.subsequencePath, ...SECTION_RANGE, save: A.save },
-        required: ['path', 'subsequencePath'],
-        outputProps: { sectionName: sectionNameOutput },
-        outputRequired: [],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'add_subsequence', path: '/Game/Cinematics/SEQ_Master', subsequencePath: '/Game/Cinematics/SEQ_Shot01' },
-    }),
-    buildRecord({
-        id: 'sequence.cinematic.add_shot_track', action: 'add_shot_track', family: F, domain: D,
-        summary: 'Add a cinematic shot track to a master sequence.',
-        whenToUse: ['A shot track must be added to organize camera cuts.'],
-        whenNotToUse: ['The master sequence already has a shot track.'],
-        inputProps: { path: masterPath, shotSequencePath: P.shotSequencePath, displayName: A.displayName, ...SECTION_RANGE, save: A.save },
-        required: ['path', 'shotSequencePath'],
-        outputProps: { sectionName: sectionNameOutput },
-        outputRequired: [],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'add_shot_track', path: '/Game/Cinematics/SEQ_Master', shotSequencePath: '/Game/Cinematics/SEQ_Shot01' },
-    }),
-    buildRecord({
-        id: 'sequence.cinematic.configure_shot_settings', action: 'configure_shot_settings', family: F, domain: D,
-        summary: 'Configure shot settings (display name, range) for a cinematic shot.',
-        whenToUse: ['Shot display name or frame range must be set.'],
-        whenNotToUse: ['The shot does not exist on the shot track.'],
-        inputProps: { path: masterPath, shotSequencePath: { type: 'string', description: 'Picks the shot whose section plays this shot sequence (alternative to sectionIndex or sectionName).' }, sectionName: { type: 'string', description: 'Shot section display name to configure (alternative to sectionIndex).' }, shotName: P.name, displayName: A.displayName, sectionIndex: A.sectionIndex, ...SECTION_RANGE, save: A.save },
-        required: ['path'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'configure_shot_settings', path: '/Game/Cinematics/SEQ_Master', sectionIndex: 0, displayName: 'Shot 01', startFrame: 0, endFrame: 120 },
-    }),
-    buildRecord({
-        id: 'sequence.cinematic.create_cine_camera_actor', action: 'create_cine_camera_actor', family: F, domain: D,
-        summary: 'Create a CineCameraActor in the level and bind it to the sequence.',
-        whenToUse: ['A cinematic camera actor must be created for a shot.'],
-        whenNotToUse: ['An existing camera should be used.'],
-        inputProps: { ...CAMERA_SETTINGS, path: P.path, actorName: P.actorName, label: A.label, location: { type: 'object', description: 'Camera location.', additionalProperties: false, properties: { x: { type: 'number' }, y: { type: 'number' }, z: { type: 'number' } }, required: ['x', 'y', 'z'] }, rotation: { type: 'object', description: 'Camera rotation as {pitch, yaw, roll} (x/y/z are accepted as aliases).', additionalProperties: false, properties: { pitch: { type: 'number' }, yaw: { type: 'number' }, roll: { type: 'number' }, x: { type: 'number' }, y: { type: 'number' }, z: { type: 'number' } } } },
-        required: ['path'],
-        outputProps: {
-            actorName: { type: 'string', description: 'Label of the created camera actor.' },
-            actorPath: { type: 'string', description: 'Path to the created camera actor.' },
-            bindingGuid: { type: 'string', description: 'Sequencer binding GUID (present when a sequence path was supplied).' },
-            appliedProperties: { type: 'array', items: { type: 'string' }, description: 'Camera properties applied to the created actor.' },
-        },
-        outputRequired: [],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'create_cine_camera_actor', path: '/Game/Cinematics/SEQ_Master', actorName: 'CineCam_01' },
-        exampleOutput: { success: true, actorName: 'CineCam_01', actorPath: '/Game/Level/SUB_01.CineCam_01' },
-    }),
-    buildRecord({
-        id: 'sequence.cinematic.configure_camera_settings', action: 'configure_camera_settings', family: F, domain: D,
-        summary: 'Configure CineCamera lens, filmback, and focus settings on a camera actor in the level.',
-        whenToUse: ['Camera lens, focal length, aperture, or focus must be set.'],
-        whenNotToUse: ['Default camera settings are acceptable.'],
-        inputProps: { focalLength: { type: 'number', description: 'Focal length in mm.' }, aperture: { type: 'number', description: 'Aperture f-stop.' }, focusDistance: { type: 'number', description: 'Focus distance.' }, cameraName: P.actorName, actorName: P.actorName, ...CAMERA_SETTINGS },
-        requiredOneOf: ['actorName', 'cameraName'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'configure_camera_settings', actorName: 'CineCam_01', focalLength: 35, aperture: 2.8 },
-    }),
-    buildRecord({
-        id: 'sequence.cinematic.add_camera_cut_track', action: 'add_camera_cut_track', family: F, domain: D,
-        summary: 'Add a camera cut track to a cinematic sequence.',
-        whenToUse: ['A camera cut track must be added for shot transitions.'],
-        whenNotToUse: ['The sequence already has a camera cut track.'],
-        inputProps: { path: P.path, actorName: P.actorName, cameraName: P.actorName, actorPath: { type: 'string', description: 'Actor path (alias of actorName).' }, bindingGuid: A.bindingGuid, ...SECTION_RANGE, save: A.save },
-        required: ['path'],
-        outputProps: { bindingGuid: { type: 'string', description: 'Binding GUID of the targeted camera or created cut.' } },
-        outputRequired: [],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'add_camera_cut_track', path: '/Game/Cinematics/SEQ_Master' },
-        exampleOutput: { success: true, bindingGuid: 'ABC-123' },
-    }),
-    buildRecord({
-        id: 'sequence.cinematic.add_camera_shake_track', action: 'add_camera_shake_track', family: F, domain: D,
-        summary: 'Add a camera shake track to a cinematic sequence.',
-        whenToUse: ['Camera shake must be animated along the sequence.'],
-        whenNotToUse: ['No camera shake is needed.', 'The shake is gameplay feedback during play (a hit, a landing): create a Blueprint with parentClass /Script/EngineCameras.LegacyCameraShake (blueprint.create) and call PlayerCameraManager StartCameraShake from a graph (blueprint.edit_graph).'],
-        inputProps: { path: P.path, cameraShakeClass: P.cameraShakeClass, cameraShakePath: A.cameraShakePath, cameraName: { type: 'string', description: 'Level actor with a camera component that the shake track is bound to.' }, ...SECTION_RANGE, save: A.save },
-        required: ['path'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'add_camera_shake_track', path: '/Game/Cinematics/SEQ_Master', cameraShakeClass: '/Script/EngineCameras.DefaultCameraShakeBase', cameraName: 'CineCam_01' },
-    }),
-    buildRecord({
-        id: 'sequence.cinematic.configure_camera_rig_rail', action: 'configure_camera_rig_rail', family: F, domain: D,
-        summary: 'Configure a camera rig rail for dolly camera movement.',
-        whenToUse: ['A camera must move along a rail for dolly shots.'],
-        whenNotToUse: ['No rail-based camera movement is needed.'],
-        inputProps: { positionOnRail: { type: 'number', description: 'Position on the rail (0-1).' }, actorName: P.actorName, label: A.label },
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'configure_camera_rig_rail', positionOnRail: 0.5 },
-    }),
-    buildRecord({
-        id: 'sequence.cinematic.configure_camera_rig_crane', action: 'configure_camera_rig_crane', family: F, domain: D,
-        summary: 'Configure a camera rig crane for boom camera movement.',
-        whenToUse: ['A camera must boom or swing on a crane arm.'],
-        whenNotToUse: ['No crane-based camera movement is needed.'],
-        inputProps: { cranePitch: { type: 'number', description: 'Crane pitch in degrees.' }, craneYaw: { type: 'number', description: 'Crane yaw in degrees.' }, craneArmLength: { type: 'number', description: 'Crane arm length.' }, actorName: P.actorName, label: A.label },
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'configure_camera_rig_crane', craneArmLength: 300 },
-    }),
-    trackRecord('sequence.cinematic.add_fade_track', 'add_fade_track', 'Add a fade track for cinematic fade-in/fade-out transitions.', { from: A.from, to: A.to, ...SECTION_RANGE }, { required: ['path'], example: {}, notFor: 'The fade happens during play (level start, death, level change): call PlayerCameraManager StartCameraFade from a graph (blueprint.edit_graph).' }),
-    trackRecord('sequence.cinematic.add_level_visibility_track', 'add_level_visibility_track', 'Add a level visibility track to control level streaming during cinematic.', { levelNames: P.levelNames, visibility: A.visibility, ...SECTION_RANGE }),
-    trackRecord('sequence.cinematic.add_material_parameter_track', 'add_material_parameter_track', 'Add a material parameter collection track to animate material parameters.', { materialPath: P.materialPath, componentName: TRACK_COMPONENT, materialIndex: A.materialIndex, parameterName: A.parameterName, bindingGuid: A.bindingGuid, actorName: P.actorName, value: { description: 'Key value at startFrame: a number for a scalar parameter, or an {r, g, b, a} object for a color parameter.' }, startFrame: A.startFrame }, { required: ['path', 'parameterName', 'value'], example: { actorName: 'Cube', parameterName: 'Opacity', value: 0.5 }, requiredOneOf: ['actorName', 'bindingGuid'] }),
-    trackRecord('sequence.cinematic.add_particle_track', 'add_particle_track', 'Add a particle track to trigger particle systems during cinematic: trigger fires a one-shot burst (a hit, a spark) once, activate keeps a system running for the section.', { activate: A.activate, particleKey: { type: 'string', enum: ['activate', 'deactivate', 'trigger'], description: 'The key at startFrame: trigger fires the system once, the key for a one-shot burst; activate keeps it running, so a one-shot that finishes starts again until the section ends; deactivate stops it. Default from activate.' }, bindingGuid: A.bindingGuid, actorName: P.actorName, ...SECTION_RANGE }, { required: ['path'], example: { actorName: 'NiagaraActor_1' }, requiredOneOf: ['actorName', 'bindingGuid'] }),
-    trackRecord('sequence.cinematic.add_skeletal_animation_track', 'add_skeletal_animation_track', 'Add a skeletal animation track to play animations on a skeletal mesh. A clip whose skeleton the mesh cannot play is refused with SKELETON_MISMATCH instead of silently showing the rest pose. Overlap the clips before and after it and give easeInFrames/easeOutFrames to crossfade between them instead of cutting in one frame.', { animationSequencePath: { type: 'string', description: 'Animation sequence asset path.' }, animationPath: A.animationPath, actorName: P.actorName, componentName: TRACK_COMPONENT, bindingGuid: A.bindingGuid, ...SECTION_RANGE,
-        easeInFrames: { type: 'number', minimum: 0, description: 'Frames at the start of the section over which the clip blends in from the clip it overlaps (0 or omitted: it takes over at once).' },
-        easeOutFrames: { type: 'number', minimum: 0, description: 'Frames at the end of the section over which the clip blends out into the clip that overlaps it.' } }, { required: ['path'], example: { actorName: 'SkeletalMeshActor_1', animationSequencePath: '/Game/Animations/AS_Walk' }, requiredOneOf: ['actorName', 'bindingGuid'] }),
-    trackRecord('sequence.cinematic.add_transform_track', 'add_transform_track', 'Add a transform track to animate actor transforms during cinematic.', { actorName: P.actorName, bindingGuid: A.bindingGuid, ...SECTION_RANGE }, { required: ['path'], example: { actorName: 'CineCameraActor_1' }, requiredOneOf: ['actorName', 'bindingGuid'] }),
-    trackRecord('sequence.cinematic.add_event_track', 'add_event_track', 'Add an event track to trigger events at specific frames.', { actorName: P.actorName, bindingGuid: A.bindingGuid, ...SECTION_RANGE }),
-    trackRecord('sequence.cinematic.add_property_track', 'add_property_track', 'Add a property track to animate a specific property on a bound actor.', { property: P.property, actorName: P.actorName, bindingGuid: A.bindingGuid, propertyName: A.propertyName, propertyPath: A.propertyPath, propertyType: A.propertyType, ...SECTION_RANGE }, { required: ['path', 'property'], example: { actorName: 'CineCameraActor_1', property: 'Transform' }, requiredOneOf: ['actorName', 'bindingGuid'] }),
-];
-//# sourceMappingURL=cinematic.js.map

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

@@ -1,119 +0,0 @@
-import type { CapabilityRecordSource, JsonObject } from '../../model.js';
-import { type CoreRecordSpec } from '../core/builder.js';
-export type PropertyMap = JsonObject;
-export declare const P: {
-    path: JsonObject;
-    name: JsonObject;
-    assetPath: JsonObject;
-    newName: JsonObject;
-    destinationPath: JsonObject;
-    actorName: JsonObject;
-    actorNames: {
-        type: string;
-        items: JsonObject;
-        description: string;
-    };
-    className: JsonObject;
-    trackType: JsonObject;
-    trackName: JsonObject;
-    property: JsonObject;
-    frame: JsonObject;
-    bindingId: JsonObject;
-    speed: JsonObject;
-    start: JsonObject;
-    end: JsonObject;
-    resolution: {
-        type: string[];
-        description: string;
-    };
-    frameRate: {
-        type: string[];
-        description: string;
-    };
-    cameraShakeClass: JsonObject;
-    levelNames: JsonObject;
-    message: JsonObject;
-    sequencePath: JsonObject;
-    subsequencePath: JsonObject;
-    shotSequencePath: JsonObject;
-    mapPath: JsonObject;
-    jobId: JsonObject;
-    renderJobName: JsonObject;
-    outputDirectory: JsonObject;
-    fileNameFormat: JsonObject;
-    mrqResolution: JsonObject;
-    width: JsonObject;
-    height: JsonObject;
-    startFrame: JsonObject;
-    mrqSettings: {
-        type: string;
-        description: string;
-        additionalProperties: boolean;
-        properties: {
-            handleFrameCount: JsonObject;
-            zeroPadFrameNumbers: JsonObject;
-            spatialSampleCount: JsonObject;
-            temporalSampleCount: JsonObject;
-            antiAliasingMethod: JsonObject;
-            method: JsonObject;
-        };
-    };
-    renderPass: JsonObject;
-    renderPasses: JsonObject;
-    materialPath: JsonObject;
-    includeTranslucentObjects: JsonObject;
-    antiAliasingMethod: JsonObject;
-    sampleCount: JsonObject;
-    useCurrentLevel: JsonObject;
-    executorClass: JsonObject;
-    burnInClassPath: JsonObject;
-    mediaPlayerPath: JsonObject;
-    mediaSourcePath: JsonObject;
-    playlistPath: JsonObject;
-    playerPath: JsonObject;
-    sourcePath: JsonObject;
-    filePath: JsonObject;
-    sourceType: JsonObject;
-    precacheFile: JsonObject;
-    defaultSourcePath: JsonObject;
-    platformSources: {
-        type: string;
-        description: string;
-        additionalProperties: boolean;
-        'x-unreal-reflection-boundary': boolean;
-    };
-    sourcePaths: JsonObject;
-    filePaths: JsonObject;
-    replayName: JsonObject;
-    demoName: JsonObject;
-    friendlyName: JsonObject;
-    additionalOptions: JsonObject;
-    prioritizeActors: JsonObject;
-    paused: JsonObject;
-    takePresetPath: JsonObject;
-    recordingSequencePath: JsonObject;
-    takeSequencePath: JsonObject;
-    recordType: JsonObject;
-    sourceClasses: JsonObject;
-    clearSources: JsonObject;
-    recordInto: JsonObject;
-    recordedTracks: JsonObject;
-    metadata: {
-        type: string;
-        description: string;
-        additionalProperties: boolean;
-        'x-unreal-reflection-boundary': boolean;
-    };
-};
-export declare const SEQ_PLUGINS: string[];
-export declare const MRQ_PLUGINS: string[];
-export declare const TAKE_PLUGINS: string[];
-export declare const MEDIA_PLUGINS: string[];
-export type RecordSpec = Omit<CoreRecordSpec, 'parentTool' | 'bareInput' | 'costLatency' | 'costResources' | 'id' | 'dispatchAction' | 'plugins'> & {
-    readonly id: string;
-    readonly plugins: readonly string[];
-    readonly latency: NonNullable<CoreRecordSpec['costLatency']>;
-    readonly resources: NonNullable<CoreRecordSpec['costResources']>;
-};
-export declare const buildRecord: ({ latency, resources, ...spec }: RecordSpec) => CapabilityRecordSource;
-//# sourceMappingURL=helpers.d.ts.map

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

@@ -1,108 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-import { bool, int, num, str, strArr } from '../shared/schema-props.js';
-export const P = {
-    path: str('Canonical /Game sequence asset path.'),
-    name: str('Name for the new sequence or asset.'),
-    assetPath: str('Canonical /Game asset path.'),
-    newName: str('New name for the sequence asset.'),
-    destinationPath: str('Destination /Game folder for the copy.'),
-    actorName: str('Actor name in the current level.'),
-    actorNames: { type: 'array', items: str('Actor name.'), description: 'Actor names.' },
-    className: str('Unreal class path for the spawnable.'),
-    trackType: str('Track type: "Audio" (music or sound, then add_section with soundPath), "Transform", or a MovieScene track class name such as MovieSceneEventTrack.'),
-    trackName: str('Name of the track to modify.'),
-    property: str('Property name to keyframe (Transform, Location, Rotation, Scale).'),
-    frame: int('Frame number for the keyframe.'),
-    bindingId: str('Sequencer binding GUID to key against.'),
-    speed: num('Playback speed multiplier (positive).'),
-    start: num('Range start frame or time.'),
-    end: num('Range end frame or time.'),
-    resolution: {
-        type: ['number', 'string'],
-        description: 'Tick resolution as ticks per second or a rate string such as 24000/1001.',
-    },
-    frameRate: {
-        type: ['number', 'string'],
-        description: 'Frame rate as fps or a rate string such as 24fps or 24000/1001.',
-    },
-    cameraShakeClass: str('Camera shake class path.'),
-    levelNames: strArr('Level name.', 'Level names toggled by the visibility track.'),
-    message: str('Human-readable result message.'),
-    sequencePath: str('Canonical /Game sequence asset path.'),
-    subsequencePath: str('Canonical /Game subsequence path.'),
-    shotSequencePath: str('Canonical /Game shot sequence path.'),
-    mapPath: str('Canonical /Game map path.'),
-    jobId: str('Render job identifier.'),
-    renderJobName: str('Render job name: names a new job, or selects an existing job (alternative to jobId).'),
-    outputDirectory: str('Output directory for rendered frames.'),
-    fileNameFormat: str('Output file name format string.'),
-    mrqResolution: str('Output resolution in WIDTHxHEIGHT format, such as 1920x1080.'),
-    width: int('Output width in pixels (positive; paired with height).'),
-    height: int('Output height in pixels (positive; paired with width).'),
-    startFrame: int('Custom playback range start frame (paired with endFrame).'),
-    mrqSettings: {
-        type: 'object',
-        description: 'Nested MRQ settings.',
-        additionalProperties: false,
-        properties: {
-            handleFrameCount: int('Handle frame count clamped to >= 0.'),
-            zeroPadFrameNumbers: int('Zero-padding width for frame numbers.'),
-            spatialSampleCount: int('Spatial sample count per render sample pass.'),
-            temporalSampleCount: int('Temporal sample count per render sample pass.'),
-            antiAliasingMethod: str('Anti-aliasing method name, such as TSAA or FXAA.'),
-            method: str('Anti-aliasing method alias.'),
-        },
-    },
-    renderPass: str('Render pass identifier: beauty (final, lit), depth, motion_vector, normal, object_id, custom_stencil (with materialPath), or ui (the game viewport\'s UMG layer: HUD and menus; widget and ui_renderer also work).'),
-    renderPasses: strArr('Render pass identifier, as renderPass takes.', 'Render pass identifiers to add.'),
-    materialPath: str('Material asset path for a material render pass.'),
-    includeTranslucentObjects: bool('Whether the pass includes translucent objects.'),
-    antiAliasingMethod: str('Anti-aliasing method name, such as TSAA or FXAA.'),
-    sampleCount: int('Sample count per render sample pass.'),
-    useCurrentLevel: bool('Whether to render against the currently loaded level.'),
-    executorClass: str('Movie pipeline executor class path.'),
-    burnInClassPath: str('Burn-in widget class path.'),
-    mediaPlayerPath: str('Canonical /Game media player path.'),
-    mediaSourcePath: str('Canonical /Game media source path.'),
-    playlistPath: str('Canonical /Game media playlist path.'),
-    playerPath: str('Canonical /Game media player path.'),
-    sourcePath: str('Source file or asset path.'),
-    filePath: str('File system path to a media file.'),
-    sourceType: str('Media source type: file or platform (network streams are refused).'),
-    precacheFile: bool('Whether the file media source precaches on open.'),
-    defaultSourcePath: str('Default media source asset path for a platform media source.'),
-    platformSources: {
-        type: 'object',
-        description: 'Per-platform media source asset paths keyed by platform name.',
-        additionalProperties: true,
-        'x-unreal-reflection-boundary': true,
-    },
-    sourcePaths: strArr('Media source asset path.', 'Media source asset paths for the playlist.'),
-    filePaths: strArr('Media file path.', 'Media file paths appended to the playlist.'),
-    replayName: str('Name for the demo replay.'),
-    demoName: str('Demo replay name.'),
-    friendlyName: str('Human-readable replay name.'),
-    additionalOptions: strArr('Replay option string.', 'Additional replay streamer options.'),
-    prioritizeActors: bool('Whether to prioritize actor replication during recording.'),
-    paused: bool('Whether replay playback is paused.'),
-    takePresetPath: str('Canonical /Game take preset path.'),
-    recordingSequencePath: str('Canonical /Game recording sequence path.'),
-    takeSequencePath: str('Canonical /Game take sequence path.'),
-    recordType: str('Take recording source type.'),
-    sourceClasses: strArr('Source class path.', 'Take Recorder source class paths.'),
-    clearSources: bool('Whether to clear existing Take Recorder sources first.'),
-    recordInto: bool('Whether to record into the supplied sequence rather than a new take.'),
-    recordedTracks: strArr('Track name.', 'Track names to record per source.'),
-    metadata: {
-        type: 'object',
-        description: 'Arbitrary metadata key-value pairs.',
-        additionalProperties: true,
-        'x-unreal-reflection-boundary': true,
-    },
-};
-export const SEQ_PLUGINS = ['LevelSequenceEditor'];
-export const MRQ_PLUGINS = ['LevelSequenceEditor', 'MovieRenderPipeline'];
-export const TAKE_PLUGINS = ['LevelSequenceEditor', 'Takes'];
-export const MEDIA_PLUGINS = ['LevelSequenceEditor', 'ElectraPlayer'];
-export const buildRecord = ({ latency, resources, ...spec }) => buildCoreRecord({ ...spec, parentTool: 'manage_sequence', costLatency: latency, costResources: resources });
-//# sourceMappingURL=helpers.js.map

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

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

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

@@ -1,28 +0,0 @@
-import { CINEMATIC_RECORDS } from './cinematic.js';
-import { MEDIA_RECORDS } from './media.js';
-import { METADATA_RECORDS } from './metadata.js';
-import { MRQ_RECORDS } from './mrq.js';
-import { REPLAY_RECORDS } from './replay.js';
-import { TAKE_RECORDS } from './take.js';
-import { TIMELINE_BINDINGS_RECORDS } from './timeline-bindings.js';
-import { TIMELINE_LIFECYCLE_RECORDS } from './timeline-lifecycle.js';
-import { TIMELINE_PLAYBACK_RECORDS } from './timeline-playback.js';
-import { TIMELINE_STATE_RANGE_RECORDS } from './timeline-state-ranges.js';
-import { TIMELINE_TRACKS_RECORDS } from './timeline-tracks.js';
-import { applyFolds } from '../shared/fold.js';
-import { MANAGE_SEQUENCE_FOLDS } from '../folds/manage-sequence.folds.js';
-export const MANAGE_SEQUENCE_UNFOLDED_SOURCES = [
-    ...TIMELINE_LIFECYCLE_RECORDS,
-    ...TIMELINE_PLAYBACK_RECORDS,
-    ...TIMELINE_BINDINGS_RECORDS,
-    ...TIMELINE_TRACKS_RECORDS,
-    ...TIMELINE_STATE_RANGE_RECORDS,
-    ...METADATA_RECORDS,
-    ...CINEMATIC_RECORDS,
-    ...MRQ_RECORDS,
-    ...MEDIA_RECORDS,
-    ...TAKE_RECORDS,
-    ...REPLAY_RECORDS,
-];
-export const MANAGE_SEQUENCE_SOURCES = applyFolds(MANAGE_SEQUENCE_UNFOLDED_SOURCES, MANAGE_SEQUENCE_FOLDS, 'manage_sequence');
-//# sourceMappingURL=index.js.map

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

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

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

@@ -1,119 +0,0 @@
-import { A } from './alias-props.js';
-import { buildRecord, MEDIA_PLUGINS, P } from './helpers.js';
-const F = 'media';
-const D = 'media';
-export const MEDIA_RECORDS = [
-    buildRecord({
-        id: 'sequence.media.create_media_player', action: 'create_media_player', family: F, domain: D,
-        summary: 'Create a MediaPlayer asset for media playback.',
-        whenToUse: ['A media player asset must be created for video/audio playback.'],
-        whenNotToUse: ['An existing media player should be reused.'],
-        inputProps: { name: P.name, path: P.path, assetPath: P.assetPath, mediaSourcePath: P.mediaSourcePath, sourcePath: P.sourcePath, autoPlay: A.autoPlay, playOnOpen: A.playOnOpen, loop: A.loop, looping: A.looping },
-        required: ['name', 'path'],
-        outputProps: {
-            assetType: { type: 'string', description: 'Created asset type (MediaPlayer).' },
-            assetPath: { type: 'string', description: 'Created media player asset path.' },
-            packageName: { type: 'string', description: 'Package name of the created asset.' },
-            classPath: { type: 'string', description: 'Class path of the created asset.' },
-            assetName: { type: 'string', description: 'Created asset name (verification).' },
-            assetClass: { type: 'string', description: 'Created asset class (verification).' },
-            created: { type: 'boolean', description: 'Whether the asset was created.' },
-            saved: { type: 'boolean', description: 'Whether the asset was saved.' },
-            existsAfter: { type: 'boolean', description: 'Whether the asset existed after the call.' },
-            looping: { type: 'boolean', description: 'Whether the player loops.' },
-            playOnOpen: { type: 'boolean', description: 'Whether the player starts on open.' },
-            mediaSourcePath: { type: 'string', description: 'Resolved media source path (when a source was supplied).' },
-            openRequested: { type: 'boolean', description: 'Whether opening the source was requested (when a source was supplied).' },
-            openStatus: { type: 'string', description: 'Open status (pending) when a source was supplied.' },
-        },
-        outputRequired: [],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: MEDIA_PLUGINS,
-        exampleInput: { action: 'create_media_player', name: 'MP_Cinematics', path: '/Game/Media' },
-        exampleOutput: { success: true, assetType: 'MediaPlayer', assetPath: '/Game/Media/MP_Cinematics', created: true, saved: true, looping: false, playOnOpen: true },
-    }),
-    buildRecord({
-        id: 'sequence.media.create_media_source', action: 'create_media_source', family: F, domain: D,
-        summary: 'Create a MediaSource asset (FileMediaSource or PlatformMediaSource).',
-        whenToUse: ['A media source asset must be created for a media file.'],
-        whenNotToUse: ['An existing media source should be reused.'],
-        inputProps: {
-            name: P.name, path: P.path, assetPath: P.assetPath,
-            sourceType: P.sourceType, filePath: P.filePath, precacheFile: P.precacheFile,
-            defaultSourcePath: P.defaultSourcePath, platformSources: P.platformSources,
-            mediaPath: A.mediaPath,
-        },
-        required: ['name', 'path'],
-        outputProps: { mediaSourcePath: P.mediaSourcePath },
-        outputRequired: ['mediaSourcePath'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: MEDIA_PLUGINS,
-        exampleInput: { action: 'create_media_source', name: 'MS_Cinematics', path: '/Game/Media', sourceType: 'File', filePath: '/tmp/cinematics/source.mp4' },
-        exampleOutput: { success: true, mediaSourcePath: '/Game/Media/MS_Cinematics' },
-    }),
-    buildRecord({
-        id: 'sequence.media.create_media_texture', action: 'create_media_texture', family: F, domain: D,
-        summary: 'Create a MediaTexture asset linked to a MediaPlayer.',
-        whenToUse: ['A media texture must be created for video rendering.'],
-        whenNotToUse: ['A media texture is not needed for audio-only playback.'],
-        inputProps: { name: P.name, path: P.path, mediaPlayerPath: P.mediaPlayerPath, playerPath: P.playerPath, autoClear: A.autoClear },
-        required: ['name', 'path'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: MEDIA_PLUGINS,
-        exampleInput: { action: 'create_media_texture', name: 'MT_Cinematics', path: '/Game/Media', mediaPlayerPath: '/Game/Media/MP_Cinematics' },
-    }),
-    buildRecord({
-        id: 'sequence.media.create_media_sound_component', action: 'create_media_sound_component', family: F, domain: D,
-        summary: 'Create a MediaSoundComponent linked to a MediaPlayer.',
-        whenToUse: ['Audio from media playback must be routed through a sound component.'],
-        whenNotToUse: ['Audio is not needed for the media playback.'],
-        inputProps: { name: P.name, mediaPlayerPath: P.mediaPlayerPath, actorName: P.actorName, targetActor: A.targetActor, componentName: A.componentName, activate: A.activate },
-        required: ['actorName', 'mediaPlayerPath'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: MEDIA_PLUGINS,
-        exampleInput: { action: 'create_media_sound_component', actorName: 'MediaScreen', mediaPlayerPath: '/Game/Media/MP_Cinematics', componentName: 'MediaSound' },
-    }),
-    buildRecord({
-        id: 'sequence.media.create_media_playlist', action: 'create_media_playlist', family: F, domain: D,
-        summary: 'Create a MediaPlaylist asset for sequential media source playback.',
-        whenToUse: ['A playlist of multiple media sources must be created.'],
-        whenNotToUse: ['Only a single media source is needed.'],
-        inputProps: {
-            name: P.name, path: P.path,
-            sourcePaths: P.sourcePaths, filePaths: P.filePaths,
-        },
-        required: ['name', 'path'],
-        outputProps: { playlistPath: P.playlistPath },
-        outputRequired: ['playlistPath'],
-        effect: 'write', latency: 'interactive', resources: 'low', plugins: MEDIA_PLUGINS,
-        exampleInput: { action: 'create_media_playlist', name: 'MPL_Cinematics', path: '/Game/Media' },
-        exampleOutput: { success: true, playlistPath: '/Game/Media/MPL_Cinematics' },
-    }),
-    buildRecord({
-        id: 'sequence.media.play_media', action: 'play_media', family: F, domain: D,
-        summary: 'Open a media source on a MediaPlayer and start playback.',
-        whenToUse: ['Media playback must be started on an existing MediaPlayer.'],
-        whenNotToUse: ['The media player is already playing.'],
-        inputProps: { playerPath: P.playerPath, mediaPlayerPath: P.mediaPlayerPath, mediaSourcePath: P.mediaSourcePath, sourcePath: P.sourcePath, playlistPath: P.playlistPath, filePath: P.filePath, mediaPath: A.mediaPath, playlistIndex: A.playlistIndex },
-        required: ['playerPath'],
-        effect: 'write', latency: 'instant', resources: 'low', plugins: MEDIA_PLUGINS,
-        exampleInput: { action: 'play_media', playerPath: '/Game/Media/MP_Cinematics', mediaSourcePath: '/Game/Media/MS_Cinematics' },
-    }),
-    buildRecord({
-        id: 'sequence.media.pause_media', action: 'pause_media', family: F, domain: D,
-        summary: 'Pause media playback on a MediaPlayer.',
-        whenToUse: ['Media playback must be paused.'],
-        whenNotToUse: ['The media player is not playing.'],
-        inputProps: { playerPath: P.playerPath },
-        required: ['playerPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: MEDIA_PLUGINS,
-        exampleInput: { action: 'pause_media', playerPath: '/Game/Media/MP_Cinematics' },
-    }),
-    buildRecord({
-        id: 'sequence.media.seek_media', action: 'seek_media', family: F, domain: D,
-        summary: 'Seek to a specific time in media playback.',
-        whenToUse: ['The media playhead must be moved to a specific time.'],
-        whenNotToUse: ['The media player is not open.'],
-        inputProps: { playerPath: P.playerPath, seekTime: { type: 'number', description: 'Seek time in seconds.' }, mediaPlayerPath: P.mediaPlayerPath, timeSeconds: { type: 'number', description: 'Seek time in seconds (<=86400).' }, seconds: { type: 'number', description: 'Seek time in seconds (alias of timeSeconds).' }, time: A.time },
-        required: ['playerPath', 'seekTime'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, latency: 'instant', resources: 'low', plugins: MEDIA_PLUGINS,
-        exampleInput: { action: 'seek_media', playerPath: '/Game/Media/MP_Cinematics', seekTime: 5.0 },
-    }),
-];
-//# sourceMappingURL=media.js.map

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

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

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

@@ -1,41 +0,0 @@
-import { buildRecord, P, SEQ_PLUGINS } from './helpers.js';
-const F = 'metadata';
-const D = 'sequence';
-export const METADATA_RECORDS = [
-    buildRecord({
-        id: 'sequence.get_metadata', action: 'get_metadata', topics: ['sequence tags'], family: F, domain: D,
-        summary: 'Read the custom metadata tags (string key/value pairs written by set_metadata) stored on a Level Sequence, or look up one key.',
-        whenToUse: ['Sequence asset metadata must be inspected.'],
-        whenNotToUse: ['Metadata is being written rather than read.'],
-        inputProps: { path: P.path, key: { type: 'string', description: 'Metadata key to look up; the reply then carries found and value.' } },
-        required: ['path'],
-        outputProps: {
-            path: { type: 'string', description: 'Resolved sequence asset path.' },
-            name: { type: 'string', description: 'Sequence asset name.' },
-            class: { type: 'string', description: 'Sequence asset class name.' },
-            metadata: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Stored metadata key-value pairs.' },
-            metadataCount: { type: 'number', description: 'Number of stored metadata pairs.' },
-            key: { type: 'string', description: 'Requested key, when one was passed.' },
-            found: { type: 'boolean', description: 'Whether the requested key exists.' },
-            value: { type: 'string', description: 'Value of the requested key.' },
-        },
-        outputRequired: ['path', 'name', 'class'],
-        effect: 'read', latency: 'instant', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'get_metadata', path: '/Game/Cinematics/SEQ_Master' },
-        exampleOutput: { success: true, path: '/Game/Cinematics/SEQ_Master', name: 'SEQ_Master', class: 'LevelSequence' },
-    }),
-    buildRecord({
-        id: 'sequence.set_metadata', action: 'set_metadata', family: F, domain: D,
-        summary: 'Write metadata key-value pairs to a Level Sequence asset and save it.',
-        whenToUse: ['Sequence asset metadata must be written.'],
-        whenNotToUse: ['The target is not a /Game asset path.'],
-        inputProps: { path: P.path, metadata: P.metadata, key: { type: 'string', description: 'Single metadata key to write (paired with value).' }, value: { type: ['string', 'number', 'boolean'], description: 'Value written under key.' } },
-        required: ['path'],
-        requiredOneOf: ['metadata', 'key'],
-        effect: 'write', behavior: { idempotency: 'idempotent' },
-        latency: 'interactive', resources: 'low', plugins: SEQ_PLUGINS,
-        exampleInput: { action: 'set_metadata', path: '/Game/Cinematics/SEQ_Master', metadata: { author: 'MCP' } },
-        aliases: ['sequence.metadata.set'],
-    }),
-];
-//# sourceMappingURL=metadata.js.map

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

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