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

package/dist/tools/catalog/capabilities/records/inspect/stats.data.d.ts

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

package/dist/tools/catalog/capabilities/records/inspect/stats.data.js

@@ -1,91 +0,0 @@
-import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
-const D = 'inspect';
-export const STATS_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_scene_stats', dispatchAction: 'get_scene_stats', domain: D, family: 'stats',
-        editorStates: ANY_EDITOR_STATE,
-        summary: 'Return scene statistics (actor counts, component counts, etc.).',
-        whenToUse: ['Scene-level statistics must be inspected.'],
-        whenNotToUse: ['Runtime performance is needed; use get_performance_stats.'],
-        inputProps: {},
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'get_scene_stats' },
-        exampleOutput: { success: true, message: 'Scene stats', actorCount: 42 },
-        outputProps: { actorCount: { type: 'number', description: 'Level-actor count — the SAME set control_actor.list reports.' }, totalWorldActors: { type: 'number', description: 'Raw world actor count including editor-internal actors (explains the gap vs actorCount).' } },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_performance_stats', dispatchAction: 'get_performance_stats', domain: D, family: 'stats',
-        editorStates: ANY_EDITOR_STATE,
-        summary: 'Return performance statistics (frame rate, frame time, game, render and GPU thread times, actor count).',
-        whenToUse: ['Performance metrics must be inspected.'],
-        whenNotToUse: ['Scene composition is needed; use get_scene_stats.'],
-        inputProps: {},
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'get_performance_stats' },
-        exampleOutput: {
-            success: true, message: 'Performance stats', worldType: 'Editor',
-            threadTimersAreProcessGlobal: true, deltaSeconds: 0.0166, frameTimeMs: 16.6,
-            estimatedFps: 60, fps: 60, gameThreadMs: 4.2, renderThreadMs: 3.1, rhiThreadMs: 1.8,
-            gpuMs: 5.5, actorCount: 42, isBenchmarking: false, useFixedTimeStep: false,
-        },
-        outputProps: {
-            worldType: { type: 'string', description: 'World measured: "Editor", "PIE", or "None".' },
-            threadTimersAreProcessGlobal: { type: 'boolean', description: 'Thread timers are process-global, not per-world.' },
-            busiestThreadMs: { type: 'number', description: 'Slowest of game/render/GPU thread times, in milliseconds.' },
-            threadTimeDerivedFps: { type: 'number', description: 'FPS implied by busiestThreadMs; unaffected by editor idle throttling.' },
-            frameDeltaMayBeEditorThrottled: { type: 'boolean', description: 'True outside PIE, where an idle editor throttles the frame delta and makes fps read far lower than actual.' },
-            deltaSeconds: { type: 'number', description: 'Frame delta time in seconds.' },
-            frameTimeMs: { type: 'number', description: 'Frame time in milliseconds.' },
-            estimatedFps: { type: 'number', description: 'Estimated frames per second from delta time.' },
-            fps: { type: 'number', description: 'Reported frames per second (same as estimatedFps).' },
-            gameThreadMs: { type: 'number', description: 'Game thread time in milliseconds; while Play In Editor runs it also holds the editor\'s own UI and viewports, so worldTickMs is the game\'s share.' },
-            worldTickMs: { type: 'number', description: 'The measured world\'s own tick in milliseconds (actors, components and physics, from the start of its tick to the end of its tick groups), averaged over about 30 frames: the game\'s share of gameThreadMs. Absent until the world has ticked.' },
-            renderThreadMs: { type: 'number', description: 'Render thread time in milliseconds.' },
-            rhiThreadMs: { type: 'number', description: 'RHI thread time in milliseconds.' },
-            gpuMs: { type: 'number', description: 'GPU frame time in milliseconds.' },
-            actorCount: { type: 'number', description: 'Actor count of the measured world.' },
-            isBenchmarking: { type: 'boolean', description: 'Whether the engine is in benchmarking mode.' },
-            useFixedTimeStep: { type: 'boolean', description: 'Whether a fixed time step is active.' },
-        },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_memory_stats', dispatchAction: 'get_memory_stats', domain: D, family: 'stats',
-        editorStates: ANY_EDITOR_STATE,
-        summary: 'Return memory statistics (allocated, virtual, resource counts).',
-        whenToUse: ['Memory usage must be inspected.'],
-        whenNotToUse: ['Performance timing is needed; use get_performance_stats.'],
-        inputProps: {},
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'get_memory_stats' },
-        exampleOutput: {
-            success: true, message: 'Memory stats',
-            totalPhysicalBytes: 17179869184, availablePhysicalBytes: 8589934592, usedPhysicalBytes: 8589934592,
-            peakUsedPhysicalBytes: 10737418240, totalVirtualBytes: 140737488355328,
-            availableVirtualBytes: 137438953472, usedVirtualBytes: 3298534883328, peakUsedVirtualBytes: 35184372088832,
-            totalPhysicalMB: 16384, totalVirtualMB: 134217728, availablePhysicalMB: 8192, availableVirtualMB: 131072,
-            usedPhysicalMB: 8192, usedVirtualMB: 3145728, peakUsedPhysicalMB: 10240, peakUsedVirtualMB: 33554432,
-        },
-        outputProps: {
-            totalPhysicalBytes: { type: 'number', description: 'Total physical memory in bytes.' },
-            availablePhysicalBytes: { type: 'number', description: 'Available physical memory in bytes.' },
-            usedPhysicalBytes: { type: 'number', description: 'Used physical memory in bytes.' },
-            peakUsedPhysicalBytes: { type: 'number', description: 'Peak used physical memory in bytes.' },
-            totalVirtualBytes: { type: 'number', description: 'Total virtual memory in bytes.' },
-            availableVirtualBytes: { type: 'number', description: 'Available virtual memory in bytes.' },
-            usedVirtualBytes: { type: 'number', description: 'Used virtual memory in bytes.' },
-            peakUsedVirtualBytes: { type: 'number', description: 'Peak used virtual memory in bytes.' },
-            totalPhysicalMB: { type: 'number', description: 'Total physical memory in megabytes.' },
-            totalVirtualMB: { type: 'number', description: 'Total virtual memory in megabytes.' },
-            availablePhysicalMB: { type: 'number', description: 'Available physical memory in megabytes.' },
-            availableVirtualMB: { type: 'number', description: 'Available virtual memory in megabytes.' },
-            usedPhysicalMB: { type: 'number', description: 'Used physical memory in megabytes.' },
-            usedVirtualMB: { type: 'number', description: 'Used virtual memory in megabytes.' },
-            peakUsedPhysicalMB: { type: 'number', description: 'Peak used physical memory in megabytes.' },
-            peakUsedVirtualMB: { type: 'number', description: 'Peak used virtual memory in megabytes.' },
-        },
-    }),
-];
-//# sourceMappingURL=stats.data.js.map

package/dist/tools/catalog/capabilities/records/manage-asset/asset-advanced.d.ts

@@ -1,3 +0,0 @@
-import type { RecordSpec } from './builder.js';
-export declare const ASSET_ADVANCED_RECORDS: readonly RecordSpec[];
-//# sourceMappingURL=asset-advanced.d.ts.map

package/dist/tools/catalog/capabilities/records/manage-asset/asset-advanced.js

