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

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

@@ -1,113 +0,0 @@
-import { buildRecord, WIDGET_PLUGINS } from './helpers.js';
-import { P } from './properties.js';
-const FAMILY = 'widget-content';
-const DOMAIN = 'widget';
-const SLOT_OUT = { slotName: P.slotName };
-function content(action, id, summary, extraProps = {}, extraRequired = []) {
-    return buildRecord({
-        id,
-        action,
-        family: FAMILY,
-        domain: DOMAIN,
-        summary,
-        whenToUse: [`A new ${action.replace(/^add_/, '').replace(/_/g, ' ')} widget must be added to a Widget Blueprint.`],
-        whenNotToUse: ['A panel container is needed instead (see widget-panels family).'],
-        inputProps: { widgetPath: P.widgetPath, slotName: P.slotName, parentSlot: P.parentSlot, positionX: P.positionX, positionY: P.positionY, sizeX: P.sizeX, sizeY: P.sizeY, ...extraProps },
-        required: ['widgetPath', ...extraRequired],
-        outputProps: SLOT_OUT,
-        outputRequired: ['slotName'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action, widgetPath: '/Game/UI/WBP_MainUI', slotName: action.replace(/_/g, ' ').replace('add ', 'Widget_') },
-        exampleOutput: { success: true, slotName: action.replace(/_/g, ' ').replace('add ', 'Widget_') },
-    });
-}
-export const WIDGET_CONTENT_RECORDS = [
-    content('add_text_block', 'blueprint.add_text_block', 'Add a Text Block widget for displaying read-only text.', { text: P.text, fontSize: P.fontSize, colorAndOpacity: P.colorAndOpacity, autoWrap: P.autoWrap, isEnabled: P.isEnabled }),
-    content('add_rich_text_block', 'blueprint.add_rich_text_block', 'Add a Rich Text Block widget for styled/markup text.', { text: P.text, fontSize: P.fontSize, isEnabled: P.isEnabled }),
-    content('add_image', 'blueprint.add_image', 'Add an Image widget for displaying a texture or brush.', { texturePath: P.texturePath, brushSize: P.brushSize, colorAndOpacity: P.colorAndOpacity, isEnabled: P.isEnabled }),
-    content('add_button', 'blueprint.add_button', 'Add a Button widget for click interaction.', { text: { type: 'string', description: 'Label: a dark text block <slotName>_Text inside the button.' }, isEnabled: P.isEnabled, colorAndOpacity: P.colorAndOpacity }),
-    content('add_check_box', 'blueprint.add_check_box', 'Add a Check Box widget for boolean toggle.', { isChecked: P.isChecked, isEnabled: P.isEnabled }),
-    content('add_slider', 'blueprint.add_slider', 'Add a Slider widget for range selection.', { minValue: P.minValue, maxValue: P.maxValue, stepSize: P.stepSize, isEnabled: P.isEnabled, value: P.value }),
-    content('add_progress_bar', 'blueprint.add_progress_bar', 'Add a Progress Bar widget for percentage display.', { percent: P.percent, fillColorAndOpacity: P.fillColorAndOpacity, isMarquee: P.isMarquee, isEnabled: P.isEnabled }),
-    content('add_text_input', 'blueprint.add_text_input', 'Add a Text Input (editable text) widget for user text entry.', { inputType: P.inputType, hintText: P.hintText, isEnabled: P.isEnabled }),
-    content('add_combo_box', 'blueprint.add_combo_box', 'Add a Combo Box (dropdown) widget for option selection.', { options: P.options, selectedOption: P.selectedOption, isEnabled: P.isEnabled }),
-    content('add_spin_box', 'blueprint.add_spin_box', 'Add a Spin Box widget for numeric increment/decrement.', { minValue: P.minValue, maxValue: P.maxValue, delta: P.delta, value: P.value, isEnabled: P.isEnabled }),
-    content('add_list_view', 'blueprint.add_list_view', 'Add a List View widget for scrollable entry lists.', { orientation: P.orientation, isEnabled: P.isEnabled }),
-    content('add_tree_view', 'blueprint.add_tree_view', 'Add a Tree View widget for hierarchical entry display.', { orientation: P.orientation, isEnabled: P.isEnabled }),
-    buildRecord({
-        id: 'blueprint.add_widget_component',
-        action: 'add_widget_component',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Add a widget of any UMG class to a Widget Blueprint by class name.',
-        whenToUse: ['A widget class is needed that no dedicated add_* action covers.'],
-        whenNotToUse: ['A dedicated action exists for the class (prefer add_button, add_text_block, and the rest).'],
-        inputProps: {
-            widgetPath: P.widgetPath,
-            componentType: P.componentType,
-            slotName: P.slotName,
-            parentSlot: P.parentSlot,
-            positionX: P.positionX,
-            positionY: P.positionY,
-            sizeX: P.sizeX,
-            sizeY: P.sizeY,
-            text: P.text,
-        },
-        required: ['widgetPath', 'componentType'],
-        outputProps: {
-            widgetPath: P.widgetPath,
-            componentName: P.componentName,
-            componentType: { type: 'string', description: 'Resolved widget class name, which may differ from the requested componentType.' },
-            parentName: P.parentName,
-        },
-        outputRequired: ['widgetPath', 'componentName', 'componentType', 'parentName'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'add_widget_component', widgetPath: '/Game/UI/WBP_MainUI', componentType: 'TextBlock', slotName: 'Caption', text: 'Ready' },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_MainUI', componentName: 'Caption', componentType: 'TextBlock', parentName: 'CanvasPanel_0' },
-    }),
-    buildRecord({
-        id: 'blueprint.set_font',
-        action: 'set_font',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Set the font asset and size on a Text Block or Rich Text Block inside a Widget Blueprint.',
-        whenToUse: ['A text widget needs a specific font face or size.'],
-        whenNotToUse: ['The target is not a text widget; the call reports success false.'],
-        inputProps: { widgetPath: P.widgetPath, slotName: P.slotName, font: P.font, fontSize: P.fontSize },
-        required: ['widgetPath', 'slotName'],
-        outputProps: { widgetPath: P.widgetPath, slotName: P.slotName, fontSize: P.fontSize },
-        outputRequired: ['widgetPath', 'slotName', 'fontSize'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'set_font', widgetPath: '/Game/UI/WBP_MainUI', slotName: 'TitleText', fontSize: 32 },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_MainUI', slotName: 'TitleText', fontSize: 32 },
-    }),
-    buildRecord({
-        id: 'blueprint.set_margin',
-        action: 'set_margin',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Set the slot margin on a widget held by a Horizontal Box, Vertical Box, Overlay, or Border.',
-        whenToUse: ['A widget needs spacing applied through its parent slot.'],
-        whenNotToUse: ['The parent slot type carries no margin; the call reports success false.'],
-        inputProps: { widgetPath: P.widgetPath, slotName: P.slotName, left: P.left, top: P.top, right: P.right, bottom: P.bottom },
-        required: ['widgetPath', 'slotName'],
-        outputProps: { widgetPath: P.widgetPath, slotName: P.slotName, left: P.left, top: P.top, right: P.right, bottom: P.bottom },
-        outputRequired: ['widgetPath', 'slotName', 'left', 'top', 'right', 'bottom'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'set_margin', widgetPath: '/Game/UI/WBP_MainUI', slotName: 'TitleText', left: 8, top: 8, right: 8, bottom: 8 },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_MainUI', slotName: 'TitleText', left: 8, top: 8, right: 8, bottom: 8 },
-    }),
-];
-//# sourceMappingURL=widget-content.js.map

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

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

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

