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

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

@@ -1,153 +0,0 @@
-import { buildRecord, WIDGET_PLUGINS } from './helpers.js';
-import { P } from './properties.js';
-const FAMILY = 'widget-panels';
-const DOMAIN = 'widget';
-const SLOT_OUT = { slotName: P.slotName };
-function panel(action, id, summary, extraProps = {}) {
-    return buildRecord({
-        id,
-        action,
-        family: FAMILY,
-        domain: DOMAIN,
-        summary,
-        whenToUse: [`A new ${action.replace(/^add_/, '').replace(/_/g, ' ')} must be added to a Widget Blueprint.`],
-        whenNotToUse: ['A content widget (button, text, etc.) is needed instead.'],
-        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'],
-        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 ', 'Panel_') },
-        exampleOutput: { success: true, slotName: action.replace(/_/g, ' ').replace('add ', 'Panel_') },
-    });
-}
-export const WIDGET_PANELS_RECORDS = [
-    panel('add_canvas_panel', 'blueprint.add_canvas_panel', 'Add a Canvas Panel to a Widget Blueprint for absolute-positioned child layout.'),
-    panel('add_horizontal_box', 'blueprint.add_horizontal_box', 'Add a Horizontal Box to a Widget Blueprint for left-to-right child layout.'),
-    panel('add_vertical_box', 'blueprint.add_vertical_box', 'Add a Vertical Box to a Widget Blueprint for top-to-bottom child layout.'),
-    panel('add_overlay', 'blueprint.add_overlay', 'Add an Overlay to a Widget Blueprint for stacked/z-order child layout.'),
-    panel('add_grid_panel', 'blueprint.add_grid_panel', 'Add a Grid Panel to a Widget Blueprint for row/column-based child layout.', { columnCount: { type: 'number', description: 'Columns given an equal share of the width (0-64).' }, rowCount: { type: 'number', description: 'Rows given an equal share of the height (0-64).' } }),
-    panel('add_uniform_grid', 'blueprint.add_uniform_grid', 'Add a Uniform Grid Panel to a Widget Blueprint for equal-cell child layout.', { slotPadding: P.slotPadding, minDesiredSlotWidth: P.minDesiredSlotWidth, minDesiredSlotHeight: P.minDesiredSlotHeight }),
-    panel('add_wrap_box', 'blueprint.add_wrap_box', 'Add a Wrap Box to a Widget Blueprint for auto-wrapping child layout.', { wrapWidth: P.wrapWidth, explicitWrapWidth: P.explicitWrapWidth, innerSlotPadding: P.innerSlotPadding }),
-    panel('add_scroll_box', 'blueprint.add_scroll_box', 'Add a Scroll Box to a Widget Blueprint for scrollable child layout.', { scrollBarVisibility: P.scrollBarVisibility, alwaysShowScrollbar: P.alwaysShowScrollbar, orientation: P.orientation }),
-    panel('add_size_box', 'blueprint.add_size_box', 'Add a Size Box to a Widget Blueprint for explicit child size override.', { widthOverride: P.widthOverride, heightOverride: P.heightOverride, minDesiredWidth: P.minDesiredWidth, minDesiredHeight: P.minDesiredHeight, maxDesiredWidth: P.maxDesiredWidth, maxDesiredHeight: P.maxDesiredHeight }),
-    panel('add_scale_box', 'blueprint.add_scale_box', 'Add a Scale Box to a Widget Blueprint for scalable child content.', { stretch: P.stretch, stretchDirection: P.stretchDirection, userSpecifiedScale: P.userSpecifiedScale }),
-    panel('add_border', 'blueprint.add_border', 'Add a Border widget to a Widget Blueprint for framed/decorative child layout.', { brushColor: P.brushColor, padding: P.padding, contentColorAndOpacity: P.contentColorAndOpacity }),
-    buildRecord({
-        id: 'blueprint.add_spacer',
-        action: 'add_spacer',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Add a Spacer to a Widget Blueprint to reserve fixed empty space inside a layout.',
-        whenToUse: ['Fixed empty space must separate sibling widgets in a box or panel.'],
-        whenNotToUse: ['The gap should belong to an existing widget (set its padding instead).'],
-        inputProps: { widgetPath: P.widgetPath, slotName: P.slotName, parentSlot: P.parentSlot, positionX: P.positionX, positionY: P.positionY, sizeX: P.sizeX, sizeY: P.sizeY },
-        required: ['widgetPath'],
-        outputProps: { widgetPath: P.widgetPath, slotName: P.slotName, sizeX: P.sizeX, sizeY: P.sizeY },
-        outputRequired: ['widgetPath', 'slotName', 'sizeX', 'sizeY'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'add_spacer', widgetPath: '/Game/UI/WBP_MainUI', slotName: 'Spacer_0', sizeX: 100, sizeY: 24 },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_MainUI', slotName: 'Spacer_0', sizeX: 100, sizeY: 24 },
-    }),
-    buildRecord({
-        id: 'blueprint.add_safe_zone',
-        action: 'add_safe_zone',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Add a Safe Zone to a Widget Blueprint so child content respects the platform title-safe area.',
-        whenToUse: ['HUD content must stay inside the title-safe area on console or TV output.'],
-        whenNotToUse: ['The layout is desktop-only and no safe-area inset applies.'],
-        inputProps: { widgetPath: P.widgetPath, slotName: P.slotName, parentSlot: P.parentSlot },
-        required: ['widgetPath'],
-        outputProps: { widgetPath: P.widgetPath, slotName: P.slotName },
-        outputRequired: ['widgetPath', 'slotName'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'add_safe_zone', widgetPath: '/Game/UI/WBP_MainUI', slotName: 'SafeZone_0' },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_MainUI', slotName: 'SafeZone_0' },
-    }),
-    buildRecord({
-        id: 'blueprint.add_widget_tree',
-        action: 'add_widget_tree',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Add a whole widget layout to a Widget Blueprint in one call: nested panels, borders, text, images and bars with their looks and slots.',
-        whenToUse: [
-            'A HUD, a panel of labels or any layout of several widgets must be built in one call instead of an add_* call per widget and a set_style call per look.',
-            'Text needs its face, letter spacing, outline or shadow, or a border its rounded corners and outline, as it is created.',
-        ],
-        whenNotToUse: ['One widget must be added (use the matching widgetKind).', 'A widget already in the tree must change (use set_widget_layout).'],
-        inputProps: {
-            widgetPath: P.widgetPath,
-            tree: {
-                type: 'object',
-                additionalProperties: true,
-                'x-unreal-reflection-boundary': true,
-                description: 'The layout as one nested node {type, name, children[], slot{}, ...props}. type: a UMG class short name (CanvasPanel, Overlay, VerticalBox, HorizontalBox, Border, SizeBox, ScaleBox, UniformGridPanel, Spacer, TextBlock, RichTextBlock, Image, ProgressBar, Button). name: the widget name, unique in the Widget Blueprint (each becomes a variable a graph can read). Props: text, fontSize, color [r,g,b,a] (text colour, border brush, image tint, bar fill), justify left|center|right, autoWrap, opacity, visibility, padding (number or [l,t,r,b]: a border\'s inner padding), radius (rounded border, image or button) with outlineColor and outlineWidth, imageSize [w,h], texture (an image\'s texture path), material (an Image\'s or Border\'s brush: a UI material or instance that draws the whole widget, such as a rounded panel with its rim and gradient), percent (progress bar), width, height, maxHeight (size box). Text blocks also take typeface (Bold, Regular, Light, Italic), fontFamily, letterSpacing, outline with outlineColor, and shadowOffset [x,y] with shadowColor. slot places the node in its parent: in a canvas anchors [minX,minY,maxX,maxY], alignment [x,y], position [x,y], size [w,h], autoSize, z; in a box padding, hAlign (left|center|right|fill), vAlign (top|center|bottom|fill) and fill (a share of the free space). A Widget Blueprint with no root yet gets a canvas, and a tree root with no slot (and no positionX/Y or sizeX/Y) fills it. An unknown field is refused, not ignored; at most 200 widgets.',
-            },
-            parentSlot: P.parentSlot,
-            positionX: P.positionX,
-            positionY: P.positionY,
-            sizeX: P.sizeX,
-            sizeY: P.sizeY,
-        },
-        required: ['widgetPath', 'tree'],
-        outputProps: {
-            widgetPath: P.widgetPath,
-            slotName: P.slotName,
-            widgets: { type: 'array', items: { type: 'string' }, description: 'Every widget the tree made, by name, parents first.' },
-            widgetCount: { type: 'number', description: 'How many widgets the tree made.' },
-            saved: { type: 'boolean', description: 'Whether the Widget Blueprint was saved.' },
-        },
-        outputRequired: ['widgetPath', 'slotName', 'widgets'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        topics: ['widget tree', 'whole hud layout', 'build ui in one call', 'hud panel with labels'],
-        exampleInput: {
-            action: 'add_widget_tree',
-            widgetPath: '/Game/UI/WBP_HUD',
-            tree: {
-                type: 'Border', name: 'ScorePanel', color: [0, 0, 0, 0.55], radius: 12, padding: [18, 10, 18, 10],
-                slot: { anchors: [0, 0, 0, 0], position: [32, 24], autoSize: true },
-                children: [{
-                        type: 'VerticalBox', name: 'ScoreStack',
-                        children: [
-                            { type: 'TextBlock', name: 'ScoreLabel', text: 'SCORE', fontSize: 14, letterSpacing: 200, color: [0.4, 1, 0.9, 1] },
-                            { type: 'TextBlock', name: 'ScoreText', text: '0', fontSize: 36, typeface: 'Bold', outline: 2 },
-                        ],
-                    }],
-            },
-        },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_HUD', slotName: 'ScorePanel', widgets: ['ScorePanel', 'ScoreStack', 'ScoreLabel', 'ScoreText'], widgetCount: 4, saved: true },
-    }),
-    buildRecord({
-        id: 'blueprint.add_widget_switcher',
-        action: 'add_widget_switcher',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Add a Widget Switcher to a Widget Blueprint to show one child at a time by index.',
-        whenToUse: ['Several pages or tabs must occupy one region with only one visible at a time.'],
-        whenNotToUse: ['All children should be visible together (use an overlay or a box).'],
-        inputProps: { widgetPath: P.widgetPath, slotName: P.slotName, parentSlot: P.parentSlot, activeIndex: P.activeIndex },
-        required: ['widgetPath'],
-        outputProps: { widgetPath: P.widgetPath, slotName: P.slotName, activeIndex: P.activeIndex },
-        outputRequired: ['widgetPath', 'slotName', 'activeIndex'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action: 'add_widget_switcher', widgetPath: '/Game/UI/WBP_MainUI', slotName: 'PageSwitcher', activeIndex: 0 },
-        exampleOutput: { success: true, widgetPath: '/Game/UI/WBP_MainUI', slotName: 'PageSwitcher', activeIndex: 0 },
-    }),
-];
-//# sourceMappingURL=widget-panels.js.map

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

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

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

@@ -1,47 +0,0 @@
-import { buildRecord, WIDGET_PLUGINS } from './helpers.js';
-import { P } from './properties.js';
-const FAMILY = 'widget-templates';
-const DOMAIN = 'widget';
-const SCREEN_OUT = {
-    widgetPath: P.widgetPath,
-    widgetCount: { type: 'number', description: 'Widgets in the new tree.' },
-    buttons: { type: 'array', items: { type: 'string' }, description: 'Every Button created; wire them with bind_widget on_clicked.' },
-    animationName: { type: 'string', description: 'Animation created with the screen (the loading screen FadeIn, the HUD damage flash).' },
-    compiled: { type: 'boolean', description: 'Whether the new Widget Blueprint compiled.' },
-    saved: { type: 'boolean', description: 'Whether the new Widget Blueprint was saved.' },
-};
-function screen(action, summary, extraProps, example) {
-    const name = `WBP_${action.replace('create_', '').split('_').map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join('')}`;
-    return buildRecord({
-        id: `blueprint.${action}`,
-        action,
-        family: FAMILY,
-        domain: DOMAIN,
-        summary,
-        whenToUse: [`A game needs a ${action.replace('create_', '').replace(/_/g, ' ')} and none exists yet.`],
-        whenNotToUse: ['The Widget Blueprint already exists (edit it with the add_* and set_* widget actions).'],
-        inputProps: { name: P.name, path: P.path, ...extraProps },
-        required: ['name'],
-        outputProps: SCREEN_OUT,
-        outputRequired: ['widgetPath', 'widgetCount'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'medium',
-        plugins: WIDGET_PLUGINS,
-        exampleInput: { action, name, path: '/Game/UI', ...example },
-        exampleOutput: { success: true, widgetPath: `/Game/UI/${name}.${name}`, widgetCount: 12 },
-    });
-}
-export const WIDGET_TEMPLATES_RECORDS = [
-    screen('create_main_menu', 'Create a main menu Widget Blueprint: backdrop, title and a column of buttons (default Play, Settings, Quit).', { title: P.title, buttons: P.buttons }, { title: 'My Game', buttons: ['Play', 'Options', 'Quit'] }),
-    screen('create_pause_menu', 'Create a pause menu Widget Blueprint: dimmed backdrop, PAUSED title and buttons (default Resume, Settings, Main Menu).', { title: P.title, buttons: P.buttons }, { buttons: ['Resume', 'Quit'] }),
-    screen('create_settings_menu', 'Create a settings menu Widget Blueprint: graphics, audio and controls rows with real combo boxes, check boxes and sliders, plus Apply and Back.', { settingsType: P.settingsType }, { settingsType: 'audio' }),
-    screen('create_loading_screen', 'Create a loading screen Widget Blueprint: backdrop, Loading text, optional progress bar and optional FadeIn animation.', { includeProgressBar: P.includeProgressBar, fadeTime: P.fadeTime }, { includeProgressBar: true, fadeTime: 0.5 }),
-    screen('create_hud_widget', 'Create a HUD Widget Blueprint on a canvas holding ready-made pieces (default health bar, crosshair, ammo counter).', { elements: P.elements }, { elements: ['health_bar', 'crosshair'] }),
-    screen('create_dialog_widget', 'Create a dialog box Widget Blueprint: speaker name, wrapped dialog line, response buttons and a continue hint.', { showSpeakerName: P.showSpeakerName, responseCount: P.responseCount }, { responseCount: 2 }),
-    screen('create_inventory_ui', 'Create an inventory Widget Blueprint: titled panel with a grid of item slots (default 6 by 4).', { columns: P.columns, rows: P.rows }, { columns: 5, rows: 3 }),
-    screen('create_radial_menu', 'Create a radial menu Widget Blueprint: a ring of round buttons around a centre label (default 8 segments).', { segmentCount: P.segmentCount }, { segmentCount: 6 }),
-    screen('create_credits_screen', 'Create a credits Widget Blueprint: centred scrolling list of role and name pairs with a Back button.', { title: P.title, entries: P.entries }, { entries: [{ title: 'Design', name: 'Ada' }, { title: 'Music', name: 'Grace' }] }),
-    screen('create_shop_ui', 'Create a shop Widget Blueprint: header with currency, a scrolling grid of item cards each with a Buy button, and Close.', { columns: P.columns, itemCount: P.itemCount }, { columns: 4, itemCount: 8 }),
-];
-//# sourceMappingURL=widget-templates.js.map

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

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

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

@@ -1,7 +0,0 @@
-import { LIFECYCLE_RECORDS } from './lifecycle.data.js';
-import { OPERATIONS_RECORDS } from './operations.data.js';
-import { applyFolds } from '../shared/fold.js';
-import { MANAGE_LEVEL_FOLDS } from '../folds/manage-level.folds.js';
-export const MANAGE_LEVEL_UNFOLDED_SOURCES = [...LIFECYCLE_RECORDS, ...OPERATIONS_RECORDS];
-export const MANAGE_LEVEL_SOURCES = applyFolds(MANAGE_LEVEL_UNFOLDED_SOURCES, MANAGE_LEVEL_FOLDS, 'manage_level');
-//# sourceMappingURL=index.js.map

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

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

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

@@ -1,132 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-const F = 'lifecycle';
-const D = 'level';
-export const LIFECYCLE_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'load', dispatchAction: 'load', domain: D, family: F,
-        topics: ['open level', 'load map', 'open map', 'switch level', 'change level', 'reload level'],
-        summary: 'Load a level into the editor, or with streaming=true stream it into the open level as a sub-level.',
-        whenToUse: ['A level must be opened or streamed into the current session.'],
-        whenNotToUse: ['The level is already the open one: the call reloads nothing and keeps its unsaved changes (the reply says alreadyLoaded and reports the unsaved state); to drop them, open another level with discardUnsaved true, to keep them use save.',
-            'Open levels have unsaved changes that opening another level would drop: the call is refused with DIRTY_PACKAGES, listing them in unsavedPackages, until saveDirtyPackages or discardUnsaved says what to do with them.'],
-        inputProps: {
-            levelPath: P.levelPath, streaming: P.streaming,
-            saveDirtyPackages: { ...P.saveDirtyPackages, description: 'Save every dirty level and asset package first, in every mode (an interactive editor used to ignore it); the load fails DIRTY_PACKAGES when one cannot be saved, and a headless run refuses to load over dirty packages unless this is true. Done even when the level is already open and nothing is loaded.' },
-            discardUnsaved: { type: 'boolean', description: 'Load even though open levels have unsaved changes, dropping them. Without this or saveDirtyPackages, a load that would drop unsaved level changes is refused with DIRTY_PACKAGES, which lists them (the editor loaded over them without a word).' },
-        },
-        required: ['levelPath'],
-        outputProps: {
-            alreadyLoaded: { type: 'boolean', description: 'True when levelPath was already the open level: nothing was loaded or reloaded, its unsaved changes were kept and a running Play In Editor session was left alone.' },
-            reloaded: { type: 'boolean', description: 'Whether this call loaded the level from disk (false when alreadyLoaded).' },
-            dirtyWorldPackagesBeforeLoad: { type: 'number', description: 'Level packages with unsaved changes when the call began, counted in every mode (it read 0 in an interactive editor).' },
-            dirtyContentPackagesBeforeLoad: { type: 'number', description: 'Asset packages with unsaved changes when the call began.' },
-            savedDirtyPackagesBeforeLoad: { type: 'boolean', description: 'Whether saveDirtyPackages saved every dirty package before the load.' },
-            unsaved: { type: 'boolean', description: 'alreadyLoaded only: whether the open level (or one of its external actor packages) still has unsaved changes after any save the call made.' },
-            unsavedPackages: { type: 'array', items: { type: 'string' }, description: 'alreadyLoaded only: the packages with unsaved changes (the first 100).' },
-            unsavedPackageCount: { type: 'number', description: 'alreadyLoaded only: how many packages have unsaved changes.' },
-        },
-        outputRequired: [],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'load', levelPath: '/Game/Maps/Demo', saveDirtyPackages: true },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'save', dispatchAction: 'save', domain: D, family: F,
-        topics: ['save level', 'save map', 'save current level', 'persist level'],
-        summary: 'Save the current level, optionally to a target path.',
-        whenToUse: ['The current level must be persisted.'],
-        whenNotToUse: ['A new path is required; use save_as instead.'],
-        inputProps: { levelPath: P.openLevelPath, savePath: { ...P.savePath, description: 'Save the open level to this /Game path instead of in place (a save-as).' } },
-        required: [],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive',
-        exampleInput: { action: 'save', levelPath: '/Game/Maps/Demo' },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'save_as', dispatchAction: 'save_level_as', domain: D, family: F,
-        summary: 'Save the current level to a new path.',
-        whenToUse: ['The current level must be saved to a new asset path.'],
-        whenNotToUse: ['No destination path is available.'],
-        inputProps: { savePath: P.savePath, levelPath: P.openLevelPath },
-        required: ['savePath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive',
-        exampleInput: { action: 'save_as', savePath: '/Game/Maps/DemoCopy' },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'save_level_as', dispatchAction: 'save_level_as', domain: D, family: F,
-        summary: 'Save the current level to a new path (alias of save_as).',
-        whenToUse: ['The current level must be saved to a new path using the save_level_as verb.'],
-        whenNotToUse: ['Prefer the shorter save_as verb.'],
-        inputProps: { savePath: P.savePath, levelPath: P.openLevelPath },
-        required: ['savePath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive',
-        exampleInput: { action: 'save_level_as', savePath: '/Game/Maps/DemoCopy' },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'create_level', dispatchAction: 'manage_level_structure',
-        domain: D, family: F,
-        topics: ['new level', 'new map', 'create map', 'empty level', 'make a new map'],
-        summary: 'Create a new level asset and load it into the editor.',
-        whenToUse: ['A brand-new level must be created and opened.'],
-        whenNotToUse: ['An existing level should be loaded instead.'],
-        inputProps: {
-            levelName: P.levelName,
-            levelPath: { ...P.levelPath, description: 'Folder the new level goes in (e.g. /Game/Maps, combined with levelName), or its full path; omitted, the level lands in /Game/Maps.' },
-            savePath: { ...P.savePath, description: 'Alias of levelPath.' },
-            useWorldPartition: P.useWorldPartition,
-            saveDirtyPackages: { ...P.saveDirtyPackages, description: 'Save every dirty level and asset package first: the new level replaces the open one. Without it, open levels with unsaved changes refuse the call with DIRTY_PACKAGES (listing them in unsavedPackages) and nothing is created.' },
-        },
-        required: ['levelName'],
-        effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'create_level', levelName: 'NewMap', useWorldPartition: false },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'delete', dispatchAction: 'delete_level', domain: D, family: F,
-        topics: ['delete level', 'delete map', 'remove level', 'delete sublevel', 'delete map file'],
-        summary: 'Delete one or more level assets from disk.',
-        whenToUse: ['A level asset must be permanently removed.'],
-        whenNotToUse: ['The level should be unloaded rather than deleted.'],
-        inputProps: { levelPath: P.levelPath, levelPaths: P.levelPaths },
-        required: ['levelPath'],
-        effect: 'destructive', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'delete', levelPath: '/Game/Maps/OldDemo' },
-        exampleOutput: { success: true, message: 'Level deleted', deletedCount: 1 },
-        outputProps: { deletedCount: { type: 'number', description: 'Number of levels successfully deleted.' } },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'delete_level', dispatchAction: 'delete_level', domain: D, family: F,
-        summary: 'Delete a level asset from disk (alias of delete).',
-        whenToUse: ['A level asset must be permanently removed using the delete_level verb.'],
-        whenNotToUse: ['Multiple levels must be deleted; use delete with levelPaths.'],
-        inputProps: { levelPath: P.levelPath, levelPaths: P.levelPaths, path: P.path },
-        required: ['levelPath'],
-        effect: 'destructive', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'delete_level', levelPath: '/Game/Maps/OldDemo' },
-        exampleOutput: { success: true, message: 'Level deleted', deletedCount: 1 },
-        outputProps: { deletedCount: { type: 'number', description: 'Number of levels successfully deleted.' } },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'rename_level', dispatchAction: 'rename', domain: D, family: F,
-        summary: 'Rename a level asset, keeping it in the same parent directory.',
-        whenToUse: ['A level asset must be renamed in place.'],
-        whenNotToUse: ['The level should be moved to a different directory; use duplicate plus delete.'],
-        inputProps: {
-            levelPath: P.levelPath, sourcePath: P.sourcePath, newName: P.newName, overwrite: P.overwrite,
-            destinationPath: { ...P.destinationPath, description: 'Full destination package path; moves the level there instead of renaming it in place (newName is then ignored).' },
-        },
-        required: [],
-        requiredOneOf: ['newName', 'destinationPath'],
-        effect: 'write', costLatency: 'interactive',
-        exampleInput: { action: 'rename_level', levelPath: '/Game/Maps/Demo', newName: 'NewDemo' },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'duplicate_level', dispatchAction: 'duplicate', domain: D, family: F,
-        summary: 'Duplicate a level asset to a new destination path.',
-        whenToUse: ['A level asset must be copied to a new path.'],
-        whenNotToUse: ['No destination path is available.'],
-        inputProps: { levelPath: P.levelPath, sourcePath: P.sourcePath, destinationPath: P.destinationPath, targetPath: P.targetPath, overwrite: P.overwrite },
-        required: ['destinationPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'duplicate_level', sourcePath: '/Game/Maps/Demo', destinationPath: '/Game/Maps/DemoCopy' },
-    }),
-];
-//# sourceMappingURL=lifecycle.data.js.map