@@ -1,185 +0,0 @@
-import { arr, arrObj, bool, DESTRUCTIVE, DESTRUCTIVE_POLICY, ex, HIGH, LOW, MEDIUM, NON_IDEMPOTENT, num, r, READ, READ_POLICY, str, WRITE, WRITE_POLICY } from './builder.js';
-import { schema } from '../shared/record-presets.js';
-const ASSET_PATH = str('Canonical /Game asset path.');
-const OK = schema({ success: bool('Operation succeeded.'), details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' } }, ['success']);
-const MESH_MATERIAL_ENTRY = {
-    type: 'object',
-    properties: {
-        slot: { type: ['integer', 'string'], description: 'The slot to set: its 0-based index (9) or its slot name ("hull"), as inspect_object objectKind=mesh lists them under materialSlots.' },
-        materialPath: str('Material or material instance asset path, e.g. /Game/Materials/M_Hull. It must load: a path that does not is refused, never swapped for a default material.'),
-    },
-    required: ['slot', 'materialPath'],
-    additionalProperties: false,
-};
-const MESH_MATERIALS_OUT = schema({
-    success: bool('Operation succeeded.'),
-    assetPath: ASSET_PATH,
-    assetType: str('StaticMesh or SkeletalMesh.'),
-    materialSlots: arrObj('Every slot of the mesh after the call, each {slotIndex, slotName, material (the asset path the slot holds, empty for none), changed (true when this call changed it)}.'),
-    applied: num('Entries that were valid and applied.'),
-    changed: num('Slots whose material this call changed; an entry that names the material a slot already holds changes nothing.'),
-    refused: arrObj('Entries that were refused, each {index (its position in materials), slot (as given), materialPath, code, reason}: a slot index out of range, an unknown slot name, a material that does not load. A refused entry changes nothing, the call fails (MATERIAL_SLOTS_PARTIAL, or MATERIAL_SLOTS_REFUSED when no entry was valid) and the valid entries stay applied.'),
-    saved: bool('Whether the mesh was saved.'),
-    saveSkippedReason: str('Why nothing was saved: save was false, or the mesh is engine content, which is never written.'),
-    details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' },
-}, ['success']);
-export const ASSET_ADVANCED_RECORDS = [
-    r('create_render_target', 'asset', 'Create a render target texture asset.', schema({ name: str('Render target name.'), packagePath: str('Package path (default /Game/Textures).'), renderTargetPath: str('Full asset path, e.g. /Game/RenderTargets/RT_Capture; replaces name and packagePath.'), width: num('Width in pixels.'), height: num('Height in pixels.'), format: str('Pixel format.'), save: bool('Save after creation. Defaults to true.') }, [], ['name', 'renderTargetPath']), OK, WRITE, WRITE_POLICY, MEDIUM, { dispatchAction: 'manage_texture',
-        topics: ['make render target'],
-        whenToUse: [
-            'A scene capture, or a Blueprint that draws to a texture, needs a render target asset to render into.',
-            'A render target of a chosen size and pixel format must exist at a /Game path; one already there is reported, not replaced.',
-        ],
-        whenNotToUse: [
-            'A capture actor must be pointed at a target or re-captured (use build_environment.configure_scene_capture).',
-            'A texture with generated pixels such as a gradient or noise is wanted (use texture.create_texture).',
-        ],
-        examples: [ex('Create a 1024x1024 HDR render target', { name: 'RT_SceneCapture', packagePath: '/Game/RenderTargets', width: 1024, height: 1024, format: 'RTF_RGBA16f', save: true }, { success: true })] }),
-    r('generate_lods', 'asset', 'Generate LOD levels for a static mesh asset.', schema({ assetPath: ASSET_PATH, assetPaths: arr('Several asset paths to process in one call.'), lodCount: num('Number of LOD levels to generate (1-50, default 4).') }, [], ['assetPath', 'assetPaths']), OK, { ...WRITE, longRunning: true }, WRITE_POLICY, HIGH, { whenToUse: ['One or several static meshes need LOD levels generated so distant copies render cheaper.'],
-        whenNotToUse: [
-            'LOD reduction settings or screen sizes must be tuned by hand (use manage_geometry.configure_mesh_lods).',
-            'The mesh should use Nanite instead of discrete LODs (use asset.nanite_rebuild_mesh).',
-        ],
-        examples: [ex('Generate four LODs for a prop', { assetPath: '/Game/Meshes/SM_Crate', lodCount: 4 }, { success: true })] }),
-    r('set_mesh_materials', 'asset', 'Set the materials in the slots of a static or skeletal mesh asset, by slot index or slot name, so every placement of the mesh shows them.', schema({
-        assetPath: ASSET_PATH,
-        materials: {
-            type: 'array', minItems: 1, items: MESH_MATERIAL_ENTRY,
-            description: 'The slots to set, one entry per slot: [{slot, materialPath}]. slot is a 0-based index or a slot name (inspect_object objectKind=mesh lists both under materialSlots). Every entry is checked first. One that is refused (index out of range, unknown slot name, a material that does not load) is named under refused and fails the call, while the valid entries are applied together in a single rebuild of the mesh.',
-        },
-        save: bool('Save the mesh after the change. Defaults to true.'),
-    }, ['assetPath', 'materials']), MESH_MATERIALS_OUT, WRITE, WRITE_POLICY, MEDIUM, { topics: ['set mesh materials', 'assign materials to a static mesh', 'mesh material slots', 'skeletal mesh materials', 'imported mesh grid material', 'materials on a mesh asset'],
-        whenToUse: [
-            'An imported mesh came in with every slot on the default grid material and each slot needs its own material, once for every placement of the mesh.',
-            'Several slots of a static or skeletal mesh asset get their materials in one call, by index or by slot name.',
-        ],
-        whenNotToUse: [
-            'Only one placed actor must look different from its mesh (use control_actor.set_material, which overrides a component and leaves the asset alone).',
-            'It is not known yet which slot holds which part of the mesh (inspect.inspect_object with objectKind=mesh lists every slot with the triangle count and bounds of its geometry).',
-        ],
-        examples: [ex('Give an imported mesh its own materials, one slot by name and one by index', { assetPath: '/Game/Meshes/SM_Rider', materials: [{ slot: 'hull', materialPath: '/Game/Materials/M_Hull' }, { slot: 9, materialPath: '/Game/Materials/M_Claw' }] }, { success: true, assetPath: '/Game/Meshes/SM_Rider', assetType: 'StaticMesh', applied: 2, changed: 2, refused: [], saved: true })] }),
-    r('set_mesh_collision', 'asset', 'Set the collision of a static mesh asset: one box, sphere or capsule fitted to its bounds, its own render triangles (complex), or none; every placed copy is rebuilt to match and the mesh is saved.', schema({
-        assetPath: str('Static mesh asset path under /Game; engine meshes are refused (duplicate one into /Game first).'),
-        collisionType: { type: 'string', enum: ['box', 'sphere', 'capsule', 'complex', 'none'], description: 'box, sphere or capsule: one shape fitted to the mesh bounds (a capsule stands upright along Z) replaces its simple collision. complex: the render triangles are the collision, exact for terrain-like or concave meshes but costlier. none: no collision, so pawns and traces pass through.' },
-        save: bool('Save the mesh after the change. Defaults to true.'),
-    }, ['assetPath', 'collisionType']), schema({
-        success: bool('Operation succeeded.'),
-        assetPath: ASSET_PATH,
-        collisionType: str('The collision the mesh has now.'),
-        shapeCount: num('Simple collision shapes the mesh holds after the call (0 for complex and none).'),
-        componentsRefreshed: num('Placed copies of the mesh in open worlds whose collision was rebuilt to match.'),
-        saved: bool('Whether the mesh was saved.'),
-        details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' },
-    }, ['success']), WRITE, WRITE_POLICY, MEDIUM, { topics: ['mesh collision', 'static mesh collision', 'add box collision', 'complex as simple', 'remove collision', 'player falls through mesh', 'walk on imported mesh'],
-        whenToUse: [
-            'An imported or Fab mesh has no simple collision, so pawns fall through it or walk through it.',
-            'A decorative mesh (grass, flowers, small debris) must stop blocking the player.',
-            'A terrain-like or concave mesh must collide exactly with its own triangles (complex).',
-        ],
-        whenNotToUse: [
-            'A dynamic mesh actor needs collision generated (use manage_geometry.configure_mesh_collision).',
-            'Only one placed copy should stop colliding (use control_actor.set_actor_collision).',
-            'It must be checked whether a placed mesh blocks at all (use inspect.raycast_world).',
-        ],
-        examples: [ex('Make an imported rock standable with one box', { assetPath: '/Game/Meshes/SM_Rock', collisionType: 'box' }, { success: true, assetPath: '/Game/Meshes/SM_Rock', collisionType: 'box', shapeCount: 1, componentsRefreshed: 3, saved: true })] }),
-    r('export_mesh', 'asset', 'Export a static or skeletal mesh asset (or an animation sequence, on its preview mesh) to a file through the editor\'s own exporters: glb (default: one self-contained glTF binary), gltf (JSON with its buffers and textures beside it), fbx or obj. It is written under Saved/Exports unless outputPath says otherwise; the reply gives the path, the size, the files written beside it and any exporter warnings.', schema({
-        assetPath: str('Asset to export, e.g. /Game/Meshes/SM_Rock or /Engine/BasicShapes/Cube. A skeletal mesh is written with its skeleton; an animation sequence is written on its skeleton\'s preview mesh.'),
-        format: { type: 'string', enum: ['glb', 'gltf', 'fbx', 'obj'], description: 'File format; default glb, or the extension outputPath ends in. glb and gltf are scaled to meters with materials converted to glTF PBR; fbx and obj keep centimeters.' },
-        outputPath: str('Where to write, inside the project, project-relative or absolute: a file (Saved/Exports/Rocks/SM_Rock.glb) or a folder, which gets <asset name>.<format>. A file already there is replaced.'),
-    }, ['assetPath']), schema({
-        success: bool('Operation succeeded.'),
-        assetPath: str('The asset exported.'),
-        format: str('The format written.'),
-        path: str('Absolute path of the file written.'),
-        bytes: num('Its size in bytes.'),
-        otherFiles: arrObj('Files the export wrote beside it, each {name, bytes}: a gltf\'s .bin buffers and textures, obj\'s UV and collision variants.'),
-        details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' },
-    }, ['success']), READ, READ_POLICY, MEDIUM, { topics: ['export mesh', 'export gltf', 'export glb', 'export fbx', 'export obj', 'save mesh to file', 'mesh to blender', 'export model'],
-        whenToUse: [
-            'A mesh must leave the editor as a file: for Blender or another DCC tool, a web viewer, a mesh checker or a 3D printer.',
-            'An animation must be looked at or checked outside Unreal (export the sequence as glb).',
-        ],
-        whenNotToUse: [
-            'A file must come into the project (use asset.import).',
-            'Only the mesh\'s soundness must be checked (use inspect.check_mesh, which needs no file).',
-        ],
-        examples: [ex('Export a mesh as glTF binary', { assetPath: '/Engine/BasicShapes/Cube' }, { success: true, assetPath: '/Engine/BasicShapes/Cube.Cube', format: 'glb', path: 'X:/Games/MyGame/Saved/Exports/Cube.glb', bytes: 41764 })] }),
-    r('add_material_parameter', 'asset', 'Add a parameter to a material.', schema({ assetPath: str('Material asset path.'), parameterName: str('Parameter name.'), parameterType: str('Parameter type.'), value: { description: 'Parameter value.' } }, ['assetPath', 'parameterName']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A new scalar, vector, texture or static-switch parameter must be introduced on a material or material function.'],
-        whenNotToUse: [
-            'An existing parameter needs a new value on a material instance (use material.set_material_parameter).',
-            'Another kind of node must be added to the material graph (use material.add_material_node).',
-        ],
-        examples: [ex('Add a scalar roughness parameter', { assetPath: '/Game/Materials/M_Base', parameterName: 'Roughness', parameterType: 'Scalar', value: 0.4 }, { success: true })] }),
-    r('list_instances', 'asset', 'List material instances using a parent material.', schema({ assetPath: str('Material asset path.') }, ['assetPath']), OK, READ, READ_POLICY, LOW, { examples: [ex('List instances of a parent material', { assetPath: '/Game/Materials/M_Base' }, { success: true })] }),
-    r('reset_instance_parameters', 'asset', 'Reset all parameter overrides on a material instance.', schema({ assetPath: str('Material instance asset path.') }, ['assetPath']), OK, WRITE, WRITE_POLICY, LOW, { whenToUse: ['A material instance must return to its parent\'s values by dropping every parameter override.'],
-        whenNotToUse: [
-            'Only some overrides need new values (use material.set_material_parameter).',
-            'A fresh instance of the parent is wanted instead (use material.create_material_instance).',
-        ],
-        examples: [ex('Drop every override on an instance', { assetPath: '/Game/Materials/MI_Base_Rusty' }, { success: true })] }),
-    r('exists', 'asset', 'Check whether an asset exists at a given path, or which of several do.', schema({ assetPath: ASSET_PATH, assetPaths: arr('Several asset paths checked in one call; the reply maps each to true or false under existsByPath.') }, [], ['assetPath', 'assetPaths']), OK, READ, READ_POLICY, LOW, { topics: ['asset exists', 'does asset exist', 'check asset', 'path exists'], dispatchAction: 'exists',
-        whenToUse: ['A path must be tested for an asset, or several paths at once, before creating, importing or referencing one.'],
-        whenNotToUse: ['A folder\'s contents must be browsed rather than one path tested (use asset.list).'],
-        examples: [ex('Probe for an asset before creating it', { assetPath: '/Game/Meshes/SM_Crate' }, { success: true })] }),
-    r('get_material_stats', 'asset', 'Retrieve rendering statistics for a material.', schema({ assetPath: str('Material asset path.') }, ['assetPath']), OK, READ, READ_POLICY, LOW, { whenToUse: ['A material\'s shading model, blend mode, domain, node and parameter counts, or the input pins its Main result node accepts, must be read.'],
-        whenNotToUse: ['The individual nodes of a material and their connections are needed (use material.get_material_info).'],
-        examples: [ex('Read instruction counts for a material', { assetPath: '/Game/Materials/M_Base' }, { success: true })] }),
-    r('nanite_rebuild_mesh', 'asset', 'Turn Nanite on for a static mesh asset and set the share of its triangles Nanite keeps; the mesh is rebuilt and saved, and the reply reads naniteEnabled and trianglePercent back from it.', schema({ assetPath: str('Static mesh asset path.'), trianglePercent: num('Percent of the source triangles Nanite keeps, 0-100 (default 100).') }, ['assetPath']), OK, { ...WRITE, longRunning: true }, WRITE_POLICY, HIGH, { dispatchAction: 'manage_render',
-        whenToUse: ['A static mesh needs Nanite enabled, or the percentage of triangles Nanite keeps changed.'],
-        whenNotToUse: [
-            'A dynamic mesh must be baked into a new Nanite static mesh asset (use manage_geometry.convert_to_nanite).',
-            'Plain LOD levels are wanted for a mesh that will not use Nanite (use asset.process_asset with process=lods).',
-        ],
-        examples: [ex('Rebuild Nanite data after a mesh edit', { assetPath: '/Game/Meshes/SM_Rock' }, { success: true })] }),
-    r('bulk_rename', 'asset', 'Rename multiple assets in one call: by a pattern (search/replace, prefix, suffix) over a folder or a list, or to explicit new names with renames.', schema({
-        folderPath: str('Folder path for bulk operation.'), assetPaths: arr('Explicit asset paths.'), searchText: str('Search pattern.'), pattern: str('Search pattern (used when searchText is absent).'), replaceText: str('Replacement text.'), replacement: str('Replacement text (used when replaceText is absent).'), prefix: str('Name prefix.'), suffix: str('Name suffix.'), checkoutFiles: bool('Check out files in source control.'),
-        renames: {
-            type: 'array',
-            description: 'Explicit renames, each asset to its own new name in its own folder, all in this one call: [{sourcePath, newName}]. An entry whose asset is missing, or whose newName is taken, is skipped and named under skipped. Replaces the pattern fields.',
-            items: { type: 'object', properties: { sourcePath: str('Asset to rename.'), newName: str('New asset name (no folder).') }, required: ['sourcePath', 'newName'], additionalProperties: false },
-        },
-    }, [], ['assetPaths', 'folderPath', 'renames']), OK, NON_IDEMPOTENT, WRITE_POLICY, MEDIUM, { dispatchAction: 'bulk_rename',
-        whenToUse: [
-            'A naming convention must be enforced across a folder or a list, such as swapping a prefix or adding a suffix to every asset.',
-            'Several unrelated assets must each get a specific new name in one call (the renames list).',
-        ],
-        whenNotToUse: ['One asset or one folder gets a new name (use asset.rename).'],
-        examples: [ex('Re-prefix every mesh in a folder', { folderPath: '/Game/Meshes', searchText: 'Mesh_', replaceText: 'SM_', checkoutFiles: true }, { success: true })] }),
-    r('bulk_delete', 'asset', 'Delete multiple assets by folder or explicit paths.', schema({ folderPath: str('Folder path for bulk operation.'), assetPaths: arr('Explicit asset paths to delete.'), fixupRedirectors: bool('Default true. After a delete that removed something, resolve the redirectors that already exist in the folders the assets were deleted from, subfolders included: their referencers are re-pointed and re-saved, then the redirectors nothing points at any more are removed. Deleting creates no redirectors, so this only cleans older ones.') }, [], ['assetPaths', 'folderPath']), OK, DESTRUCTIVE, DESTRUCTIVE_POLICY, HIGH, { dispatchAction: 'bulk_delete',
-        whenToUse: [
-            'Every asset under a folder, or a long list of assets, must be deleted in one call.',
-            'Old redirectors in the folders the assets are deleted from must be resolved in the same call (on by default).',
-        ],
-        whenNotToUse: [
-            'Assets that other assets still use must be kept, with the blocked ones reported (use asset.delete).',
-            'The folder itself must be removed as well as its assets (use asset.delete with the folder path).',
-        ],
-        examples: [ex('Delete two obsolete assets and clean redirectors', { assetPaths: ['/Game/MCPTest/OldA', '/Game/MCPTest/OldB'], fixupRedirectors: true }, { success: true })] }),
-    r('source_control_checkout', 'asset', 'Check out assets in source control.', schema({ assetPath: ASSET_PATH, paths: arr('Asset paths to check out.') }, []), OK, WRITE, WRITE_POLICY, MEDIUM, { dispatchAction: 'source_control_checkout',
-        whenToUse: ['Assets must be checked out of revision control before they are edited.'],
-        whenNotToUse: ['The checked-out or modified state of assets is wanted (use asset.query_asset for source control state).'],
-        examples: [ex('Check out two materials before editing', { paths: ['/Game/Materials/M_Base', '/Game/Materials/M_Trim'] }, { success: true })] }),
-    r('source_control_submit', 'asset', 'Submit checked-out assets to source control.', schema({ assetPath: ASSET_PATH, paths: arr('Asset paths to submit.'), description: str('Submit description.') }, ['description']), OK, WRITE, WRITE_POLICY, MEDIUM, { dispatchAction: 'source_control_submit',
-        whenToUse: ['Checked-out assets must be submitted to the revision-control server with a change description.'],
-        whenNotToUse: [
-            'Unsaved editor changes must reach disk first (use control_editor.save_all).',
-            'Every change in the project is wanted as one Git snapshot, without listing assets (use sourceControlOp=commit_all).',
-        ],
-        examples: [ex('Submit the edited materials', { paths: ['/Game/Materials/M_Base'], description: 'Retune base material roughness' }, { success: true })] }),
-    r('source_control_enable', 'asset', 'Enable revision control and select the provider (Git, Perforce, Subversion...).', schema({ provider: str('Provider name as the editor registers it, e.g. Git or Perforce. Omit to report the current provider without changing it.') }, []), OK, WRITE, WRITE_POLICY, MEDIUM, { dispatchAction: 'source_control_enable',
-        whenToUse: ['A revision-control provider such as Git or Perforce must be selected before checkout or submit can work.'],
-        whenNotToUse: ['Only the state of particular assets is wanted (use asset.query_asset for source control state).'],
-        examples: [ex('Point the editor at the Git provider', { provider: 'Git' }, { success: true, provider: 'Git' })] }),
-    r('source_control_init', 'asset', 'Create a repository for this project, write an Unreal .gitignore, make the first commit and select the Git provider.', schema({ description: str('First commit message. Defaults to "Initial commit".'), userName: str('Commit author name, written to the repository config only.'), userEmail: str('Commit author email, written to the repository config only.') }, []), OK, { ...WRITE, longRunning: true }, WRITE_POLICY, HIGH, { dispatchAction: 'source_control_init',
-        whenToUse: ['A project with no repository needs one, with an Unreal .gitignore and a first commit, in one call.'],
-        whenNotToUse: ['A Perforce or Subversion provider is wanted; init builds only a Git repository (select the provider with sourceControlOp=enable).'],
-        examples: [ex('Put a fresh project under revision control', { description: 'Initial commit', userName: 'Dev', userEmail: 'dev@example.com' }, { success: true, committed: true })] }),
-    r('source_control_commit_all', 'asset', 'Stage every change in the project and commit it as a snapshot.', schema({ description: str('Commit message.'), userName: str('Commit author name, written to the repository config only.'), userEmail: str('Commit author email, written to the repository config only.') }, ['description']), OK, { ...WRITE, longRunning: true }, WRITE_POLICY, HIGH, { dispatchAction: 'source_control_commit_all',
-        whenToUse: ['A snapshot of every change in the project is wanted as one commit, for example after a batch of edits.'],
-        whenNotToUse: [
-            'Unsaved editor changes must reach disk first (use control_editor.save_all).',
-            'Only chosen assets must go in, or the project uses Perforce or Subversion (use sourceControlOp=submit).',
-        ],
-        examples: [ex('Snapshot the project after a batch of edits', { description: 'Roster pass: 12 distinct brawler kits' }, { success: true, committed: true })] })
-];
-//# sourceMappingURL=asset-advanced.js.map

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

@@ -1,3 +0,0 @@
-import type { RecordSpec } from './builder.js';
-export declare const ASSET_LIFECYCLE_RECORDS: readonly RecordSpec[];
-//# sourceMappingURL=asset-lifecycle.d.ts.map

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

@@ -1,136 +0,0 @@
-import { arr, arrObj, bool, boundedLimit, boundedPagination, DESTRUCTIVE, DESTRUCTIVE_POLICY, ex, HIGH, LOW, MEDIUM, NON_IDEMPOTENT, num, READ, READ_POLICY, r, str, WRITE, WRITE_POLICY } from './builder.js';
-import { schema } from '../shared/record-presets.js';
-const SOURCE_PATH = str('Source filesystem path for import.');
-const DEST_PATH = str('Destination /Game asset path.');
-const PAGINATED_OUTPUT = schema({
-    success: bool('Operation succeeded.'),
-    assets: arrObj('Matched assets on this page.'),
-    folders: arr('Subfolder paths.'),
-    totalCount: num('Total matched count before pagination.'),
-    count: num('Asset count on this page.'),
-    limit: num('Applied page size.'),
-    offset: num('Applied zero-based offset.'),
-    hasMore: bool('True when more results exist beyond the current page.'),
-    nextOffset: num('Next-page offset.'),
-    cursor: { type: ['string', 'null'], description: 'Opaque cursor for the current page, or null when the page was requested without one.' },
-    nextCursor: { type: ['string', 'null'], description: 'Opaque cursor for the next page, or null on the last page.' }
-}, ['success']);
-const OK_OUTPUT = schema({ success: bool('Operation succeeded.'), details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' } }, ['success']);
-export const ASSET_LIFECYCLE_RECORDS = [
-    r('list', 'asset', 'List assets under a /Game path with bounded pagination and opaque cursor continuation.', schema({
-        path: { type: 'string', default: '/Game', description: 'Canonical /Game path to list.' },
-        limit: boundedLimit(500, 50),
-        offset: num('Zero-based offset into the full result set.'),
-        pagination: boundedPagination(500, 50),
-        cursor: str('Opaque pagination cursor returned by a previous list response. Forward verbatim to resume.'),
-        recursive: bool('Include the assets of every subfolder (default true); false lists only this folder\'s own assets, its subfolders still named under folders.'),
-        depth: num('Maximum recursion depth.'),
-        includeTags: bool('When true, include asset tags in the listing response.'),
-        includeMetadata: bool('When true, include the file size and modification date of each asset.'),
-        filter: str('Substring filter. Listing assets: a case-insensitive match on the asset name. Listing content sources: a case-sensitive match on the source id and, for plugins, the category.')
-    }, ['path']), PAGINATED_OUTPUT, READ, READ_POLICY, MEDIUM, { topics: ['list assets', 'browse folder', 'content browser', 'assets in folder', 'directory listing', 'folder contents'], dispatchAction: 'list', examples: [ex('List first page', { path: '/Game' }, { success: true, assets: [], hasMore: false, nextCursor: null })] }),
-    r('import', 'asset', 'Import an asset from a filesystem source into the project content hierarchy.', schema({ sourcePath: SOURCE_PATH, destinationPath: DEST_PATH, overwrite: bool('Replace an asset already sitting at the destination. Needed for an FBX animation import, which otherwise refuses rather than let the editor reimport the old asset with its own stored settings.'), save: bool('Save the imported asset. Defaults to true; pass false to keep it in memory only.'), importAnimations: bool('Import animation takes from an FBX. Off by default, which imports mesh only.'), skeletonPath: str('Existing skeleton to import the take against, e.g. /Game/Chars/SK_Hero_Skeleton. Set it to import the animation ALONE; omit it to import mesh and animation together. Implies importAnimations.') }, ['sourcePath', 'destinationPath']), OK_OUTPUT, WRITE, WRITE_POLICY, MEDIUM, { aliases: ['asset.import_asset'], topics: ['import fbx', 'import file', 'import mesh', 'import texture', 'import obj', 'import png', 'import wav', 'import sound file', 'import audio file', 'bring file into project', 'import animation', 'import mocap', 'fbx animation', 'import anim sequence', 'import mp3', 'import 3d model', 'add file to project', 'import image'],
-        whenToUse: [
-            'A source file inside the project folder (FBX, OBJ, PNG, WAV) must become an asset at a /Game path.',
-            'An FBX animation take must be imported onto an existing skeleton without importing the mesh again.',
-        ],
-        whenNotToUse: [
-            'The content is a Fab listing or a downloaded Megascans pack (use asset.import_marketplace_asset with marketplace=fab_listing or megascans).',
-            'Ready-made assets from an engine template, plugin or downloaded pack must be copied in as they are (use asset.maintain_content with maintenance=migrate).',
-        ],
-        examples: [ex('Import FBX', { sourcePath: '/tmp/mesh.fbx', destinationPath: '/Game/Imports/Mesh' }, { success: true }), ex('Import a mocap take onto an existing skeleton', { sourcePath: '/Game/../Imports/Mocap.fbx', destinationPath: '/Game/Anims/A_Mocap', importAnimations: true, skeletonPath: '/Game/Chars/SK_Hero_Skeleton' }, { success: true })] }),
-    r('duplicate', 'asset', 'Duplicate an existing asset to a new path.', schema({ sourcePath: str('Source /Game asset path.'), destinationPath: DEST_PATH, newName: str('New asset name.') }, ['sourcePath']), OK_OUTPUT, WRITE, WRITE_POLICY, MEDIUM, { topics: ['copy asset', 'clone asset', 'copy material', 'copy texture', 'duplicate material', 'duplicate blueprint', 'duplicate data table', 'make copy of asset', 'copy asset to another folder'],
-        whenToUse: [
-            'An asset needs a copy to edit safely while the original stays unchanged.',
-            'A whole folder must be copied with its sub-folders and every asset in it.',
-        ],
-        whenNotToUse: [
-            'The asset keeps its identity but changes name or folder (use asset.rename or asset.move).',
-            'A variant of a material with different parameter values is wanted, without copying its graph (use material.create_material_instance).',
-        ],
-        examples: [ex('Duplicate a material', { sourcePath: '/Game/Materials/M_Base', destinationPath: '/Game/Materials', newName: 'M_Base_Variant' }, { success: true })] }),
-    r('duplicate_asset', 'asset', 'Long-form alias for duplicate.', schema({ sourcePath: str('Source /Game asset path.'), destinationPath: DEST_PATH, newName: str('New asset name.') }, ['sourcePath']), OK_OUTPUT, WRITE, WRITE_POLICY, MEDIUM, {
-        examples: [ex('Duplicate via the long-form alias', { sourcePath: '/Game/Materials/M_Base', destinationPath: '/Game/Materials', newName: 'M_Base_Variant' }, { success: true })]
-    }),
-    r('rename', 'asset', 'Rename an existing asset, or a whole folder, in place; settings that point at it follow.', schema({ sourcePath: str('Source /Game asset path, or a folder: a folder is renamed with everything under it.'), destinationPath: DEST_PATH, newName: str('New asset name.') }, ['sourcePath']), OK_OUTPUT, NON_IDEMPOTENT, WRITE_POLICY, MEDIUM, { topics: ['rename asset'],
-        whenToUse: [
-            'An asset needs a new name in its own folder; settings that point at it (default map, game mode) follow.',
-            'A folder must get a new name and every asset under it must go along.',
-        ],
-        whenNotToUse: [
-            'Many assets need new names by pattern, prefix, suffix or a list (use asset.maintain_content with maintenance=bulk_rename).',
-            'A copy under a new name is wanted, with the original kept (use asset.duplicate).',
-        ],
-        examples: [ex('Rename a mesh in place', { sourcePath: '/Game/Meshes/SM_Crate', newName: 'SM_Crate_Large' }, { success: true })] }),
-    r('rename_asset', 'asset', 'Long-form alias for rename.', schema({ sourcePath: str('Source /Game asset path.'), destinationPath: DEST_PATH, newName: str('New asset name.') }, ['sourcePath']), OK_OUTPUT, NON_IDEMPOTENT, WRITE_POLICY, MEDIUM, {
-        examples: [ex('Rename via the long-form alias', { sourcePath: '/Game/Meshes/SM_Crate', newName: 'SM_Crate_Large' }, { success: true })]
-    }),
-    r('move', 'asset', 'Move an asset, or a whole folder, to a new path; references and settings that point at it follow.', schema({ sourcePath: str('Source /Game asset path, or a folder: everything under it moves into destinationPath, keeping sub-folders, and the emptied folder is removed.'), destinationPath: DEST_PATH, newName: str('Rename in place instead: the asset keeps its folder and takes this name (used when destinationPath is omitted).') }, ['sourcePath']), OK_OUTPUT, NON_IDEMPOTENT, WRITE_POLICY, MEDIUM, { topics: ['move asset', 'relocate asset', 'move folder', 'rename folder'],
-        whenToUse: [
-            'An asset must go to another folder; references and project settings (default map, game mode) that point at it follow.',
-            'A whole content folder must relocate with its sub-folders; its redirectors are resolved and the emptied source folder is removed.',
-        ],
-        whenNotToUse: [
-            'Only the name changes and the asset stays in its folder (use asset.rename).',
-            'The asset must be copied and the original left in place (use asset.duplicate).',
-        ],
-        examples: [
-            ex('Move a texture into a subfolder', { sourcePath: '/Game/Textures/T_Rock', destinationPath: '/Game/Textures/Terrain/T_Rock' }, { success: true }),
-            ex('Move a whole game folder', { sourcePath: '/Game/OldGame', destinationPath: '/Game/NewGame' }, { success: true }),
-        ] }),
-    r('delete', 'asset', 'Permanently delete one or more assets after explicit confirmation.', schema({ paths: arr('Asset paths to delete.'), path: str('Single asset path (alternative to paths).'), assetPath: str('Alias for path (accepted for compatibility).'), force: bool('Delete an asset even when assets outside this delete still reference it (their references break). Default false: such an asset is kept and listed in referencedPaths. Folders are always deleted whole.') }, []), OK_OUTPUT, DESTRUCTIVE, DESTRUCTIVE_POLICY, HIGH, { topics: ['delete asset', 'remove asset', 'destroy asset'],
-        whenToUse: [
-            'One or several assets, or a whole folder, must be removed from the project for good.',
-            'An asset should go only if nothing else uses it; a still-referenced asset is kept and reported.',
-        ],
-        whenNotToUse: [
-            'A placed actor must leave the open level, not its asset (use inspect.delete_object).',
-            'The assets under a folder must go while the folder stays, with old redirectors there resolved in the same call (use asset.bulk_delete).',
-        ],
-        examples: [ex('Delete one asset', { paths: ['/Game/MCPTest/Disposable'] }, { success: true })] }),
-    r('delete_asset', 'asset', 'Long-form alias for delete.', schema({ paths: arr('Asset paths to delete.'), path: str('Single asset path.'), assetPath: str('Alias for path (accepted for compatibility).'), force: bool('Delete an asset even when assets outside this delete still reference it (their references break). Default false: such an asset is kept and listed in referencedPaths. Folders are always deleted whole.') }, []), OK_OUTPUT, DESTRUCTIVE, DESTRUCTIVE_POLICY, HIGH, {
-        examples: [ex('Delete a single asset by path', { path: '/Game/MCPTest/Disposable' }, { success: true })]
-    }),
-    r('delete_assets', 'asset', 'Plural-form alias for delete.', schema({ paths: arr('Asset paths to delete.'), path: str('Single asset path.'), assetPath: str('Alias for path (accepted for compatibility).'), force: bool('Delete an asset even when assets outside this delete still reference it (their references break). Default false: such an asset is kept and listed in referencedPaths. Folders are always deleted whole.') }, []), OK_OUTPUT, DESTRUCTIVE, DESTRUCTIVE_POLICY, HIGH, {
-        examples: [ex('Delete several assets in one call', { paths: ['/Game/MCPTest/DisposableA', '/Game/MCPTest/DisposableB'] }, { success: true })]
-    }),
-    r('create_folder', 'asset', 'Create a new content-browser folder under a /Game path.', schema({ path: str('Folder path (must start with /).') }, ['path']), OK_OUTPUT, WRITE, WRITE_POLICY, LOW, { topics: ['make folder', 'new folder', 'create directory'],
-        whenToUse: [
-            'A new empty folder is wanted in the content browser, for example to organise assets before moving them in.',
-            'A folder must be ensured at a path without knowing whether it exists; alreadyExisted in the reply says which it was.',
-        ],
-        whenNotToUse: [
-            'An existing folder must change name or location (use asset.rename or asset.move).',
-            'The folder exists and its contents must be seen (use asset.list).',
-        ],
-        examples: [ex('Create folder', { path: '/Game/NewFolder' }, { success: true })] }),
-    r('search_assets', 'asset', 'Find or search assets by text, class, or package path with bounded pagination.', schema({
-        searchText: str('Text to search for.'),
-        classNames: arr('Asset classes to filter: a short class name (StaticMesh, Blueprint, ObjectRedirector, InputMappingContext) or a full class path (/Script/Engine.StaticMesh).'),
-        packagePaths: arr('Package paths to search within.'),
-        recursivePaths: bool('Recurse into subdirectories.'),
-        recursiveClasses: bool('Recurse into child classes.'),
-        limit: boundedLimit(500, 50),
-        offset: num('Zero-based offset into the full result set.')
-    }, []), PAGINATED_OUTPUT, READ, READ_POLICY, MEDIUM, { aliases: ['asset.find_assets'], topics: ['find assets', 'search assets', 'assets by class', 'filter assets', 'query assets', 'assets of type', 'list sounds', 'list sound cues', 'list materials', 'list textures', 'list images', 'list meshes', 'list blueprints', 'list widget blueprints', 'list animations'],
-        whenToUse: ['Assets must be found across the project by name, class, folder or asset-registry tag.'],
-        whenNotToUse: ['Actors placed in the open level must be found (use control_actor.find).'],
-        examples: [ex('Search materials by name', { searchText: 'M_Rock', classNames: ['Material'], packagePaths: ['/Game/Materials'], recursivePaths: true, limit: 25 }, { success: true, assets: [{ name: 'M_Rock', path: '/Game/Materials/M_Rock.M_Rock', class: 'Material', packagePath: '/Game/Materials' }], folders: [], totalCount: 1, count: 1, limit: 25, offset: 0, hasMore: false, nextOffset: 1, cursor: null, nextCursor: null })] }),
-    r('find_text', 'asset', 'Find where a piece of text appears: Blueprint graph nodes by title (every call of a function, by its name as the graph shows it), literals, assets picked on pins and comments, variable and component defaults (a reference to another asset matches by its path, so a sound name finds the node or component that plays it), widget texts, DataTable rows, String Table entries, and the actors of the open level.', schema({
-        searchText: str('Text to search for.'),
-        packagePaths: arr('Package paths to search within.'),
-        caseSensitive: bool('Match letter case (default false).'),
-        includeLevel: bool('Also search the actors and components of the open level: true or false outright; omitted, only when that level lies under packagePaths (always with the default /Game).'),
-        limit: boundedLimit(500, 50)
-    }, ['searchText']), schema({
-        success: bool('Operation succeeded.'),
-        matches: arrObj('Each match: asset, where (graph and node title, widget, row, string key or actor label), field, the full text, and nodeId for a graph literal.'),
-        matchCount: num('Every match found; more than the matches returned when truncated.'),
-        scannedAssets: num('Blueprints, DataTables and String Tables searched.'),
-        truncated: bool('True when limit cut the list; raise limit to see the rest.')
-    }, ['success', 'matches', 'matchCount']), READ, READ_POLICY, MEDIUM, { topics: ['find text', 'search text', 'find string', 'where is text used', 'text in widgets', 'text in blueprints', 'find literal'],
-        whenToUse: ['A piece of text, such as a UI label or dialogue line, must be traced to the Blueprint, widget, table row or level actor holding it.'],
-        whenNotToUse: ['One known Blueprint graph must be read node by node (use blueprint.inspect_graph).'],
-        examples: [ex('Find a string in the UI and the open level', { searchText: 'Game Over', packagePaths: ['/Game/UI'] }, { success: true, matches: [{ asset: '/Game/UI/WBP_HUD.WBP_HUD', where: 'GameOverText', field: 'Text', text: 'Game Over' }], matchCount: 1, scannedAssets: 12, truncated: false })] })
-];
-//# sourceMappingURL=asset-lifecycle.js.map

package/dist/tools/catalog/capabilities/records/manage-asset/asset-query.d.ts

@@ -1,3 +0,0 @@
-import type { RecordSpec } from './builder.js';
-export declare const ASSET_QUERY_RECORDS: readonly RecordSpec[];
-//# sourceMappingURL=asset-query.d.ts.map

package/dist/tools/catalog/capabilities/records/manage-asset/asset-query.js

@@ -1,95 +0,0 @@
-import { arr, arrObj, bool, ex, LOW, MEDIUM, num, READ, READ_POLICY, r, str, WRITE, WRITE_POLICY } from './builder.js';
-import { schema } from '../shared/record-presets.js';
-const ASSET_PATH = str('Canonical /Game asset path.');
-const OK = schema({ success: bool('Operation succeeded.'), details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' } }, ['success']);
-const GRAPH_OK = schema({
-    success: bool('Operation succeeded.'),
-    graph: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Adjacency map of asset path -> array of dependency paths.' },
-    nodeCount: num('Number of distinct assets visited.'),
-    maxDepth: num('Traversal depth actually used after clamping.'),
-    truncated: bool('True when the walk hit the depth or node ceiling and the graph is partial.'),
-}, ['success']);
-const ANALYZE_GRAPH_OK = schema({
-    success: bool('Operation succeeded.'),
-    assetPath: ASSET_PATH,
-    assetClass: str('Concrete UClass name of the analyzed asset.'),
-    graphType: str('Graph kind analyzed: Material, Blueprint, None, or the class of an asset whose graph another action reads (see nextCall).'),
-    nodeCount: num('Material expression nodes in the graph.'),
-    parameterCount: num('Material parameter expressions in the graph.'),
-    textureSampleCount: num('Texture sample expressions in the graph.'),
-    parameters: arr('Material parameter names.'),
-    isMaterialInstance: bool('True when the asset is a material instance.'),
-    isTwoSided: bool('True when the material renders two-sided.'),
-    isMasked: bool('True when the material uses masked blending.'),
-    blendMode: str('Material blend mode enum name.'),
-    shadingModel: str('First matching shading model name.'),
-    blueprintType: str('Blueprint kind: Class, Interface, MacroLibrary, or FunctionLibrary.'),
-    totalNodes: num('Total nodes across every Blueprint graph.'),
-    graphCount: num('Number of graphs in the Blueprint.'),
-    graphs: arrObj('Per-graph breakdown (name, nodeCount).'),
-    message: str('Explanation when the asset type carries no graph, or which action reads it.'),
-    nextCall: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'A MetaSound, Niagara or Behavior Tree asset: the execute call of the action that reads its graph.' },
-}, ['success']);
-export const ASSET_QUERY_RECORDS = [
-    r('get_dependencies', 'asset', 'List the packages an asset uses, or with referencers the packages that use it. Direct packages only; lookup "graph" walks dependencies recursively.', schema({
-        assetPath: ASSET_PATH,
-        referencers: bool('List the packages that USE this asset (Blueprints that spawn it, levels that place it) instead of the ones it uses; check this before deleting or replacing an asset.'),
-    }, ['assetPath']), OK, READ, READ_POLICY, MEDIUM, { whenToUse: [
-            'Before deleting or replacing an asset, the packages, Blueprints and levels that use it must be listed.',
-            'The packages an asset itself uses must be listed (direct ones only).',
-        ],
-        whenNotToUse: ['The node graph inside a material or Blueprint is wanted, not package links (use asset.query_asset with lookup=graph).'],
-        examples: [ex('List the Blueprints and levels that use a Niagara system', { assetPath: '/Game/FX/NS_Puff', referencers: true }, { success: true })] }),
-    r('get_source_control_state', 'asset', 'Retrieve source-control state for an asset.', schema({ assetPath: ASSET_PATH, assetPaths: arr('Several asset paths to query in one call.'), recursive: bool('Also report every /Game package the assets depend on, transitively (up to 512).') }, [], ['assetPath', 'assetPaths']), OK, READ, READ_POLICY, LOW, { whenToUse: ['Before editing, it must be known whether assets are checked out, modified or held by someone else.'],
-        whenNotToUse: ['Assets must be checked out or submitted (use asset.source_control).'],
-        examples: [ex('Check whether a mesh is checked out', { assetPath: '/Game/Meshes/SM_Crate' }, { success: true })] }),
-    r('analyze_graph', 'asset', 'Analyze the node graph inside a material or Blueprint asset; a MetaSound, Niagara or Behavior Tree asset answers with the nextCall that reads its graph.', schema({ assetPath: ASSET_PATH }, ['assetPath']), ANALYZE_GRAPH_OK, READ, READ_POLICY, MEDIUM, { whenToUse: ['A material or Blueprint must be summarised: node counts, parameters, blend mode or graph count.'],
-        whenNotToUse: ['One Blueprint\'s variables, functions or components are wanted (use blueprint.get_blueprint).'],
-        examples: [ex('Inspect a material\'s expression graph', { assetPath: '/Game/Materials/M_Base' }, { success: true, graphType: 'Material', nodeCount: 4, parameterCount: 2, blendMode: 'BLEND_Opaque' })] }),
-    r('get_asset_graph', 'asset', 'Retrieve the asset reference graph directly via the get_asset_graph bridge action.', schema({ assetPath: ASSET_PATH, maxDepth: num('Maximum traversal depth (clamped to 8).') }, ['assetPath']), GRAPH_OK, READ, READ_POLICY, MEDIUM, { whenToUse: ['The reference graph of an asset must be walked several levels deep in one call (depth is capped at 8).'],
-        whenNotToUse: [
-            'Only the direct packages an asset uses, or the packages that use it, are needed (use lookup=dependencies, which is cheaper).',
-            'A material\'s package references are wanted; a plain material answers here with its expression nodes (use lookup=dependencies).',
-        ],
-        examples: [ex('Read the reference graph through the direct bridge route', { assetPath: '/Game/Materials/M_Base', maxDepth: 2 }, { success: true })] }),
-    r('create_thumbnail', 'asset', 'Generate a thumbnail for an asset.', schema({ assetPath: ASSET_PATH, width: num('Thumbnail width.'), height: num('Thumbnail height.'), outputPath: str('Project-relative PNG file to write, e.g. Saved/Thumbnails/SM_Crate.png.') }, ['assetPath']), OK, WRITE, WRITE_POLICY, LOW, { dispatchAction: 'generate_thumbnail',
-        whenToUse: ['An asset needs a preview image, optionally written as a PNG file inside the project.'],
-        whenNotToUse: ['The image should show the editor viewport or a level camera view (use control_editor.screenshot).'],
-        examples: [ex('Render a 256x256 thumbnail', { assetPath: '/Game/Meshes/SM_Crate', width: 256, height: 256 }, { success: true })] }),
-    r('set_tags', 'asset', 'Set tags on an asset, stored as package metadata: each tag name is written with the value "true".', schema({ assetPath: ASSET_PATH, tags: arr('Tag names to set; each is written as package metadata with the value "true".') }, ['assetPath', 'tags']), OK, WRITE, WRITE_POLICY, LOW, { dispatchAction: 'set_tags',
-        whenToUse: ['Simple labels such as Reviewed or Prop must be attached to an asset as package metadata; the change stays unsaved until the asset is saved.'],
-        whenNotToUse: [
-            'Actors in a level need a tag (use control_actor.add_tag).',
-            'Assets must be found by the tag afterwards. asset.query_asset lookup=by_tag reads the asset registry, which carries a package-metadata tag only when its name is listed under Project Settings > Asset Manager > Metadata Tags For Asset Registry and the asset has been saved; otherwise it finds nothing.',
-            'The tags on an asset must be read back (use asset.inspect_asset lookup=metadata, which lists them under metadata at once).',
-        ],
-        examples: [ex('Tag an asset for review, as package metadata', { assetPath: '/Game/Meshes/SM_Crate', tags: ['Reviewed', 'Prop'] }, { success: true })] }),
-    r('get_metadata', 'asset', 'Retrieve metadata and tags for an asset.', schema({ assetPath: ASSET_PATH }, ['assetPath']), schema({ success: bool('Operation succeeded.'), assetPath: ASSET_PATH, tags: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Asset Registry tags (key-value). A tag written by set_tags appears here only when its name is listed under Project Settings > Asset Manager > Metadata Tags For Asset Registry.' }, metadata: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Package metadata (key-value): what set_metadata wrote, and each set_tags tag as its name with the value "true".' } }, ['success']), READ, READ_POLICY, LOW, { whenToUse: ['What was recorded on an asset must be read back: its registry tags and the package metadata that asset.set_metadata writes, tags included (a tag set with kind=tags shows under metadata as "true").'],
-        whenNotToUse: ['The asset\'s own values are wanted, such as a texture size or material parameters (use texture.get_texture_info or material.get_material_info).'],
-        examples: [ex('Read metadata for a mesh', { assetPath: '/Game/Meshes/SM_Crate' }, { success: true, assetPath: '/Game/Meshes/SM_Crate', metadata: { Author: 'ArtTeam' } })] }),
-    r('set_metadata', 'asset', 'Set metadata key-value pairs on an asset.', schema({ assetPath: ASSET_PATH, metadata: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Metadata key-value pairs.' } }, ['assetPath', 'metadata']), OK, WRITE, WRITE_POLICY, LOW, { dispatchAction: 'set_metadata',
-        whenToUse: ['Key and value notes such as author or revision must be attached to an asset; the change stays unsaved until the asset is saved.'],
-        whenNotToUse: [
-            'The stored values must be read back (use asset.inspect_asset).',
-            'A property of the asset itself must change (use inspect.set_property).',
-        ],
-        examples: [ex('Record authoring provenance', { assetPath: '/Game/Meshes/SM_Crate', metadata: { Author: 'ArtTeam', Revision: '3' } }, { success: true })] }),
-    r('validate', 'asset', 'Confirm an asset exists and loads. It runs no content, reference or data checks.', schema({ assetPath: ASSET_PATH }, ['assetPath']), OK, READ, READ_POLICY, MEDIUM, { whenToUse: ['An asset must be confirmed to exist and load before other calls rely on it (no content, reference or data checks are run).'],
-        whenNotToUse: ['Every asset in a folder must be checked for load errors (use system_control.validate_assets).'],
-        examples: [ex('Confirm a material exists and loads', { assetPath: '/Game/Materials/M_Base' }, { success: true })] }),
-    r('fixup_redirectors', 'asset', 'Fix up redirector assets in a directory.', schema({ directoryPath: str('Directory path to fix up.'), path: str('Alternative directory path.'), checkoutFiles: bool('Check the referencing packages out of source control before resaving them.') }, [], ['directoryPath', 'path']), OK, WRITE, WRITE_POLICY, MEDIUM, { dispatchAction: 'fixup_redirectors',
-        whenToUse: ['Redirectors left in a folder by earlier moves or renames must be resolved: referencers are repointed and the redirectors deleted.'],
-        whenNotToUse: ['Redirectors should only be listed before anything changes (use asset.query_asset with lookup=search and classNames ObjectRedirector).'],
-        examples: [ex('Clean up redirectors left by a move', { directoryPath: '/Game/Meshes' }, { success: true })] }),
-    r('refresh_blueprints', 'asset', 'Refresh every node of the Blueprints under a folder (or listed), then compile and save each; run it after renaming or moving classes so casts and node titles follow.', schema({ folderPath: str('Folder path for bulk operation.'), assetPaths: arr('Explicit asset paths.') }, [], ['assetPaths', 'folderPath']), OK, { ...WRITE, longRunning: true }, WRITE_POLICY, MEDIUM, { dispatchAction: 'refresh_blueprints',
-        whenToUse: ['Blueprints in a folder or a list need every node refreshed, then compiled and saved, for example after a class was renamed.'],
-        whenNotToUse: ['One Blueprint only needs compiling (use blueprint.compile).'],
-        examples: [ex('Refresh the Blueprints after a class rename', { folderPath: '/Game/Blueprints' }, { success: true })] }),
-    r('find_by_tag', 'asset', 'Find /Game assets that carry an asset-registry tag, optionally with a given value (compared ignoring case).', schema({ tag: str('Asset-registry tag name, for example ParentClass, which every Blueprint carries.'), value: str('Optional tag value to match, ignoring case.') }, ['tag']), OK, READ, READ_POLICY, LOW, { whenToUse: ['Assets under /Game must be found by an asset-registry tag, optionally with one value, such as the ParentClass tag every Blueprint carries. A tag written by asset.set_metadata with kind=tags is in the registry only when its name is listed under Project Settings > Asset Manager > Metadata Tags For Asset Registry and the asset has been saved; otherwise nothing matches (asset.inspect_asset lookup=metadata reads one asset).'],
-        whenNotToUse: ['Actors placed in the open level must be found (use control_actor.find).'],
-        examples: [ex('Find every Blueprint by its ParentClass registry tag', { tag: 'ParentClass' }, { success: true })] }),
-    r('generate_report', 'asset', 'Generate an asset report for a directory.', schema({ directory: str('Directory to report on.'), reportType: str('Report type.'), outputPath: str('Output file path.') }, []), OK, READ, READ_POLICY, MEDIUM, { whenToUse: ['Every asset under a directory, with name, path and class, must be listed in one reply, optionally saved as a JSON file in the project.'],
-        whenNotToUse: ['A paged view of one folder is enough (use asset.list); the report returns the whole tree unpaged.'],
-        examples: [ex('Report on the Meshes directory', { directory: '/Game/Meshes', reportType: 'summary', outputPath: '/Game/Reports/Meshes' }, { success: true })] })
-];
-//# sourceMappingURL=asset-query.js.map