@@ -1,56 +0,0 @@
-import { buildRecord, WIDGET_PLUGINS } from './helpers.js';
-import { P } from './properties.js';
-const FAMILY = 'widget-game-ui';
-const DOMAIN = 'widget';
-const HUD_TEXT = { type: 'string', description: 'Text the piece shows: health bar label (default HP), ammo counter (30 / 90), crosshair glyph (+), compass heading (N) or prompt action (Interact).' };
-const HUD_TEXTURE = { type: 'string', description: 'Texture drawn as the minimap image or the compass strip; a path that does not load is refused.' };
-const HUD_TITLE = { type: 'string', description: 'Objective tracker heading (default OBJECTIVES) or the quest name (default Quest Name).' };
-const HUD_OUT = {
-    widgetPath: P.widgetPath,
-    slotName: P.slotName,
-    widgets: { type: 'array', items: { type: 'string' }, description: 'Every widget created, root first; bind or restyle them by these names.' },
-    animationName: { type: 'string', description: 'Animation created with the piece (the damage indicator\'s <slot>_Flash); play it on a hit.' },
-    saved: { type: 'boolean', description: 'Whether the Widget Blueprint was saved.' },
-};
-function hud(action, summary, defaultSlot, extraProps, example) {
-    return buildRecord({
-        id: `blueprint.${action}`,
-        action,
-        family: FAMILY,
-        domain: DOMAIN,
-        summary,
-        whenToUse: [`A HUD needs a ${action.replace('add_', '').replace(/_/g, ' ')} without assembling it widget by widget.`],
-        whenNotToUse: ['A single plain widget is enough (add_content_widget).', 'The screen does not exist yet (create_widget_template hud builds one with pieces).'],
-        inputProps: {
-            widgetPath: P.widgetPath,
-            slotName: { type: 'string', description: 'Name of the root widget of the piece (default: the piece name, such as HealthBar); its parts are named <slotName>_<Part>.' },
-            parentSlot: P.parentSlot,
-            positionX: P.positionX,
-            positionY: P.positionY,
-            sizeX: P.sizeX,
-            sizeY: P.sizeY,
-            ...extraProps,
-        },
-        required: ['widgetPath'],
-        outputProps: HUD_OUT,
-        outputRequired: ['widgetPath', 'slotName', 'widgets'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action, widgetPath: '/Game/UI/WBP_HUD', ...example },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_HUD', slotName: defaultSlot, widgets: [defaultSlot] },
-    });
-}
-export const WIDGET_GAME_UI_RECORDS = [
-    hud('add_health_bar', 'Add a health bar (a label and a red progress bar, top-left) to a Widget Blueprint.', 'HealthBar', { percent: P.percent, fillColorAndOpacity: P.fillColorAndOpacity, text: HUD_TEXT }, { percent: 0.75, text: 'HP' }),
-    hud('add_ammo_counter', 'Add an ammo counter text (bottom-right) to a Widget Blueprint.', 'AmmoCounter', { text: HUD_TEXT, fontSize: P.fontSize, colorAndOpacity: P.colorAndOpacity }, { text: '12 / 48', fontSize: 32 }),
-    hud('add_crosshair', 'Add a crosshair glyph centred on screen (ignores the mouse) to a Widget Blueprint.', 'Crosshair', { text: HUD_TEXT, fontSize: P.fontSize, colorAndOpacity: P.colorAndOpacity }, { fontSize: 40 }),
-    hud('add_minimap', 'Add a minimap frame (map image plus a player dot, top-right) to a Widget Blueprint.', 'Minimap', { mapSize: P.mapSize, texturePath: HUD_TEXTURE }, { mapSize: 240 }),
-    hud('add_compass', 'Add a compass bar with a heading letter (top-centre) to a Widget Blueprint.', 'Compass', { text: HUD_TEXT, texturePath: HUD_TEXTURE }, { text: 'N' }),
-    hud('add_damage_indicator', 'Add a full-screen damage vignette with a flash animation and four edge arrows to a Widget Blueprint.', 'DamageIndicator', { colorAndOpacity: P.colorAndOpacity, fadeTime: P.fadeTime }, { fadeTime: 0.5 }),
-    hud('add_interaction_prompt', 'Add an interaction prompt (key badge plus action text, lower centre) to a Widget Blueprint.', 'InteractionPrompt', { text: HUD_TEXT, keyLabel: P.keyLabel }, { text: 'Open door', keyLabel: 'E' }),
-    hud('add_objective_tracker', 'Add an objective list panel (title plus rows, right side) to a Widget Blueprint.', 'ObjectiveTracker', { title: HUD_TITLE, items: P.items, maxVisibleObjectives: P.maxVisibleObjectives }, { title: 'OBJECTIVES', items: ['Find the key', 'Open the gate'] }),
-    hud('add_quest_tracker', 'Add an active-quest panel (header, quest name and objective rows, left side) to a Widget Blueprint.', 'QuestTracker', { title: HUD_TITLE, items: P.items }, { title: 'The Lost Relic', items: ['Reach the temple'] }),
-];
-//# sourceMappingURL=widget-game-ui.js.map

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

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

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