package/dist/tools/catalog/capabilities/records/manage-level/operations-io.data.d.ts

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

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

@@ -1,32 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-import { D } from './operations-power.data.js';
-export const OPERATIONS_IO_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'export_level', dispatchAction: 'export_level',
-        domain: D, family: 'io',
-        summary: 'Export a level asset to a file.',
-        whenToUse: ['A level must be serialized to an external file.'],
-        whenNotToUse: ['The level should be saved as a new asset; use save_as.'],
-        inputProps: { levelPath: P.levelPath, exportPath: P.exportPath, destinationPath: P.destinationPath },
-        required: ['levelPath'],
-        effect: 'read', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'export_level', levelPath: '/Game/Maps/Demo', exportPath: '/Temp/Demo.export' },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'import_level', dispatchAction: 'import_level',
-        domain: D, family: 'io',
-        summary: 'Import a level asset from a package or source file.',
-        whenToUse: ['A level must be imported from an external file.'],
-        whenNotToUse: ['A new empty level is needed; use create_level.'],
-        inputProps: {
-            packagePath: P.packagePath, sourcePath: P.sourcePath,
-            destinationPath: P.destinationPath, targetPath: P.targetPath,
-            overwrite: P.overwrite,
-        },
-        required: ['packagePath'],
-        effect: 'write', costLatency: 'interactive', costResources: 'medium',
-        exampleInput: { action: 'import_level', packagePath: '/Temp/Demo.export', destinationPath: '/Game/Maps/Imported' },
-    }),
-];
-//# sourceMappingURL=operations-io.data.js.map

