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

package/dist/tools/catalog/capabilities/records/manage-blueprint/scs-components.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-blueprint/scs-components.js

@@ -1,203 +0,0 @@
-import { BP_PLUGINS, buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const FAMILY = 'scs';
-const DOMAIN = 'blueprint';
-const PART_WARNINGS = {
-    type: 'array',
-    items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-    'x-unreal-reflection-boundary': true,
-    description: 'Mesh parts this edit left sunk or buried, worst first (at most 8, each also a warnings[] sentence): componentName, kind (sunk: below the actor\'s ground, a Character\'s capsule bottom; buried: inside otherComponent), depth in cm, insideShare (0-1, how much of the part\'s surface is inside the other) and issue. Measured on the real triangles of a preview instance, not on bounds. A part tagged mcp.placement.ok (set ComponentTags to ["mcp.placement.ok"]) is a deliberate embed, such as an eyeball in its socket, and is left out; mcp.placement.ok:<component> accepts the embed in that one part only (a neck in its collar, a hand round a handle) and keeps every other check. control_actor.audit_placement with blueprintPath lists every part of the Blueprint.',
-};
-export const SCS_COMPONENTS_RECORDS = [
-    buildRecord({
-        id: 'blueprint.add_component',
-        action: 'add_component',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Add a component to a Blueprint (the same SCS template add_scs_component adds), optionally attached, placed, meshed and configured.',
-        whenToUse: ['A component must be added to a Blueprint under the add_component verb.'],
-        whenNotToUse: ['Several components or other SCS edits must be batched (use modify_scs).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, componentClass: P.componentClass, componentType: P.componentType, componentName: P.componentName, parentComponent: P.parentComponent, attachTo: P.attachTo, properties: P.properties,
-            meshPath: P.meshPath, materialPath: P.materialPath, location: P.location, rotation: P.rotation, scale: P.scale,
-        },
-        required: ['blueprintPath', 'componentClass', 'componentName'],
-        outputProps: { componentName: P.componentName, partWarnings: PART_WARNINGS },
-        outputRequired: ['componentName'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'add_component', blueprintPath: '/Game/Blueprints/BP_Test', componentClass: '/Script/Engine.StaticMeshComponent', componentName: 'Mesh' },
-        exampleOutput: { success: true, componentName: 'Mesh' },
-    }),
-    buildRecord({
-        id: 'blueprint.add_scs_component',
-        action: 'add_scs_component',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['add component', 'attach component', 'static mesh component', 'mesh component', 'component template', 'add mesh to blueprint', 'add camera component', 'add component to blueprint', 'blueprint component'],
-        aliases: ['blueprint.add_component_to_blueprint'],
-        summary: 'Add an SCS-owned component template node to the Blueprint\'s Simple Construction Script.',
-        whenToUse: ['A component template must be owned by the SCS tree for instanced property overrides.'],
-        whenNotToUse: ['A non-template component instance is sufficient (use add_component).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, componentClass: P.componentClass, componentType: P.componentType, componentName: P.componentName, parentComponent: P.parentComponent, attachTo: P.attachTo, meshPath: P.meshPath, materialPath: P.materialPath,
-            location: P.location, rotation: P.rotation, scale: P.scale, properties: P.properties,
-        },
-        required: ['blueprintPath', 'componentClass', 'componentName'],
-        outputProps: {
-            componentName: P.componentName,
-            componentClass: P.componentClass,
-            parent: P.parentComponent,
-            compiled: P.success,
-            saved: P.success,
-            scsVerification: { type: 'object', description: 'SCS node verification (exists, parent matches).', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-            appliedProperties: { type: 'array', items: { type: 'string' }, description: 'The names in properties that took their value; one that did not apply fails the call and is named in the error.' },
-            partWarnings: PART_WARNINGS,
-        },
-        outputRequired: ['componentName'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'add_scs_component', blueprintPath: '/Game/Blueprints/BP_Test', componentClass: '/Script/Engine.StaticMeshComponent', componentName: 'SCS_Mesh', parentComponent: 'DefaultSceneRoot' },
-        exampleOutput: { success: true, componentName: 'SCS_Mesh', componentClass: '/Script/Engine.StaticMeshComponent', parent: 'DefaultSceneRoot', compiled: true, saved: true, scsVerification: { exists: true } },
-    }),
-    buildRecord({
-        id: 'blueprint.modify_scs',
-        action: 'modify_scs',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Modify an existing SCS component template node (properties or transform).',
-        whenToUse: ['An SCS-owned component template needs property or transform updates.'],
-        whenNotToUse: ['Only a single property is needed (use set_scs_property).'],
-        inputProps: {
-            componentClass: P.componentClass, componentType: P.componentType, attachTo: P.attachTo,
-            location: P.location, rotation: P.rotation, scale: P.scale, properties: P.properties, meshPath: P.meshPath, materialPath: P.materialPath,
-            compile: { type: 'boolean', description: 'Compile the Blueprint after the operations (default false; applyAndSave also compiles).' },
-            save: { type: 'boolean', description: 'Save the Blueprint after the operations (default true, so the edit survives an editor restart); applyAndSave overrides it.' },
-            blueprintPath: P.blueprintPath, componentName: P.componentName, operations: { type: 'array', description: 'SCS operations applied in order. Each entry is an object with `type` plus that operation\'s own fields; `type: "add_component"` also takes componentName, componentClass (or componentType), attachTo, transform, meshPath, materialPath and a nested properties bag; `type: "modify_component"` takes the same transform, meshPath, materialPath and properties for a component that already exists; transform is {location:{x,y,z}, rotation:{pitch,yaw,roll}, scale:{x,y,z}} (or those three directly on the operation), and a part left out keeps its current value, while a transform that cannot be applied (a part that is not an {x,y,z} or {pitch,yaw,roll} object or a three-number array, or a component with no transform) is named in warnings, not skipped, as is a meshPath or materialPath that does not load or that its component cannot take; `type: "attach_component"` (or "reparent") moves componentName under parentComponent (or attachTo/newParent). A failed operation is named in warnings, and the call fails when none applied. Each result carries instancesUpdated (placed copies that took the change, 0 included) with up to three of their paths, and a hint, repeated in warnings, when a mesh or material lands on a hidden component.', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, 'x-unreal-reflection-boundary': true }, applyAndSave: P.applyAndSave
-        },
-        required: ['blueprintPath'],
-        requiredOneOf: ['operations', 'componentName'],
-        outputProps: { partWarnings: PART_WARNINGS },
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'modify_scs', blueprintPath: '/Game/Blueprints/BP_Test', operations: [{ type: 'add_component', componentName: 'SCS_Mesh', componentClass: 'StaticMeshComponent', properties: { bCastShadow: true } }], applyAndSave: true },
-    }),
-    buildRecord({
-        id: 'blueprint.get_scs',
-        action: 'get_scs',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['component hierarchy', 'component tree', 'inherited from parent class', 'attach parent names', 'which blueprints have a component', 'which blueprints use a component', 'find blueprints by component class', 'search blueprints for a component class'],
-        summary: 'List a Blueprint\'s own components (SCS nodes) with class, parent, root flag and relative transform, plus the components it inherits from parent Blueprints and its native parent class; or, given a folder (path) and componentClass, every Blueprint under it that has such a component, owned or inherited.',
-        whenToUse: [
-            'The SCS node hierarchy must be inspected before modifying components.',
-            'An inherited component must be named as an attach parent for add_scs_component.',
-            'Every Blueprint with a kind of component (a TextRender label, a light, an audio source) must be found in one call: path plus componentClass.',
-        ],
-        whenNotToUse: [
-            'A single component property is needed (use get or set_scs_property).',
-            'The assets that use a Blueprint are wanted (use asset.inspect_asset lookup=dependencies with referencers true).',
-        ],
-        inputProps: {
-            blueprintPath: P.blueprintPath,
-            path: { type: 'string', description: 'A folder (e.g. /Game/Blueprints) to scan instead of one Blueprint: each Blueprint under it, subfolders included, that has a component matching componentClass, its own or inherited, is listed under blueprints (at most 300 Blueprints are opened; truncated says when more exist).' },
-            componentClass: { type: 'string', description: 'Only components of this class or a subclass, by name part or /Script path: "TextRender" matches TextRenderComponent, "PointLight" PointLightComponent, "PrimitiveComponent" every primitive. Filters one Blueprint\'s listing too.' },
-        },
-        required: [],
-        requiredOneOf: ['blueprintPath', 'path'],
-        outputProps: { components: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'SCS node descriptors with name, class, and parent.', 'x-unreal-reflection-boundary': true }, componentCount: { type: 'number', description: 'Number of SCS-owned components.' }, inheritedComponents: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Components inherited from parent Blueprints (their own components) and from the native parent class (a Character\'s CollisionCylinder): componentName, componentType, isSceneComponent, ownerClass. A native one is valid as parentComponent for add_scs_component; one from a parent Blueprint is not.', 'x-unreal-reflection-boundary': true }, inheritedComponentCount: { type: 'number', description: 'Number of inherited components.' }, blueprints: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'With path: each matching Blueprint as blueprintPath and components (componentName, componentType; inherited and ownerClass on one it inherits), in path order.', 'x-unreal-reflection-boundary': true }, blueprintCount: { type: 'number', description: 'With path: how many Blueprints matched.' }, scanned: { type: 'number', description: 'With path: how many Blueprints were opened.' }, truncated: { type: 'boolean', description: 'With path: true when the folder holds more than 300 Blueprints and the rest were not opened.' } },
-        effect: 'read',
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'get_scs', blueprintPath: '/Game/Blueprints/BP_Test' },
-        exampleOutput: { success: true, components: [{ componentName: 'DefaultSceneRoot', componentType: 'SceneComponent' }], componentCount: 1, inheritedComponents: [{ componentName: 'CollisionCylinder', componentType: 'CapsuleComponent', isSceneComponent: true, ownerClass: 'Character' }], inheritedComponentCount: 1 },
-    }),
-    buildRecord({
-        id: 'blueprint.remove_scs_component',
-        action: 'remove_scs_component',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Remove one or several SCS-owned component template nodes from the Blueprint. As the editor deletes, the children move up to the removed node\'s parent, and removing a root makes its first scene child the root (DefaultSceneRoot gives way to the mesh under it).',
-        whenToUse: ['An SCS component node and its template must be permanently removed.', 'A mesh under DefaultSceneRoot must become the root, as physics simulation and buoyancy need: remove DefaultSceneRoot.'],
-        whenNotToUse: ['The component should be detached but preserved (no detach action exists; remove is destructive).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, componentName: P.componentName,
-            componentNames: { type: 'array', items: { type: 'string' }, description: 'Several components to remove in one call, in place of componentName; each is reported, and the call fails naming any that were not removed.' },
-        },
-        required: ['blueprintPath'],
-        requiredOneOf: ['componentName', 'componentNames'],
-        outputProps: {
-            promotedChildren: { type: 'array', items: { type: 'string' }, description: 'The removed component\'s children, which moved up instead of going with it.' },
-            newRoot: { type: 'string', description: 'The root after a root was removed, read back after the compile.' },
-        },
-        effect: 'destructive',
-        behavior: { safeToRetry: false },
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'remove_scs_component', blueprintPath: '/Game/Blueprints/BP_Test', componentName: 'SCS_Mesh' },
-    }),
-    buildRecord({
-        id: 'blueprint.reparent_scs_component',
-        action: 'reparent_scs_component',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Reparent an SCS component node to a new parent node in the SCS tree.',
-        whenToUse: ['An SCS component must move under a different parent node.'],
-        whenNotToUse: ['The component hierarchy does not need restructuring.'],
-        inputProps: { blueprintPath: P.blueprintPath, componentName: P.componentName, newParent: P.newParent },
-        required: ['blueprintPath', 'componentName', 'newParent'],
-        outputProps: { partWarnings: PART_WARNINGS },
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'reparent_scs_component', blueprintPath: '/Game/Blueprints/BP_Test', componentName: 'SCS_Mesh', newParent: 'CameraRoot' },
-    }),
-    buildRecord({
-        id: 'blueprint.set_scs_transform',
-        action: 'set_scs_transform',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Set the transform (location, rotation, scale) of an SCS-owned component template. Placed actors that still had the old transform take the new one (instancesUpdated); an actor whose component was changed by hand keeps its own. instancesUpdated counts copies in loaded levels only: a copy in a level that is not loaded keeps the transform saved with it, so move it with control_actor.edit_component once its level is open.',
-        whenToUse: ['An SCS component template transform must be updated.'],
-        whenNotToUse: ['A non-SCS component transform is needed (use set_node_property or add_component).'],
-        inputProps: { blueprintPath: P.blueprintPath, componentName: P.componentName, location: P.location, rotation: P.rotation, scale: P.scale },
-        required: ['blueprintPath', 'componentName'],
-        outputProps: { partWarnings: PART_WARNINGS },
-        effect: 'write',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'set_scs_transform', blueprintPath: '/Game/Blueprints/BP_Test', componentName: 'SCS_Mesh' },
-    }),
-    buildRecord({
-        id: 'blueprint.set_scs_property',
-        action: 'set_scs_property',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Set a single property on an SCS-owned component template; placed actors that still had the old value take the new one (instancesUpdated), one changed by hand keeps its own. For RelativeScale3D/RelativeLocation, note that a child inherits its parent\'s scale: Unreal multiplies parent and child scale COMPONENT-WISE in the child\'s own local axes, and rotation does NOT permute which axis each factor lands on. World size = ParentScale * ChildScale * MeshExtent per local axis, and world offset = ParentScale * RelativeLocation. Under a parent scaled non-uniformly, divide the offset you want by the parent scale on that axis.',
-        whenToUse: ['One property on an SCS component template must be changed.'],
-        whenNotToUse: ['Multiple properties need batch updates (use modify_scs).'],
-        inputProps: { blueprintPath: P.blueprintPath, componentName: P.componentName, propertyName: P.propertyName, propertyValue: P.propertyValue },
-        required: ['blueprintPath', 'componentName', 'propertyName', 'propertyValue'],
-        outputProps: { verifiedValue: P.propertyValue, partWarnings: PART_WARNINGS },
-        effect: 'write',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'set_scs_property', blueprintPath: '/Game/Blueprints/BP_Test', componentName: 'SCS_Mesh', propertyName: 'bCastShadow', propertyValue: true },
-        exampleOutput: { success: true, message: 'SCS property set', verifiedValue: true },
-    }),
-];
-//# sourceMappingURL=scs-components.js.map

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

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

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

