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

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

@@ -1,82 +0,0 @@
-import { arrObj, bool, DESTRUCTIVE, DESTRUCTIVE_POLICY, ex, HIGH, LOW, MEDIUM, NON_IDEMPOTENT, READ, READ_POLICY, r, str, WRITE, WRITE_POLICY } from './builder.js';
-import { schema } from '../shared/record-presets.js';
-const STRUCT_PATH = str('Asset path of the Blueprint Struct (e.g. /Game/Structs/S_MyStruct).');
-const MEMBER_NAME = str('Member (variable) name.');
-const MEMBER_TYPE = str('Unreal property type: Bool, Int, Float, String, Name, Text, Vector, Rotator, Transform, Object, SoftObject, Class, SoftClass, Enum:<Name>, Struct:<Path>, or with container prefix Array:..., Set:..., Map:<K>,<V>:');
-const SAVE = bool('Persist the struct to disk. Defaults to true; pass false to keep the change in memory only.');
-const MEMBERS = arrObj('Member definitions, each { name, type } (or memberName, memberType) with optional defaultValue, tooltip and metadata.');
-const OK = schema({ success: bool('Operation succeeded.'), details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' } }, ['success']);
-const S = '/Game/Structs/S_WeaponRow';
-const DONE = { success: true };
-export const STRUCT_RECORDS = [
-    r('create_struct', 'struct', 'Create a new Blueprint Struct asset.', schema({ name: str('Struct name.'), path: str('Package path (default /Game/Structs).'), structPath: str('Full asset path of the new struct, e.g. /Game/Structs/S_WeaponRow; alternative to name and path.'), members: MEMBERS, save: SAVE }, [], ['name', 'structPath']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Create a weapon row struct', { name: 'S_WeaponRow', path: '/Game/Structs', members: [{ memberName: 'Damage', memberType: 'Float' }] }, DONE)],
-        whenToUse: ['A new Blueprint struct is needed; give its members up front, otherwise it keeps one placeholder member.'],
-        whenNotToUse: ['A DataTable is wanted as well as its row struct (use datatable.edit_data_table to create the table and bind the struct).'] }),
-    r('get_struct', 'struct', 'Read a Blueprint or native struct: name, status, validity and every member as { guid, name, type, default, tooltip, containerType, metaData }.', schema({ structPath: STRUCT_PATH }, ['structPath']), OK, READ, READ_POLICY, LOW, { examples: [ex('Read a struct\'s metadata', { structPath: S }, DONE)],
-        whenToUse: ['A struct\'s member names, types, defaults and tooltips must be known before rows or edits are written; native /Script structs such as Vector can be read too.'],
-        whenNotToUse: ['A struct must be changed rather than read (use struct.edit_struct).'] }),
-    r('read_struct', 'struct', 'Read a struct definition: the same reply as get_struct, with the name, status, validity and every member. It returns no row or instance values.', schema({ structPath: STRUCT_PATH }, ['structPath']), OK, READ, READ_POLICY, LOW, { examples: [ex('Read a struct definition', { structPath: S }, DONE)],
-        whenToUse: ['A struct\'s member names, types, defaults and tooltips must be known before rows or edits are written; native /Script structs such as Vector can be read too.'],
-        whenNotToUse: ['A struct must be changed rather than read (use struct.edit_struct).'] }),
-    r('list_struct_members', 'struct', 'List a struct\'s members with guid, type, default, tooltip and metadata. The reply is the same as get_struct, so it also carries the struct name, status and validity.', schema({ structPath: STRUCT_PATH }, ['structPath']), OK, READ, READ_POLICY, LOW, { examples: [ex('List a struct\'s members', { structPath: S }, DONE)],
-        whenToUse: ['A struct\'s member names, types, defaults and tooltips must be known before rows or edits are written; native /Script structs such as Vector can be read too.'],
-        whenNotToUse: ['A struct must be changed rather than read (use struct.edit_struct).'] }),
-    r('add_struct_member', 'struct', 'Add a new member to a Blueprint Struct.', schema({ structPath: STRUCT_PATH, memberName: MEMBER_NAME, memberType: MEMBER_TYPE, defaultValue: str('Default value as string.'), tooltip: str('Member tooltip.'), metadata: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Metadata key/value pairs.' }, members: arrObj('Several members at once, each { name, type } (or memberName, memberType) with optional defaultValue, tooltip and metadata; replaces the single memberName form.'), save: SAVE }, ['structPath'], ['memberName', 'members']), OK, WRITE, WRITE_POLICY, LOW, { examples: [ex('Add a float damage member', { structPath: S, memberName: 'Damage', memberType: 'Float', defaultValue: '25.0', tooltip: 'Base damage per hit.' }, DONE)],
-        whenToUse: ['One or several fields, each with a type, optional default and tooltip, must be added to an existing struct.'],
-        whenNotToUse: ['A variable is needed on a Blueprint, not a field on a struct (use blueprint.edit_variable).'] }),
-    r('remove_struct_member', 'struct', 'Remove a member from a Blueprint Struct.', schema({ structPath: STRUCT_PATH, memberName: MEMBER_NAME, varGuid: str('Stable member GUID.'), save: SAVE }, ['structPath', 'memberName']), OK, { ...DESTRUCTIVE, longRunning: false }, DESTRUCTIVE_POLICY, LOW, { examples: [ex('Remove an obsolete member', { structPath: S, memberName: 'LegacyFlag' }, DONE)],
-        whenToUse: ['One field must be removed from a struct; referencing Blueprints and DataTables are refreshed afterwards.'],
-        whenNotToUse: ['A field only needs a new name or type (use struct.edit_struct).'] }),
-    r('rename_struct_member', 'struct', 'Rename a member in a Blueprint Struct.', schema({ structPath: STRUCT_PATH, memberName: MEMBER_NAME, newMemberName: str('New member name.'), varGuid: str('Stable member GUID.'), save: SAVE }, ['structPath', 'memberName', 'newMemberName']), OK, NON_IDEMPOTENT, WRITE_POLICY, LOW, { examples: [ex('Rename Damage to BaseDamage', { structPath: S, memberName: 'Damage', newMemberName: 'BaseDamage' }, DONE)],
-        whenToUse: ['A field must be renamed while keeping its type and default; it is found by memberName or varGuid.'],
-        whenNotToUse: ['A field must be removed instead of renamed (use struct.delete_struct with deleteScope=member).'] }),
-    r('set_struct_member_type', 'struct', 'Change the type of a member in a Blueprint Struct.', schema({ structPath: STRUCT_PATH, memberName: MEMBER_NAME, memberType: MEMBER_TYPE, varGuid: str('Stable member GUID.'), save: SAVE }, ['structPath', 'memberName', 'memberType']), OK, WRITE, WRITE_POLICY, LOW, { examples: [ex('Widen an int member to a float', { structPath: S, memberName: 'Damage', memberType: 'Float' }, DONE)],
-        whenToUse: ['A field needs a different type, for example Int to Float or a container; self-referencing and cyclic types are refused.'],
-        whenNotToUse: ['The assets that use the struct must be found before a type change (use struct.get_struct with info=usage).'] }),
-    r('reorder_struct_members', 'struct', 'Reorder members in a Blueprint Struct.', schema({ structPath: STRUCT_PATH, position: { type: 'string', enum: ['first', 'last', 'before', 'after'], description: 'Where the moved member goes: first or last of the struct, or before or after the member named in relativeTo.' }, relativeTo: str('Name or GUID of the member to place the moved member next to. Required for before and after; ignored for first and last.'), memberName: str('Name of the member to move. Pass this or varGuid.'), varGuid: str('Stable GUID of the member to move. Pass this or memberName.'), save: SAVE }, ['structPath', 'position'], ['memberName', 'varGuid']), OK, WRITE, WRITE_POLICY, LOW, { examples: [ex('Move a member to the front', { structPath: S, memberName: 'Damage', position: 'first' }, DONE), ex('Move a member after another', { structPath: S, memberName: 'Damage', position: 'after', relativeTo: 'Range' }, DONE)],
-        whenToUse: ['One field, named by memberName or varGuid, must move to first, last, or before or after another field.'],
-        whenNotToUse: ['The current member order must be read before moving anything (use struct.get_struct).'] }),
-    r('set_struct_member_default', 'struct', 'Set the default value of a member in a Blueprint Struct.', schema({ structPath: STRUCT_PATH, memberName: MEMBER_NAME, defaultValue: str('Default value as string.'), varGuid: str('Stable member GUID.'), save: SAVE }, ['structPath', 'memberName', 'defaultValue']), OK, WRITE, WRITE_POLICY, LOW, { examples: [ex('Default damage to 25', { structPath: S, memberName: 'Damage', defaultValue: '25.0' }, DONE)],
-        whenToUse: ['A field needs a new default value; a value that cannot convert to the field type is rejected.'],
-        whenNotToUse: ['Values stored in a DataTable row must change, not the struct default (use datatable.edit_data_table).'] }),
-    r('set_struct_member_metadata', 'struct', 'Set metadata (tooltip, etc.) on a member in a Blueprint Struct.', schema({ structPath: STRUCT_PATH, memberName: MEMBER_NAME, tooltip: str('Member tooltip.'), metadata: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Metadata key/value pairs.' }, varGuid: str('Stable member GUID.'), save: SAVE }, ['structPath', 'memberName']), OK, WRITE, WRITE_POLICY, LOW, { examples: [ex('Document a member with a tooltip', { structPath: S, memberName: 'Damage', tooltip: 'Base damage per hit.' }, DONE)],
-        whenToUse: ['A field needs a tooltip or metadata key and value pairs.'],
-        whenNotToUse: ['Metadata for an enum entry is wanted (use enum.edit_enum).'] }),
-    r('compare_structs', 'struct', 'Compare two Blueprint Structs for differences.', schema({ structPath: STRUCT_PATH, otherStructPath: str('Second struct path for comparison.') }, ['structPath', 'otherStructPath']), OK, READ, READ_POLICY, MEDIUM, { examples: [ex('Diff two struct revisions', { structPath: S, otherStructPath: '/Game/Structs/S_WeaponRow_V2' }, DONE)],
-        whenToUse: ['Two structs must be diffed for added, removed, renamed or retyped members and changed defaults, tooltips or order.'],
-        whenNotToUse: ['A struct must be brought in line with another; the comparison only reports differences (use struct.edit_struct).'] }),
-    r('search_struct_usage', 'struct', 'Search for references to a Blueprint Struct across the project.', schema({ structPath: STRUCT_PATH, searchScope: str('Optional path scope.') }, ['structPath']), OK, READ, READ_POLICY, MEDIUM, { examples: [ex('Find every user of a struct', { structPath: S, searchScope: '/Game' }, DONE)],
-        whenToUse: ['Every asset that references a struct, such as Blueprints, other structs and DataTables, must be found before changing or deleting it.'],
-        whenNotToUse: ['References to an asset that is not a struct are needed (use asset.inspect_asset).'] }),
-    r('recompile_struct', 'struct', 'Recompile a Blueprint Struct to update generated headers.', schema({ structPath: STRUCT_PATH, save: SAVE }, ['structPath']), OK, { ...WRITE, longRunning: true }, WRITE_POLICY, HIGH, { examples: [ex('Recompile after member changes', { structPath: S }, DONE)],
-        whenToUse: ['Dependent Blueprints must be recompiled after a struct change and their compile errors listed; the changed assets are saved unless save is false.'],
-        whenNotToUse: ['One Blueprint must be compiled rather than a struct (use blueprint.compile).'] }),
-    r('rename_struct', 'struct', 'Rename a Blueprint Struct asset.', schema({ structPath: STRUCT_PATH, newName: str('New struct name; the struct stays in its folder unless destinationFolder is given.'), destinationFolder: str('Folder to move the renamed struct into, e.g. /Game/Data.'), newStructPath: str('Full new object path, e.g. /Game/Data/S_WeaponStats.S_WeaponStats; alternative to newName.') }, ['structPath'], ['newName', 'newStructPath']), OK, NON_IDEMPOTENT, WRITE_POLICY, MEDIUM, { examples: [ex('Rename the struct asset', { structPath: S, newName: 'S_WeaponStats' }, DONE)],
-        whenToUse: ['The struct asset needs a new name or folder; a redirector is left at the old path when it is referenced, and dependent Blueprints recompile.'],
-        whenNotToUse: ['A non-struct asset must be renamed or moved (use asset.rename or asset.move).'] }),
-    r('duplicate_struct', 'struct', 'Duplicate a Blueprint Struct asset.', schema({ structPath: STRUCT_PATH, destinationPath: str('Folder for the copy, e.g. /Game/Structs, when destinationName is given, the path ends in "/" or the folder exists; the copy is destinationPath/destinationName, or keeps the source name without one. Otherwise the full new asset path, e.g. /Game/Structs/S_WeaponRow_V2. A copy onto an existing struct is refused with ALREADY_EXISTS.'), destinationName: str('Name of the new asset. With destinationPath it is placed in that folder; on its own the copy stays beside the source.') }, ['structPath'], ['destinationPath', 'destinationName']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Fork a struct for a second revision', { structPath: S, destinationPath: '/Game/Structs', destinationName: 'S_WeaponRow_V2' }, DONE)],
-        whenToUse: ['A struct must be forked into a new asset with the same members, for example to try a second revision.'],
-        whenNotToUse: ['An asset that is not a struct must be copied (use asset.duplicate).'] }),
-    r('delete_struct', 'struct', 'Delete a Blueprint Struct asset.', schema({ structPath: STRUCT_PATH, force: bool('Delete even when other assets still reference the struct (their references break). Default false, which refuses and lists the referencers.') }, ['structPath']), OK, { ...DESTRUCTIVE, longRunning: false }, DESTRUCTIVE_POLICY, MEDIUM, { examples: [ex('Delete an unreferenced struct', { structPath: '/Game/Structs/S_Deprecated' }, DONE)],
-        whenToUse: ['An unused struct asset must be deleted; a struct still referenced is refused, with its referencers listed, unless force is set.'],
-        whenNotToUse: ['The struct should be renamed or moved instead of removed (use struct.edit_struct).', 'The assets that use the struct must be found first (use struct.get_struct with info=usage).'] }),
-    r('refresh_struct_dependencies', 'struct', 'Refresh dependencies of a Blueprint Struct after external changes.', schema({ structPath: STRUCT_PATH }, ['structPath']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Refresh dependents after a type change', { structPath: S }, DONE)],
-        whenToUse: ['A struct was edited outside these tools and its Blueprints and DataTables must be rebuilt against the new layout; the affected assets are listed.'],
-        whenNotToUse: ['Only the struct status and validity must be read (use struct.get_struct).'] }),
-    r('list_structs', 'struct', 'List all Blueprint Struct assets in a path.', schema({ path: str('Package path to search (default /Game/Structs), recursive.') }, []), OK, READ, READ_POLICY, LOW, { examples: [ex('List the project\'s structs', { path: '/Game/Structs' }, DONE)],
-        whenToUse: ['The Blueprint structs under a folder must be found; the search is recursive and defaults to /Game/Structs.'],
-        whenNotToUse: ['Assets of another type must be found (use asset.query_asset).'] }),
-    r('export_struct', 'struct', 'Return a struct definition as JSON: the same reply as get_struct, whose members array (name, type, default, tooltip, metaData) import_struct accepts as members or as a sourcePath file. Nothing is written to disk.', schema({ structPath: STRUCT_PATH }, ['structPath']), OK, READ, READ_POLICY, LOW, { examples: [ex('Export a struct definition', { structPath: S }, DONE)],
-        whenToUse: ['A struct definition must be returned as JSON members that import_struct accepts, to reuse or restore it.'],
-        whenNotToUse: ['A struct must be copied as a new asset (use struct.edit_struct with edit=duplicate_struct).'] }),
-    r('import_struct', 'struct', 'Replace the members of an existing Blueprint Struct, or create a new one, from member definitions or a JSON file.', schema({ structPath: str('Existing struct whose members are replaced.'), name: str('Name of a new struct to create instead (with path).'), path: str('Package path for a new struct (default /Game/Structs).'), sourcePath: str('Project-relative JSON file holding the members: a bare array, or an object with a members array as export_struct returns. Used when members is omitted.'), members: MEMBERS, save: SAVE }, [], ['structPath', 'name']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Import a struct definition from disk', { structPath: S, sourcePath: 'Saved/Structs/S_WeaponRow.json' }, DONE)],
-        whenToUse: ['A struct must be rebuilt from a member list or a JSON file; members are replaced and a failed apply is rolled back.'],
-        whenNotToUse: ['The definition must be exported as JSON, not imported (use struct.get_struct with info=export).'] }),
-    r('get_instanced_struct_property', 'struct', 'Get a property from an FInstancedStruct on an asset.', schema({ assetPath: str('Asset /Game path.'), propertyName: str('Property name.') }, ['assetPath', 'propertyName']), OK, READ, READ_POLICY, LOW, { examples: [ex('Read an instanced-struct property', { assetPath: '/Game/Blueprints/BP_Weapon', propertyName: 'Stats' }, DONE)],
-        whenToUse: ['The struct type and field values held in an FInstancedStruct property of an asset must be read.'],
-        whenNotToUse: ['A plain property on an actor or asset must be read (use inspect.get_property).'] }),
-    r('set_instanced_struct_property', 'struct', 'Set a property on an FInstancedStruct on an asset.', schema({ assetPath: str('Asset /Game path.'), propertyName: str('Property name.'), structType: str('Inner UScriptStruct asset path.'), structValues: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Field-name to value map.' }, save: bool('Save the asset afterwards. Defaults to true.') }, ['assetPath', 'propertyName', 'structType']), OK, WRITE, WRITE_POLICY, LOW, { examples: [ex('Set an instanced-struct property', { assetPath: '/Game/Blueprints/BP_Weapon', propertyName: 'Stats', structType: S, structValues: { Damage: 32 } }, DONE)],
-        whenToUse: ['An FInstancedStruct property on an asset must be set to a chosen struct type with given field values.'],
-        whenNotToUse: ['A plain property on an actor or asset must be written (use inspect.set_property).'] })
-];
-//# sourceMappingURL=struct-records.js.map

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

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

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

@@ -1,42 +0,0 @@
-import { bool, ex, MEDIUM, num, r, str, WRITE, WRITE_POLICY } from './builder.js';
-import { schema } from '../shared/record-presets.js';
-const OK = schema({ success: bool('Operation succeeded.'), details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' } }, ['success']);
-const T = '/Game/Textures/T_Rock';
-const TEXTURES = '/Game/Textures';
-const DONE = { success: true };
-const OTHER_FORMATS = 'Other source formats (G16, RGBA16, float, HDR) fail with an error naming the format found.';
-const READ_FORMATS = `an 8-bit BGRA8 or single-channel G8 texture (a channel_extract result, read as gray in R, G and B with alpha 255). ${OTHER_FORMATS}`;
-const EDIT_PATH = str(`Texture /Game path. Its source must be 8-bit BGRA8 or single-channel G8 (a channel_extract result); a G8 texture is rewritten as BGRA8 with its gray in R, G and B and alpha 255. ${OTHER_FORMATS}`);
-export const TEXTURE_ADJUST_RECORDS = [
-    r('resize_texture', 'texture', 'Resize a texture to new dimensions.', schema({ sourcePath: str(`Source texture path; its source must be ${READ_FORMATS}`), name: str('Output name (default <source>_Resized).'), path: str('Package path (default the source folder).'), outputPath: str('Full output asset path; replaces name and path.'), newWidth: num('New width.'), newHeight: num('New height.'), filterMethod: str('Resampling filter.') }, ['sourcePath']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Halve a texture to 512px', { sourcePath: T, name: 'T_Rock_512', path: TEXTURES, newWidth: 512, newHeight: 512, filterMethod: 'Bilinear' }, DONE)],
-        whenToUse: ['A texture must be copied at a smaller or larger size such as 512px; the source texture is left as it is.'],
-        whenNotToUse: ['Only runtime mip detail or memory must drop, not the source size (use texture.configure_texture).'] }),
-    r('adjust_levels', 'texture', 'Adjust levels (black/white points, gamma) on a texture.', schema({ assetPath: EDIT_PATH, inBlack: num('Input black point.'), inWhite: num('Input white point.'), gamma: num('Gamma.'), channel: str('Channel to adjust.'), save: bool('Save after adjustment.') }, ['assetPath']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Lift the black point and regamma', { assetPath: T, inBlack: 0.05, inWhite: 0.95, gamma: 1.1, channel: 'RGB', save: true }, DONE)],
-        whenToUse: ['Brightness or contrast must change through black point, white point or gamma, on one channel or on all colour channels.'],
-        whenNotToUse: ['The original pixels must be kept, since these edits are made in place (duplicate the texture first with asset.duplicate).'] }),
-    r('adjust_curves', 'texture', 'Apply curve-based adjustments to a texture.', schema({ assetPath: EDIT_PATH, channel: str('Channel to adjust.'), curvePoints: { type: 'array', items: { type: 'object', 'x-unreal-reflection-boundary': true }, description: 'Curve control points as {x, y} pairs in 0-1; at least two.' }, save: bool('Save after adjustment.') }, ['assetPath']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Apply an S-curve to the red channel', { assetPath: T, channel: 'R', curvePoints: [{ x: 0, y: 0 }, { x: 0.25, y: 0.18 }, { x: 0.75, y: 0.82 }, { x: 1, y: 1 }], save: true }, DONE)],
-        whenToUse: ['A tonal curve such as an S-curve for contrast must be applied to one colour channel or to all of them.'],
-        whenNotToUse: ['The original pixels must be kept, since these edits are made in place (duplicate the texture first with asset.duplicate).', 'Two textures must be blended, not one edited (use texture.create_texture with kind=combined).'] }),
-    r('blur', 'texture', 'Apply a blur filter to a texture.', schema({ assetPath: EDIT_PATH, radius: num('Blur radius.'), save: bool('Save after blur.') }, ['assetPath']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Soften a texture', { assetPath: T, radius: 4, save: true }, DONE)],
-        whenToUse: ['A texture must be softened; radius is a whole number from 1 to 10.'],
-        whenNotToUse: ['The original pixels must be kept, since these edits are made in place (duplicate the texture first with asset.duplicate).', 'A smaller copy is wanted rather than softer pixels (use texture.create_texture with kind=resized).'] }),
-    r('sharpen', 'texture', 'Apply a sharpen filter to a texture.', schema({ assetPath: EDIT_PATH, strength: num('Sharpen strength.'), save: bool('Save after sharpen.') }, ['assetPath']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Sharpen a downsampled texture', { assetPath: T, strength: 0.6, save: true }, DONE)],
-        whenToUse: ['A soft or downsampled texture needs crisper edges; strength runs from 0 to 5.'],
-        whenNotToUse: ['The original pixels must be kept, since these edits are made in place (duplicate the texture first with asset.duplicate).', 'The texture only looks soft at a distance (use texture.configure_texture for mip bias and streaming).'] }),
-    r('invert', 'texture', 'Invert color channels of a texture.', schema({ assetPath: EDIT_PATH, channel: str('Channel to invert.'), save: bool('Save after inversion.') }, ['assetPath']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Invert a green channel for normal-map handedness', { assetPath: '/Game/Textures/T_Normal', channel: 'G', save: true }, DONE)],
-        whenToUse: ['Colour channels must be flipped, for example the green channel of a normal map to change its handedness.'],
-        whenNotToUse: ['The original pixels must be kept, since these edits are made in place (duplicate the texture first with asset.duplicate).', 'A normal map only needs its compression fixed (use texture.configure_texture).'] }),
-    r('desaturate', 'texture', 'Desaturate a texture by an amount.', schema({ assetPath: EDIT_PATH, amount: num('Desaturation amount (0-1).'), save: bool('Save after desaturation.') }, ['assetPath']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Half-desaturate a texture', { assetPath: T, amount: 0.5, save: true }, DONE)],
-        whenToUse: ['A texture must lose colour, fully or by an amount from 0 to 1.'],
-        whenNotToUse: ['The original pixels must be kept, since these edits are made in place (duplicate the texture first with asset.duplicate).', 'A grayscale copy of one channel is wanted as a new texture (use texture.create_texture with kind=channel_extract).'] }),
-    r('channel_pack', 'texture', 'Pack individual channels from multiple textures into one.', schema({ redTexture: str('Red channel source: an 8-bit BGRA8 or G8 texture.'), greenTexture: str('Green channel source: an 8-bit BGRA8 or G8 texture.'), blueTexture: str('Blue channel source: an 8-bit BGRA8 or G8 texture.'), alphaTexture: str('Alpha channel source: an 8-bit BGRA8 or G8 texture.'), outputPath: str('Output texture path; or give path and name.'), path: str('Output package path (default /Game/Textures).'), name: str('Output texture name.') }, [], ['redTexture', 'greenTexture', 'blueTexture', 'alphaTexture']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Pack AO, roughness and metallic into one map', { redTexture: `${TEXTURES}/T_Rock_AO`, greenTexture: `${TEXTURES}/T_Rock_Roughness`, blueTexture: `${TEXTURES}/T_Rock_Metallic`, outputPath: `${TEXTURES}/T_Rock_ORM` }, DONE)],
-        whenToUse: ['Separate AO, roughness and metallic maps must be packed into the channels of one linear texture.', 'Sources are 8-bit BGRA8 or single-channel G8 textures such as channel_extract results; a BGRA8 source gives its same channel (alpha from its alpha), a G8 source gives its gray to whichever channel it is assigned, and any other source format (G16, RGBA16, float, HDR) fails naming the format found.'],
-        whenNotToUse: ['Separate textures can simply be sampled in a material (use material.add_material_node with nodeKind=texture_sample).'] }),
-    r('channel_extract', 'texture', 'Extract a single channel from a texture.', schema({ assetPath: str(`Texture /Game path; its source must be ${READ_FORMATS}`), channel: str('Channel to extract.'), outputPath: str('Output texture path; or give path and name.'), path: str('Output package path (default the source folder).'), name: str('Output texture name (default <source>_<channel>).') }, ['assetPath', 'channel']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Pull roughness out of a packed map', { assetPath: `${TEXTURES}/T_Rock_ORM`, channel: 'G', outputPath: `${TEXTURES}/T_Rock_Roughness` }, DONE)],
-        whenToUse: ['One channel of a packed texture must become its own grayscale texture.'],
-        whenNotToUse: ['A material only needs one channel of a texture (use material.add_material_node with a texture sample).'] }),
-    r('combine_textures', 'texture', 'Blend two textures together.', schema({ baseTexture: str(`Base texture path; its source must be ${READ_FORMATS}`), blendTexture: str(`Blend texture path; it must have the width and height of baseTexture. Its source can be BGRA8 or G8 whichever baseTexture is. ${OTHER_FORMATS}`), blendType: str('Blend mode.'), opacity: num('Blend opacity.'), outputPath: str('Output texture path; or give path and name.'), path: str('Output package path (default /Game/Textures).'), name: str('Output texture name.') }, ['baseTexture', 'blendTexture']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Overlay grime onto a base texture', { baseTexture: T, blendTexture: `${TEXTURES}/T_Grime`, blendType: 'Overlay', opacity: 0.4, outputPath: `${TEXTURES}/T_Rock_Weathered` }, DONE)],
-        whenToUse: ['Two same-size textures must be blended into a new texture with Multiply, Screen, Overlay or Add at a set opacity.'],
-        whenNotToUse: ['Two textures should blend per pixel at render time (use material.add_material_node).'] })
-];
-//# sourceMappingURL=texture-adjust.js.map

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

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

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

@@ -1,26 +0,0 @@
-import { bool, ex, LOW, num, READ, READ_POLICY, r, str, WRITE, WRITE_POLICY } from './builder.js';
-import { schema } from '../shared/record-presets.js';
-const OK = schema({ success: bool('Operation succeeded.'), details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' } }, ['success']);
-const T = '/Game/Textures/T_Rock';
-const DONE = { success: true };
-export const TEXTURE_CONFIG_RECORDS = [
-    r('set_compression_settings', 'texture', 'Set compression settings on a texture.', schema({ assetPath: str('Texture /Game path.'), compressionSettings: str('Compression format.'), save: bool('Save after change.') }, ['assetPath', 'compressionSettings']), OK, WRITE, WRITE_POLICY, LOW, { examples: [ex('Compress a normal map as TC_Normalmap', { assetPath: '/Game/Textures/T_Normal', compressionSettings: 'TC_Normalmap', save: true }, DONE)],
-        whenToUse: ['A texture needs the right compression such as TC_Normalmap or TC_Masks; an unknown name falls back to TC_Default.'],
-        whenNotToUse: ['The pixels or size of the texture must change, not its asset settings (use texture.adjust_texture or texture.create_texture).'] }),
-    r('set_texture_group', 'texture', 'Set the texture group on a texture.', schema({ assetPath: str('Texture /Game path.'), textureGroup: str('Texture group name.'), save: bool('Save after change.') }, ['assetPath', 'textureGroup']), OK, WRITE, WRITE_POLICY, LOW, { examples: [ex('Assign a texture to the World group', { assetPath: T, textureGroup: 'TEXTUREGROUP_World', save: true }, DONE)],
-        whenToUse: ['A texture must move to another group, such as UI, Character or Effects, so it follows that group\'s LOD rules; an unrecognised name falls back to World.'],
-        whenNotToUse: ['The pixels or size of the texture must change, not its asset settings (use texture.adjust_texture or texture.create_texture).'] }),
-    r('set_lod_bias', 'texture', 'Set the LOD bias on a texture.', schema({ assetPath: str('Texture /Game path.'), lodBias: num('LOD bias value.'), save: bool('Save after change.') }, ['assetPath', 'lodBias']), OK, WRITE, WRITE_POLICY, LOW, { examples: [ex('Drop one mip on a background texture', { assetPath: T, lodBias: 1, save: true }, DONE)],
-        whenToUse: ['A background or distant texture uses too much memory and can lose its largest mip levels; a lodBias of 1 drops one level.'],
-        whenNotToUse: ['The pixels or size of the texture must change, not its asset settings (use texture.adjust_texture or texture.create_texture).', 'A smaller copy of the source image is wanted, not a runtime mip drop (use texture.create_texture with kind=resized).'] }),
-    r('configure_virtual_texture', 'texture', 'Configure virtual texture streaming settings on a texture.', schema({ assetPath: str('Texture /Game path.'), virtualTextureStreaming: bool('Enable VT streaming.'), save: bool('Save after change.') }, ['assetPath']), OK, WRITE, WRITE_POLICY, LOW, { examples: [ex('Enable virtual texture streaming', { assetPath: T, virtualTextureStreaming: true, save: true }, DONE)],
-        whenToUse: ['Virtual texture streaming must be switched on or off for a large texture; leaving virtualTextureStreaming out switches it off.'],
-        whenNotToUse: ['The pixels or size of the texture must change, not its asset settings (use texture.adjust_texture or texture.create_texture).'] }),
-    r('set_streaming_priority', 'texture', 'Set never-stream on a texture (keep every mip resident). UTexture has no per-texture streaming priority to set.', schema({ assetPath: str('Texture /Game path.'), neverStream: bool('Never stream this texture.'), save: bool('Save after change.') }, ['assetPath']), OK, WRITE, WRITE_POLICY, LOW, { examples: [ex('Prioritise a hero texture and pin it resident', { assetPath: T, neverStream: true, save: true }, DONE)],
-        whenToUse: ['A texture must stay sharp because every mip is kept resident instead of streaming in late; there is no per-texture streaming priority to set.'],
-        whenNotToUse: ['The pixels or size of the texture must change, not its asset settings (use texture.adjust_texture or texture.create_texture).', 'The global texture streaming budget must change, not one texture (use system_control.configure_performance with setting=texture_streaming).'] }),
-    r('get_texture_info', 'texture', 'Read a 2D texture asset: width and height, pixel format, mip count, sRGB, compression setting, LOD bias, and virtual texture and never-stream flags.', schema({ assetPath: str('Texture /Game path.') }, ['assetPath']), OK, READ, READ_POLICY, LOW, { topics: ['size and resolution', 'pixel format', 'compression setting', 'mip count', 'how big is a texture'], examples: [ex('Read a texture\'s size and format', { assetPath: T }, DONE)],
-        whenToUse: ['A texture\'s size, pixel format, mip count, sRGB flag and compression must be read before its pixels or settings are changed.', 'A texture setting must be verified after it was changed.'],
-        whenNotToUse: ['A texture setting must be changed, not read (use texture.configure_texture).', 'The texture group or another property not listed here must be read (use inspect.get_property).'] })
-];
-//# sourceMappingURL=texture-config.js.map

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

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

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

@@ -1,28 +0,0 @@
-import { bool, ex, HIGH, MEDIUM, num, r, str, WRITE, WRITE_POLICY } from './builder.js';
-import { schema } from '../shared/record-presets.js';
-const OK = schema({ success: bool('Operation succeeded.'), details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' } }, ['success']);
-const TEXTURES = '/Game/Textures';
-const OUTPUT_PATH = str('Full output asset path, e.g. /Game/Textures/T_Noise; replaces name and path.');
-const COLOR = (what) => ({ description: `${what} as {r, g, b, a} or [r, g, b, a] in 0-1.` });
-const DONE = { success: true };
-export const TEXTURE_CREATE_RECORDS = [
-    r('create_noise_texture', 'texture', 'Generate a procedural noise texture.', schema({ name: str('Texture name.'), path: str('Package path.'), outputPath: OUTPUT_PATH, noiseType: str('Perlin (default), FBM (same as Perlin), Ridged or Billow.'), width: num('Texture width in pixels (default 1024).'), height: num('Texture height in pixels (default 1024).'), seed: num('Random seed.'), octaves: num('Noise octaves, 1-16 (default 4).'), scale: num('Noise scale (default 1).'), persistence: num('Amplitude kept per octave (default 0.5).'), lacunarity: num('Frequency gain per octave (default 2).'), seamless: bool('Tile seamlessly (default false).') }, [], ['name', 'outputPath']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Generate a 1024px Perlin noise texture', { name: 'T_Noise', path: TEXTURES, noiseType: 'Perlin', width: 1024, height: 1024, seed: 1337, octaves: 4, scale: 8 }, DONE)],
-        whenToUse: ['A procedural Perlin, ridged or billow noise texture is needed as a mask, cloud or roughness variation; it can tile.'],
-        whenNotToUse: ['The noise can be computed in the material graph instead of baked (use material.add_material_node with nodeKind=noise).'] }),
-    r('create_gradient_texture', 'texture', 'Generate a gradient texture.', schema({ name: str('Texture name.'), path: str('Package path.'), outputPath: OUTPUT_PATH, gradientType: str('Linear (default), Radial or Angular.'), width: num('Texture width in pixels (default 1024).'), height: num('Texture height in pixels (default 1024).'), angle: num('Linear gradient direction in degrees (default 0).'), centerX: num('Radial or angular centre X, 0-1 (default 0.5).'), centerY: num('Radial or angular centre Y, 0-1 (default 0.5).'), radius: num('Radial gradient radius, 0-1 (default 0.5).'), startColor: COLOR('Start colour (default black)'), endColor: COLOR('End colour (default white)') }, [], ['name', 'outputPath']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Generate a linear gradient ramp', { name: 'T_Gradient', path: TEXTURES, gradientType: 'Linear', width: 512, height: 512 }, DONE)],
-        whenToUse: ['A linear, radial or angular gradient ramp texture is needed, for example a mask or falloff.'],
-        whenNotToUse: ['A gradient is only needed inside one material and can come from its UVs and math nodes (use material.add_material_node).'] }),
-    r('create_pattern_texture', 'texture', 'Generate a pattern texture (checker, grid, brick, stripes, dots).', schema({ name: str('Texture name.'), path: str('Package path.'), outputPath: OUTPUT_PATH, patternType: str('Checker (default), Grid, Brick, Stripes or Dots.'), width: num('Texture width in pixels (default 1024).'), height: num('Texture height in pixels (default 1024).'), tilesX: num('Pattern repeats across, 1-1024 (default 8).'), tilesY: num('Pattern repeats down, 1-1024 (default 8).'), lineWidth: num('Grid line width as a fraction of a tile (default 0.02).'), brickRatio: num('Brick width to height ratio (default 2).'), offset: num('Brick row offset, 0-1 (default 0.5).'), primaryColor: COLOR('Main colour (default white)'), secondaryColor: COLOR('Second colour (default black)') }, [], ['name', 'outputPath']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Generate a brick pattern', { name: 'T_Brick', path: TEXTURES, patternType: 'Brick', width: 1024, height: 1024 }, DONE)],
-        whenToUse: ['A checker, grid, brick, stripe or dot pattern texture is needed, for example a debug or placeholder surface.'],
-        whenNotToUse: ['A photo or authored image file must be brought into the project (use asset.import).'] }),
-    r('create_text_texture', 'texture', 'Draw text into a texture with any Font asset and face, scaled to fit, for a print, sign, label or logo on a mesh.', schema({ text: str('The words to draw; a newline starts a new line.'), name: str('Texture name.'), path: str('Package path.'), outputPath: OUTPUT_PATH, width: num('Texture width in pixels (default 1024).'), height: num('Texture height in pixels (default 256).'), fontFamily: str('Font asset, e.g. /Engine/EngineFonts/Roboto (default) or a project font.'), typeface: str('Face of the font: Regular, Bold, Italic, Light... (default Bold when the font has it). A face the font lacks is refused with the list it has.'), letterSpacing: num('Extra space between letters, in thousandths of an em (0 normal, 100 airy, negative tighter).'), justification: str('Line alignment of multi-line text: left, center (default) or right.'), padding: num('Space kept clear around the text, in pixels (default 4% of the shorter side); the text is scaled to fill the rest.'), color: COLOR('Text colour (default white)'), backgroundColor: COLOR('Background (default transparent, so the alpha channel is the text mask)') }, ['text'], ['name', 'outputPath']), schema({ success: bool('Operation succeeded.'), assetPath: str('The new texture.'), width: num('Texture width.'), height: num('Texture height.'), fontFamily: str('Font asset drawn with.'), typeface: str('Face drawn with.'), typefaces: { type: 'array', items: { type: 'string' }, description: 'Every face the font has.' }, inkBounds: { type: 'object', properties: { x: num('Left pixel.'), y: num('Top pixel.'), width: num('Width in pixels.'), height: num('Height in pixels.') }, additionalProperties: false, description: 'Pixel box the drawn letters cover.' }, fontSize: num('Font size the text was fitted at, the largest whose lines (letter spacing included) fit inside the padding.'), saved: bool('Whether the texture was saved.'), details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' } }, ['success']), WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Draw a shirt print', { text: 'ANTHROPOMORPHIC', name: 'T_Print', path: TEXTURES, width: 2048, height: 256, typeface: 'Bold', letterSpacing: 120 }, DONE)],
-        whenToUse: ['Words must appear on a surface: a shirt print, sign, label, logo or number, sampled by a material or a decal.'],
-        whenNotToUse: ['The text belongs in the HUD or a menu (use manage_blueprint widget text), or must change at runtime (use a Text Render component).'] }),
-    r('create_normal_from_height', 'texture', 'Generate a normal map from a heightmap texture.', schema({ sourceTexture: str('Source heightmap texture path; its source must be an 8-bit BGRA8 or single-channel G8 texture, read as its luminance (a G8 source is its gray). Other source formats (G16, RGBA16, float, HDR) fail with an error naming the format found.'), name: str('Output texture name (default <source>_N).'), path: str('Package path (default the source folder).'), outputPath: OUTPUT_PATH, strength: num('Normal strength.') }, ['sourceTexture']), OK, WRITE, WRITE_POLICY, MEDIUM, { examples: [ex('Derive a normal map from a heightmap', { sourceTexture: `${TEXTURES}/T_Height`, name: 'T_Normal', path: TEXTURES, strength: 2 }, DONE)],
-        whenToUse: ['A normal map must be derived from a heightmap texture; strength scales the bump depth.'],
-        whenNotToUse: ['An existing normal map only needs a channel flipped (use texture.adjust_texture with adjust=invert).'] }),
-    r('create_ao_from_mesh', 'texture', 'Bake a real ray-traced ambient occlusion texture of a static mesh in its own UV space (grayscale, linear): crevices come out dark, open surfaces white.', schema({ meshPath: str('Static mesh to bake, e.g. /Game/Meshes/SM_Rock.'), name: str('Output texture name.'), path: str('Package path (default /Game/Textures).'), outputPath: OUTPUT_PATH, width: num('Texture width in pixels (default 1024).'), height: num('Texture height in pixels (default 1024).'), samples: num('Occlusion rays per texel, 1-1024 (default 64); more is smoother and slower.'), rayDistance: num('Farthest occluder counted, in cm; 0 (default) means unlimited, negative is refused.'), uvChannel: num('UV channel to bake into (default 0, the one materials sample); a lightmap channel avoids overlapping UVs.') }, ['meshPath'], ['name', 'outputPath']), schema({ success: bool('Operation succeeded.'), assetPath: str('The baked texture.'), width: num('Texture width.'), height: num('Texture height.'), minValue: num('Darkest texel, 0-1.'), meanValue: num('Average texel over the whole texture, 0-1 (unused texels count as 1).'), maxValue: num('Brightest texel, 0-1.'), convexMesh: bool('True when the bake is flat because the mesh is convex and cannot occlude itself.'), saved: bool('Whether the texture was saved.'), details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Operation details.' } }, ['success']), { ...WRITE, longRunning: true }, WRITE_POLICY, HIGH, { examples: [ex('Bake ambient occlusion of a mesh', { meshPath: '/Engine/EngineMeshes/SM_MatPreviewMesh_01', name: 'T_AO_Preview', path: TEXTURES, width: 256, height: 256, samples: 32 }, DONE)],
-        whenToUse: ['A static mesh needs a ray-traced ambient occlusion map in its UV space; a convex mesh comes out flat white.'],
-        whenNotToUse: ['Scene lighting must be built, not a per-mesh texture (use build_environment.build_lighting).'] }),
-];
-//# sourceMappingURL=texture-create.js.map

package/dist/tools/catalog/capabilities/records/manage-audio/authoring.data.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-audio/authoring.data.js

@@ -1,121 +0,0 @@
-import { utilityRecord, withInputProps, withTopics } from '../utility/utility-record-builders.js';
-const T = 'manage_audio';
-const META = ['MetaSound'];
-const META_LITERAL = {
-    description: 'Value in the data type of the input: a number (Float, Int32, Time, enums), a boolean, a string, or a JSON '
-        + 'array of them for an array input such as Float:Array. Converted to the declared type; a mismatch is refused.',
-};
-const OBJ_ITEM = { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true };
-const BUILD_METASOUND_EXAMPLE = {
-    input: {
-        action: 'build_metasound', assetPath: '/Game/Audio/MS_Beep', operations: [
-            { edit: 'add_node', id: 'osc', nodeClassName: 'UE.Sine.Audio' },
-            { edit: 'set_default', nodeId: '$osc', inputName: 'Frequency', defaultValue: 880 },
-        ],
-    },
-    output: { success: true, message: 'Ran 2 MetaSound operations', nodeIds: { osc: '5E1F0C2A4B7D4E8F9A0B1C2D3E4F5A6B' } },
-};
-const SINE_ID = '5E1F0C2A4B7D4E8F9A0B1C2D3E4F5A6B';
-const OUT_ID = '0A1B2C3D4E5F60718293A4B5C6D7E8F9';
-const GET_METASOUND_GRAPH_EXAMPLE = {
-    input: { action: 'get_metasound_graph', assetPath: '/Game/Audio/MS_Beep' },
-    output: {
-        success: true, assetPath: '/Game/Audio/MS_Beep.MS_Beep', nodeCount: 2, edgeCount: 1,
-        nodes: [
-            { nodeId: SINE_ID, name: 'Sine', className: 'UE.Sine.Audio', kind: 'Node', inputs: [{ name: 'Frequency', type: 'Float', literal: '880.000000' }], outputs: [{ name: 'Audio', type: 'Audio' }] },
-            { nodeId: OUT_ID, name: 'Out Mono', className: 'Out Mono', kind: 'GraphOutput', inputs: [{ name: 'Out Mono', type: 'Audio' }], outputs: [] },
-        ],
-        edges: [{ fromNodeId: SINE_ID, fromNode: 'Sine', fromPin: 'Audio', toNodeId: OUT_ID, toNode: 'Out Mono', toPin: 'Out Mono' }],
-        graphInputs: [], graphOutputs: [{ name: 'Out Mono', type: 'Audio', nodeId: OUT_ID }],
-    },
-};
-const SAVE = { type: 'boolean', description: 'Persist the asset to disk (default true); false leaves the change in memory only.' };
-const PARENT_CLASS = { type: 'string', description: 'Canonical /Game SoundClass asset path of the parent class.' };
-const a = (action, summary, params, required, outputs = [], outputRequired = [], plugins = [], requiredOneOf) => {
-    const record = utilityRecord({
-        tool: T, action, family: plugins.length > 0 ? 'metasound' : 'authoring', summary,
-        params, required, requiredOneOf, outputs, outputRequired, plugins,
-    });
-    return params.includes('save') ? withInputProps(record, { save: SAVE }) : record;
-};
-export const AUDIO_AUTHORING_RECORDS = [
-    a('add_cue_node', 'Add a node to a Sound Cue graph: wave_player (wavePath), mixer, random, modulator (volume, pitch), looping (indefinite, loopCount), attenuation (attenuationPath), concatenator, delay (delay), switch or branch.', ['assetPath', 'nodeType', 'wavePath', 'volume', 'pitch', 'indefinite', 'loopCount', 'attenuationPath', 'delay', 'save'], ['assetPath', 'nodeType'], ['nodeId'], ['nodeId']),
-    withInputProps(a('add_metasound_input', 'Add an input to a MetaSound graph.', ['assetPath', 'inputName', 'inputType', 'defaultValue', 'save'], ['assetPath', 'inputName', 'inputType'], [], [], META), { defaultValue: META_LITERAL }),
-    a('add_metasound_node', 'Add a node to a MetaSound graph.', ['assetPath', 'nodeClassName', 'nodeType', 'save'], ['assetPath'], ['nodeId'], ['nodeId'], META, ['nodeClassName', 'nodeType']),
-    a('add_metasound_output', 'Add an output to a MetaSound graph.', ['assetPath', 'outputName', 'outputType', 'save'], ['assetPath', 'outputName', 'outputType'], [], [], META),
-    withInputProps(a('set_metasound_default', 'Set the default of a MetaSound graph input, or with nodeId the literal on a node input (an oscillator frequency, an envelope time, a note array).', ['assetPath', 'inputName', 'defaultValue', 'save'], ['assetPath', 'inputName', 'defaultValue'], [], [], META), {
-        defaultValue: META_LITERAL,
-        nodeId: { type: 'string', description: 'Set an input on this node (the nodeId add_metasound_node returned) instead of a graph input; inputName then names the node input.' },
-    }),
-    a('add_mix_modifier', 'Add a Sound Class modifier to a Sound Mix; fadeInTime and fadeOutTime set the fades of the mix itself.', ['assetPath', 'soundClassPath', 'volumeAdjuster', 'pitchAdjuster', 'applyToChildren', 'fadeInTime', 'fadeOutTime', 'save'], ['assetPath', 'soundClassPath']),
-    a('add_source_effect', 'Add an effect to a Source Effect Chain: a new preset of effectType, or an existing preset asset by effectPresetPath.', ['assetPath', 'effectType', 'effectPresetPath', 'bypass', 'save'], ['assetPath'], [], [], [], ['effectType', 'effectPresetPath']),
-    { ...(withInputProps(a('build_metasound', 'Run many MetaSound graph edits in one call: add nodes, inputs and outputs, connect pins and set literals, with $id references between steps.', ['assetPath'], ['assetPath', 'operations'], ['nodeIds', 'results', 'saved'], [], META), {
-            operations: {
-                type: 'array', items: OBJ_ITEM, 'x-unreal-reflection-boundary': true,
-                description: 'Steps run in order, 1-200, stopping at the first failure; every add_node class is looked up first, so a node '
-                    + 'class the registry does not hold fails the batch with nothing applied, and so is every pin a connect or set_default names '
-                    + 'on a node the batch adds (a wrong one fails with PIN_NOT_FOUND and that node\'s pins). Each is {edit, ...the params of that edit}: edit is '
-                    + 'add_node, connect, disconnect, remove_node, set_default, add_input or add_output (the add_metasound_node, connect_metasound_nodes, '
-                    + 'disconnect_metasound_nodes, remove_metasound_node, set_metasound_default, add_metasound_input, add_metasound_output params). Optional per step: id (names the node '
-                    + 'it creates; later steps use "$id" in nodeId/nodeIds/sourceNodeId/targetNodeId), from/to ("$id.PinName" shorthand for '
-                    + 'connect; interface nodes such as the On Play input are named with the explicit fields).',
-            },
-            save: { type: 'boolean', description: 'Save the MetaSound once, after the steps (default true); a batch that stops at a failing step saves the steps before it. false leaves every edit in memory only.' },
-        })), examples: [{ title: 'Build a one-oscillator MetaSound', ...BUILD_METASOUND_EXAMPLE }] },
-    withInputProps(a('configure_distance_attenuation', 'Configure distance attenuation: inner radius, falloff distance and curve, and air absorption (a low-pass that muffles the sound with distance).', ['assetPath', 'innerRadius', 'falloffDistance', 'distanceAlgorithm', 'save'], ['assetPath']), {
-        attenuateWithLPF: { type: 'boolean', description: 'Air absorption on or off: a low-pass whose cutoff drops with distance. Sending any lpf value turns it on unless this is false.' },
-        lpfRadiusMin: { type: 'number', description: 'Distance in cm where the low-pass starts closing; nearer than this the cutoff is lpfFrequencyAtMin.' },
-        lpfRadiusMax: { type: 'number', description: 'Distance in cm where the cutoff reaches lpfFrequencyAtMax.' },
-        lpfFrequencyAtMin: { type: 'number', description: 'Low-pass cutoff in Hz at lpfRadiusMin and nearer (20000 leaves the sound unfiltered).' },
-        lpfFrequencyAtMax: { type: 'number', description: 'Low-pass cutoff in Hz at lpfRadiusMax and beyond (900 sounds like a distant, muffled engine).' },
-    }),
-    a('configure_mix_eq', 'Configure Sound Mix equalization: the four bands through eqSettings, or the low, mid, highMid and high fields.', ['assetPath', 'applyEQ', 'eqPriority', 'eqSettings', 'lowFrequency', 'lowGain', 'midFrequency', 'midGain', 'highMidFrequency', 'highMidGain', 'highFrequency', 'highGain', 'save'], ['assetPath']),
-    a('configure_occlusion', 'Configure audio occlusion.', ['assetPath', 'enable', 'occlusionVolumeScale', 'occlusionFilterScale', 'occlusionInterpolationTime', 'save'], ['assetPath']),
-    a('configure_reverb_send', 'Configure an audio reverb send.', ['assetPath', 'enableReverbSend', 'reverbDistanceMin', 'reverbDistanceMax', 'reverbWetLevelMin', 'reverbWetLevelMax', 'save'], ['assetPath']),
-    a('configure_spatialization', 'Configure audio spatialization.', ['assetPath', 'spatialize', 'spatialization', 'save'], ['assetPath']),
-    a('connect_cue_nodes', 'Connect two Sound Cue graph nodes.', ['assetPath', 'sourceNodeId', 'targetNodeId', 'childIndex', 'save'], ['assetPath', 'sourceNodeId', 'targetNodeId']),
-    withInputProps(a('remove_metasound_node', 'Remove one node, or several with nodeIds, and every link on them from a MetaSound graph; graph inputs and outputs (On Play, Out Mono) are refused. All or nothing.', ['assetPath', 'nodeId', 'nodeIds', 'save'], ['assetPath'], ['removed', 'removedCount', 'saved'], ['removed'], META, ['nodeId', 'nodeIds']), {
-        nodeIds: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 200, description: 'Several node ids to remove in one call, in place of nodeId; every one must exist or nothing is removed.' },
-    }),
-    a('disconnect_metasound_nodes', 'Remove a link from a MetaSound graph: the one into targetNodeId.targetInputName, or every link out of sourceNodeId.sourceOutputName; with both ends given, that exact link. Refused when there is no such link.', ['assetPath', 'sourceNodeId', 'sourceOutputName', 'targetNodeId', 'targetInputName', 'save'], ['assetPath'], ['edgesRemoved', 'saved'], ['edgesRemoved'], META, ['targetNodeId', 'sourceNodeId']),
-    { ...withTopics(utilityRecord({
-            tool: T, action: 'get_metasound_graph', family: 'metasound', summary: 'Read a MetaSound graph: every node with its input literals, the links by pin name, and the graph inputs and outputs.',
-            params: ['assetPath'], required: ['assetPath'], effect: 'read', plugins: META,
-            outputs: ['assetPath', 'nodeCount', 'edgeCount', 'nodes', 'edges', 'graphInputs', 'graphOutputs'], outputRequired: ['nodes', 'edges'],
-        }), ['read metasound graph', 'metasound nodes', 'list metasound nodes', 'inspect metasound', 'metasound links']), examples: [{ title: 'Read a one-oscillator MetaSound', ...GET_METASOUND_GRAPH_EXAMPLE }] },
-    a('connect_metasound_nodes', 'Connect two MetaSound graph pins.', ['assetPath', 'sourceNodeId', 'sourceOutputName', 'targetNodeId', 'targetInputName', 'save'], ['assetPath', 'sourceNodeId', 'sourceOutputName', 'targetNodeId', 'targetInputName'], [], [], META),
-    a('create_attenuation_settings', 'Create attenuation settings and return the asset path.', ['name', 'path', 'innerRadius', 'falloffDistance', 'save'], ['name'], ['assetPath'], ['assetPath']),
-    a('create_dialogue_voice', 'Create a Dialogue Voice asset and return its path.', ['name', 'path', 'gender', 'plurality', 'save'], ['name'], ['assetPath'], ['assetPath']),
-    a('create_dialogue_wave', 'Create a Dialogue Wave asset and return its path; wavePath or speakerPath adds its first context mapping.', ['name', 'path', 'spokenText', 'wavePath', 'speakerPath', 'save'], ['name'], ['assetPath'], ['assetPath']),
-    withInputProps(a('create_metasound', 'Create a MetaSound asset, named by name and path or by its full assetPath, and return its asset path. A MetaSound already at that path is refused (ASSET_EXISTS), never replaced. A one-shot source (the default: On Play in, On Finished out) is never virtualized by the engine, so one left playing on an AudioComponent that starts out of earshot is dropped for good; make a drone, hum or ambience with oneShot false.', ['name', 'path', 'assetPath', 'oneShot', 'save'], [], ['assetPath', 'oneShot'], ['assetPath'], META, ['name', 'assetPath']), {
-        oneShot: { type: 'boolean', description: 'false makes a continuous source with no On Finished output: the engine treats it as looping, so a hum or ambience whose AudioComponent starts out of earshot resumes when the listener comes near. Default true (it plays until On Finished fires).' },
-    }),
-    a('create_reverb_effect', 'Create a Reverb Effect asset and return its path.', ['name', 'path', 'density', 'diffusion', 'gain', 'gainHF', 'decayTime', 'decayHFRatio', 'save'], ['name'], ['assetPath'], ['assetPath']),
-    a('create_source_effect_chain', 'Create a Source Effect Chain asset and return its path.', ['name', 'path', 'save'], ['name'], ['assetPath'], ['assetPath']),
-    withInputProps(a('create_submix_effect', 'Create a Sound Submix whose effect chain holds a new submix effect preset of effectType, and return its path.', ['name', 'path', 'effectType', 'save'], ['name', 'effectType'], ['assetPath'], ['assetPath']), {
-        effectType: { type: 'string', description: 'Submix effect: Reverb, EQ or Dynamics (a compressor).' },
-    }),
-    withInputProps(a('create_sound_class', 'Create a Sound Class asset and return its asset path.', ['name', 'path', 'parentClass', 'volume', 'pitch', 'save'], ['name'], ['assetPath'], ['assetPath']), { parentClass: PARENT_CLASS }),
-    withTopics(a('create_sound_cue', 'Create a Sound Cue asset and return its asset path; volume and pitch add a modulator over the wave player.', ['name', 'path', 'wavePath', 'looping', 'volume', 'pitch', 'save'], ['name'], ['assetPath'], ['assetPath']), ['sound cue', 'new sound cue', 'audio cue']),
-    a('create_sound_mix', 'Create a Sound Mix asset and return its asset path.', ['name', 'path', 'save'], ['name'], ['assetPath'], ['assetPath']),
-    utilityRecord({
-        tool: T, action: 'get_audio_info', family: 'authoring',
-        summary: 'Read an audio asset: Sound Wave duration, sample rate and channel count; Sound Cue duration, node count and attenuation; Sound Class volume, pitch and parent; Sound Mix modifier count; Attenuation falloff.',
-        topics: ['sound length', 'duration', 'sample rate', 'channel count', 'how long is a sound', 'wav sample rate', 'how many nodes in a sound cue'],
-        params: ['assetPath'], required: ['assetPath'], effect: 'read',
-        outputs: ['assetPath', 'assetClass', 'type', 'duration', 'nodeCount', 'attenuationPath', 'sampleRate',
-            'numChannels', 'volume', 'pitch', 'parentClass', 'modifierCount', 'falloffDistance', 'spatialize'],
-        outputRequired: ['assetPath', 'assetClass', 'type'],
-    }),
-    a('set_audio_occlusion', 'Configure occlusion settings on a sound asset.', ['soundPath', 'enable', 'occlusionVolumeScale', 'occlusionFilterScale', 'occlusionInterpolationTime', 'save'], ['soundPath']),
-    withInputProps(a('set_class_parent', 'Set a Sound Class parent.', ['assetPath', 'parentClass', 'save'], ['assetPath']), {
-        parentClass: { type: 'string', description: 'Canonical /Game SoundClass asset path of the new parent; omit it to clear the parent.' },
-    }),
-    a('set_class_properties', 'Set Sound Class properties.', ['assetPath', 'volume', 'pitch', 'lowPassFilterFrequency', 'lfeBleed', 'voiceCenterChannelVolume', 'save'], ['assetPath']),
-    a('set_cue_attenuation', 'Assign attenuation settings to a Sound Cue; omit attenuationPath to clear them.', ['assetPath', 'attenuationPath', 'save'], ['assetPath']),
-    withTopics(a('set_doppler_effect', 'Add a Doppler node at the root of a Sound Cue (or update the one already there) so the cue shifts pitch as its source moves toward or away from the listener. Sound Cues only; a SoundWave or MetaSound is refused.', ['assetPath', 'dopplerIntensity', 'smoothing', 'save'], ['assetPath'], ['nodeName', 'inserted', 'dopplerIntensity', 'smoothing', 'rootNodeClass', 'drivesNode', 'saved'], ['inserted']), ['doppler effect', 'pitch shift moving sound']),
-    a('set_cue_concurrency', 'Assign concurrency settings to a Sound Cue.', ['assetPath', 'concurrencyPath', 'save'], ['assetPath']),
-    withTopics(a('set_dialogue_context', 'Add a context mapping to a Dialogue Wave: who speaks it, to whom, and which SoundWave plays.', ['assetPath', 'speakerPath', 'targetVoices', 'soundWavePath', 'localizationKeyFormat', 'replace', 'save'], ['assetPath']), ['link sound to speaker']),
-    a('set_sound_attenuation', 'Create or update sound attenuation settings.', ['name', 'path', 'innerRadius', 'falloffDistance', 'attenuationShape', 'falloffMode', 'save'], ['name'], ['assetPath'], ['assetPath']),
-];
-//# sourceMappingURL=authoring.data.js.map

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

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

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

@@ -1,10 +0,0 @@
-import { AUDIO_AUTHORING_RECORDS } from './authoring.data.js';
-import { AUDIO_RUNTIME_RECORDS } from './runtime.data.js';
-import { MANAGE_AUDIO_FOLDS } from '../folds/manage-audio.folds.js';
-import { applyFolds } from '../shared/fold.js';
-export const MANAGE_AUDIO_UNFOLDED_SOURCES = [
-    ...AUDIO_RUNTIME_RECORDS,
-    ...AUDIO_AUTHORING_RECORDS,
-];
-export const MANAGE_AUDIO_SOURCES = Object.freeze(applyFolds(MANAGE_AUDIO_UNFOLDED_SOURCES, MANAGE_AUDIO_FOLDS, 'manage_audio'));
-//# sourceMappingURL=index.js.map

package/dist/tools/catalog/capabilities/records/manage-audio/runtime.data.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-audio/runtime.data.js

@@ -1,30 +0,0 @@
-import { utilityRecord, withTopics } from '../utility/utility-record-builders.js';
-const T = 'manage_audio';
-const RUNTIME = ['edit', 'pie', 'simulate'];
-const r = (action, summary, params = [], required = [], outputs = [], outputRequired = []) => utilityRecord({
-    tool: T, action, family: 'runtime', summary, params, required, outputs, outputRequired,
-    states: RUNTIME, safeToRetry: false,
-});
-export const AUDIO_RUNTIME_RECORDS = [
-    r('clear_sound_mix_class_override', 'Clear a Sound Mix class override.', ['mixName', 'soundClassName', 'fadeOutTime'], ['mixName', 'soundClassName']),
-    r('create_ambient_sound', 'Create an ambient sound actor.', ['soundPath', 'location', 'name', 'volume', 'pitch', 'attenuationPath', 'concurrencyPath'], ['soundPath'], ['actorName'], ['actorName']),
-    r('create_audio_component', 'Create an audio component on an actor, or on a new actor at location when actorName is omitted.', ['actorName', 'componentName', 'soundPath', 'location', 'rotation', 'volume', 'pitch', 'autoPlay'], ['soundPath'], ['componentName'], ['componentName']),
-    r('create_reverb_zone', 'Create a runtime reverb zone actor.', ['name', 'location', 'size', 'reverbEffect', 'volume', 'fadeTime'], ['name'], ['actorName'], ['actorName']),
-    r('fade_sound', 'Fade a named sound instance to a target volume.', ['soundName', 'componentName', 'targetVolume', 'fadeTime', 'fadeType'], ['soundName']),
-    r('fade_sound_in', 'Fade a sound instance in.', ['soundName', 'componentName', 'fadeInTime', 'targetVolume'], ['soundName']),
-    r('fade_sound_out', 'Fade a sound instance out.', ['soundName', 'componentName', 'fadeOutTime', 'targetVolume'], ['soundName']),
-    withTopics(r('play_sound_2d', 'Play a non-spatial sound.', ['soundPath', 'volume', 'pitch', 'startTime'], ['soundPath']), ['play sound', 'play audio', 'play sfx', 'ui sound', 'play music']),
-    withTopics(r('play_sound_at_location', 'Play a sound at a world location.', ['soundPath', 'location', 'rotation', 'volume', 'pitch', 'startTime', 'attenuationPath', 'concurrencyPath'], ['soundPath']), ['play sound at location', '3d sound', 'spatial sound', 'positional audio']),
-    r('play_sound_attached', 'Play a sound attached to an actor component.', ['soundPath', 'actorName', 'componentName', 'attachPointName', 'volume', 'pitch'], ['soundPath', 'actorName']),
-    withTopics(r('play_sound_measure', 'Play a sound 2D and measure how loud it played, from the mixer\'s own meter: peak and average level in dB and a timeline, with silent: true when it played but produced no audio (an empty Sound Cue, a MetaSound whose audio output is unconnected). A Sound Wave also gets the peak, RMS and length of the recording itself (wavePeakDb, waveRmsDb, waveSeconds), which hold however slowly the editor draws. Answers when the sound ends or after maxSeconds.', ['soundPath', 'volume', 'maxSeconds'], ['soundPath'], ['peakDb', 'averageDb', 'silent', 'envelopeUpdates', 'endedBecause', 'timeline', 'timelineStepSeconds', 'wavePeakDb', 'waveRmsDb', 'waveSeconds'], ['peakDb', 'silent']), ['measure sound', 'sound level', 'is sound audible', 'loudness', 'silent sound', 'audio meter', 'verify sound plays']),
-    r('pop_sound_mix', 'Pop a Sound Mix from the runtime mix stack.', ['mixName'], ['mixName']),
-    r('prime_sound', 'Prime a sound asset for playback.', ['soundPath'], ['soundPath']),
-    r('push_sound_mix', 'Push a Sound Mix onto the runtime mix stack.', ['mixName'], ['mixName']),
-    r('set_base_sound_mix', 'Set the runtime base Sound Mix.', ['mixName'], ['mixName']),
-    r('set_sound_mix_class_override', 'Set a Sound Mix class override.', ['mixName', 'soundClassName', 'volume', 'pitch', 'fadeTime'], ['mixName', 'soundClassName']),
-    withTopics(r('stop_sound', 'Stop sounds: the 2D sounds play_sound started (only that sound with soundPath), or with all every sound the editor and a running game play, its music included.', ['soundPath', 'all'], [], ['stopped', 'allStopped']), ['stop sound', 'stop music', 'stop audio', 'silence', 'mute audio']),
-    r('pause_sound', 'Pause the sounds stop_sound would stop, each held where it is. Sounds already paused are not counted.', ['soundPath', 'all'], [], ['paused']),
-    r('resume_sound', 'Resume the paused sounds stop_sound would stop, each from where it was paused.', ['soundPath', 'all'], [], ['resumed']),
-    r('spawn_sound_at_location', 'Spawn a transient sound at a world location.', ['soundPath', 'location', 'rotation', 'volume', 'pitch', 'name'], ['soundPath'], ['componentName']),
-];
-//# sourceMappingURL=runtime.data.js.map

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

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