@@ -1,107 +0,0 @@
-import { buildRecord, WIDGET_PLUGINS } from './helpers.js';
-import { P } from './properties.js';
-export const WIDGET_INFO_RECORDS = [
-    buildRecord({
-        id: 'blueprint.get_widget_info',
-        action: 'get_widget_info',
-        family: 'widget-info',
-        domain: 'widget',
-        summary: 'Read the widget tree of a Widget Blueprint, returning slot names, types, and hierarchy.',
-        whenToUse: ['The widget tree of a Widget Blueprint must be inspected before modifying widgets.'],
-        whenNotToUse: ['A single widget property is needed (use get or set_style).'],
-        inputProps: { widgetPath: P.widgetPath },
-        required: ['widgetPath'],
-        outputProps: {
-            widgetInfo: {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    widgetClass: { type: 'string', description: 'Widget Blueprint class name.' },
-                    parentClass: { type: 'string', description: 'Native parent class name (omitted when the Widget Blueprint has no parent class).' },
-                    slots: { type: 'array', items: { type: 'string' }, description: 'Names of every widget in the widget tree.' },
-                    widgets: {
-                        type: 'array',
-                        description: 'One entry per widget in the tree, in traversal order: what it is, where it sits, and what it says.',
-                        items: {
-                            type: 'object',
-                            additionalProperties: false,
-                            properties: {
-                                name: { type: 'string', description: 'Widget name, the same value that appears in slots[].' },
-                                widgetClass: { type: 'string', description: 'Widget class, e.g. TextBlock or CanvasPanel.' },
-                                parentName: { type: 'string', description: 'Name of the parent panel (omitted for the root widget).' },
-                                slotClass: { type: 'string', description: 'Class of the slot holding this widget (omitted when it occupies none).' },
-                                isVariable: { type: 'boolean', description: 'Whether the widget is exposed as a Blueprint variable.' },
-                                text: { type: 'string', description: 'Literal text of a TextBlock or button label (omitted for widgets that carry none).' },
-                            },
-                            required: ['name', 'widgetClass'],
-                        },
-                    },
-                    rootWidget: { type: 'string', description: 'Name of the widget tree root (omitted when the tree is empty).' },
-                    animations: { type: 'array', items: { type: 'string' }, description: 'Names of the Widget Blueprint animations.' },
-                },
-                required: ['widgetClass', 'slots', 'widgets', 'animations'],
-            },
-            assetPath: { type: 'string', description: 'Asset path of the inspected Widget Blueprint (verification).' },
-            assetName: { type: 'string', description: 'Asset name of the inspected Widget Blueprint (verification).' },
-            existsAfter: { type: 'boolean', description: 'Whether the Widget Blueprint exists after inspection (verification).' },
-            assetClass: { type: 'string', description: 'Class of the inspected Widget Blueprint (verification).' },
-        },
-        outputRequired: ['widgetInfo'],
-        effect: 'read',
-        latency: 'instant',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'get_widget_info', widgetPath: '/Game/UI/WBP_MainUI' },
-        exampleOutput: { success: true, widgetInfo: { widgetClass: 'WBP_MainUI', parentClass: 'UserWidget', slots: ['CanvasPanel_0', 'TitleText'], widgets: [{ name: 'CanvasPanel_0', widgetClass: 'CanvasPanel', isVariable: false }, { name: 'TitleText', widgetClass: 'TextBlock', parentName: 'CanvasPanel_0', slotClass: 'CanvasPanelSlot', isVariable: true, text: 'Neon Drift' }], rootWidget: 'CanvasPanel_0', animations: [] } },
-    }),
-    buildRecord({
-        id: 'blueprint.get_widget_slot_info',
-        action: 'get_widget_slot_info',
-        family: 'widget-info',
-        domain: 'widget',
-        summary: 'Read the slot, geometry, and parent of one widget inside a Widget Blueprint.',
-        whenToUse: ['The layout of a single widget must be inspected before adjusting it.'],
-        whenNotToUse: ['The whole widget tree is needed (use get_widget_info).'],
-        inputProps: { widgetPath: P.widgetPath, slotName: P.slotName },
-        required: ['widgetPath', 'slotName'],
-        outputProps: {
-            widgetPath: P.widgetPath,
-            slotName: P.slotName,
-            widgetClass: { type: 'string', description: 'Class name of the inspected widget.' },
-            isVisible: { type: 'boolean', description: 'Whether the widget draws, derived from `visibility` (false only for Collapsed and Hidden).' },
-            visibility: { type: 'string', enum: ['Visible', 'Collapsed', 'Hidden', 'HitTestInvisible', 'SelfHitTestInvisible'], description: 'The widget\'s design-time Visibility, the same value set_visibility writes.' },
-            slotClass: { type: 'string', description: 'Class name of the slot holding the widget (omitted when the widget occupies no slot).' },
-            layout: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'The widget layout for any slot kind: visibility, renderOpacity, renderTransform, slotClass, then canvas anchors, alignment, position, size, zOrder and autoSize, or box padding, horizontal and vertical alignment and the sizeRule (Auto or Fill) with its fillValue.' },
-            canvasSlotInfo: {
-                type: 'object',
-                additionalProperties: false,
-                description: 'Canvas geometry of the widget (omitted unless the slot is a canvas panel slot).',
-                properties: {
-                    anchorMinX: { type: 'number', description: 'Minimum anchor X.' },
-                    anchorMinY: { type: 'number', description: 'Minimum anchor Y.' },
-                    anchorMaxX: { type: 'number', description: 'Maximum anchor X.' },
-                    anchorMaxY: { type: 'number', description: 'Maximum anchor Y.' },
-                    alignmentX: { type: 'number', description: 'Alignment X within the slot.' },
-                    alignmentY: { type: 'number', description: 'Alignment Y within the slot.' },
-                    positionX: { type: 'number', description: 'Slot position X.' },
-                    positionY: { type: 'number', description: 'Slot position Y.' },
-                    sizeX: { type: 'number', description: 'Slot width.' },
-                    sizeY: { type: 'number', description: 'Slot height.' },
-                    zOrder: { type: 'number', description: 'Slot draw order.' },
-                },
-                required: ['anchorMinX', 'anchorMinY', 'anchorMaxX', 'anchorMaxY', 'alignmentX', 'alignmentY', 'positionX', 'positionY', 'sizeX', 'sizeY', 'zOrder'],
-            },
-            parentName: P.parentName,
-            parentClass: { type: 'string', description: 'Class name of the parent widget (omitted when the widget has no parent).' },
-        },
-        outputRequired: ['widgetPath', 'slotName', 'widgetClass', 'isVisible'],
-        effect: 'read',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        latency: 'instant',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'get_widget_slot_info', widgetPath: '/Game/UI/WBP_MainUI', slotName: 'TitleText' },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_MainUI', slotName: 'TitleText', widgetClass: 'TextBlock', isVisible: true, visibility: 'Visible', slotClass: 'CanvasPanelSlot', parentName: 'CanvasPanel_0', parentClass: 'CanvasPanel' },
-    }),
-];
-//# sourceMappingURL=widget-info.js.map

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

