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

package/dist/tools/catalog/capabilities/records/manage-level/operations.data.js

@@ -1,88 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-import { D, OPERATIONS_POWER_RECORDS } from './operations-power.data.js';
-import { OPERATIONS_IO_RECORDS } from './operations-io.data.js';
-const UNSAVED_OUT = {
-    unsaved: { type: 'boolean', description: 'Whether this level has changes that are not saved.' },
-    unsavedPackages: { type: 'array', items: { type: 'string' }, description: 'Every level and asset package with unsaved changes, levels first (the first 100).' },
-    unsavedPackageCount: { type: 'number', description: 'How many packages have unsaved changes.' },
-};
-export const OPERATIONS_RECORDS = [
-    ...OPERATIONS_POWER_RECORDS,
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'get_current_level', dispatchAction: 'get_current_level',
-        domain: D, family: 'query',
-        topics: ['current level', 'current map', 'which level is open', 'active level', 'level name', 'is the level saved', 'list unsaved changes'],
-        summary: 'Return the path of the level currently loaded in the editor.',
-        whenToUse: ['The active level path must be inspected.'],
-        whenNotToUse: ['All levels must be enumerated; use list_levels.'],
-        inputProps: {},
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'get_current_level' },
-        exampleOutput: { success: true, message: 'Current level', levelPath: '/Game/Maps/Demo', unsaved: true, unsavedPackages: ['/Game/Maps/Demo'], unsavedPackageCount: 1 },
-        outputProps: { levelPath: P.levelPath, ...UNSAVED_OUT },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'get_summary', dispatchAction: 'get_summary',
-        domain: D, family: 'query',
-        summary: 'Return a summary of a level asset (native maps to get_level_info).',
-        whenToUse: ['Metadata and stats for a specific level must be inspected.'],
-        whenNotToUse: ['The current level path is needed; use get_current_level.'],
-        inputProps: { levelPath: P.levelPath },
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'get_summary', levelPath: '/Game/Maps/Demo' },
-        exampleOutput: {
-            success: true, message: 'Level summary', levelPath: '/Game/Maps/Demo',
-            levelName: 'Demo', actorCount: 42, loaded: true,
-        },
-        outputProps: {
-            levelPath: P.levelPath,
-            levelName: { type: 'string', description: 'Level asset name.' },
-            actorCount: { type: 'number', description: 'Actor count when the level is loaded.' },
-            loaded: { type: 'boolean', description: 'Whether the level is loaded in the editor.' },
-            packageName: { type: 'string', description: 'Package name (asset-registry lookup).' },
-            assetName: { type: 'string', description: 'Asset name (asset-registry lookup).' },
-            objectPath: { type: 'string', description: 'Object path (asset-registry lookup).' },
-            assetClass: { type: 'string', description: 'Asset class path (asset-registry lookup).' },
-            tagsAndValues: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Asset-registry tag/value pairs (asset-registry lookup).' },
-            ...UNSAVED_OUT,
-        },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'validate_level',
-        domain: D, family: 'query',
-        topics: ['does it exist', 'map file', 'check map path'],
-        summary: 'Check that a level asset exists: returns exists, its normalized path, the .umap file path, and whether the package and the file are present.',
-        whenToUse: ['A level asset path must be verified before load or delete.'],
-        whenNotToUse: ['The level should be loaded; use load.'],
-        inputProps: { levelPath: P.levelPath, assetPath: P.assetPath },
-        required: ['levelPath'],
-        effect: 'read',
-        exampleInput: { action: 'validate_level', levelPath: '/Game/Maps/Demo' },
-        exampleOutput: { success: true, exists: true, levelPath: '/Game/Maps/Demo', message: 'Level asset exists' },
-        outputProps: {
-            exists: { type: 'boolean', description: 'Whether the level asset exists.' },
-            levelPath: P.levelPath,
-        },
-        outputRequired: ['exists'],
-    }),
-    ...OPERATIONS_IO_RECORDS,
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'add_sublevel', topics: ['add streaming level'], dispatchAction: 'add_sublevel',
-        domain: D, family: 'sublevel',
-        summary: 'Add a sub-level as a streaming child of the level open in the editor.',
-        whenToUse: ['A streaming child level must be associated with a parent.'],
-        whenNotToUse: ['The sub-level should be streamed independently; use stream.'],
-        inputProps: {
-            subLevelPath: P.subLevelPath, levelPath: P.levelPath,
-            parentLevel: P.parentLevel, streamingMethod: P.streamingMethod,
-        },
-        required: [],
-        requiredOneOf: ['subLevelPath', 'levelPath'],
-        effect: 'write', costLatency: 'interactive',
-        exampleInput: { action: 'add_sublevel', subLevelPath: '/Game/Maps/Sub01', parentLevel: '/Game/Maps/Demo' },
-    }),
-];
-//# sourceMappingURL=operations.data.js.map

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