@@ -1,140 +0,0 @@
-import { BP_PLUGINS, buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const FAMILY = 'variables';
-const DOMAIN = 'blueprint';
-export const VARIABLES_METADATA_RECORDS = [
-    buildRecord({
-        id: 'blueprint.add_variable',
-        action: 'add_variable',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['new variable', 'member variable', 'add property', 'float variable', 'bool variable', 'integer variable', 'declare variable'],
-        summary: 'Add a new member variable to a Blueprint.',
-        whenToUse: ['A Blueprint needs a new member variable with a type and default.'],
-        whenNotToUse: ['A graph-local variable is needed (use create_node with a local variable).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, variableName: P.variableName, variableType: P.variableType, defaultValue: P.defaultValue, category: P.category, isReplicated: P.isReplicated, isPublic: P.isPublic,
-            exposeOnSpawn: { type: 'boolean', description: 'Expose on Spawn: the variable becomes an input pin on SpawnActor and Create Widget nodes for this class, set as the actor is made (before its BeginPlay). Makes it instance-editable too, as the editor does.' },
-        },
-        required: ['blueprintPath', 'variableName', 'variableType'],
-        outputProps: { variableName: P.variableName },
-        outputRequired: ['variableName'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'add_variable', blueprintPath: '/Game/Blueprints/BP_Test', variableName: 'Health', variableType: 'Float', defaultValue: 100, category: 'Stats', isReplicated: false, isPublic: true },
-        exampleOutput: { success: true, variableName: 'Health' },
-    }),
-    buildRecord({
-        id: 'blueprint.remove_variable',
-        action: 'remove_variable',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Permanently remove a member variable from a Blueprint.',
-        whenToUse: ['A member variable must be permanently deleted.'],
-        whenNotToUse: ['The variable should be renamed rather than removed.'],
-        inputProps: { blueprintPath: P.blueprintPath, variableName: P.variableName },
-        required: ['blueprintPath', 'variableName'],
-        effect: 'destructive',
-        behavior: { safeToRetry: false },
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'remove_variable', blueprintPath: '/Game/Blueprints/BP_Test', variableName: 'OldStat' },
-    }),
-    buildRecord({
-        id: 'blueprint.rename_variable',
-        action: 'rename_variable',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Rename a member variable or a component in a Blueprint; its graph nodes follow.',
-        whenToUse: ['A member variable needs a new name.', 'A component (Simple Construction Script node) needs a new name.'],
-        whenNotToUse: ['The variable should be removed rather than renamed.'],
-        inputProps: {
-            blueprintPath: P.blueprintPath,
-            oldName: { type: 'string', description: 'Current name of the variable or component.' },
-            newName: P.newName,
-        },
-        required: ['blueprintPath', 'oldName', 'newName'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'rename_variable', blueprintPath: '/Game/Blueprints/BP_Test', oldName: 'HP', newName: 'Health' },
-    }),
-    buildRecord({
-        id: 'blueprint.set_variable_metadata',
-        action: 'set_variable_metadata',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Set metadata (tooltip, category, replication) on a Blueprint member variable.',
-        whenToUse: ['Variable metadata such as tooltip or category must be updated.'],
-        whenNotToUse: ['Only the default value is needed (use set_default).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, variableName: P.variableName, metadata: P.metadata,
-            variableNames: {
-                type: 'array', items: { type: 'string' },
-                description: 'Several variables to give the same metadata in one call (one compile and save), in place of or besides variableName.',
-            },
-        },
-        required: ['blueprintPath'],
-        requiredOneOf: ['variableName', 'variableNames'],
-        outputProps: {
-            variableName: P.variableName,
-            variableNames: { type: 'array', items: { type: 'string' }, description: 'Every variable that took the metadata.' },
-        },
-        effect: 'write',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'set_variable_metadata', blueprintPath: '/Game/Blueprints/BP_Test', variableName: 'Health', metadata: { tooltip: 'Current health points', category: 'Stats' } },
-    }),
-    buildRecord({
-        id: 'blueprint.set_metadata',
-        action: 'set_metadata',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Set arbitrary metadata key-value pairs on a Blueprint class, or on one member variable.',
-        whenToUse: ['Freeform metadata must be attached to a Blueprint or its members.'],
-        whenNotToUse: ['Several variables need the same metadata (set_variable_metadata takes variableNames).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, metadata: P.metadata,
-            propertyName: { ...P.propertyName, description: 'A member variable to put the metadata on (as set_variable_metadata does); omitted, the keys go on the Blueprint class.' },
-        },
-        required: ['blueprintPath', 'metadata'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'set_metadata', blueprintPath: '/Game/Blueprints/BP_Test', metadata: { author: 'MCP', version: '2' } },
-    }),
-    buildRecord({
-        id: 'blueprint.set_default',
-        action: 'set_default',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['default value', 'cdo default', 'variable default', 'set property default'],
-        aliases: ['blueprint.set_default_value'],
-        summary: 'Set a default property value on the Blueprint CDO (Class Default Object).',
-        whenToUse: ['A default property must be set on the CDO; if the property denotes a component, the component CDO is targeted.'],
-        whenNotToUse: ['An SCS component template property is the target (use set_scs_property).'],
-        inputProps: { blueprintPath: P.blueprintPath, propertyName: P.propertyName, propertyValue: P.propertyValue },
-        required: ['blueprintPath', 'propertyName'],
-        outputProps: {
-            value: { description: 'Property value re-read from the Class Default Object after the write. Emitted on the literal path only and omitted when the value cannot be exported to JSON.' },
-            instancesUpdated: { type: 'number', description: 'Placed actors (in loaded levels) that still held the old default and took the new value, as the Details panel propagates a class default; an actor that overrides the value keeps it. Save the level to keep them.' },
-        },
-        effect: 'write',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'set_default', blueprintPath: '/Game/Blueprints/BP_Test', propertyName: 'InitialHealth', propertyValue: 100 },
-        exampleOutput: { success: true, value: 100 },
-    }),
-];
-//# sourceMappingURL=variables-metadata.js.map