@@ -1,24 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-import type { JsonObject } from '../../model.js';
-export declare const LAYOUT_OUT: {
-    slotName: JsonObject;
-    applied: {
-        type: string;
-        additionalProperties: boolean;
-        'x-unreal-reflection-boundary': boolean;
-        description: string;
-    };
-    saved: {
-        type: string;
-        description: string;
-    };
-    appliedFields: {
-        type: string;
-        items: {
-            type: string;
-        };
-        description: string;
-    };
-};
-export declare const WIDGET_LAYOUT_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=widget-layout.d.ts.map

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

@@ -1,45 +0,0 @@
-import { buildRecord, WIDGET_PLUGINS } from './helpers.js';
-import { P } from './properties.js';
-const FAMILY = 'widget-layout';
-const DOMAIN = 'widget';
-export const LAYOUT_OUT = {
-    slotName: P.slotName,
-    applied: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'The widget as it is now: visibility, renderOpacity, renderTransform, slotClass, and the canvas anchors, alignment, position, size, zOrder and autoSize or the box padding and horizontal and vertical alignment.' },
-    saved: { type: 'boolean', description: 'Whether the Widget Blueprint was saved.' },
-    appliedFields: { type: 'array', items: { type: 'string' }, description: 'set_style: the style fields that were written (text, fontSize, colorAndOpacity, cornerRadius...).' },
-};
-function layout(action, id, summary, extras) {
-    return buildRecord({
-        id,
-        ...(extras.aliases === undefined ? {} : { aliases: extras.aliases }),
-        action,
-        family: FAMILY,
-        domain: DOMAIN,
-        summary,
-        whenToUse: [`The ${action.replace(/_/g, ' ')} of a widget must be updated.`],
-        whenNotToUse: ['The widget should be removed rather than restyled.'],
-        inputProps: { widgetPath: P.widgetPath, slotName: P.slotName, ...extras.props },
-        required: ['widgetPath', 'slotName', ...extras.required],
-        outputProps: LAYOUT_OUT,
-        effect: 'write',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        latency: 'instant',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action, widgetPath: '/Game/UI/WBP_MainUI', slotName: 'Widget_Button', ...extras.example },
-        exampleOutput: { success: true, message: `${action} set` },
-    });
-}
-export const WIDGET_LAYOUT_RECORDS = [
-    layout('set_anchor', 'blueprint.set_anchor', 'Set the anchor points (min/max) for a widget in a canvas panel slot.', { props: { anchorMin: P.anchorMin, anchorMax: P.anchorMax, preset: P.preset }, required: [], example: { preset: 'StretchAll' } }),
-    layout('set_alignment', 'blueprint.set_alignment', 'Set the alignment (0-1) for a widget in its slot.', { props: { alignment: P.alignment }, required: ['alignment'], example: { alignment: { x: 0.5, y: 0.5 } } }),
-    layout('set_position', 'blueprint.set_position', 'Set the position offset for a widget in its slot.', { props: { position: P.position }, required: ['position'], example: { position: { x: 120, y: 64 } } }),
-    layout('set_size', 'blueprint.set_size', 'Set the size of a widget in its slot: a size override {x,y} for a CanvasPanel child, or sizeRule (Auto or Fill) and fillValue (the Fill weight) for a HorizontalBox, VerticalBox or ScrollBox child.', { props: { size: P.size, sizeRule: P.sizeRule, fillValue: P.fillValue }, required: [], example: { size: { x: 240, y: 80 } } }),
-    layout('set_padding', 'blueprint.set_padding', 'Set the padding for a widget in its slot.', { props: { padding: P.padding }, required: ['padding'], example: { padding: { left: 8, top: 4, right: 8, bottom: 4 } } }),
-    layout('set_z_order', 'blueprint.set_z_order', 'Set the Z-order for a widget in a canvas panel slot.', { props: { zOrder: P.zOrder }, required: ['zOrder'], example: { zOrder: 10 } }),
-    layout('set_render_transform', 'blueprint.set_render_transform', 'Set the render transform (translation, shear, angle) for a widget.', { props: { translation: P.translation, shear: P.shear, angle: P.angle, scale: P.scale }, required: [], example: {} }),
-    layout('set_visibility', 'blueprint.set_visibility', 'Set the visibility mode (Visible, Collapsed, Hidden, etc.) for a widget.', { props: { visibility: P.visibility }, required: ['visibility'], example: { visibility: 'Visible' }, aliases: ['blueprint.hide_widget'] }),
-    layout('set_style', 'blueprint.set_style', 'Set the visual style (color, font size, face and letter spacing, text, text justification, brush texture, button hover/press sounds) for a widget, or copy the look of another text block with copyStyleFrom.', { props: { colorAndOpacity: P.colorAndOpacity, fontSize: P.fontSize, text: P.text, texturePath: P.texturePath, renderOpacity: P.renderOpacity, propertyName: { type: 'string', description: 'Any other widget property, by reflection (such as WidgetStyle or Brush): read without value, written with it. A dotted path reaches into a struct: Font.OutlineSettings.OutlineSize (a number) outlines the text of a TextBlock and Font.OutlineSettings.OutlineColor colors that outline; ShadowOffset ({X, Y}) with ShadowColorAndOpacity gives it a drop shadow.' }, value: { description: 'New value for propertyName: a string, number or bool, or an object or array for a struct property.' }, cornerRadius: P.cornerRadius, outlineColor: P.outlineColor, outlineWidth: P.outlineWidth, hoverSoundPath: P.hoverSoundPath, pressSoundPath: P.pressSoundPath, justification: P.justification, fontFamily: P.fontFamily, typeface: P.typeface, letterSpacing: P.letterSpacing, copyStyleFrom: P.copyStyleFrom }, required: [], example: { cornerRadius: 18 } }),
-    layout('set_clipping', 'blueprint.set_clipping', 'Set the clipping mode (Inherit, ClipToBounds, etc.) for a widget.', { props: { clipping: P.clipping }, required: ['clipping'], example: { clipping: 'ClipToBounds' } }),
-];
-//# sourceMappingURL=widget-layout.js.map

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

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

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