@@ -1,45 +0,0 @@
-import type { JsonObject } from '../../model.js';
-type Prop = JsonObject;
-export declare const P: {
-    readonly levelPath: JsonObject;
-    readonly openLevelPath: JsonObject;
-    readonly levelName: JsonObject;
-    readonly levelPaths: JsonObject;
-    readonly savePath: JsonObject;
-    readonly destinationPath: JsonObject;
-    readonly sourcePath: JsonObject;
-    readonly exportPath: JsonObject;
-    readonly packagePath: JsonObject;
-    readonly subLevelPath: JsonObject;
-    readonly assetPath: JsonObject;
-    readonly path: JsonObject;
-    readonly targetPath: JsonObject;
-    readonly parentLevel: JsonObject;
-    readonly streamingMethod: JsonObject;
-    readonly streaming: JsonObject;
-    readonly shouldBeLoaded: JsonObject;
-    readonly shouldBeVisible: JsonObject;
-    readonly saveDirtyPackages: JsonObject;
-    readonly newName: JsonObject;
-    readonly overwrite: JsonObject;
-    readonly lightClass: JsonObject;
-    readonly lightProperties: Prop;
-    readonly lightType: JsonObject;
-    readonly name: JsonObject;
-    readonly intensity: JsonObject;
-    readonly color: Prop;
-    readonly location: Prop;
-    readonly rotation: Prop;
-    readonly quality: JsonObject;
-    readonly useWorldPartition: JsonObject;
-    readonly metadata: Prop;
-    readonly gameMode: JsonObject;
-    readonly killZ: JsonObject;
-    readonly gravityZ: JsonObject;
-    readonly timeDilation: JsonObject;
-    readonly enableWorldBoundsChecks: JsonObject;
-    readonly settingsApplied: JsonObject;
-    readonly appliedSettings: JsonObject;
-};
-export {};
-//# sourceMappingURL=properties.d.ts.map

package/dist/tools/catalog/capabilities/records/manage-level/properties.js