package/dist/tools/catalog/capabilities/records/manage-blueprint/widget-animation.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-blueprint/widget-animation.js

@@ -1,124 +0,0 @@
-import { buildRecord, WIDGET_PLUGINS } from './helpers.js';
-import { P } from './properties.js';
-const FAMILY = 'widget-animation';
-const DOMAIN = 'widget';
-const TRACK_OUTPUT = {
-    widgetPath: P.widgetPath,
-    animationName: P.animationName,
-    slotName: { type: 'string', description: 'Widget the track animates.' },
-    trackType: { type: 'string', description: 'Normalised track type.' },
-    propertyName: { type: 'string', description: 'Widget property driven by the track (RenderOpacity, ColorAndOpacity, RenderTransform).' },
-    trackClass: { type: 'string', description: 'MovieScene track class that owns the section.' },
-    createdTrack: { type: 'boolean', description: 'Whether the property track was created by this call.' },
-    createdBinding: { type: 'boolean', description: 'Whether the widget binding was created by this call.' },
-    bindingGuid: { type: 'string', description: 'MovieScene possessable GUID bound to the widget.' },
-    saved: { type: 'boolean', description: 'Whether the Widget Blueprint was saved.' },
-};
-export const WIDGET_ANIMATION_RECORDS = [
-    buildRecord({
-        id: 'blueprint.create_widget_animation',
-        action: 'create_widget_animation',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Create a new widget animation timeline in a Widget Blueprint.',
-        whenToUse: ['A new UMG widget animation must be created for property keyframing.'],
-        whenNotToUse: [
-            'A Blueprint graph animation is needed (use animation_physics).',
-            'An animation must be seen playing in PIE: write the value that sets it off with inspect.set_property and watch (a short pop ends before a later call can read it).',
-        ],
-        inputProps: { widgetPath: P.widgetPath, animationName: P.animationName, duration: P.duration },
-        required: ['widgetPath', 'animationName'],
-        outputProps: {
-            animationName: P.animationName,
-            widgetPath: P.widgetPath,
-            duration: { type: 'number', description: 'Length of the new animation in seconds.' },
-        },
-        outputRequired: ['animationName'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'create_widget_animation', widgetPath: '/Game/UI/WBP_MainUI', animationName: 'FadeIn' },
-        exampleOutput: { success: true, animationName: 'FadeIn' },
-    }),
-    buildRecord({
-        id: 'blueprint.add_animation_track',
-        action: 'add_animation_track',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Add a property track (transform, color, opacity, material) to a widget animation.',
-        whenToUse: ['A property track must be added to a widget animation for keyframing.'],
-        whenNotToUse: ['The animation has enough tracks.'],
-        inputProps: { widgetPath: P.widgetPath, animationName: P.animationName, trackType: P.trackType, slotName: P.slotName },
-        required: ['widgetPath', 'animationName', 'trackType'],
-        outputProps: TRACK_OUTPUT,
-        outputRequired: [],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'add_animation_track', widgetPath: '/Game/UI/WBP_MainUI', animationName: 'FadeIn', trackType: 'opacity', slotName: 'Widget_Text' },
-    }),
-    buildRecord({
-        id: 'blueprint.add_animation_keyframe',
-        action: 'add_animation_keyframe',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Add a keyframe at a specific time on a widget animation track, or a whole animation across several widgets in one call (keys).',
-        whenToUse: [
-            'A property value must be keyframed at a specific time in a widget animation.',
-            'A whole widget animation (a logo popping in, a menu sliding up, a pulse) must be keyed in one call (keys).',
-        ],
-        whenNotToUse: ['The track should be removed rather than keyframed.'],
-        inputProps: { widgetPath: P.widgetPath, animationName: P.animationName, trackType: P.trackType, slotName: P.slotName, time: P.time,
-            propertyValue: { description: 'The key value, by trackType: opacity a number 0-1; color {r,g,b,a} or [r,g,b,a]; translation, scale or shear {x,y} or [x,y]; angle a number in degrees; transform any of {translation:{x,y}, scale:{x,y}, angle, shear:{x,y}}. A value of the wrong shape is refused before anything is added.' },
-            interpolation: P.interpolation,
-            value: { type: 'number', description: 'A plain number for an opacity or angle key, in place of propertyValue.' },
-            keys: {
-                type: 'array', minItems: 1, maxItems: 200,
-                items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-                'x-unreal-reflection-boundary': true,
-                description: 'Many keyframes in one call, in place of time: each {time, propertyValue or value, and any of slotName, trackType, interpolation that differ from the call\'s own}. Every key is checked before any is written: a refused one is named by its index (keys[3]) and nothing is added. The Widget Blueprint is saved once.',
-            } },
-        required: ['widgetPath', 'animationName'],
-        outputProps: {
-            ...TRACK_OUTPUT,
-            keysAdded: { type: 'number', description: 'With keys: how many keyframes were added; the other fields describe the last one.' },
-            time: { type: 'number', description: 'Key time in seconds.' },
-            frameNumber: { type: 'number', description: 'Key position in MovieScene tick-resolution frames.' },
-            keyCount: { type: 'number', description: 'Keys on the last channel written after this call.' },
-            channelCount: { type: 'number', description: 'Channels that received a key.' },
-        },
-        outputRequired: ['animationName', 'slotName', 'propertyName', 'keyCount'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'add_animation_keyframe', widgetPath: '/Game/UI/WBP_MainUI', animationName: 'FadeIn', trackType: 'opacity', slotName: 'Widget_Text', time: 0, propertyValue: 1, interpolation: 'linear' },
-        exampleOutput: { success: true, message: 'Keyframe added at 0.500s on Ammo.RenderOpacity (1 key in the track)', animationName: 'FadeIn', slotName: 'Ammo', trackType: 'opacity', propertyName: 'RenderOpacity', keyCount: 1, channelCount: 1, createdTrack: true, createdBinding: true, saved: true },
-    }),
-    buildRecord({
-        id: 'blueprint.delete_animation',
-        action: 'delete_animation',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Delete a named animation from a Widget Blueprint.',
-        whenToUse: ['An animation is obsolete and must be removed from the Widget Blueprint.'],
-        whenNotToUse: ['The animation should only stop playing (change its loop or play mode instead).'],
-        inputProps: { widgetPath: P.widgetPath, animationName: P.animationName },
-        required: ['widgetPath', 'animationName'],
-        outputProps: {
-            widgetPath: P.widgetPath,
-            deletedAnimation: { type: 'string', description: 'Name of the animation that was removed.' },
-            remainingAnimations: { type: 'number', description: 'Number of animations left on the Widget Blueprint.' },
-        },
-        outputRequired: ['widgetPath', 'deletedAnimation', 'remainingAnimations'],
-        effect: 'destructive',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'delete_animation', widgetPath: '/Game/UI/WBP_MainUI', animationName: 'Pulse' },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_MainUI', deletedAnimation: 'Pulse', remainingAnimations: 2 },
-    }),
-];
-//# sourceMappingURL=widget-animation.js.map

