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

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

@@ -1,152 +0,0 @@
-import { BP_PLUGINS, buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const FAMILY = 'lifecycle';
-const DOMAIN = 'blueprint';
-const CREATE_OUTPUT = {
-    blueprintPath: P.blueprintPath,
-    appliedProperties: { type: 'array', items: { type: 'string' }, description: 'The properties names set on the class defaults; a subobject property reads Holder.Property.' },
-    failedProperties: { type: 'array', items: { type: 'string' }, description: 'Each properties name that was not set, as "Name: reason"; the Blueprint is created anyway.' },
-};
-export const BLUEPRINT_LIFECYCLE_RECORDS = [
-    buildRecord({
-        id: 'blueprint.create',
-        action: 'create',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['new blueprint', 'blueprint class', 'actor blueprint', 'make blueprint', 'blueprint asset', 'subclass', 'derive from', 'parent class', 'blueprint from parent class', 'child blueprint', 'camera shake class', 'camera shake blueprint', 'screen shake'],
-        aliases: ['blueprint.make_blueprint', 'blueprint.new_blueprint'],
-        summary: 'Create a new Blueprint asset from a parent class.',
-        whenToUse: ['A new Blueprint of a known parent class is needed.'],
-        whenNotToUse: ['An existing Blueprint should be opened or modified instead.'],
-        inputProps: { name: P.name, savePath: P.savePath, parentClass: P.parentClass, properties: P.properties, blueprintType: P.blueprintType },
-        required: ['name', 'savePath', 'parentClass'],
-        outputProps: CREATE_OUTPUT,
-        outputRequired: ['blueprintPath'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'create', name: 'BP_TestActor', savePath: '/Game/Blueprints', parentClass: '/Script/Engine.Actor' },
-        exampleOutput: { success: true, blueprintPath: '/Game/Blueprints/BP_TestActor' },
-    }),
-    buildRecord({
-        id: 'blueprint.create_blueprint',
-        action: 'create_blueprint',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Create a Blueprint asset with explicit type and path.',
-        whenToUse: ['A Blueprint must be created with a specific type hint.'],
-        whenNotToUse: ['The simpler create action suffices when only a parent class is needed.'],
-        inputProps: { name: P.name, savePath: P.savePath, parentClass: P.parentClass, blueprintType: P.blueprintType, properties: P.properties },
-        required: ['name', 'savePath', 'parentClass'],
-        outputProps: CREATE_OUTPUT,
-        outputRequired: ['blueprintPath'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'create_blueprint', name: 'BP_Typed', savePath: '/Game/Blueprints', parentClass: '/Script/Engine.Pawn', blueprintType: 'Character' },
-        exampleOutput: { success: true, blueprintPath: '/Game/Blueprints/BP_Typed' },
-    }),
-    buildRecord({
-        id: 'blueprint.get_blueprint',
-        action: 'get_blueprint',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['blueprint info', 'blueprint metadata', 'list variables', 'list functions', 'inspect blueprint', 'blueprint details', 'blueprint variables', 'blueprint functions', 'blueprint components'],
-        aliases: ['blueprint.list_variables', 'blueprint.list_blueprint_variables'],
-        summary: 'Retrieve metadata for one Blueprint asset.',
-        whenToUse: ['Blueprint parent class, components, or variables must be inspected.'],
-        whenNotToUse: ['The full graph or node details are needed (use blueprint.inspect_graph).'],
-        inputProps: { blueprintPath: P.blueprintPath },
-        required: ['blueprintPath'],
-        outputProps: {
-            parentClass: P.parentClass,
-            name: { type: 'string', description: 'Blueprint asset name.' },
-            assetPath: { type: 'string', description: 'Resolved object path of the Blueprint.' },
-            blueprintType: { type: 'string', description: 'Blueprint type (Normal, Interface, MacroLibrary, FunctionLibrary, ...).' },
-            compileStatus: { type: 'string', description: 'Last compile status.' },
-            hasCompileErrors: { type: 'boolean', description: 'Whether the last compile reported errors.' },
-            variables: { type: 'array', description: 'Blueprint variables (NewVariables).', items: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Variable entry: name, type, category, replication, default value.' } },
-            functions: { type: 'array', description: 'User function graphs with parameters.', items: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Function entry: name, parameters, nodeCount.' } },
-            events: { type: 'array', description: 'Event graph entry points.', items: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Event entry: name, eventType.' } },
-            functionGraphs: { type: 'array', description: 'Names of function graphs.', items: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Graph entry.' } },
-            eventGraphs: { type: 'array', description: 'Names of event graphs.', items: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Graph entry.' } },
-            defaults: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Class default values keyed by variable name: a bool as true/false, anything else as its property text.' },
-            metadata: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Blueprint metadata recorded by the bridge.' },
-            details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Additional snapshot fields not named by the contract.' },
-        },
-        outputRequired: ['parentClass'],
-        effect: 'read',
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'get_blueprint', blueprintPath: '/Game/Blueprints/BP_TestActor' },
-        exampleOutput: { success: true, parentClass: '/Script/Engine.Actor', name: 'BP_TestActor', variables: [], functions: [] },
-    }),
-    buildRecord({
-        id: 'blueprint.get',
-        action: 'get',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Read a property value from a Blueprint asset or its CDO, or a component default as Component.Property.',
-        whenToUse: ['A single property must be read from the Blueprint CDO.', 'One default of a Blueprint component must be read, for example Shield.bVisible.'],
-        whenNotToUse: ['The entire Blueprint metadata is needed (use get_blueprint).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath,
-            propertyName: { type: 'string', description: 'A variable or CDO property (Health, MaxWalkSpeed), or Component.Property for a component the Blueprint adds (Shield.bVisible, Mesh.RelativeLocation).' },
-        },
-        required: ['blueprintPath', 'propertyName'],
-        outputProps: { propertyValue: P.propertyValue },
-        outputRequired: ['propertyValue'],
-        effect: 'read',
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'get', blueprintPath: '/Game/Blueprints/BP_TestActor', propertyName: 'Health' },
-        exampleOutput: { success: true, propertyValue: 100 },
-    }),
-    buildRecord({
-        id: 'blueprint.ensure_exists',
-        action: 'ensure_exists',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['get or create blueprint', 'idempotent create', 'create if missing'],
-        summary: 'Ensure a Blueprint asset exists, creating it if absent.',
-        whenToUse: ['Idempotent setup requires a Blueprint to exist without failing on duplicates.'],
-        whenNotToUse: ['A fresh Blueprint is always required even if one exists.'],
-        inputProps: {
-            name: P.name, savePath: P.savePath, parentClass: P.parentClass,
-            createIfMissing: { type: 'boolean', description: 'Create the Blueprint when savePath/name does not exist (default true); false only reports whether it exists.' },
-        },
-        required: ['name', 'savePath', 'parentClass'],
-        outputProps: { blueprintPath: P.blueprintPath },
-        outputRequired: ['blueprintPath'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'ensure_exists', name: 'BP_Standard', savePath: '/Game/Blueprints', parentClass: '/Script/Engine.Actor' },
-        exampleOutput: { success: true, blueprintPath: '/Game/Blueprints/BP_Standard' },
-    }),
-    buildRecord({
-        id: 'blueprint.compile',
-        action: 'compile',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['build blueprint', 'recompile', 'compile errors', 'compile blueprint', 'compile widget blueprint', 'compile widget'],
-        summary: 'Compile a Blueprint asset, optionally saving after compile.',
-        whenToUse: ['Blueprint changes must be compiled to take effect.'],
-        whenNotToUse: ['The Blueprint has no pending changes.'],
-        inputProps: { blueprintPath: P.blueprintPath, saveAfterCompile: P.saveAfterCompile },
-        required: ['blueprintPath'],
-        effect: 'write',
-        behavior: { longRunning: true },
-        latency: 'long-running',
-        resources: 'high',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'compile', blueprintPath: '/Game/Blueprints/BP_TestActor', saveAfterCompile: true },
-    }),
-];
-//# sourceMappingURL=blueprint-lifecycle.js.map

package/dist/tools/catalog/capabilities/records/manage-blueprint/functions-events.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-blueprint/functions-events.js

@@ -1,103 +0,0 @@
-import { BP_PLUGINS, buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const FAMILY = 'functions';
-const DOMAIN = 'blueprint';
-export const FUNCTIONS_EVENTS_RECORDS = [
-    buildRecord({
-        id: 'blueprint.add_function',
-        action: 'add_function',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['new function', 'custom function', 'function graph', 'define function'],
-        summary: 'Add a new function graph to a Blueprint with optional inputs and outputs; an existing function of that name is reused only when it matches the pure, inputs and outputs given. A name the parent class lets a Blueprint override (a widget\'s OnKeyDown) makes that override with its own signature, so leave inputs, outputs, pure and isPublic out.',
-        whenToUse: ['A new callable function must be created on the Blueprint.', 'A parent function with a return value must be overridden, such as a widget\'s OnKeyDown to handle a key.'],
-        whenNotToUse: ['An event handler is needed (use add_event).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, functionName: P.functionName, inputs: P.inputs, outputs: P.outputs,
-            isPublic: { type: 'boolean', description: 'Access specifier: true public (the default), false private (callable only from this Blueprint).' },
-            pure: { type: 'boolean', description: 'Pure function (the Details panel\'s Pure checkbox): its call nodes have no exec pins. Default false.' },
-        },
-        required: ['blueprintPath', 'functionName'],
-        outputProps: {
-            functionName: P.functionName,
-            nodeGuid: { type: 'string', description: 'Node guid: the function\'s entry node, or the event node. A built-in event that already exists in the graph may be bound without one.' },
-            resultNodeGuid: { type: 'string', description: 'The function\'s return node, present when the function has one (it is made when outputs are declared).' },
-            overrides: { type: 'string', description: 'The parent function the new one overrides (UserWidget::OnKeyDown), when functionName names one.' },
-        },
-        outputRequired: ['functionName'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'add_function', blueprintPath: '/Game/Blueprints/BP_Test', functionName: 'CalculateDamage', inputs: [{ name: 'BaseDamage', type: 'Float' }], outputs: [{ name: 'Result', type: 'Float' }], pure: true },
-        exampleOutput: { success: true, functionName: 'CalculateDamage', nodeGuid: '8C1D0E6A4F2B4C1D9E0F1A2B3C4D5E6F', resultNodeGuid: '1A2B3C4D5E6F40718293A4B5C6D7E8F9' },
-    }),
-    buildRecord({
-        id: 'blueprint.remove_function',
-        action: 'remove_function',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Permanently remove a function graph from a Blueprint.',
-        whenToUse: ['A function must be permanently deleted from the Blueprint.'],
-        whenNotToUse: ['The function should be renamed rather than removed.'],
-        inputProps: { blueprintPath: P.blueprintPath, functionName: P.functionName },
-        required: ['blueprintPath', 'functionName'],
-        effect: 'destructive',
-        behavior: { safeToRetry: false },
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'remove_function', blueprintPath: '/Game/Blueprints/BP_Test', functionName: 'OldFunction' },
-    }),
-    buildRecord({
-        id: 'blueprint.add_event',
-        action: 'add_event',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['custom event', 'event node', 'begin play', 'tick event', 'event graph'],
-        summary: 'Add an event node to a Blueprint event graph: built-in, custom, or bound to a component delegate (componentName plus eventName, e.g. OnComponentBeginOverlap on a BoxComponent) or to a Widget Blueprint widget\'s event (componentName the widget, e.g. PlayButton with OnClicked).',
-        whenToUse: ['An event handler node must be created in the EventGraph.', 'A component event such as OnComponentBeginOverlap or OnComponentHit must be handled.', 'A Widget Blueprint button, slider or other widget event such as OnClicked must be handled.'],
-        whenNotToUse: ['A callable function is needed (use add_function).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, eventType: P.eventType, customEventName: P.customEventName, posX: P.posX, posY: P.posY, parameters: P.parameters,
-            graphName: { ...P.graphName, description: 'Event graph page to add the event to; omitted, the main EventGraph.' },
-            eventName: { ...P.eventName, description: 'Custom event name; with componentName, the delegate to bind: a component\'s (OnComponentBeginOverlap, OnComponentHit, ...) or a widget\'s (OnClicked, OnHovered, OnValueChanged, ...).' },
-            componentName: { ...P.componentName, description: 'Component whose delegate fires the event, added by the Blueprint or inherited (a Character\'s CapsuleComponent), or in a Widget Blueprint a widget of its tree that is a variable (every widget the widget handlers add is), e.g. PlayButton with eventName OnClicked. Makes a component-bound event (K2Node_ComponentBoundEvent) named by eventName.' },
-        },
-        required: ['blueprintPath'],
-        outputProps: {
-            nodeGuid: { type: 'string', description: 'Event node identifier. Returned for custom events; the built-in-event path may bind an event that already exists in the graph and reports no new node.' },
-            eventName: P.eventName,
-        },
-        outputRequired: [],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'add_event', blueprintPath: '/Game/Blueprints/BP_Test', graphName: 'EventGraph', eventType: 'CustomEvent', customEventName: 'OnDamaged', posX: 0, posY: 0 },
-        exampleOutput: { success: true, nodeGuid: 'V1W2X3Y4', eventName: 'OnDamaged' },
-    }),
-    buildRecord({
-        id: 'blueprint.remove_event',
-        action: 'remove_event',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Remove an event node from a Blueprint event graph by node id, or a custom event by name.',
-        whenToUse: ['An event node must be permanently removed from the graph.'],
-        whenNotToUse: ['The event should be reconnected rather than removed.'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, nodeId: P.nodeId,
-            graphName: { ...P.graphName, description: 'Event graph page to search; omitted, the main EventGraph.' },
-            eventName: { ...P.eventName, description: 'Custom event to remove by name, in place of nodeId.' },
-        },
-        required: ['blueprintPath'],
-        requiredOneOf: ['nodeId', 'eventName'],
-        effect: 'destructive',
-        behavior: { safeToRetry: false },
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'remove_event', blueprintPath: '/Game/Blueprints/BP_Test', graphName: 'EventGraph', nodeId: 'V1W2X3Y4' },
-    }),
-];
-//# sourceMappingURL=functions-events.js.map

package/dist/tools/catalog/capabilities/records/manage-blueprint/graph-batch.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-blueprint/graph-batch.js

@@ -1,80 +0,0 @@
-import { BP_PLUGINS, buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const ITEM = { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true };
-export const GRAPH_BATCH_RECORDS = [
-    buildRecord({
-        id: 'blueprint.build_graph',
-        action: 'build_graph',
-        family: 'graph',
-        domain: 'blueprint',
-        topics: ['batch graph edit', 'build event graph', 'wire many nodes', 'blueprint graph batch', 'function with body'],
-        summary: 'Run many graph edits in one call: add variables, functions (with their bodies), events and event dispatchers, create nodes, connect pins, set pin defaults and node properties, with $id references between steps.',
-        whenToUse: ['More than a couple of nodes or links must be added to one Blueprint graph.', 'A new function and the nodes inside it must be built in one call.'],
-        whenNotToUse: ['Nodes or links must be deleted (use delete_node; destructive edits are not batched).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath,
-            graphName: { type: 'string', description: 'Graph every step targets unless the step names its own graphName (default EventGraph).' },
-            operations: {
-                type: 'array',
-                items: ITEM,
-                'x-unreal-reflection-boundary': true,
-                description: 'Steps run in order, 1-200. Each is {edit, ...that edit\'s own params}. Member steps come before the nodes '
-                    + 'that use them: add_variable (variableName, variableType as add_variable takes it: basic, class, struct, enum and container '
-                    + 'types, defaultValue, isPublic, exposeOnSpawn, category), add_function '
-                    + '(functionName, inputs, outputs, pure, isPublic; its body steps set graphName to the function name; with an id, "$id" '
-                    + 'is its entry node and "$id_return" its return node, which exists when outputs are declared), add_event '
-                    + '(customEventName and parameters, or componentName plus eventName for a component or Widget Blueprint widget delegate, '
-                    + 'e.g. PlayButton with OnClicked) and add_event_dispatcher '
-                    + '(dispatcherName, parameters [{name, type}]). Node steps: create_node, connect_pins, set_pin_default_value, '
-                    + 'set_node_property, create_reroute_node. create_node also takes nodeType CallDelegate (memberName: a dispatcher), '
-                    + 'Message (memberClass: an interface, memberName: its function), AsyncTask (memberClass: the task or async-action '
-                    + 'class, memberName: its static factory; event graphs only) and FunctionResult (one more return node in a function '
-                    + 'graph). Optional per step: id (names the created node; later steps use "$id" in fromNodeId, toNodeId and nodeId), '
-                    + 'from and to ("$id.PinName" shorthand for connect_pins), pinDefaults (create_node only: {PinName: value} applied '
-                    + 'to the new node; a read-only pin such as Set Text\'s Value gets a MakeLiteral node wired into it). "$entry" is '
-                    + 'the graph\'s own entry node (a Construction Script or function graph starts there: from "$entry.then"). A create '
-                    + 'step without posX and posY is auto-placed, and once every step ran it moves beside a node it is wired to (right of what runs it, below-left of what reads it); one whose posX and posY overlap an existing node is placed at the nearest '
-                    + 'free position instead, and its result says where in placementWarning, so a crowded row never stops the batch (a '
-                    + 'single create_node call still refuses an overlap). Every function, variable, dispatcher and async factory a step names is '
-                    + 'checked before any step runs, so a misspelled one fails the batch with nothing applied; any other failure stops '
-                    + 'the batch at that step, and that step leaves nothing behind (a member step included), in whichever graph it ran.',
-            },
-        },
-        required: ['blueprintPath', 'operations'],
-        outputProps: {
-            results: { type: 'array', items: ITEM, 'x-unreal-reflection-boundary': true, description: 'Per-step outcome: index, edit, id, success, error, nodeGuid, resultNodeGuid (add_function), pins (for created nodes), connected, appliedValue, placementWarning (a create step that was moved off an overlapping position, or placed where it still overlaps), inputPins and boundToMembers (a Math Expression\'s Expression step: the pins it made, and the names that read member variables instead). A step that ran and has nothing more to say (a plain connect_pins, an add_variable) is counted in succeeded, not listed; a failed batch lists every step.' },
-            nodeIds: { type: 'object', additionalProperties: { type: 'string' }, description: 'Step id -> node guid for every node the batch created or reused; an add_function step with an id also adds "<id>_return" for its return node.' },
-            succeeded: { type: 'number', description: 'Steps that completed.' },
-            failedIndex: { type: 'number', description: 'Index of the step that stopped the batch (failures only).' },
-            compiled: { type: 'boolean', description: 'True when the Blueprint compiles after the batch (warnings allowed).' },
-            compilerStatus: { type: 'string', description: 'Blueprint status after the final compile.' },
-            diagnostics: { type: 'array', items: ITEM, 'x-unreal-reflection-boundary': true, description: 'Compile messages: { severity, message }.' },
-            saved: { type: 'boolean', description: 'Whether the Blueprint was saved after the batch.' },
-        },
-        outputRequired: [],
-        effect: 'write',
-        behavior: { idempotency: 'non-idempotent', safeToRetry: false },
-        latency: 'interactive',
-        resources: 'medium',
-        plugins: BP_PLUGINS,
-        exampleInput: {
-            action: 'build_graph',
-            blueprintPath: '/Game/Blueprints/BP_Test',
-            graphName: 'EventGraph',
-            operations: [
-                { edit: 'create_node', id: 'begin', nodeType: 'Event', eventName: 'BeginPlay' },
-                { edit: 'create_node', id: 'print', nodeType: 'CallFunction', memberName: 'PrintString', pinDefaults: { InString: 'Hello' } },
-                { edit: 'connect_pins', from: '$begin.then', to: '$print.execute' },
-            ],
-        },
-        exampleOutput: {
-            success: true,
-            message: 'Ran 3 graph operations; the blueprint compiles.',
-            nodeIds: { begin: '8C1D0E6A4F2B4C1D9E0F1A2B3C4D5E6F', print: '1A2B3C4D5E6F40718293A4B5C6D7E8F9' },
-            succeeded: 3,
-            compiled: true,
-            saved: true,
-        },
-    }),
-];
-//# sourceMappingURL=graph-batch.js.map

package/dist/tools/catalog/capabilities/records/manage-blueprint/graph-nodes.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-blueprint/graph-nodes.js

@@ -1,274 +0,0 @@
-import { BP_PLUGINS, buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const FAMILY = 'graph';
-const DOMAIN = 'blueprint';
-export const GRAPH_NODES_RECORDS = [
-    buildRecord({
-        id: 'blueprint.create_node',
-        action: 'create_node',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['add node', 'place node', 'graph node', 'call function node', 'print string node'],
-        summary: 'Create a graph node (function call, event, variable, branch, etc.) in a Blueprint graph.',
-        whenToUse: ['A new node must be placed in a Blueprint event or function graph.'],
-        whenNotToUse: ['A reroute node for wire organization is needed (use create_reroute_node).'],
-        inputProps: { blueprintPath: P.blueprintPath, graphName: P.graphName, nodeType: P.nodeType, memberName: P.memberName, posX: P.posX, posY: P.posY, functionName: P.nodeFunctionName, pure: P.pure, eventName: P.eventName, customEventName: P.customEventName, memberClass: P.memberClass, targetClass: P.targetClass, inputAxisName: P.inputAxisName, inputActionPath: P.inputActionPath, inputActionAssetPath: P.inputActionAssetPath, actionPath: P.actionPath, structPath: { ...P.structPath, description: 'For MakeStruct or BreakStruct: the struct, a Blueprint Struct asset (/Game/Data/F_Item) or a native one (/Script/SlateCore.SlateColor, /Script/CoreUObject.Vector); without it the node is refused.' }, parameters: { ...P.parameters, description: 'CustomEvent inputs, each {name, type}: float, double, int, int64, bool, byte, string, name, text, object, class, or a struct (Vector, /Script/CoreUObject.Vector).' } },
-        required: ['blueprintPath', 'nodeType', 'posX', 'posY'],
-        outputProps: {
-            nodeGuid: { type: 'string', description: 'Unique node identifier for subsequent graph operations.' },
-            graphName: P.graphName,
-            nodeClass: { type: 'string', description: 'Resolved UK2Node class name.' },
-            nodeName: P.nodeName,
-            posX: { type: 'number', description: 'X coordinate the node was placed at.' },
-            posY: { type: 'number', description: 'Y coordinate the node was placed at.' },
-            estimatedWidth: { type: 'number', description: 'Approximate node width. Slate computes the real size at draw time, so this is derived from title length and is an estimate, not a measurement.' },
-            estimatedHeight: { type: 'number', description: 'Approximate node height, derived from pin-row count. Offset the next node by at least this much to avoid overlap.' },
-            overlappingNodes: { type: 'array', items: { type: 'string' }, description: 'Titles of existing nodes whose estimated bounds intersect this one. Empty or absent when placement is clear.' },
-            placementWarning: { type: 'string', description: 'Human-readable overlap warning, present only when overlappingNodes is non-empty.' },
-        },
-        outputRequired: ['nodeGuid'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'create_node', blueprintPath: '/Game/Blueprints/BP_Test', graphName: 'EventGraph', nodeType: 'CallFunction', memberName: 'PrintString', posX: 100, posY: 200 },
-        exampleOutput: { success: true, nodeGuid: 'A1B2C3D4', graphName: 'EventGraph', nodeClass: 'UK2Node_CallFunction', nodeName: 'Print String' },
-    }),
-    buildRecord({
-        id: 'blueprint.add_node',
-        action: 'add_node',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Add a node to a Blueprint graph (alias of create_node with simplified type resolution).',
-        whenToUse: ['A node must be added using a friendly type alias (e.g. Branch, Cast, GetVariable).'],
-        whenNotToUse: ['Full member-class control is needed (use create_node).'],
-        inputProps: { blueprintPath: P.blueprintPath, graphName: P.graphName, nodeType: P.nodeType, posX: P.posX, posY: P.posY, memberName: P.memberName, functionName: P.nodeFunctionName, eventName: P.eventName, nodeName: P.nodeName, targetClass: P.targetClass },
-        required: ['blueprintPath', 'nodeType'],
-        outputProps: {
-            nodeGuid: { type: 'string', description: 'Unique node identifier for subsequent graph operations.' },
-            graphName: P.graphName,
-        },
-        outputRequired: ['nodeGuid'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'add_node', blueprintPath: '/Game/Blueprints/BP_Test', graphName: 'EventGraph', nodeType: 'Branch', posX: 50, posY: 50 },
-        exampleOutput: { success: true, nodeGuid: 'E5F6G7H8', graphName: 'EventGraph' },
-    }),
-    buildRecord({
-        id: 'blueprint.delete_node',
-        action: 'delete_node',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Delete a node from a Blueprint graph by its nodeGuid, or many nodes at once with nodeIds (one consent, one compile, all or nothing).',
-        whenToUse: ['A graph node must be permanently removed.', 'A whole dead chain of nodes must be removed in one call.'],
-        whenNotToUse: ['The node should be moved rather than deleted.'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, graphName: P.graphName, nodeId: P.nodeId, nodeGuid: P.nodeGuid,
-            nodeIds: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 500, description: 'Several node ids or guids to delete in one call, in place of nodeId. Every id must resolve to a deletable node or nothing is deleted.' },
-        },
-        outputProps: {
-            removed: { type: 'array', items: { type: 'string' }, description: 'Guids of the nodes that were deleted.' },
-            removedCount: { type: 'number', description: 'How many nodes were deleted.' },
-        },
-        required: ['blueprintPath'],
-        requiredOneOf: ['nodeId', 'nodeGuid', 'nodeIds'],
-        effect: 'destructive',
-        behavior: { safeToRetry: false },
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'delete_node', blueprintPath: '/Game/Blueprints/BP_Test', graphName: 'EventGraph', nodeId: 'A1B2C3D4' },
-    }),
-    buildRecord({
-        id: 'blueprint.create_reroute_node',
-        action: 'create_reroute_node',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Create a reroute node for organizing exec/data wire paths in a Blueprint graph.',
-        whenToUse: ['Wire paths need a reroute node for cleaner layout.'],
-        whenNotToUse: ['A functional node is needed (use create_node).'],
-        inputProps: { blueprintPath: P.blueprintPath, graphName: P.graphName, posX: P.posX, posY: P.posY },
-        required: ['blueprintPath', 'posX', 'posY'],
-        outputProps: {
-            nodeGuid: { type: 'string', description: 'Reroute node identifier.' },
-        },
-        outputRequired: ['nodeGuid'],
-        effect: 'write',
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'create_reroute_node', blueprintPath: '/Game/Blueprints/BP_Test', graphName: 'EventGraph', posX: 300, posY: 300 },
-        exampleOutput: { success: true, nodeGuid: 'R9S0T1U2' },
-    }),
-    buildRecord({
-        id: 'blueprint.get_node_details',
-        action: 'get_node_details',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Read details for one graph node, including its pins and linked connections; with followExec, also what runs after it along its exec wires.',
-        whenToUse: [
-            'A single node\'s pins, type, and links must be inspected.',
-            'What an event or function does must be read: followExec on its entry node lists every node its exec wires reach, with their inputs, in one call.',
-        ],
-        whenNotToUse: ['All nodes in a graph are needed (use get_graph_details).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, graphName: P.graphName, nodeId: P.nodeId, nodeGuid: P.nodeGuid,
-            followExec: { type: 'number', minimum: 0, maximum: 50, description: 'Also walk this many nodes (1-50) along the exec wires leaving the node, depth-first (a Branch\'s then side before its else), and list each under chain with its inputs.' },
-        },
-        required: ['blueprintPath'],
-        requiredOneOf: ['nodeId', 'nodeGuid'],
-        outputProps: {
-            nodeId: P.nodeId,
-            nodeName: P.nodeName,
-            nodeTitle: { type: 'string', description: 'Display title of the node.' },
-            nodeComment: { type: 'string', description: 'Node comment, empty when it has none.' },
-            x: { type: 'number', description: 'Node X position in the graph.' },
-            y: { type: 'number', description: 'Node Y position in the graph.' },
-            pins: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Pin descriptors (name, direction, type, links).', 'x-unreal-reflection-boundary': true },
-            animationAsset: { type: 'string', description: 'An animation graph node that plays an asset (a Sequence Player, a Blend Space Player ...): the path of the animation it plays. Absent on other nodes and on a player with no asset.' },
-            animationAssetClass: { type: 'string', description: 'The class of that animation asset (AnimSequence, BlendSpace ...).' },
-            settings: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'An animation graph node\'s editable settings, name to value (a Sequence Player: Sequence, PlayRate, StartPosition, bLoopAnimation ...; at most 24, lists left out). Absent on any other node. graphName is the AnimGraph, or the name of the state whose graph holds the node.' },
-            chain: {
-                type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-                description: 'With followExec: each node the exec wires reach, in walk order: nodeId, nodeTitle, via (the "Title.Pin" exec output that led to it) and inputs (each input pin as its literal value, or "<- Title.Pin" for the node feeding it).',
-            },
-        },
-        outputRequired: ['nodeId'],
-        effect: 'read',
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'get_node_details', blueprintPath: '/Game/Blueprints/BP_Test', graphName: 'EventGraph', nodeId: 'A1B2C3D4' },
-        exampleOutput: { success: true, nodeId: 'A1B2C3D4', nodeName: 'Print String', nodeTitle: 'Print String', pins: [] },
-    }),
-    buildRecord({
-        id: 'blueprint.get_graph_details',
-        action: 'get_graph_details',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Read all nodes in a Blueprint graph, optionally including per-node pins and links; filter and page a large graph.',
-        whenToUse: ['The full node list of a graph must be inspected in one call.', 'A large graph must be read in parts: filter by node title or by what a pin holds, page with offset/limit.', 'The node that builds or uses a given asset, class or literal must be found, e.g. the Create Widget node for WBP_MainMenu.'],
-        whenNotToUse: ['A single node\'s details are needed (use get_node_details).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, graphName: P.graphName, includePins: P.includePins,
-            filter: { type: 'string', description: 'Only nodes whose title or name, or whose pin default value or default object path, contains this text (case-insensitive, spaces ignored), e.g. "IA_Move", "Set bLocked", or "WBP_MainMenu" for the Create Widget node whose Class pin holds /Game/UI/WBP_MainMenu.WBP_MainMenu_C.' },
-            offset: { type: 'number', description: 'Skip this many matching nodes (paging).' },
-            limit: { type: 'number', description: 'Return at most this many nodes; totalCount and hasMore say what is left. Use it with includePins on a big graph.' },
-        },
-        required: ['blueprintPath'],
-        outputProps: {
-            nodes: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Node descriptors (nodeId, nodeName, nodeTitle, and position x and y; pins if includePins=true).', 'x-unreal-reflection-boundary': true },
-            totalCount: { type: 'number', description: 'Nodes matching filter, before offset/limit.' },
-            hasMore: { type: 'boolean', description: 'More matching nodes lie past this page.' },
-        },
-        outputRequired: ['nodes'],
-        effect: 'read',
-        latency: 'interactive',
-        resources: 'medium',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'get_graph_details', blueprintPath: '/Game/Blueprints/BP_Test', graphName: 'EventGraph', includePins: true },
-        exampleOutput: { success: true, nodes: [{ nodeId: 'A1B2C3D4', nodeName: 'Print String' }] },
-    }),
-    buildRecord({
-        id: 'blueprint.get_pin_details',
-        action: 'get_pin_details',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Read pin details (direction, type, links, defaults) for one node in a Blueprint graph.',
-        whenToUse: ['Pin-level details including linkedTo connections must be inspected for a single node.'],
-        whenNotToUse: ['All nodes with pins are needed (use get_graph_details with includePins).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, graphName: P.graphName, nodeId: P.nodeId, nodeGuid: P.nodeGuid,
-            pinName: { ...P.pinName, description: 'Report only this pin; omitted, every pin on the node.' },
-        },
-        required: ['blueprintPath'],
-        requiredOneOf: ['nodeId', 'nodeGuid'],
-        outputProps: {
-            nodeId: P.nodeId,
-            pins: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Pin descriptors (pinName, direction, pinType, pinSubType, linkedTo[] of {nodeId, pinName, nodeTitle}, defaults).', 'x-unreal-reflection-boundary': true },
-        },
-        outputRequired: ['pins'],
-        effect: 'read',
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'get_pin_details', blueprintPath: '/Game/Blueprints/BP_Test', graphName: 'EventGraph', nodeId: 'A1B2C3D4' },
-        exampleOutput: { success: true, nodeId: 'A1B2C3D4', pins: [{ pinName: 'InExec', direction: 'EGPD_Input', pinType: 'exec' }] },
-    }),
-    buildRecord({
-        id: 'blueprint.list_node_types',
-        action: 'list_node_types',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'List available Blueprint node types that can be created via create_node or add_node.',
-        whenToUse: ['The set of creatable node types must be enumerated before node creation.'],
-        whenNotToUse: ['A specific node type is already known.'],
-        inputProps: { blueprintPath: P.blueprintPath },
-        outputProps: {
-            nodeTypes: {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    additionalProperties: false,
-                    properties: {
-                        className: { type: 'string', description: 'Blueprint node class name (e.g. UK2Node_CallFunction).' },
-                        displayName: { type: 'string', description: 'Localized node display name shown in the Blueprint palette.' },
-                    },
-                    required: ['className', 'displayName'],
-                },
-                description: 'Available Blueprint node types, each an object with className and displayName.',
-            },
-            count: { type: 'number', description: 'Total number of node types listed.' },
-        },
-        outputRequired: ['nodeTypes', 'count'],
-        effect: 'read',
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'list_node_types', blueprintPath: '/Game/Blueprints/BP_Test' },
-        exampleOutput: { success: true, nodeTypes: [{ className: 'UK2Node_CallFunction', displayName: 'Call Function' }], count: 1 },
-    }),
-    buildRecord({
-        id: 'blueprint.create_struct_make_break_nodes',
-        action: 'create_struct_make_break_nodes',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Create a Make or Break Struct node in a Blueprint graph from a UserDefinedStruct or native UScriptStruct.',
-        whenToUse: ['A MakeStruct or BreakStruct node must be placed for a known struct type.'],
-        whenNotToUse: ['A general CallFunction or event node is needed (use create_node).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath,
-            structPath: P.structPath,
-            nodeType: { type: 'string', enum: ['make', 'break'], description: 'Struct node kind: make (UK2Node_MakeStruct) or break (UK2Node_BreakStruct).' },
-            graphName: P.graphName,
-            posX: P.posX,
-            posY: P.posY,
-        },
-        required: ['blueprintPath', 'structPath', 'nodeType'],
-        outputProps: {
-            nodeGuid: { type: 'string', description: 'Unique node identifier for subsequent graph operations.' },
-            nodeType: { type: 'string', enum: ['make', 'break'], description: 'Echoed struct node kind.' },
-            structPath: { type: 'string', description: 'Resolved struct object path.' },
-            pinNames: { type: 'array', items: { type: 'string' }, description: 'Pin display names (legacy).' },
-            pinTypes: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Per-pin objects: { name, direction, type, category, subCategory }.', 'x-unreal-reflection-boundary': true },
-            diagnostics: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Compile messages: { severity, message }.', 'x-unreal-reflection-boundary': true },
-            compilerStatus: { type: 'string', description: 'Blueprint status after compile (UpToDate, UpToDateWithWarnings, Error, Dirty, BeingCreated).' },
-            compiled: { type: 'boolean', description: 'True when the Blueprint is up-to-date (warnings allowed).' },
-            assetPath: { type: 'string', description: 'Asset path of the created node (verification).' },
-            assetName: { type: 'string', description: 'Name of the created node (verification).' },
-            existsAfter: { type: 'boolean', description: 'Whether the node exists after creation (verification).' },
-            assetClass: { type: 'string', description: 'Class of the created node (verification).' },
-        },
-        outputRequired: ['nodeGuid'],
-        effect: 'write',
-        behavior: { longRunning: false },
-        latency: 'interactive',
-        resources: 'medium',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'create_struct_make_break_nodes', blueprintPath: '/Game/Blueprints/BP_Test', structPath: '/Game/Blueprints/Structs/FMyStruct', nodeType: 'make', graphName: 'EventGraph', posX: 100, posY: 200 },
-        exampleOutput: { success: true, nodeGuid: 'A1B2C3D4', nodeType: 'make', structPath: '/Game/Blueprints/Structs/FMyStruct', pinNames: ['A', 'B'], pinTypes: [{ name: 'A', direction: 'input', type: 'Float', category: 'float', subCategory: '' }], diagnostics: [], compilerStatus: 'UpToDate', compiled: true, assetPath: '/Game/Blueprints/BP_Test', assetName: 'Make MyStruct', existsAfter: true, assetClass: 'UK2Node_MakeStruct' },
-    }),
-];
-//# sourceMappingURL=graph-nodes.js.map