@@ -1,45 +0,0 @@
-import { str, bool, num } from '../shared/schema-props.js';
-import { LIGHT_AIM_TEXT, LIGHT_CLASS_TEXT, LIGHT_COLOR_WITH_PROPERTIES_TEXT, LIGHT_INTENSITY_TEXT, LIGHT_LOCATION_TEXT, LIGHT_PROPERTIES_TEXT, LIGHT_TYPE_TEXT, } from '../shared/light-text.js';
-const arrStr = (description) => ({ type: 'array', items: { type: 'string' }, description });
-export const P = {
-    levelPath: str('Level asset path (e.g. /Game/Maps/Demo).'),
-    openLevelPath: str('The level you expect to be open in the editor; the call is refused when another level is open, instead of saving the wrong one.'),
-    levelName: str('Level name identifier.'),
-    levelPaths: arrStr('Array of level asset paths.'),
-    savePath: str('Path to save the level asset.'),
-    destinationPath: str('Destination path for move/copy.'),
-    sourcePath: str('Source path for import/move/copy.'),
-    exportPath: str('Export file path.'),
-    packagePath: str('Package path for import.'),
-    subLevelPath: str('Sub-level asset path to add as a streaming child.'),
-    assetPath: str('Alias of levelPath resolved by the manage_level argument normalizer.'),
-    path: str('Alias of levelPath resolved by the manage_level argument normalizer.'),
-    targetPath: str('Alias of destinationPath resolved by the manage_level argument normalizer.'),
-    parentLevel: str('Level the sub-level belongs to; it must be the level open in the editor, or the call is refused (load it first).'),
-    streamingMethod: str('Streaming method: Blueprint or AlwaysLoaded.'),
-    streaming: bool('Stream the level into the open level as a sub-level (like add_sublevel) instead of replacing it.'),
-    shouldBeLoaded: bool('Whether the level should be loaded.'),
-    shouldBeVisible: bool('Whether the level should be visible.'),
-    saveDirtyPackages: bool('Save dirty packages before the operation.'),
-    newName: str('New name for the level asset.'),
-    overwrite: bool('Overwrite if the destination already exists.'),
-    lightClass: str(LIGHT_CLASS_TEXT),
-    lightProperties: { type: 'object', description: LIGHT_PROPERTIES_TEXT, additionalProperties: true, 'x-unreal-reflection-boundary': true },
-    lightType: str(LIGHT_TYPE_TEXT),
-    name: str('Light actor name.'),
-    intensity: num(LIGHT_INTENSITY_TEXT),
-    color: { type: 'array', items: { type: 'number' }, description: `Light color [r, g, b] or [r, g, b, a]. ${LIGHT_COLOR_WITH_PROPERTIES_TEXT}` },
-    location: { type: 'object', description: LIGHT_LOCATION_TEXT, additionalProperties: true, 'x-unreal-reflection-boundary': true },
-    rotation: { type: 'object', description: `Actor rotation {pitch, yaw, roll} or {x, y, z, w}. ${LIGHT_AIM_TEXT}`, additionalProperties: true, 'x-unreal-reflection-boundary': true },
-    quality: str('Lighting build quality: Preview, Medium, High, or Production.'),
-    useWorldPartition: bool('Create the level with World Partition enabled.'),
-    metadata: { type: 'object', description: 'Metadata key/value pairs to write.', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-    gameMode: str('GameMode override for the level. Accepts the Blueprint asset path or its generated _C class path.'),
-    killZ: num('Z height below which actors are destroyed.'),
-    gravityZ: num('World gravity along Z; setting it also enables the global gravity override.'),
-    timeDilation: num('Global time dilation multiplier for the level.'),
-    enableWorldBoundsChecks: bool('Whether actors leaving the world bounds are culled.'),
-    settingsApplied: bool('Whether any world setting was written.'),
-    appliedSettings: arrStr('Names of the world settings actually written by this call.'),
-};
-//# sourceMappingURL=properties.js.map

package/dist/tools/catalog/capabilities/records/manage-networking/framework.data.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-networking/framework.data.js

@@ -1,45 +0,0 @@
-import { utilityRecord, withInputProps, withTopics, withWhenNotToUse } from '../utility/utility-record-builders.js';
-const T = 'manage_networking';
-const SAVE = {
-    save: { type: 'boolean', description: 'Save the Blueprint asset to disk after the change (default true).' },
-};
-const f = (action, summary, params, required, outputs = [], outputRequired = [], read = false, props = {}) => {
-    const record = utilityRecord({
-        tool: T, action, family: 'gameFramework', summary, params, required, outputs, outputRequired,
-        effect: read ? 'read' : 'write', safeToRetry: read, dispatchAction: 'manage_game_framework',
-    });
-    return withInputProps(record, read ? props : { ...SAVE, ...props });
-};
-const create = (action, label, extra = []) => f(action, `Create a ${label} Blueprint asset and return its path; an unloadable parentClass, or one that is not a ${label}, is refused.`, ['name', 'path', 'parentClass', 'save', ...extra], ['name', 'path'], ['assetPath'], ['assetPath']);
-const EFFECTIVE = ' Pass makeDefault: true to also make this game mode the project default; the reply says whether the open level runs it (effectiveInOpenLevel).';
-const setClass = (action, label, field, alias = []) => withWhenNotToUse(f(action, `Set a GameMode ${label} class.${EFFECTIVE}`, ['gameModeBlueprint', 'blueprintPath', field, ...alias, 'makeDefault', 'save'], ['gameModeBlueprint', field], ['madeDefault', 'effectiveInOpenLevel', 'openLevelGameMode']), ['A Blueprint\'s own class default values (its CDO) must be set (use blueprint.edit_variable edit=set_default).']);
-export const NETWORKING_FRAMEWORK_RECORDS = [
-    create('create_game_mode', 'GameMode', ['defaultPawnClass', 'playerControllerClass', 'gameStateClass', 'playerStateClass', 'hudClass']),
-    create('create_game_state', 'GameState'),
-    create('create_player_controller', 'PlayerController'),
-    create('create_player_state', 'PlayerState'),
-    create('create_game_instance', 'GameInstance'),
-    create('create_hud_class', 'HUD'),
-    setClass('set_default_pawn_class', 'default pawn', 'pawnClass', ['defaultPawnClass']),
-    setClass('set_player_controller_class', 'PlayerController', 'playerControllerClass'),
-    setClass('set_game_state_class', 'GameState', 'gameStateClass'),
-    setClass('set_player_state_class', 'PlayerState', 'playerStateClass'),
-    setClass('set_hud_class', 'HUD', 'hudClass'),
-    f('configure_game_rules', 'Set a GameMode\'s bDelayedStart match rule; only GameMode (AGameMode) children have it, a GameModeBase child is refused with NOT_SUPPORTED.', ['gameModeBlueprint', 'blueprintPath', 'bDelayedStart', 'save'], ['gameModeBlueprint', 'bDelayedStart'], [], [], false, {
-        bDelayedStart: { type: 'boolean', description: 'Hold the match in WaitingToStart until StartMatch is called (AGameMode::bDelayedStart).' },
-    }),
-    f('set_respawn_rules', 'Set the game mode\'s minimum respawn delay (AGameMode::MinRespawnDelay); a GameModeBase child is refused with NOT_SUPPORTED.', ['gameModeBlueprint', 'blueprintPath', 'respawnDelay', 'save'], ['gameModeBlueprint', 'respawnDelay']),
-    f('configure_spectating', 'Set the GameMode spectator pawn class (SpectatorClass).', ['gameModeBlueprint', 'blueprintPath', 'spectatorClass', 'save'], ['gameModeBlueprint', 'spectatorClass'], [], [], false, {
-        spectatorClass: { type: 'string', description: 'SpectatorPawn class path, e.g. /Script/Engine.SpectatorPawn or a Blueprint path.' },
-    }),
-    withTopics(utilityRecord({
-        tool: T, action: 'configure_player_start', family: 'gameFramework',
-        summary: 'Set the PlayerStartTag of a PlayerStart in the open level: an explicit tag, or TeamN for teamIndex N. The engine only matches the tag against a ?Portal=<tag> travel option; team spawning needs a game mode that reads it. Undoable; the level is left modified, not saved.',
-        whenNotToUse: ['A PlayerStart must be placed in the level first (use control_actor.spawn with the PlayerStart class).'],
-        params: ['playerStartName', 'playerStartTag', 'teamIndex'], requiredOneOf: ['playerStartTag', 'teamIndex'],
-        outputs: ['playerStart', 'playerStartTag', 'previousTag'], outputRequired: ['playerStart', 'playerStartTag', 'previousTag'],
-        dispatchAction: 'manage_game_framework',
-    }), ['player start', 'player start tag', 'team spawn point', 'spawn point tag']),
-    withTopics(f('get_game_framework_info', 'Read which game mode is in use and its default classes (pawn, player controller, game state, player state, HUD), from a game mode Blueprint or from the live world, the level override or the project default.', ['gameModeBlueprint', 'blueprintPath'], [], ['gameFrameworkInfo'], ['gameFrameworkInfo'], true), ['which mode is used', 'default pawn class', 'default classes', 'read game mode', 'game mode settings']),
-];
-//# sourceMappingURL=framework.data.js.map

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

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

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

@@ -1,15 +0,0 @@
-import { compareById } from '../../../../../utils/serialization/ordering.js';
-import { NETWORKING_FRAMEWORK_RECORDS } from './framework.data.js';
-import { NETWORKING_INPUT_RECORDS } from './input.data.js';
-import { NETWORKING_REPLICATION_RECORDS } from './replication.data.js';
-import { NETWORKING_SESSION_RECORDS } from './session.data.js';
-import { MANAGE_NETWORKING_FOLDS } from '../folds/manage-networking.folds.js';
-import { applyFolds } from '../shared/fold.js';
-export const MANAGE_NETWORKING_UNFOLDED_SOURCES = [
-    ...NETWORKING_REPLICATION_RECORDS,
-    ...NETWORKING_SESSION_RECORDS,
-    ...NETWORKING_FRAMEWORK_RECORDS,
-    ...NETWORKING_INPUT_RECORDS,
-].sort(compareById);
-export const MANAGE_NETWORKING_SOURCES = Object.freeze(applyFolds(MANAGE_NETWORKING_UNFOLDED_SOURCES, MANAGE_NETWORKING_FOLDS, 'manage_networking'));
-//# sourceMappingURL=index.js.map

package/dist/tools/catalog/capabilities/records/manage-networking/input.data.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-networking/input.data.js

@@ -1,24 +0,0 @@
-import { utilityRecord, withTopics } from '../utility/utility-record-builders.js';
-const T = 'manage_networking';
-const ENHANCED = ['EnhancedInput'];
-const i = (action, summary, params, required, outputs = [], outputRequired = [], enhanced = true, effect = 'write') => utilityRecord({
-    tool: T, action, family: 'input', summary, params, required,
-    outputs, outputRequired, plugins: enhanced ? ENHANCED : [], effect,
-    safeToRetry: effect === 'read', dispatchAction: 'manage_input',
-});
-export const NETWORKING_INPUT_RECORDS = [
-    withTopics(i('create_input_action', 'Create an Enhanced Input Action asset (valueType: digital, axis1d, axis2d, or axis3d — movement/look actions need axes).', ['name', 'path', 'valueType'], ['name', 'path'], ['assetPath'], ['assetPath']), ['input action', 'enhanced input', 'new input action', 'key binding']),
-    withTopics(i('create_input_mapping_context', 'Create an Enhanced Input Mapping Context asset; its priority is chosen when it is enabled (enable_input_mapping).', ['name', 'path'], ['name', 'path'], ['assetPath'], ['assetPath']), ['input mapping', 'mapping context', 'imc', 'key mapping', 'enhanced input mapping']),
-    i('add_mapping', 'Add an Enhanced Input mapping with optional trigger and modifier types.', ['contextPath', 'actionPath', 'key', 'triggerType', 'modifierType'], ['contextPath', 'actionPath', 'key']),
-    withTopics(i('remove_mapping', 'Remove an Enhanced Input mapping; removing an action\'s keys is how an input action is disabled.', ['contextPath', 'actionPath', 'key'], ['contextPath', 'actionPath'], [], [], true, 'destructive'), ['disable input action', 'unbind key', 'remove key binding']),
-    i('add_legacy_action_mapping', 'Add a legacy action mapping.', ['name', 'actionName', 'key', 'shift', 'ctrl', 'alt', 'cmd'], ['key'], [], [], false),
-    i('remove_legacy_action_mapping', 'Remove a legacy action mapping.', ['name', 'actionName', 'key', 'shift', 'ctrl', 'alt', 'cmd'], ['key'], [], [], false, 'destructive'),
-    i('add_legacy_axis_mapping', 'Add a legacy axis mapping.', ['name', 'axisName', 'key', 'scale'], ['key'], [], [], false),
-    i('remove_legacy_axis_mapping', 'Remove a legacy axis mapping.', ['name', 'axisName', 'key', 'scale'], ['key'], [], [], false, 'destructive'),
-    i('map_input_action', 'Map an Enhanced Input Action to a key in a context, with an optional trigger and modifier on that mapping; mapping the same action and key again redefines it.', ['contextPath', 'actionPath', 'key', 'triggerType', 'modifierType'], ['contextPath', 'actionPath', 'key']),
-    i('set_input_trigger', 'Add a trigger to an Enhanced Input Action; a trigger of that class already on the action is kept, not stacked.', ['actionPath', 'triggerType'], ['actionPath', 'triggerType']),
-    i('set_input_modifier', 'Add a modifier to an Enhanced Input Action, or to one mapping when contextPath and key are given; a modifier of that class already there is kept, not stacked.', ['contextPath', 'actionPath', 'key', 'modifierType'], ['actionPath', 'modifierType']),
-    i('enable_input_mapping', 'Enable an Enhanced Input Mapping Context on the PIE local player at a priority; outside PIE it fails with PIE_NOT_RUNNING.', ['contextPath', 'priority'], ['contextPath']),
-    withTopics(i('get_input_info', 'Read an input asset: every key mapping of an Input Mapping Context (details.mappings: key, action, triggers, modifiers) or an Input Action\'s value type and consume flag.', ['assetPath'], ['assetPath'], ['assetPath', 'assetClass', 'assetName', 'existsAfter', 'type', 'valueType', 'consumeInput', 'mappingCount'], ['assetPath', 'assetClass', 'assetName', 'existsAfter'], true, 'read'), ['key bindings', 'input mappings', 'which keys', 'game controls', 'mapping context keys', 'keys bound']),
-];
-//# sourceMappingURL=input.data.js.map

package/dist/tools/catalog/capabilities/records/manage-networking/replication.data.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-networking/replication.data.js

@@ -1,60 +0,0 @@
-import { utilityRecord, withAliases, withInputProps, withTopics } from '../utility/utility-record-builders.js';
-const T = 'manage_networking';
-const EDIT = ['edit'];
-const RUNTIME = ['pie', 'simulate'];
-const bool = (description) => ({ type: 'boolean', description });
-const num = (description) => ({ type: 'number', description });
-const str = (description) => ({ type: 'string', description });
-const NET_PROPS = {
-    condition: str('Replication condition, a ELifetimeCondition name such as COND_OwnerOnly, COND_SkipOwner, COND_InitialOnly or COND_AutonomousOnly; an unknown name is refused.'),
-    dormancy: str('Net dormancy, a ENetDormancy name: DORM_Never, DORM_Awake, DORM_DormantAll, DORM_DormantPartial or DORM_Initial; an unknown name is refused.'),
-    role: str('How clients see the actor: ROLE_None (not replicated), ROLE_SimulatedProxy or ROLE_AutonomousProxy (replicated). ROLE_Authority is refused: the server always has it.'),
-    rpcType: str('Server, Client or NetMulticast (Multicast is accepted too); anything else is refused.'),
-    spatiallyLoaded: bool('World Partition: stream the actor in by distance (AActor bIsSpatiallyLoaded).'),
-    netLoadOnClient: bool('Load the placed actor on clients with the map (AActor bNetLoadOnClient).'),
-    isAutonomousProxy: bool('true: every replicated variable replicates to the autonomous proxy only (COND_AutonomousOnly). false: variables using COND_AutonomousOnly go back to COND_None; other conditions stay.'),
-    enablePrediction: bool('CharacterMovement bNetworkAlwaysReplicateTransformUpdateTimestamp: always replicate the transform timestamp simulated proxies smooth with.'),
-    smoothingRate: num('Seconds simulated proxies take to smooth a server correction (location and rotation, dedicated and listen server).'),
-    networkSmoothingMode: str('CharacterMovement NetworkSmoothingMode: Disabled, Linear, Exponential or Replay.'),
-    networkMaxSmoothUpdateDistance: num('CharacterMovement NetworkMaxSmoothUpdateDistance in cm: corrections farther than this snap after smoothing.'),
-    networkNoSmoothUpdateDistance: num('CharacterMovement NetworkNoSmoothUpdateDistance in cm: corrections farther than this snap without smoothing.'),
-    maxClientRate: num('Game net driver MaxClientRate (bytes per second per LAN client).'),
-    maxInternetClientRate: num('Game net driver MaxInternetClientRate (bytes per second per internet client).'),
-    netServerMaxTickRate: num('Game net driver NetServerMaxTickRate (server ticks per second).'),
-    dataType: str('Variable type in the add_variable grammar: Vector, Rotator, Transform, Float, Int, Bool, Name, Struct:/Game/Path/S_Name.S_Name, Array:Vector and so on.'),
-    variableName: str('Variable to add or convert; default PredictionData_<dataType> (required when dataType is not a plain type name).'),
-};
-const r = (action, summary, params = [], required = [], outputs = [], outputRequired = [], read = false, runtime = false) => withInputProps(utilityRecord({
-    tool: T, action, family: 'replication', summary, params, required, outputs, outputRequired,
-    effect: read ? 'read' : 'write', states: runtime ? RUNTIME : EDIT,
-    safeToRetry: read, dispatchAction: 'manage_networking',
-}), Object.fromEntries(params.flatMap((name) => { const prop = NET_PROPS[name]; return prop === undefined ? [] : [[name, prop]]; })));
-export const NETWORKING_REPLICATION_RECORDS = [
-    withAliases(withTopics(r('set_property_replicated', 'Turn replication of a Blueprint variable on or off, optionally with its replication condition.', ['blueprintPath', 'propertyName', 'replicated', 'condition'], ['blueprintPath', 'propertyName']), ['replicate variable', 'replication', 'replicated property', 'network variable', 'enable replication', 'multiplayer variable', 'replicate', 'replicated variable', 'variable replication']), ['manage_networking.replicate_variable', 'manage_networking.enable_replication']),
-    r('set_replication_condition', 'Set a Blueprint property replication condition.', ['blueprintPath', 'propertyName', 'condition'], ['blueprintPath', 'propertyName', 'condition']),
-    r('configure_net_update_frequency', 'Configure actor network update frequency.', ['blueprintPath', 'netUpdateFrequency', 'minNetUpdateFrequency'], ['blueprintPath']),
-    r('configure_net_priority', 'Configure actor network bandwidth priority.', ['blueprintPath', 'netPriority'], ['blueprintPath']),
-    r('set_net_dormancy', 'Set an Actor Blueprint\'s default network dormancy.', ['blueprintPath', 'dormancy'], ['blueprintPath', 'dormancy']),
-    r('configure_replication_graph', 'Set an Actor Blueprint\'s spatially loaded (World Partition) and net load on client defaults; only the fields sent are written.', ['blueprintPath', 'spatiallyLoaded', 'netLoadOnClient'], ['blueprintPath']),
-    r('create_rpc_function', 'Create a Blueprint RPC function (Server, Client or NetMulticast).', ['blueprintPath', 'functionName', 'rpcType', 'reliable'], ['blueprintPath', 'functionName', 'rpcType'], ['functionName'], ['functionName']),
-    r('configure_rpc_validation', 'Configure RPC validation.', ['blueprintPath', 'functionName', 'withValidation'], ['blueprintPath', 'functionName']),
-    r('set_rpc_reliability', 'Set RPC reliability.', ['blueprintPath', 'functionName', 'reliable'], ['blueprintPath', 'functionName', 'reliable']),
-    r('set_owner', 'Set or clear (empty ownerActorName) the owner of a runtime actor; an owner name that matches no actor is refused.', ['actorName', 'ownerActorName'], ['actorName'], [], [], false, true),
-    r('set_autonomous_proxy', 'Make every replicated variable of a Blueprint replicate to the autonomous proxy only (COND_AutonomousOnly), or undo that; fails when it has no replicated variable.', ['blueprintPath', 'isAutonomousProxy'], ['blueprintPath']),
-    r('check_has_authority', 'Read runtime actor authority state.', ['actorName'], ['actorName'], ['hasAuthority', 'role'], ['hasAuthority'], true, true),
-    r('check_is_locally_controlled', 'Read local-control state for an actor.', ['actorName'], ['actorName'], ['isLocallyControlled', 'isLocalController'], ['isLocallyControlled'], true, true),
-    r('configure_net_cull_distance', 'Configure network relevancy cull distance.', ['blueprintPath', 'netCullDistanceSquared', 'useOwnerNetRelevancy'], ['blueprintPath']),
-    r('set_always_relevant', 'Set always-relevant replication behavior.', ['blueprintPath', 'alwaysRelevant'], ['blueprintPath']),
-    r('set_only_relevant_to_owner', 'Set owner-only relevancy behavior.', ['blueprintPath', 'onlyRelevantToOwner'], ['blueprintPath']),
-    r('set_replicated_using', 'Assign a RepNotify function to a property.', ['blueprintPath', 'propertyName', 'repNotifyFunc'], ['blueprintPath', 'propertyName', 'repNotifyFunc']),
-    r('configure_push_model', 'Turn push-model replication on or off for every replicated variable of a Blueprint; fails when it has none.', ['blueprintPath', 'usePushModel'], ['blueprintPath']),
-    r('configure_client_prediction', 'Set whether a Character Blueprint always replicates its movement transform timestamp (CharacterMovement bNetworkAlwaysReplicateTransformUpdateTimestamp); other Blueprints are refused.', ['blueprintPath', 'enablePrediction'], ['blueprintPath', 'enablePrediction']),
-    r('configure_server_correction', 'Set how long a Character Blueprint\'s simulated proxies smooth server corrections; other Blueprints are refused.', ['blueprintPath', 'smoothingRate'], ['blueprintPath', 'smoothingRate']),
-    r('add_network_prediction_data', 'Add a Blueprint variable, or convert an existing one of the same type, that replicates only to the owning client (COND_AutonomousOnly) for client-side prediction state. Pawn, Character, Controller and ActorComponent Blueprints only (no other actor is an autonomous proxy); the reply says whether the Blueprint itself replicates.', ['blueprintPath', 'dataType', 'variableName'], ['blueprintPath', 'dataType'], ['variableName', 'dataType', 'created', 'updated', 'actorReplicates', 'compiled', 'saved'], ['variableName', 'created', 'updated', 'actorReplicates', 'compiled', 'saved']),
-    r('configure_movement_prediction', 'Set a Character Blueprint\'s movement network smoothing mode and smoothing distances; only the fields sent are written, other Blueprints are refused.', ['blueprintPath', 'networkSmoothingMode', 'networkMaxSmoothUpdateDistance', 'networkNoSmoothUpdateDistance'], ['blueprintPath']),
-    r('configure_net_driver', 'Write the game net driver\'s rate limits to its class defaults and DefaultEngine.ini, and to the running net driver when there is one; only the fields sent are written.', ['maxClientRate', 'maxInternetClientRate', 'netServerMaxTickRate']),
-    r('set_net_role', 'Choose how clients see an Actor Blueprint\'s actors: ROLE_None turns replication off, ROLE_SimulatedProxy or ROLE_AutonomousProxy turn it on.', ['blueprintPath', 'role'], ['blueprintPath', 'role']),
-    r('configure_replicated_movement', 'Configure replicated movement.', ['blueprintPath', 'replicateMovement'], ['blueprintPath']),
-    withTopics(r('get_networking_info', 'Read an actor\'s or Blueprint\'s replication settings: replicates, always relevant, only relevant to owner, net update frequency, cull distance, priority and dormancy; for a live actor also its net role, remote role and authority.', ['blueprintPath', 'actorName'], [], ['networkingInfo'], ['networkingInfo'], true), ['replication settings', 'is actor replicated', 'net dormancy value']),
-];
-//# sourceMappingURL=replication.data.js.map

package/dist/tools/catalog/capabilities/records/manage-networking/session.data.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-networking/session.data.js

@@ -1,26 +0,0 @@
-import { utilityRecord, withTopics } from '../utility/utility-record-builders.js';
-const T = 'manage_networking';
-const ONLINE = ['OnlineSubsystem', 'OnlineSubsystemUtils'];
-const s = (action, summary, params = [], required = [], outputs = [], outputRequired = [], effect = 'write', requiredOneOf, states = ['edit', 'pie']) => utilityRecord({
-    tool: T, action, family: 'session', summary, params, required, requiredOneOf, outputs, outputRequired,
-    plugins: ONLINE, states, effect,
-    safeToRetry: effect === 'read', dispatchAction: 'manage_sessions',
-});
-const SPLIT_SCREEN = 'Turn local split screen on or off and pick a layout by name: None (off), TwoPlayer_Horizontal, TwoPlayer_Vertical, ThreePlayer_FavorTop, ThreePlayer_FavorBottom, ThreePlayer_Vertical, ThreePlayer_Horizontal, FourPlayer_Grid, FourPlayer_Vertical or FourPlayer_Horizontal. Only the layout for that player count changes; written to DefaultEngine.ini and live in PIE.';
-const SPLIT_OUT = ['enabled', 'splitScreenType', 'layoutsWritten', 'settingsSaved'];
-const SPLIT_OUT_REQUIRED = ['enabled', 'settingsSaved'];
-export const NETWORKING_SESSION_RECORDS = [
-    s('configure_split_screen', SPLIT_SCREEN, ['enabled', 'splitScreenType'], [], SPLIT_OUT, SPLIT_OUT_REQUIRED, 'write', ['enabled', 'splitScreenType']),
-    s('set_split_screen_type', SPLIT_SCREEN, ['splitScreenType', 'enabled'], ['splitScreenType'], SPLIT_OUT, SPLIT_OUT_REQUIRED),
-    s('configure_lan_play', 'Set the project default game port ([URL] Port in DefaultEngine.ini) that listen servers bind and joins without a port connect to; packaged games use it from their next launch and the running editor at once.', ['serverPort'], ['serverPort'], ['serverPort', 'previousPort', 'configFile', 'persisted'], ['serverPort', 'previousPort', 'configFile', 'persisted']),
-    s('configure_session_interface', 'Choose the online subsystem the project uses ([OnlineSubsystem] DefaultPlatformService in DefaultEngine.ini): Null for LAN and local play, Steam, EOS and others whose OnlineSubsystem plugin is enabled; also turns on [OnlineSubsystem<Name>] bEnabled when the engine config has it off. Takes effect on the next launch (Steam only in standalone and packaged games).', ['interfaceType'], ['interfaceType'], ['interfaceType', 'previous', 'configFile', 'written', 'persisted', 'requiresRestart'], ['interfaceType', 'configFile', 'persisted', 'requiresRestart']),
-    s('join_lan_server', 'Make a running Play-In-Editor instance join a server at serverAddress:serverPort (ClientTravel); the connection completes asynchronously. Refused when PIE is not running or every instance is hosting.', ['serverAddress', 'serverPort', 'travelOptions'], ['serverAddress'], ['connectionURL', 'pieWorld', 'travelStarted'], ['connectionURL', 'pieWorld', 'travelStarted']),
-    s('configure_voice_settings', 'Configure project VoIP: turn online voice on or off, microphone gain, noise gate and silence detection thresholds, and the VoIP sample rate. Written to DefaultEngine.ini for packaged games; the voice console variables also apply to the running editor.', ['voiceEnabled', 'micInputGain', 'noiseGateThreshold', 'silenceDetectionThreshold', 'sampleRate'], [], ['written', 'configFile', 'liveApplied', 'requiresRestart'], ['written', 'configFile', 'liveApplied', 'requiresRestart'], 'write', ['voiceEnabled', 'micInputGain', 'noiseGateThreshold', 'silenceDetectionThreshold', 'sampleRate']),
-    s('add_local_player', 'Add a local player and return its player state.', ['controllerId'], ['controllerId'], ['playerIndex'], ['playerIndex'], 'write', undefined, ['pie']),
-    s('remove_local_player', 'Remove a local player.', ['playerIndex'], ['playerIndex'], [], [], 'destructive', undefined, ['pie']),
-    s('host_lan_server', 'Build the LAN listen-server travel URL for a map; nothing is hosted unless executeTravel is true, which travels the running world to it.', ['mapName', 'maxPlayers', 'travelOptions', 'executeTravel'], ['mapName'], ['mapPath', 'travelURL'], ['travelURL']),
-    s('enable_voice_chat', 'Enable or disable online voice chat.', ['voiceEnabled'], ['voiceEnabled']),
-    s('mute_player', 'Mute or unmute an online player through the voice chat or online voice interface; fails with NOT_SUPPORTED when neither applies it.', ['playerName', 'targetPlayerId', 'muted', 'localPlayerNum', 'systemWide'], [], undefined, undefined, undefined, ['playerName', 'targetPlayerId']),
-    withTopics(s('get_sessions_info', 'Read the current play session: local player count, whether PIE is running, the split-screen setting and layout, and each PIE instance\'s net mode (Standalone, DedicatedServer, ListenServer or Client) and URL.', [], [], ['sessionsInfo'], ['sessionsInfo'], 'read'), ['split screen settings', 'pie net mode']),
-];
-//# sourceMappingURL=session.data.js.map

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

@@ -1,49 +0,0 @@
-import type { JsonObject } from '../../model.js';
-export declare const A: {
-    save: JsonObject;
-    durationFrames: JsonObject;
-    rowIndex: JsonObject;
-    startFrame: JsonObject;
-    endFrame: JsonObject;
-    currentAperture: JsonObject;
-    currentFocalLength: JsonObject;
-    manualFocusDistance: JsonObject;
-    lens: JsonObject;
-    filmback: JsonObject;
-    focus: JsonObject;
-    label: JsonObject;
-    from: JsonObject;
-    to: JsonObject;
-    visibility: JsonObject;
-    activate: JsonObject;
-    displayName: JsonObject;
-    sectionIndex: JsonObject;
-    cameraShakePath: JsonObject;
-    animationPath: JsonObject;
-    componentName: JsonObject;
-    materialIndex: JsonObject;
-    parameterName: JsonObject;
-    propertyName: JsonObject;
-    propertyPath: JsonObject;
-    propertyType: JsonObject;
-    bindingGuid: JsonObject;
-    autoPlay: JsonObject;
-    playOnOpen: JsonObject;
-    loop: JsonObject;
-    looping: JsonObject;
-    autoClear: JsonObject;
-    mediaPath: JsonObject;
-    targetActor: JsonObject;
-    playlistIndex: JsonObject;
-    time: JsonObject;
-    properties: JsonObject;
-    trackNames: JsonObject;
-    actors: JsonObject;
-    enabled: JsonObject;
-    disableOthers: JsonObject;
-    recordParentHierarchy: JsonObject;
-    jobName: JsonObject;
-    renderJobId: JsonObject;
-    method: JsonObject;
-};
-//# sourceMappingURL=alias-props.d.ts.map

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

@@ -1,78 +0,0 @@
-import { bool, int, num, str, strArr } from '../shared/schema-props.js';
-const lensSettings = {
-    type: 'object',
-    description: 'Nested lens overrides (Cameras.cpp:71-76 nested object "lens").',
-    additionalProperties: false,
-    properties: {
-        currentFocalLength: num('Focal length in millimetres.'),
-        focalLength: num('Focal length alias in millimetres.'),
-        currentAperture: num('Aperture as an f-stop.'),
-        aperture: num('Aperture alias as an f-stop.'),
-    },
-};
-const filmbackSettings = {
-    type: 'object',
-    description: 'Nested filmback overrides (Cameras.cpp:77-80 nested object "filmback").',
-    additionalProperties: false,
-    properties: {
-        sensorWidth: num('Sensor width in millimetres.'),
-        sensorHeight: num('Sensor height in millimetres.'),
-    },
-};
-const focusSettings = {
-    type: 'object',
-    description: 'Nested focus overrides (Cameras.cpp:81-83 nested object "focus").',
-    additionalProperties: false,
-    properties: {
-        manualFocusDistance: num('Manual focus distance in centimetres.'),
-        focusDistance: num('Manual focus distance alias in centimetres.'),
-    },
-};
-export const A = {
-    save: bool('Whether to save the sequence asset after the mutation.'),
-    durationFrames: int('Section duration in display-rate frames.'),
-    rowIndex: int('Sequencer row index for the created section.'),
-    startFrame: int('Section start in display-rate frames (default 0).'),
-    endFrame: int('Section end in display-rate frames; used when durationFrames is absent.'),
-    currentAperture: num('Aperture as an f-stop (read before aperture).'),
-    currentFocalLength: num('Focal length in millimetres (read before focalLength).'),
-    manualFocusDistance: num('Manual focus distance in centimetres (read before focusDistance).'),
-    lens: lensSettings,
-    filmback: filmbackSettings,
-    focus: focusSettings,
-    label: str('Actor label alias for the camera or rig actor (alias of actorName).'),
-    from: num('Fade start opacity value.'),
-    to: num('Fade end opacity value.'),
-    visibility: str('Level visibility state: Visible or Hidden.'),
-    activate: bool('Whether the key activates (true) or deactivates (false).'),
-    displayName: str('Shot display name (alias of shotName).'),
-    sectionIndex: int('Index of the shot section to configure.'),
-    cameraShakePath: str('Camera shake asset path.'),
-    animationPath: str('Animation sequence asset path (alias of animationSequencePath).'),
-    componentName: str('Name of the component owning the target material.'),
-    materialIndex: int('Material slot index on the component.'),
-    parameterName: str('Material parameter name to animate.'),
-    propertyName: str('Property name to animate (alias of property).'),
-    propertyPath: str('Nested property path to animate.'),
-    propertyType: str('Property value type hint (alias of type).'),
-    bindingGuid: str('Sequencer binding GUID (alias of bindingId).'),
-    autoPlay: bool('Whether the media player plays automatically on open.'),
-    playOnOpen: bool('Whether the media player plays on open (alias of autoPlay).'),
-    loop: bool('Whether media playback loops.'),
-    looping: bool('Whether media playback loops (alias of loop).'),
-    autoClear: bool('Whether the media texture clears when playback stops.'),
-    mediaPath: str('Media file path (alias of filePath).'),
-    targetActor: str('Actor receiving the media sound component (alias of actorName).'),
-    playlistIndex: int('Zero-based index into the media playlist.'),
-    time: num('Seek time in seconds (alias of timeSeconds).'),
-    properties: strArr('Property name.', 'Recorded property names (alias of tracks).'),
-    trackNames: strArr('Track name.', 'Recorded track names (alias of tracks).'),
-    actors: strArr('Actor name.', 'Actor names to record (alias of actorNames).'),
-    enabled: bool('Whether the matched recorded tracks are enabled.'),
-    disableOthers: bool('Whether non-matching recorded tracks are disabled.'),
-    recordParentHierarchy: bool('Whether the source records its parent hierarchy.'),
-    jobName: str('Render job name (alias of renderJobName).'),
-    renderJobId: str('Render job identifier (alias of jobId).'),
-    method: str('Anti-aliasing method (alias of antiAliasingMethod).'),
-};
-//# sourceMappingURL=alias-props.js.map

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

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