@@ -1,189 +0,0 @@
-import { buildRecord, WIDGET_PLUGINS } from './helpers.js';
-import { P } from './properties.js';
-import { LAYOUT_OUT } from './widget-layout.js';
-const FAMILY = 'widget-lifecycle';
-const DOMAIN = 'widget';
-export const WIDGET_LIFECYCLE_RECORDS = [
-    buildRecord({
-        id: 'blueprint.create_widget_blueprint',
-        action: 'create_widget_blueprint',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['umg widget', 'user widget', 'ui widget', 'hud', 'new widget', 'menu widget'],
-        summary: 'Create a new Widget Blueprint (UMG) asset with an optional parent class, named by name and path or by its full widgetPath.',
-        whenToUse: ['A new UMG Widget Blueprint must be created.'],
-        whenNotToUse: ['A non-widget Blueprint is needed (use create or create_blueprint).'],
-        inputProps: {
-            name: P.name, path: P.path, folder: P.folder,
-            widgetPath: { type: 'string', description: 'Full asset path of the new Widget Blueprint (/Game/UI/WBP_Title), in place of name and path.' },
-            parentClass: P.parentClass,
-        },
-        required: [],
-        requiredOneOf: ['name', 'widgetPath'],
-        outputProps: { widgetPath: P.widgetPath },
-        outputRequired: ['widgetPath'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'create_widget_blueprint', name: 'WBP_MainUI', path: '/Game/UI', parentClass: '/Script/UMG.UserWidget' },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_MainUI' },
-        aliases: ['blueprint.create_widget'],
-    }),
-    buildRecord({
-        id: 'blueprint.set_widget_parent_class',
-        action: 'set_widget_parent_class',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Set the parent class of a Widget Blueprint.',
-        whenToUse: ['A Widget Blueprint must inherit from a specific UserWidget subclass.'],
-        whenNotToUse: ['The Widget Blueprint already has the correct parent.'],
-        inputProps: { widgetPath: P.widgetPath, parentClass: P.parentClass },
-        required: ['widgetPath', 'parentClass'],
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'set_widget_parent_class', widgetPath: '/Game/UI/WBP_MainUI', parentClass: '/Game/Blueprints/WBP_BaseUI' },
-    }),
-    buildRecord({
-        id: 'blueprint.preview_widget',
-        action: 'preview_widget',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['preview widget', 'render widget', 'see widget', 'widget screenshot', 'widget image', 'preview ui'],
-        summary: 'Look at a Widget Blueprint without running the game: it is drawn offscreen for a screen size and returned as a PNG image, as the game creates it: Construct graphs do not run, so texts are the designer defaults, and widgets set Collapsed or Hidden stay hidden.',
-        whenToUse: ['A Widget Blueprint must be seen after an edit (layout, colours, fonts) without running PIE.'],
-        whenNotToUse: ['What the running game shows is needed, runtime texts included (play, then control_editor screenshot mode full_editor_window).'],
-        inputProps: {
-            widgetPath: P.widgetPath,
-            resolution: { type: 'string', description: 'Screen size the widget is drawn for, "WxH" (default "1280x720"); the project DPI scaling for that size applies, as in the game.' },
-            openEditor: { type: 'boolean', description: 'Also open it in the Widget Blueprint editor, which takes focus (default false).' },
-            waitForShaders: { type: 'boolean', description: 'true: when the drawing left shaders compiling (the editor compiles a material\'s UI shaders the first time it is drawn: right after the editor starts, or after a material edit), wait for them, at most 25 seconds, and draw again; shaderWait in the reply says how long it waited. Default false: draw once and report shadersCompiling.' },
-        },
-        required: ['widgetPath'],
-        outputProps: {
-            widgetPath: P.widgetPath,
-            imageBase64: { type: 'string', description: 'The drawn widget as PNG, base64; returned as an image.' },
-            mimeType: { type: 'string', description: 'image/png.' },
-            width: { type: 'number', description: 'Image width in pixels.' },
-            height: { type: 'number', description: 'Image height in pixels.' },
-            sizeBytes: { type: 'number', description: 'PNG size in bytes.' },
-            editorOpened: { type: 'boolean', description: 'Whether the Widget Blueprint editor was opened (openEditor).' },
-            shadersCompiling: { type: 'number', description: 'Shader compile jobs still outstanding when the widget was drawn. Above 0, images and borders that use a material may be drawn blank and a warning says so; pass waitForShaders to draw after they finish.' },
-            shaderWait: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'With waitForShaders while shaders compiled: waitedSeconds, jobsLeft (still outstanding when the wait ended) and timedOut (true when jobs were left after the 25 second cap).' },
-        },
-        outputRequired: ['widgetPath'],
-        effect: 'read',
-        latency: 'interactive',
-        resources: 'medium',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'preview_widget', widgetPath: '/Game/UI/WBP_MainUI' },
-        exampleOutput: { success: true, message: 'Widget drawn at 1280x720 as the game creates it (Construct graphs do not run)', widgetPath: '/Game/UI/WBP_MainUI', mimeType: 'image/png', width: 1280, height: 720 },
-    }),
-    buildRecord({
-        id: 'blueprint.remove_widget',
-        action: 'remove_widget',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['delete widget', 'remove widget', 'delete button', 'remove button', 'remove label'],
-        summary: 'Remove a widget from the widget tree of a Widget Blueprint.',
-        whenToUse: ['A widget must be deleted from a Widget Blueprint layout.'],
-        whenNotToUse: ['The widget should stay but be hidden (use set_visibility).'],
-        inputProps: { widgetPath: P.widgetPath, slotName: P.slotName },
-        required: ['widgetPath', 'slotName'],
-        outputProps: {
-            widgetPath: P.widgetPath,
-            removedWidget: { type: 'string', description: 'Name of the widget that was removed from the widget tree.' },
-        },
-        outputRequired: ['widgetPath', 'removedWidget'],
-        effect: 'destructive',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'remove_widget', widgetPath: '/Game/UI/WBP_MainUI', slotName: 'TitleText' },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_MainUI', removedWidget: 'TitleText' },
-    }),
-    buildRecord({
-        id: 'blueprint.rename_widget',
-        action: 'rename_widget',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Rename a widget inside the widget tree of a Widget Blueprint.',
-        whenToUse: ['A widget name must change so bindings and lookups can address it.'],
-        whenNotToUse: ['A Blueprint or Widget Blueprint asset itself should be renamed (use asset.rename).'],
-        inputProps: { widgetPath: P.widgetPath, slotName: P.slotName, newName: P.newName },
-        required: ['widgetPath', 'slotName', 'newName'],
-        outputProps: { widgetPath: P.widgetPath, oldName: P.oldName, newName: P.newName },
-        outputRequired: ['widgetPath', 'oldName', 'newName'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'rename_widget', widgetPath: '/Game/UI/WBP_MainUI', slotName: 'TitleText', newName: 'HeaderText' },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_MainUI', oldName: 'TitleText', newName: 'HeaderText' },
-    }),
-    buildRecord({
-        id: 'blueprint.reparent_widget',
-        action: 'reparent_widget',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Move a widget under a different parent widget inside a Widget Blueprint, or to another position in its own parent, keeping its slot layout.',
-        whenToUse: ['An existing widget must move into another panel without being recreated.', 'Children of a panel must be reordered (same newParent, with index).'],
-        whenNotToUse: ['The widget is being added for the first time (use the matching add action).'],
-        inputProps: {
-            widgetPath: P.widgetPath, slotName: P.slotName, newParent: P.newParent,
-            index: { type: 'integer', minimum: 0, description: 'Position among the children of the new parent after the move (0 = first). Without it the widget goes last.' },
-        },
-        required: ['widgetPath', 'slotName', 'newParent'],
-        outputProps: {
-            widgetPath: P.widgetPath,
-            slotName: LAYOUT_OUT.slotName,
-            newParent: P.newParent,
-            index: { type: 'integer', description: 'Where the widget now sits among the children of the new parent (0 = first).' },
-            applied: LAYOUT_OUT.applied,
-            saved: LAYOUT_OUT.saved,
-        },
-        outputRequired: ['widgetPath', 'slotName', 'newParent', 'index', 'applied'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'reparent_widget', widgetPath: '/Game/UI/WBP_MainUI', slotName: 'TitleText', newParent: 'HeaderBox' },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_MainUI', slotName: 'TitleText', newParent: 'HeaderBox', index: 0 },
-    }),
-    buildRecord({
-        id: 'blueprint.duplicate_widget',
-        action: 'duplicate_widget',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['duplicate widget', 'copy widget', 'clone widget', 'duplicate button', 'copy button', 'repeat row'],
-        summary: 'Copy a widget and everything under it (a list row with its label, icon and button) inside a Widget Blueprint: same properties, slot layout and children, placed right after the original or under another panel.',
-        whenToUse: ['A widget or a whole panel subtree is needed again, e.g. the next row of a list or a second button like the first.'],
-        whenNotToUse: ['The widget should move rather than be copied (use reparent_widget).'],
-        inputProps: {
-            widgetPath: P.widgetPath,
-            slotName: { type: 'string', description: 'Widget to copy; everything under it is copied too.' },
-            newName: { type: 'string', description: 'Name of the copy (default the original name with _Copy; _1, _2... is added when that name is taken). Every widget under it is copied as <its own name>_Copy, made unique the same way: copying QuitButton gives QuitButton_Copy and its label QuitButtonText_Copy. copiedWidgets lists the pairs.' },
-            newParent: { type: 'string', description: 'Panel the copy goes under (default the parent of the original).' },
-            index: { type: 'integer', minimum: 0, description: 'Position among the children of that panel (0 = first). Default: right after the original, or last under another panel.' },
-        },
-        required: ['widgetPath', 'slotName'],
-        outputProps: {
-            widgetPath: P.widgetPath,
-            slotName: { type: 'string', description: 'Name of the copy, for later calls.' },
-            newParent: { type: 'string', description: 'Panel the copy sits under.' },
-            index: { type: 'integer', description: 'Where the copy sits among the children of that panel (0 = first).' },
-            copiedWidgets: { type: 'array', description: 'Every widget copied, as {source, copy} name pairs: the children come first, each copied as <source>_Copy, and the copy of the original comes last.', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true } },
-        },
-        outputRequired: ['widgetPath', 'slotName', 'newParent', 'index'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'duplicate_widget', widgetPath: '/Game/UI/WBP_Shop', slotName: 'Row_1', newName: 'Row_2' },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_Shop', slotName: 'Row_2', newParent: 'RowList', index: 1, copiedWidgets: [{ source: 'RowLabel', copy: 'RowLabel_Copy' }, { source: 'Row_1', copy: 'Row_2' }] },
-    }),
-];
-//# sourceMappingURL=widget-lifecycle.js.map

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

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