package/dist/tools/catalog/capabilities/records/manage-blueprint/widget-bindings.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-blueprint/widget-bindings.js

@@ -1,108 +0,0 @@
-import { buildRecord, WIDGET_PLUGINS } from './helpers.js';
-import { P } from './properties.js';
-const FAMILY = 'widget-bindings';
-const DOMAIN = 'widget';
-const BINDING_OUT = {
-    slotName: { type: 'string', description: 'The widget that was bound.' },
-    property: { type: 'string', description: 'Property binds: the widget property now bound (Text, Visibility, ColorAndOpacity, bIsEnabled, ...).' },
-    functionName: { type: 'string', description: 'The function now bound or called: the generated Get_<Widget>_<Property> getter, or the event handler.' },
-    generatedGetter: { type: 'boolean', description: 'Property binds: true when a converting getter was generated for a variable.' },
-    bindings: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Event binds: per event, its name, functionName, createdFunction, createdEvent, nodeId and callNodeId.' },
-    saved: { type: 'boolean', description: 'Whether the Widget Blueprint was saved.' },
-};
-function binding(action, id, summary, extras) {
-    const extraProps = extras?.props ?? {};
-    const extraRequired = extras?.required ?? [];
-    return buildRecord({
-        id,
-        action,
-        family: FAMILY,
-        domain: DOMAIN,
-        summary,
-        whenToUse: [action.startsWith('bind_on_')
-                ? `A widget's ${action.slice(5).split('_').map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join('')} event must run a Blueprint function.`
-                : `A widget's ${action.slice(5).replace(/_/g, ' ')} must follow a Blueprint variable or function at runtime.`],
-        whenNotToUse: ['The widget should be set directly rather than bound.'],
-        inputProps: { widgetPath: P.widgetPath, slotName: P.slotName, bindingSource: P.bindingSource, ...extraProps },
-        required: ['widgetPath', 'slotName', 'bindingSource', ...extraRequired],
-        outputProps: BINDING_OUT,
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action, widgetPath: '/Game/UI/WBP_MainUI', slotName: 'Widget_Text', bindingSource: 'PlayerName', ...(extras?.example ?? {}) },
-        exampleOutput: { success: true, message: `${action} bound` },
-    });
-}
-export const WIDGET_BINDINGS_RECORDS = [
-    binding('bind_text', 'blueprint.bind_text', 'Bind the Text of a widget to a Blueprint variable (any type that converts to text) or pure function.'),
-    binding('bind_visibility', 'blueprint.bind_visibility', 'Bind the Visibility of a widget to a Blueprint variable (a bool maps true to Visible, false to Collapsed) or pure function.'),
-    binding('bind_color', 'blueprint.bind_color', 'Bind the tint of a widget (text or image color, progress fill, border brush) to a Blueprint variable or pure function.'),
-    binding('bind_enabled', 'blueprint.bind_enabled', 'Bind whether a widget is enabled to a Blueprint bool variable or pure function.'),
-    binding('bind_percent', 'blueprint.bind_percent', 'Bind the fill Percent of a Progress Bar (or the Value of a Slider or SpinBox) to a Blueprint float variable or pure function, so a health or loading bar follows it at runtime.'),
-    binding('bind_on_clicked', 'blueprint.bind_on_clicked', 'Wire the OnClicked event of a Button to a Blueprint function (bindingSource), creating the function when missing.'),
-    buildRecord({
-        id: 'blueprint.bind_on_hovered',
-        action: 'bind_on_hovered',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Wire the OnHovered (and optionally OnUnhovered) event of a Button to Blueprint functions, creating them when missing.',
-        whenToUse: ['A button must react when the pointer moves onto or off it.'],
-        whenNotToUse: ['Only a hover sound is wanted (set_style hoverSoundPath).'],
-        inputProps: { widgetPath: P.widgetPath, slotName: P.slotName, onHoveredFunction: P.onHoveredFunction, onUnhoveredFunction: P.onUnhoveredFunction },
-        required: ['widgetPath', 'slotName', 'onHoveredFunction'],
-        outputProps: BINDING_OUT,
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'bind_on_hovered', widgetPath: '/Game/UI/WBP_MainUI', slotName: 'PlayButton', onHoveredFunction: 'OnPlayHovered', onUnhoveredFunction: 'OnPlayUnhovered' },
-        exampleOutput: { success: true, message: "OnHovered of 'PlayButton' now calls OnPlayHovered" },
-    }),
-    binding('bind_on_value_changed', 'blueprint.bind_on_value_changed', 'Wire the value-changed event of a Slider, SpinBox, CheckBox or ComboBoxString to a Blueprint function (bindingSource) that receives the new value; the function is created when missing.'),
-    buildRecord({
-        id: 'blueprint.bind_localized_text',
-        action: 'bind_localized_text',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Point a Text Block at a string-table entry so its text follows the active localization.',
-        whenToUse: ['Displayed text must come from a string table rather than a literal.'],
-        whenNotToUse: ['The text is authored inline and never localized (set it directly instead).'],
-        inputProps: { widgetPath: P.widgetPath, slotName: P.slotName, stringTableId: P.stringTableId, stringKey: P.stringKey },
-        required: ['widgetPath', 'slotName', 'stringTableId', 'stringKey'],
-        outputProps: {
-            widgetPath: P.widgetPath,
-            slotName: P.slotName,
-            stringTableId: P.stringTableId,
-            stringKey: P.stringKey,
-            note: { type: 'string', description: 'Why the binding was not applied; present only when success is false.' },
-        },
-        outputRequired: ['widgetPath', 'slotName', 'stringTableId', 'stringKey'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'bind_localized_text', widgetPath: '/Game/UI/WBP_MainUI', slotName: 'TitleText', stringTableId: '/Game/Localization/ST_UI.ST_UI', stringKey: 'Menu_Title' },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_MainUI', slotName: 'TitleText', stringTableId: '/Game/Localization/ST_UI.ST_UI', stringKey: 'Menu_Title' },
-    }),
-    buildRecord({
-        id: 'blueprint.set_localization_key',
-        action: 'set_localization_key',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Assign the localization namespace and key a Text Block resolves its text through.',
-        whenToUse: ['A Text Block must carry an explicit localization key for translators.'],
-        whenNotToUse: ['The text should read from a string table asset (use bind_localized_text).'],
-        inputProps: { widgetPath: P.widgetPath, slotName: P.slotName, key: P.key, namespace: P.namespace },
-        required: ['widgetPath', 'slotName', 'key'],
-        outputProps: { widgetPath: P.widgetPath, slotName: P.slotName, namespace: P.namespace, key: P.key },
-        outputRequired: ['widgetPath', 'slotName', 'namespace', 'key'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'set_localization_key', widgetPath: '/Game/UI/WBP_MainUI', slotName: 'TitleText', key: 'Menu_Title', namespace: 'Game' },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_MainUI', slotName: 'TitleText', namespace: 'Game', key: 'Menu_Title' },
-    }),
-];
-//# sourceMappingURL=widget-bindings.js.map

package/dist/tools/catalog/capabilities/records/manage-blueprint/widget-content.d.ts

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