package/dist/tools/catalog/capabilities/records/manage-level/operations-power.data.d.ts

@@ -1,5 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const D = "level";
-export declare const NR = "Distinct manage_level operation verb and target; no cross-tool duplicate.";
-export declare const OPERATIONS_POWER_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=operations-power.data.d.ts.map

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

@@ -1,178 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-export const D = 'level';
-export const NR = 'Distinct manage_level operation verb and target; no cross-tool duplicate.';
-export const OPERATIONS_POWER_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'stream', dispatchAction: 'stream_level',
-        domain: D, family: 'streaming',
-        summary: 'Stream a level in or out of the world, controlling load and visibility state.',
-        whenToUse: ['A streaming level must be loaded, unloaded, or toggled visible.'],
-        whenNotToUse: ['The level should be permanently loaded; use load.'],
-        inputProps: {
-            levelPath: P.levelPath, levelName: P.levelName,
-            shouldBeLoaded: P.shouldBeLoaded, shouldBeVisible: P.shouldBeVisible,
-        },
-        required: ['shouldBeLoaded'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive',
-        exampleInput: { action: 'stream', levelPath: '/Game/Maps/Sub01', shouldBeLoaded: true, shouldBeVisible: true },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'unload', dispatchAction: 'stream_level',
-        domain: D, family: 'streaming',
-        summary: 'Unload a streaming level (force stream-out with load and visibility false).',
-        whenToUse: ['A streaming level must be removed from the world.'],
-        whenNotToUse: ['The level asset should be deleted; use delete.'],
-        inputProps: { levelPath: P.levelPath, levelName: P.levelName },
-        required: ['levelPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive',
-        exampleInput: { action: 'unload', levelPath: '/Game/Maps/Sub01' },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'unload_level', dispatchAction: 'unload_level',
-        domain: D, family: 'streaming',
-        summary: 'Unload a streaming level via the manage_level parent (alias of unload).',
-        whenToUse: ['A streaming level must be unloaded using the unload_level verb.'],
-        whenNotToUse: ['Prefer the shorter unload verb.'],
-        inputProps: { levelPath: P.levelPath, levelName: P.levelName },
-        required: ['levelPath'],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive',
-        exampleInput: { action: 'unload_level', levelPath: '/Game/Maps/Sub01' },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'create_light', dispatchAction: 'manage_lighting',
-        domain: D, family: 'lighting',
-        summary: 'Create a light actor in the current level.',
-        whenToUse: ['A Point, Directional, Spot, Sky, or Rect light must be added.'],
-        whenNotToUse: [
-            'A generic actor spawn is needed; use control_actor.',
-            'build_environment.create_light runs this same handler; prefer it, which carries the full light documentation.',
-            'The light must exist in the running PIE world; manage_effect.create_dynamic_light spawns into the active world.',
-        ],
-        inputProps: {
-            lightType: P.lightType, lightClass: P.lightClass, name: P.name, intensity: P.intensity, color: P.color,
-            location: P.location, rotation: P.rotation, properties: P.lightProperties,
-        },
-        required: [],
-        requiredOneOf: ['lightType', 'lightClass'],
-        effect: 'write', costLatency: 'interactive',
-        exampleInput: {
-            action: 'create_light', lightType: 'Spot', name: 'KeyLight', location: { x: 0, y: 0, z: 200 },
-            color: [1, 0.7, 0.42], properties: { castShadows: true, outerConeAngle: 40 },
-        },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'build_lighting', dispatchAction: 'manage_lighting',
-        domain: D, family: 'lighting',
-        summary: 'Build baked lighting for the current level (long-running; cannot be cancelled mid-bake).',
-        whenToUse: ['Baked lighting must be (re)computed for the level.'],
-        whenNotToUse: ['Dynamic lighting is in use and no bake is required.'],
-        inputProps: {
-            quality: P.quality,
-        },
-        required: [],
-        effect: 'write', behavior: { longRunning: true, safeToRetry: false },
-        costLatency: 'long-running', costResources: 'high',
-        exampleInput: { action: 'build_lighting', quality: 'Preview' },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'set_metadata', dispatchAction: 'set_metadata',
-        domain: D, family: 'metadata',
-        summary: 'Write metadata key/value pairs to a level asset via the shared metadata bridge route.',
-        whenToUse: ['Level asset metadata must be written.'],
-        whenNotToUse: ['The target is not a /Game level asset path.'],
-        inputProps: { levelPath: P.levelPath, assetPath: P.assetPath, metadata: P.metadata },
-        required: ['levelPath', 'metadata'],
-        effect: 'write', behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'set_metadata', levelPath: '/Game/Maps/Demo', metadata: { author: 'MCP' } },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'set_world_settings', topics: ['kill z height', 'world gravity', 'override game mode'], dispatchAction: 'set_level_world_settings',
-        domain: D, family: 'settings',
-        summary: "Set the loaded level's WorldSettings: GameMode override, kill Z, gravity, time dilation, and world bounds checks.",
-        whenToUse: ['A level needs its GameMode override or physics/world defaults set.'],
-        whenNotToUse: ['The GameMode class itself must be configured; use manage_networking.'],
-        inputProps: {
-            levelPath: P.levelPath,
-            gameMode: P.gameMode,
-            killZ: P.killZ,
-            gravityZ: P.gravityZ,
-            timeDilation: P.timeDilation,
-            enableWorldBoundsChecks: P.enableWorldBoundsChecks,
-        },
-        required: [],
-        requiredOneOf: ['gameMode', 'killZ', 'gravityZ', 'timeDilation', 'enableWorldBoundsChecks'],
-        outputProps: {
-            levelPath: P.levelPath,
-            settingsApplied: P.settingsApplied,
-            appliedSettings: P.appliedSettings,
-            gameMode: P.gameMode,
-            killZ: P.killZ,
-            gravityZ: P.gravityZ,
-            timeDilation: P.timeDilation,
-        },
-        effect: 'write', behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'set_world_settings', gameMode: '/Game/Maps/BP_RaceGameMode' },
-        exampleOutput: {
-            success: true, message: 'World settings updated (1 applied)',
-            levelPath: '/Game/Maps/Demo', settingsApplied: true, appliedSettings: ['gameMode'],
-            gameMode: '/Game/Maps/BP_RaceGameMode.BP_RaceGameMode_C', killZ: -100000, gravityZ: -980, timeDilation: 1,
-        },
-    }),
-    buildCoreRecord({
-        parentTool: 'manage_level', action: 'list_levels', dispatchAction: 'list_levels',
-        domain: D, family: 'query',
-        topics: ['all levels', 'maps in project', 'list maps', 'available levels', 'what maps exist', 'what levels exist'],
-        summary: 'List all levels available in the project.',
-        whenToUse: ['The set of available level assets must be enumerated.'],
-        whenNotToUse: ['A single level summary is needed; use get_summary.'],
-        inputProps: {},
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'list_levels' },
-        exampleOutput: {
-            success: true, message: 'Levels listed',
-            currentWorldLevels: [{ name: 'Demo', path: '/Game/Maps/Demo', isPersistent: true, isLoaded: true, isVisible: true }],
-            currentWorldLevelCount: 1,
-            allMaps: [{ name: 'Demo', path: '/Game/Maps/Demo', objectPath: '/Game/Maps/Demo.Demo' }],
-            allMapsCount: 1,
-            currentMap: 'Demo', currentMapPath: '/Game/Maps/Demo',
-        },
-        outputProps: {
-            currentWorldLevels: {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    additionalProperties: false,
-                    properties: {
-                        name: { type: 'string', description: 'Level name.' },
-                        path: { type: 'string', description: 'Level package path.' },
-                        isPersistent: { type: 'boolean', description: 'Whether this is the persistent level.' },
-                        isLoaded: { type: 'boolean', description: 'Whether the level is loaded.' },
-                        isVisible: { type: 'boolean', description: 'Whether the level is visible.' },
-                        streamingState: { type: 'string', description: 'Streaming state for streaming levels.' },
-                    },
-                },
-                description: 'Levels in the current world (persistent level plus streaming levels).',
-            },
-            currentWorldLevelCount: { type: 'number', description: 'Number of current-world level entries.' },
-            allMaps: {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    additionalProperties: false,
-                    properties: {
-                        name: { type: 'string', description: 'Map asset name.' },
-                        path: { type: 'string', description: 'Map package path.' },
-                        objectPath: { type: 'string', description: 'Full object path of the map asset.' },
-                    },
-                },
-                description: 'All World assets discovered in the asset registry.',
-            },
-            allMapsCount: { type: 'number', description: 'Number of map assets in the asset registry.' },
-            currentMap: { type: 'string', description: 'Name of the current persistent map.' },
-            currentMapPath: { type: 'string', description: 'Package path of the current persistent map.' },
-        },
-    }),
-];
-//# sourceMappingURL=operations-power.data.js.map

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

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