@uemcp/server 1.2.0 → 1.3.0

package/dist/index.mjs

@@ -2972,6 +2972,1603 @@ function createBridgeGetCreateClassStatusRequest(createClassJobId, requestId = r
 		version: 2
 	});
 }
+const BRIDGE_LIST_ASSET_FACTORIES_REQUEST_TYPE = "list_asset_factories";
+const BRIDGE_CREATE_ASSET_REQUEST_TYPE = "create_asset";
+const BRIDGE_DUPLICATE_ASSET_REQUEST_TYPE = "duplicate_asset";
+const BRIDGE_RENAME_ASSET_REQUEST_TYPE = "rename_asset";
+const BRIDGE_MOVE_ASSET_REQUEST_TYPE = "move_asset";
+const BRIDGE_DELETE_ASSET_REQUEST_TYPE = "delete_asset";
+const BRIDGE_SAVE_ASSET_REQUEST_TYPE = "save_asset";
+const BRIDGE_CREATE_FOLDER_REQUEST_TYPE = "create_folder";
+const BRIDGE_GET_ASSET_METADATA_REQUEST_TYPE = "get_asset_metadata";
+const BRIDGE_LIST_GRAPH_NODES_REQUEST_TYPE = "list_graph_nodes";
+const BRIDGE_ADD_GRAPH_NODE_REQUEST_TYPE = "add_graph_node";
+const BRIDGE_REMOVE_GRAPH_NODE_REQUEST_TYPE = "remove_graph_node";
+const BRIDGE_CONNECT_PINS_REQUEST_TYPE = "connect_pins";
+const BRIDGE_DISCONNECT_PINS_REQUEST_TYPE = "disconnect_pins";
+const BRIDGE_SET_PIN_DEFAULT_REQUEST_TYPE = "set_pin_default";
+const BRIDGE_LIST_AVAILABLE_NODES_REQUEST_TYPE = "list_available_nodes";
+const BRIDGE_SET_VIEWPORT_CAMERA_REQUEST_TYPE = "set_viewport_camera";
+const BRIDGE_FOCUS_ACTORS_REQUEST_TYPE = "focus_actors";
+const BRIDGE_SET_VIEW_MODE_REQUEST_TYPE = "set_view_mode";
+const BRIDGE_TOGGLE_SHOW_FLAGS_REQUEST_TYPE = "toggle_show_flags";
+const BRIDGE_HIGH_RES_SCREENSHOT_REQUEST_TYPE = "high_res_screenshot";
+const BRIDGE_DUPLICATE_ACTOR_REQUEST_TYPE = "duplicate_actor";
+const BRIDGE_ATTACH_ACTOR_REQUEST_TYPE = "attach_actor";
+const BRIDGE_ADD_ACTOR_COMPONENT_REQUEST_TYPE = "add_actor_component";
+const BRIDGE_SET_ACTOR_TAGS_REQUEST_TYPE = "set_actor_tags";
+const BRIDGE_MOVE_TO_FOLDER_REQUEST_TYPE = "move_to_folder";
+const BRIDGE_PLACE_ASSET_REQUEST_TYPE = "place_asset";
+const BRIDGE_REPLACE_ACTORS_REQUEST_TYPE = "replace_actors";
+const BRIDGE_START_EDITOR_BUILD_REQUEST_TYPE = "start_editor_build";
+const BRIDGE_GET_BUILD_JOB_STATUS_REQUEST_TYPE = "get_build_job_status";
+const BRIDGE_CREATE_GAMEPLAY_TAG_REQUEST_TYPE = "create_gameplay_tag";
+const BRIDGE_LIST_GAMEPLAY_TAGS_REQUEST_TYPE = "list_gameplay_tags";
+const BRIDGE_CREATE_LANDSCAPE_REQUEST_TYPE = "create_landscape";
+const BRIDGE_SCULPT_LANDSCAPE_REQUEST_TYPE = "sculpt_landscape";
+const BRIDGE_PAINT_LANDSCAPE_LAYER_REQUEST_TYPE = "paint_landscape_layer";
+const BRIDGE_RUN_GEOMETRY_SCRIPT_REQUEST_TYPE = "run_geometry_script";
+const BRIDGE_LIST_DATA_LAYERS_REQUEST_TYPE = "list_data_layers";
+const BRIDGE_SET_DATA_LAYER_STATE_REQUEST_TYPE = "set_data_layer_state";
+const BRIDGE_LOAD_WP_REGION_REQUEST_TYPE = "load_wp_region";
+const BRIDGE_CREATIVE_EDIT_STATES = ["applied", "unsupported"];
+const BRIDGE_FACTORY_OPTION_VALUE_MAX_CHARS = 1024;
+const BRIDGE_DELETE_ASSET_STATES = [
+	"deleted",
+	"blocked",
+	"unsupported"
+];
+const BRIDGE_CREATE_FOLDER_STATES = [
+	"created",
+	"exists",
+	"unsupported"
+];
+const BRIDGE_ASSET_METADATA_STATES = ["reported", "unsupported"];
+const BRIDGE_GRAPH_PIN_VALUE_MAX_CHARS = 4096;
+const BRIDGE_GRAPH_NODE_POSITION_LIMIT = 1e6;
+const BRIDGE_GRAPH_NODE_KINDS = [
+	"class",
+	"function",
+	"variable_get",
+	"variable_set"
+];
+const BRIDGE_VIEWPORT_VIEW_TYPES = [
+	"perspective",
+	"ortho_top",
+	"ortho_bottom",
+	"ortho_left",
+	"ortho_right",
+	"ortho_front",
+	"ortho_back"
+];
+const BRIDGE_VIEW_MODES = [
+	"lit",
+	"unlit",
+	"wireframe",
+	"brush_wireframe",
+	"lit_lightmap_density",
+	"detail_lighting",
+	"lighting_only",
+	"light_complexity",
+	"shader_complexity",
+	"stationary_light_overlap",
+	"lightmap_density",
+	"reflections",
+	"collision_pawn",
+	"collision_visibility",
+	"quad_overdraw",
+	"primitive_distance_accuracy",
+	"mesh_uv_density_accuracy",
+	"material_texture_scale_accuracy",
+	"required_texture_resolution",
+	"path_tracing",
+	"ray_tracing_debug",
+	"visualize_buffer",
+	"visualize_nanite",
+	"visualize_lumen",
+	"visualize_virtual_shadow_map"
+];
+const BRIDGE_SCREENSHOT_STATES = ["requested", "unsupported"];
+const BRIDGE_ATTACHMENT_RULES = [
+	"keep_relative",
+	"keep_world",
+	"snap_to_target"
+];
+const BRIDGE_ACTOR_TAG_MODES = [
+	"set",
+	"add",
+	"remove"
+];
+const BRIDGE_EDITOR_BUILD_KINDS = [
+	"lighting",
+	"navigation",
+	"hlod",
+	"reflection_captures",
+	"geometry",
+	"texture_streaming",
+	"virtual_textures",
+	"precomputed_visibility"
+];
+const BRIDGE_LIGHTING_QUALITIES = [
+	"preview",
+	"medium",
+	"high",
+	"production"
+];
+const BRIDGE_HLOD_ACTIONS = [
+	"build_clusters",
+	"build_meshes",
+	"build_all",
+	"delete_clusters"
+];
+const BRIDGE_EDITOR_BUILD_ACCEPT_STATES = [
+	"accepted",
+	"busy",
+	"unsupported"
+];
+const BRIDGE_EDITOR_BUILD_JOB_STATES = [
+	"running",
+	"succeeded",
+	"failed",
+	"cancelled",
+	"unknown_job"
+];
+const BRIDGE_CREATE_GAMEPLAY_TAG_STATES = [
+	"created",
+	"exists",
+	"unsupported"
+];
+const BRIDGE_LANDSCAPE_SCULPT_MODES = [
+	"flatten",
+	"ramp",
+	"noise",
+	"heightmap_file"
+];
+const BRIDGE_LANDSCAPE_RAMP_AXES = ["x", "y"];
+const BRIDGE_LANDSCAPE_MAX_VERTEX_COORDINATE = 1e6;
+const BRIDGE_LANDSCAPE_MIN_HEIGHT = -1e6;
+const BRIDGE_LANDSCAPE_MAX_HEIGHT = 1e6;
+const BRIDGE_FILE_PATH_MAX_CHARS = 1024;
+const BRIDGE_GEOMETRY_OPERATIONS = [
+	"append_box",
+	"append_sphere",
+	"append_cylinder",
+	"append_cone",
+	"append_torus",
+	"subtract_box",
+	"subtract_sphere",
+	"subtract_cylinder",
+	"subtract_cone",
+	"subtract_torus",
+	"intersect_box",
+	"intersect_sphere",
+	"intersect_cylinder",
+	"intersect_cone",
+	"intersect_torus",
+	"translate",
+	"rotate",
+	"scale",
+	"recompute_normals",
+	"apply_displace_noise",
+	"simplify_to_triangle_count"
+];
+const BRIDGE_GEOMETRY_OUTPUTS = ["static_mesh", "dynamic_mesh_actor"];
+const BRIDGE_DATA_LAYER_RUNTIME_STATES = [
+	"unloaded",
+	"loaded",
+	"activated"
+];
+const BRIDGE_WP_REGION_ACTIONS = [
+	"pin",
+	"unpin",
+	"unpin_all"
+];
+const BRIDGE_WP_REGION_COORDINATE_LIMIT = 21e6;
+const creativeEditStateSchema = z.enum(BRIDGE_CREATIVE_EDIT_STATES);
+const contentPathSchema = z.string().trim().min(1).max(512).refine((value) => value.startsWith("/"), { message: "Content paths must start with '/', e.g. '/Game/Materials'." });
+const assetNameSchema = z.string().trim().min(1).max(256).refine((value) => !value.includes("/") && !value.includes("."), { message: "An asset name must be a single path segment; use a destination path to move the asset." });
+const factoryOptionsSchema = z.record(z.string().trim().min(1).max(128), z.string().max(BRIDGE_FACTORY_OPTION_VALUE_MAX_CHARS)).refine((value) => Object.keys(value).length <= 32, { message: `A create_asset request carries at most ${String(32)} factory options.` });
+const assetFactoryMaxResultsSchema = z.number().int().min(1).max(100);
+const saveAssetPathBatchSchema = z.array(assetPathSchema).min(1).max(64);
+const deleteAssetStateSchema = z.enum(BRIDGE_DELETE_ASSET_STATES);
+const createFolderStateSchema = z.enum(BRIDGE_CREATE_FOLDER_STATES);
+const assetMetadataStateSchema = z.enum(BRIDGE_ASSET_METADATA_STATES);
+const graphNameSchema = z.string().trim().min(1).max(256);
+const graphNodeGuidSchema = z.string().trim().min(1).max(64);
+const graphPinNameSchema = z.string().trim().min(1).max(256);
+const graphPinValueSchema = z.string().max(BRIDGE_GRAPH_PIN_VALUE_MAX_CHARS);
+const graphNodeKindSchema = z.enum(BRIDGE_GRAPH_NODE_KINDS);
+const graphNodeMaxResultsSchema = z.number().int().min(1).max(100);
+const availableNodeMaxResultsSchema = z.number().int().min(1).max(100);
+const graphNodePositionSchema = z.object({
+	x: z.number().int().min(-1e6).max(BRIDGE_GRAPH_NODE_POSITION_LIMIT).default(0),
+	y: z.number().int().min(-1e6).max(BRIDGE_GRAPH_NODE_POSITION_LIMIT).default(0)
+});
+const viewportViewTypeSchema = z.enum(BRIDGE_VIEWPORT_VIEW_TYPES);
+const viewModeSchema = z.enum(BRIDGE_VIEW_MODES);
+const viewportFovSchema = z.number().min(5).max(170);
+const screenshotStateSchema = z.enum(BRIDGE_SCREENSHOT_STATES);
+const showFlagNameSchema = z.string().trim().min(1).max(128);
+const showFlagEntrySchema = z.object({
+	enabled: z.boolean(),
+	name: showFlagNameSchema
+});
+const attachmentRuleSchema = z.enum(BRIDGE_ATTACHMENT_RULES);
+const actorTagModeSchema = z.enum(BRIDGE_ACTOR_TAG_MODES);
+const actorFolderSchema = z.string().trim().max(512);
+const editorBuildKindSchema = z.enum(BRIDGE_EDITOR_BUILD_KINDS);
+const lightingQualitySchema = z.enum(BRIDGE_LIGHTING_QUALITIES);
+const hlodActionSchema = z.enum(BRIDGE_HLOD_ACTIONS);
+const editorBuildAcceptStateSchema = z.enum(BRIDGE_EDITOR_BUILD_ACCEPT_STATES);
+const editorBuildJobStateSchema = z.enum(BRIDGE_EDITOR_BUILD_JOB_STATES);
+const buildJobIdSchema = z.string().trim().min(1);
+const gameplayTagNameSchema = z.string().trim().min(1).max(256).regex(/^[A-Za-z0-9_]+(\.[A-Za-z0-9_]+)*$/, { message: "A gameplay tag name is dot-separated, with each segment made of letters, digits or underscores." });
+const gameplayTagPrefixSchema = z.string().trim().min(1).max(256);
+const gameplayTagMaxResultsSchema = z.number().int().min(1).max(200);
+const createGameplayTagStateSchema = z.enum(BRIDGE_CREATE_GAMEPLAY_TAG_STATES);
+const landscapeQuadsPerSectionSchema = z.union([
+	z.literal(7),
+	z.literal(15),
+	z.literal(31),
+	z.literal(63),
+	z.literal(127),
+	z.literal(255)
+]);
+const landscapeSectionsPerComponentSchema = z.union([z.literal(1), z.literal(4)]);
+const landscapeComponentCountSchema = z.number().int().min(1).max(32);
+const landscapeSculptModeSchema = z.enum(BRIDGE_LANDSCAPE_SCULPT_MODES);
+const landscapeRampAxisSchema = z.enum(BRIDGE_LANDSCAPE_RAMP_AXES);
+const landscapeCoordinateSchema = z.number().int().min(-1e6).max(BRIDGE_LANDSCAPE_MAX_VERTEX_COORDINATE);
+const landscapeHeightSchema = z.number().min(BRIDGE_LANDSCAPE_MIN_HEIGHT).max(BRIDGE_LANDSCAPE_MAX_HEIGHT);
+const landscapeWeightSchema = z.number().min(0).max(1);
+const filePathSchema = z.string().trim().min(1).max(BRIDGE_FILE_PATH_MAX_CHARS);
+const landscapeRegionSchema = z.object({
+	maxX: landscapeCoordinateSchema,
+	maxY: landscapeCoordinateSchema,
+	minX: landscapeCoordinateSchema,
+	minY: landscapeCoordinateSchema
+}).refine((value) => value.maxX >= value.minX && value.maxY >= value.minY, { message: "A landscape region must have maxX >= minX and maxY >= minY." });
+const geometryOperationKindSchema = z.enum(BRIDGE_GEOMETRY_OPERATIONS);
+const geometryOutputSchema = z.enum(BRIDGE_GEOMETRY_OUTPUTS);
+const geometryParamsSchema = z.record(z.string().trim().min(1).max(64), z.number()).refine((value) => Object.keys(value).length <= 16, { message: `A geometry operation carries at most ${String(16)} params.` });
+const geometryOperationSchema = z.object({
+	kind: geometryOperationKindSchema,
+	params: geometryParamsSchema.default({}),
+	transform: transformInputSchema.optional()
+});
+const dataLayerRuntimeStateSchema = z.enum(BRIDGE_DATA_LAYER_RUNTIME_STATES);
+const dataLayerMaxResultsSchema = z.number().int().min(1).max(100);
+const wpRegionActionSchema = z.enum(BRIDGE_WP_REGION_ACTIONS);
+const wpRegionIdSchema = z.string().trim().min(1).max(64);
+const wpCoordinateSchema = z.number().min(-21e6).max(BRIDGE_WP_REGION_COORDINATE_LIMIT);
+const wpRegionBoxSchema = z.object({
+	maxX: wpCoordinateSchema,
+	maxY: wpCoordinateSchema,
+	maxZ: wpCoordinateSchema,
+	minX: wpCoordinateSchema,
+	minY: wpCoordinateSchema,
+	minZ: wpCoordinateSchema
+}).refine((value) => value.maxX >= value.minX && value.maxY >= value.minY && value.maxZ >= value.minZ, { message: "A World Partition region must have every max component >= its min component." });
+const bridgeListAssetFactoriesRequestSchema = z.object({
+	cursor: assetCursorSchema.optional(),
+	maxResults: assetFactoryMaxResultsSchema.optional(),
+	nameFilter: boundedStringSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_LIST_ASSET_FACTORIES_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateAssetRequestSchema = z.object({
+	assetClass: assetPathSchema,
+	assetName: assetNameSchema,
+	factoryClass: assetPathSchema.optional(),
+	options: factoryOptionsSchema.optional(),
+	packagePath: contentPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_CREATE_ASSET_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeDuplicateAssetRequestSchema = z.object({
+	destinationName: assetNameSchema,
+	destinationPath: contentPathSchema,
+	requestId: requestIdSchema,
+	sourceAssetPath: assetPathSchema,
+	type: z.literal(BRIDGE_DUPLICATE_ASSET_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeRenameAssetRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	newName: assetNameSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_RENAME_ASSET_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeMoveAssetRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	destinationPath: contentPathSchema,
+	newName: assetNameSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_MOVE_ASSET_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeDeleteAssetRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	force: z.boolean().optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_DELETE_ASSET_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSaveAssetRequestSchema = z.object({
+	assetPaths: saveAssetPathBatchSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_SAVE_ASSET_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateFolderRequestSchema = z.object({
+	folderPath: contentPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_CREATE_FOLDER_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeGetAssetMetadataRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_ASSET_METADATA_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeListGraphNodesRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	cursor: assetCursorSchema.optional(),
+	graphName: graphNameSchema,
+	loadIfNeeded: z.boolean().optional(),
+	maxResults: graphNodeMaxResultsSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_LIST_GRAPH_NODES_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddGraphNodeRequestFieldsSchema = z.object({
+	assetPath: assetPathSchema,
+	graphName: graphNameSchema,
+	nodeClass: assetPathSchema.optional(),
+	kind: graphNodeKindSchema,
+	memberName: boundedStringSchema.optional(),
+	memberParentClass: assetPathSchema.optional(),
+	pinDefaults: z.record(graphPinNameSchema, graphPinValueSchema).refine((value) => Object.keys(value).length <= 64, { message: `An add_graph_node request carries at most ${String(64)} pin defaults.` }).optional(),
+	position: graphNodePositionSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_ADD_GRAPH_NODE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddGraphNodeRequestSchema = bridgeAddGraphNodeRequestFieldsSchema.refine((value) => value.kind === "class" ? value.nodeClass !== void 0 : value.memberName !== void 0, {
+	message: "kind 'class' requires nodeClass; every other kind requires memberName.",
+	path: ["nodeClass"]
+});
+const bridgeRemoveGraphNodeRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	graphName: graphNameSchema,
+	nodeGuid: graphNodeGuidSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_REMOVE_GRAPH_NODE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const graphPinPairFields = {
+	assetPath: assetPathSchema,
+	graphName: graphNameSchema,
+	requestId: requestIdSchema,
+	sourceNodeGuid: graphNodeGuidSchema,
+	sourcePinName: graphPinNameSchema,
+	targetNodeGuid: graphNodeGuidSchema,
+	targetPinName: graphPinNameSchema,
+	version: z.literal(2)
+};
+const bridgeConnectPinsRequestSchema = z.object({
+	...graphPinPairFields,
+	type: z.literal(BRIDGE_CONNECT_PINS_REQUEST_TYPE)
+});
+const bridgeDisconnectPinsRequestSchema = z.object({
+	...graphPinPairFields,
+	type: z.literal(BRIDGE_DISCONNECT_PINS_REQUEST_TYPE)
+});
+const bridgeSetPinDefaultRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	graphName: graphNameSchema,
+	nodeGuid: graphNodeGuidSchema,
+	pinName: graphPinNameSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_SET_PIN_DEFAULT_REQUEST_TYPE),
+	value: graphPinValueSchema,
+	version: z.literal(2)
+});
+const bridgeListAvailableNodesRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	cursor: assetCursorSchema.optional(),
+	graphName: graphNameSchema,
+	maxResults: availableNodeMaxResultsSchema.optional(),
+	nameFilter: boundedStringSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_LIST_AVAILABLE_NODES_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSetViewportCameraRequestSchema = z.object({
+	fov: viewportFovSchema.optional(),
+	location: vectorInputSchema.optional(),
+	orthoWidth: z.number().min(1).optional(),
+	requestId: requestIdSchema,
+	rotation: rotatorInputSchema.optional(),
+	type: z.literal(BRIDGE_SET_VIEWPORT_CAMERA_REQUEST_TYPE),
+	version: z.literal(2),
+	viewType: viewportViewTypeSchema.optional()
+});
+const bridgeFocusActorsRequestSchema = z.object({
+	actorPaths: actorPathBatchSchema,
+	instant: z.boolean().optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_FOCUS_ACTORS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSetViewModeRequestSchema = z.object({
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_SET_VIEW_MODE_REQUEST_TYPE),
+	version: z.literal(2),
+	viewMode: viewModeSchema
+});
+const bridgeToggleShowFlagsRequestSchema = z.object({
+	flags: z.array(showFlagEntrySchema).min(1).max(32),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_TOGGLE_SHOW_FLAGS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeHighResScreenshotRequestSchema = z.object({
+	fileName: z.string().trim().min(1).max(128).refine((value) => !/[/\\:]/.test(value) && !value.includes(".."), { message: "Screenshot names may not contain '/', '\\', ':' or '..'." }).optional(),
+	includeUi: z.boolean().optional(),
+	multiplier: z.number().min(1).max(8).optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_HIGH_RES_SCREENSHOT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeDuplicateActorEntrySchema = z.object({
+	actorPath: actorPathSchema,
+	offset: vectorInputSchema.optional()
+});
+const bridgeDuplicateActorRequestSchema = z.object({
+	actors: z.array(bridgeDuplicateActorEntrySchema).min(1).max(64),
+	dryRun: z.boolean().optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_DUPLICATE_ACTOR_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAttachActorEntrySchema = z.object({
+	childActorPath: actorPathSchema,
+	locationRule: attachmentRuleSchema.optional(),
+	parentActorPath: z.string().trim().max(512),
+	rotationRule: attachmentRuleSchema.optional(),
+	scaleRule: attachmentRuleSchema.optional(),
+	socketName: boundedStringSchema.optional(),
+	weldSimulatedBodies: z.boolean().optional()
+});
+const bridgeAttachActorRequestSchema = z.object({
+	attachments: z.array(bridgeAttachActorEntrySchema).min(1).max(64),
+	dryRun: z.boolean().optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_ATTACH_ACTOR_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddActorComponentEntrySchema = z.object({
+	actorPath: actorPathSchema,
+	attachParent: boundedStringSchema.optional(),
+	componentClass: assetPathSchema,
+	componentName: boundedStringSchema.optional()
+});
+const bridgeAddActorComponentRequestSchema = z.object({
+	components: z.array(bridgeAddActorComponentEntrySchema).min(1).max(64),
+	dryRun: z.boolean().optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_ADD_ACTOR_COMPONENT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSetActorTagsEntrySchema = z.object({
+	actorPath: actorPathSchema,
+	mode: actorTagModeSchema,
+	tags: actorTagArraySchema
+});
+const bridgeSetActorTagsRequestSchema = z.object({
+	dryRun: z.boolean().optional(),
+	entries: z.array(bridgeSetActorTagsEntrySchema).min(1).max(64),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_SET_ACTOR_TAGS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeMoveToFolderEntrySchema = z.object({
+	actorPath: actorPathSchema,
+	folderPath: actorFolderSchema
+});
+const bridgeMoveToFolderRequestSchema = z.object({
+	dryRun: z.boolean().optional(),
+	entries: z.array(bridgeMoveToFolderEntrySchema).min(1).max(64),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_MOVE_TO_FOLDER_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgePlaceAssetEntrySchema = z.object({
+	assetPath: assetPathSchema,
+	folderPath: actorFolderSchema.optional(),
+	label: boundedStringSchema.optional(),
+	transform: transformInputSchema.optional()
+});
+const bridgePlaceAssetRequestSchema = z.object({
+	dryRun: z.boolean().optional(),
+	placements: z.array(bridgePlaceAssetEntrySchema).min(1).max(64),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_PLACE_ASSET_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeReplaceActorsRequestFieldsSchema = z.object({
+	actorPaths: actorPathBatchSchema,
+	dryRun: z.boolean().optional(),
+	replacementAssetPath: assetPathSchema.optional(),
+	replacementClass: assetPathSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_REPLACE_ACTORS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeReplaceActorsRequestSchema = bridgeReplaceActorsRequestFieldsSchema.refine((value) => value.replacementAssetPath === void 0 !== (value.replacementClass === void 0), {
+	message: "A replace_actors request needs exactly one of replacementAssetPath or replacementClass.",
+	path: ["replacementAssetPath"]
+});
+const bridgeStartEditorBuildRequestSchema = z.object({
+	buildKind: editorBuildKindSchema,
+	hlodAction: hlodActionSchema.optional(),
+	quality: lightingQualitySchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_START_EDITOR_BUILD_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeGetBuildJobStatusRequestSchema = z.object({
+	buildJobId: buildJobIdSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_BUILD_JOB_STATUS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateGameplayTagRequestSchema = z.object({
+	comment: z.string().trim().max(512).optional(),
+	requestId: requestIdSchema,
+	source: z.string().trim().min(1).max(128).optional(),
+	tagName: gameplayTagNameSchema,
+	type: z.literal(BRIDGE_CREATE_GAMEPLAY_TAG_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeListGameplayTagsRequestSchema = z.object({
+	cursor: assetCursorSchema.optional(),
+	maxResults: gameplayTagMaxResultsSchema.optional(),
+	prefix: gameplayTagPrefixSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_LIST_GAMEPLAY_TAGS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateLandscapeRequestSchema = z.object({
+	componentCountX: landscapeComponentCountSchema,
+	componentCountY: landscapeComponentCountSchema,
+	heightmapFilePath: filePathSchema.optional(),
+	label: boundedStringSchema.optional(),
+	location: vectorInputSchema.optional(),
+	quadsPerSection: landscapeQuadsPerSectionSchema,
+	requestId: requestIdSchema,
+	rotation: rotatorInputSchema.optional(),
+	scale: vectorInputSchema.optional(),
+	sectionsPerComponent: landscapeSectionsPerComponentSchema,
+	type: z.literal(BRIDGE_CREATE_LANDSCAPE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSculptLandscapeRequestFieldsSchema = z.object({
+	actorPath: actorPathSchema,
+	height: landscapeHeightSchema.optional(),
+	heightmapFilePath: filePathSchema.optional(),
+	mode: landscapeSculptModeSchema,
+	noiseAmplitude: landscapeHeightSchema.optional(),
+	noiseFrequency: z.number().min(0).max(1).optional(),
+	noiseSeed: z.number().int().min(0).optional(),
+	rampAxis: landscapeRampAxisSchema.optional(),
+	rampEndHeight: landscapeHeightSchema.optional(),
+	rampStartHeight: landscapeHeightSchema.optional(),
+	region: landscapeRegionSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_SCULPT_LANDSCAPE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSculptLandscapeRequestSchema = bridgeSculptLandscapeRequestFieldsSchema.superRefine((value, ctx) => {
+	if (value.mode === "flatten" && value.height === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "mode 'flatten' requires height.",
+		path: ["height"]
+	});
+	if (value.mode === "heightmap_file" && value.heightmapFilePath === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "mode 'heightmap_file' requires heightmapFilePath.",
+		path: ["heightmapFilePath"]
+	});
+	if (value.mode === "ramp" && (value.rampStartHeight === void 0 || value.rampEndHeight === void 0)) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "mode 'ramp' requires rampStartHeight and rampEndHeight.",
+		path: ["rampStartHeight"]
+	});
+	if (value.mode === "noise" && value.noiseAmplitude === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "mode 'noise' requires noiseAmplitude.",
+		path: ["noiseAmplitude"]
+	});
+});
+const bridgePaintLandscapeLayerRequestSchema = z.object({
+	actorPath: actorPathSchema,
+	layerName: boundedStringSchema,
+	region: landscapeRegionSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_PAINT_LANDSCAPE_LAYER_REQUEST_TYPE),
+	version: z.literal(2),
+	weight: landscapeWeightSchema
+});
+const bridgeRunGeometryScriptRequestFieldsSchema = z.object({
+	actorTransform: transformInputSchema.optional(),
+	assetName: assetNameSchema.optional(),
+	assetPath: contentPathSchema.optional(),
+	label: boundedStringSchema.optional(),
+	operations: z.array(geometryOperationSchema).min(1).max(32),
+	output: geometryOutputSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_RUN_GEOMETRY_SCRIPT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeRunGeometryScriptRequestSchema = bridgeRunGeometryScriptRequestFieldsSchema.refine((value) => value.output !== "static_mesh" || value.assetName !== void 0 && value.assetPath !== void 0, {
+	message: "output 'static_mesh' requires assetName and assetPath.",
+	path: ["assetName"]
+});
+const bridgeListDataLayersRequestSchema = z.object({
+	cursor: assetCursorSchema.optional(),
+	maxResults: dataLayerMaxResultsSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_LIST_DATA_LAYERS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSetDataLayerStateEntrySchema = z.object({
+	dataLayerAsset: assetPathSchema,
+	loadedInEditor: z.boolean().optional(),
+	runtimeState: dataLayerRuntimeStateSchema.optional(),
+	visible: z.boolean().optional()
+});
+const bridgeSetDataLayerStateRequestSchema = z.object({
+	entries: z.array(bridgeSetDataLayerStateEntrySchema).min(1).max(32),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_SET_DATA_LAYER_STATE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeLoadWpRegionRequestFieldsSchema = z.object({
+	action: wpRegionActionSchema,
+	region: wpRegionBoxSchema.optional(),
+	regionId: wpRegionIdSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_LOAD_WP_REGION_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeLoadWpRegionRequestSchema = bridgeLoadWpRegionRequestFieldsSchema.superRefine((value, ctx) => {
+	if (value.action === "pin" && value.region === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "action 'pin' requires region.",
+		path: ["region"]
+	});
+	if (value.action === "unpin" && value.regionId === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "action 'unpin' requires regionId.",
+		path: ["regionId"]
+	});
+});
+const bridgeAssetFactorySchema = z.object({
+	assetClass: z.string(),
+	assetClassPath: z.string(),
+	description: z.string().optional(),
+	factoryClass: z.string(),
+	menuCategory: z.string(),
+	requiredOptions: z.array(z.string()).max(32)
+});
+const bridgeListAssetFactoriesSuccessResponseSchema = z.object({
+	factories: z.array(bridgeAssetFactorySchema).max(100),
+	nextCursor: assetCursorSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	totalCount: z.number().int().min(0),
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_LIST_ASSET_FACTORIES_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const createdAssetResponseFields = {
+	message: nonEmptyStringSchema.optional(),
+	objectPath: z.string(),
+	ok: z.literal(true),
+	packageName: z.string(),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	version: z.literal(2)
+};
+const bridgeCreateAssetSuccessResponseSchema = z.object({
+	...createdAssetResponseFields,
+	factoryClass: z.string(),
+	type: z.literal(BRIDGE_CREATE_ASSET_REQUEST_TYPE)
+});
+const bridgeDuplicateAssetSuccessResponseSchema = z.object({
+	...createdAssetResponseFields,
+	type: z.literal(BRIDGE_DUPLICATE_ASSET_REQUEST_TYPE)
+});
+const relocatedAssetResponseFields = {
+	message: nonEmptyStringSchema.optional(),
+	objectPath: z.string(),
+	ok: z.literal(true),
+	packageName: z.string(),
+	previousObjectPath: z.string(),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	version: z.literal(2)
+};
+const bridgeRenameAssetSuccessResponseSchema = z.object({
+	...relocatedAssetResponseFields,
+	type: z.literal(BRIDGE_RENAME_ASSET_REQUEST_TYPE)
+});
+const bridgeMoveAssetSuccessResponseSchema = z.object({
+	...relocatedAssetResponseFields,
+	type: z.literal(BRIDGE_MOVE_ASSET_REQUEST_TYPE)
+});
+const bridgeDeleteAssetSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	deleted: z.boolean(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	referencerCount: z.number().int().min(0),
+	referencers: z.array(z.string()).max(25),
+	requestId: requestIdSchema,
+	state: deleteAssetStateSchema,
+	type: z.literal(BRIDGE_DELETE_ASSET_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine((value) => value.state !== "blocked" || value.referencerCount > 0, {
+	message: "A 'blocked' delete_asset response must report at least one referencer.",
+	path: ["referencerCount"]
+}).refine((value) => value.deleted === (value.state === "deleted"), {
+	message: "delete_asset must report deleted true exactly when state is 'deleted'.",
+	path: ["deleted"]
+});
+const bridgeSaveAssetItemResultSchema = z.object({
+	assetPath: z.string(),
+	error: z.string().optional(),
+	index: z.number().int().min(0),
+	ok: z.boolean(),
+	saved: z.boolean()
+});
+const bridgeSaveAssetSuccessResponseSchema = z.object({
+	failureCount: z.number().int().min(0),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	results: z.array(bridgeSaveAssetItemResultSchema).max(64),
+	state: creativeEditStateSchema,
+	successCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_SAVE_ASSET_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateFolderSuccessResponseSchema = z.object({
+	folderPath: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	state: createFolderStateSchema,
+	type: z.literal(BRIDGE_CREATE_FOLDER_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAssetMetadataTagSchema = z.object({
+	key: z.string(),
+	value: z.string()
+});
+const bridgeGetAssetMetadataSuccessResponseSchema = z.object({
+	assetName: z.string(),
+	className: z.string(),
+	classPath: z.string(),
+	diskSizeBytes: z.number().int().min(0).optional(),
+	loaded: z.boolean(),
+	message: nonEmptyStringSchema.optional(),
+	objectPath: z.string(),
+	ok: z.literal(true),
+	packageName: z.string(),
+	packagePath: z.string(),
+	requestId: requestIdSchema,
+	state: assetMetadataStateSchema,
+	tagCount: z.number().int().min(0),
+	tags: z.array(bridgeAssetMetadataTagSchema).max(100),
+	type: z.literal(BRIDGE_GET_ASSET_METADATA_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeListGraphNodesSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	graphName: z.string(),
+	nextCursor: assetCursorSchema.optional(),
+	nodeCount: z.number().int().min(0),
+	nodes: z.array(bridgeBlueprintNodeSchema).max(100),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_LIST_GRAPH_NODES_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddGraphNodeSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	graphName: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	node: bridgeBlueprintNodeSchema,
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_ADD_GRAPH_NODE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeRemoveGraphNodeSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	graphName: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	nodeGuid: z.string(),
+	ok: z.literal(true),
+	removed: z.boolean(),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_REMOVE_GRAPH_NODE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const graphPinPairResponseFields = {
+	assetPath: z.string(),
+	graphName: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	sourceNodeGuid: z.string(),
+	sourcePinName: z.string(),
+	state: creativeEditStateSchema,
+	targetNodeGuid: z.string(),
+	targetPinName: z.string(),
+	version: z.literal(2)
+};
+const bridgeConnectPinsSuccessResponseSchema = z.object({
+	...graphPinPairResponseFields,
+	connected: z.boolean(),
+	type: z.literal(BRIDGE_CONNECT_PINS_REQUEST_TYPE)
+});
+const bridgeDisconnectPinsSuccessResponseSchema = z.object({
+	...graphPinPairResponseFields,
+	disconnected: z.boolean(),
+	type: z.literal(BRIDGE_DISCONNECT_PINS_REQUEST_TYPE)
+});
+const bridgeSetPinDefaultSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	graphName: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	nodeGuid: z.string(),
+	ok: z.literal(true),
+	pinName: z.string(),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_SET_PIN_DEFAULT_REQUEST_TYPE),
+	value: z.string(),
+	version: z.literal(2)
+});
+const bridgeGraphActionSchema = z.object({
+	category: z.string(),
+	keywords: z.string().optional(),
+	memberName: z.string().optional(),
+	memberParentClass: z.string().optional(),
+	nodeClass: z.string(),
+	nodeKind: graphNodeKindSchema,
+	title: z.string(),
+	tooltip: z.string().optional()
+});
+const bridgeListAvailableNodesSuccessResponseSchema = z.object({
+	actions: z.array(bridgeGraphActionSchema).max(100),
+	assetPath: z.string(),
+	graphName: z.string(),
+	nextCursor: assetCursorSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	totalCount: z.number().int().min(0),
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_LIST_AVAILABLE_NODES_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSetViewportCameraSuccessResponseSchema = z.object({
+	fov: z.number(),
+	location: bridgeVectorSchema,
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	orthoWidth: z.number().optional(),
+	requestId: requestIdSchema,
+	rotation: bridgeRotatorSchema,
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_SET_VIEWPORT_CAMERA_REQUEST_TYPE),
+	version: z.literal(2),
+	viewType: viewportViewTypeSchema
+});
+const bridgeFocusActorsSuccessResponseSchema = z.object({
+	focusedCount: z.number().int().min(0),
+	location: bridgeVectorSchema,
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	rotation: bridgeRotatorSchema,
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_FOCUS_ACTORS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSetViewModeSuccessResponseSchema = z.object({
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_SET_VIEW_MODE_REQUEST_TYPE),
+	version: z.literal(2),
+	viewMode: viewModeSchema
+});
+const bridgeShowFlagResultSchema = z.object({
+	enabled: z.boolean().optional(),
+	error: z.string().optional(),
+	index: z.number().int().min(0),
+	name: z.string(),
+	ok: z.boolean(),
+	suggestions: z.array(z.string()).max(5)
+});
+const bridgeToggleShowFlagsSuccessResponseSchema = z.object({
+	failureCount: z.number().int().min(0),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	results: z.array(bridgeShowFlagResultSchema).max(32),
+	state: creativeEditStateSchema,
+	successCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_TOGGLE_SHOW_FLAGS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeHighResScreenshotSuccessResponseSchema = z.object({
+	filePath: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	multiplier: z.number(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	state: screenshotStateSchema,
+	type: z.literal(BRIDGE_HIGH_RES_SCREENSHOT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeDuplicateActorSuccessResponseSchema = z.object({
+	...levelEditResponseFields,
+	type: z.literal(BRIDGE_DUPLICATE_ACTOR_REQUEST_TYPE)
+}).refine(isLevelEditStateConsistent, levelEditStateRefinement);
+const bridgeAttachActorSuccessResponseSchema = z.object({
+	...levelEditResponseFields,
+	type: z.literal(BRIDGE_ATTACH_ACTOR_REQUEST_TYPE)
+}).refine(isLevelEditStateConsistent, levelEditStateRefinement);
+const bridgeAddActorComponentSuccessResponseSchema = z.object({
+	...levelEditResponseFields,
+	type: z.literal(BRIDGE_ADD_ACTOR_COMPONENT_REQUEST_TYPE)
+}).refine(isLevelEditStateConsistent, levelEditStateRefinement);
+const bridgeSetActorTagsSuccessResponseSchema = z.object({
+	...levelEditResponseFields,
+	type: z.literal(BRIDGE_SET_ACTOR_TAGS_REQUEST_TYPE)
+}).refine(isLevelEditStateConsistent, levelEditStateRefinement);
+const bridgeMoveToFolderSuccessResponseSchema = z.object({
+	...levelEditResponseFields,
+	type: z.literal(BRIDGE_MOVE_TO_FOLDER_REQUEST_TYPE)
+}).refine(isLevelEditStateConsistent, levelEditStateRefinement);
+const bridgePlaceAssetSuccessResponseSchema = z.object({
+	...levelEditResponseFields,
+	type: z.literal(BRIDGE_PLACE_ASSET_REQUEST_TYPE)
+}).refine(isLevelEditStateConsistent, levelEditStateRefinement);
+const bridgeReplaceActorsSuccessResponseSchema = z.object({
+	...levelEditResponseFields,
+	type: z.literal(BRIDGE_REPLACE_ACTORS_REQUEST_TYPE)
+}).refine(isLevelEditStateConsistent, levelEditStateRefinement);
+const bridgeStartEditorBuildSuccessResponseSchema = z.object({
+	buildJobId: buildJobIdSchema.optional(),
+	buildKind: editorBuildKindSchema,
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	state: editorBuildAcceptStateSchema,
+	type: z.literal(BRIDGE_START_EDITOR_BUILD_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine((value) => value.state === "accepted" === (value.buildJobId !== void 0), {
+	message: "A start_editor_build response must carry buildJobId exactly when state is 'accepted'.",
+	path: ["buildJobId"]
+});
+const bridgeGetBuildJobStatusSuccessResponseSchema = z.object({
+	buildJobId: buildJobIdSchema,
+	buildKind: editorBuildKindSchema.optional(),
+	durationMs: z.number().int().min(0).optional(),
+	errorCount: z.number().int().min(0),
+	errors: z.array(z.string()).max(50),
+	finishedAt: nonEmptyStringSchema.optional(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	startedAt: nonEmptyStringSchema.optional(),
+	state: editorBuildJobStateSchema,
+	type: z.literal(BRIDGE_GET_BUILD_JOB_STATUS_REQUEST_TYPE),
+	version: z.literal(2),
+	warningCount: z.number().int().min(0),
+	warnings: z.array(z.string()).max(50)
+}).refine((value) => value.state !== "unknown_job" || value.errors.length === 0, {
+	message: "An unknown_job get_build_job_status response must carry no build errors.",
+	path: ["errors"]
+}).refine((value) => value.state !== "failed" || value.errorCount > 0, {
+	message: "A 'failed' get_build_job_status response must report at least one error.",
+	path: ["errorCount"]
+});
+const bridgeCreateGameplayTagSuccessResponseSchema = z.object({
+	configFilePath: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	state: createGameplayTagStateSchema,
+	tagName: z.string(),
+	type: z.literal(BRIDGE_CREATE_GAMEPLAY_TAG_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeGameplayTagSchema = z.object({
+	comment: z.string().optional(),
+	source: z.string().optional(),
+	tagName: z.string()
+});
+const bridgeListGameplayTagsSuccessResponseSchema = z.object({
+	nextCursor: assetCursorSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	tags: z.array(bridgeGameplayTagSchema).max(200),
+	totalCount: z.number().int().min(0),
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_LIST_GAMEPLAY_TAGS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateLandscapeSuccessResponseSchema = z.object({
+	actorPath: z.string(),
+	componentCount: z.number().int().min(0),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	resolutionX: z.number().int().min(0),
+	resolutionY: z.number().int().min(0),
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_CREATE_LANDSCAPE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const landscapeEditResponseFields = {
+	actorPath: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	modifiedVertexCount: z.number().int().min(0),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	version: z.literal(2)
+};
+const bridgeSculptLandscapeSuccessResponseSchema = z.object({
+	...landscapeEditResponseFields,
+	mode: landscapeSculptModeSchema,
+	type: z.literal(BRIDGE_SCULPT_LANDSCAPE_REQUEST_TYPE)
+});
+const bridgePaintLandscapeLayerSuccessResponseSchema = z.object({
+	...landscapeEditResponseFields,
+	layerName: z.string(),
+	type: z.literal(BRIDGE_PAINT_LANDSCAPE_LAYER_REQUEST_TYPE)
+});
+const bridgeRunGeometryScriptSuccessResponseSchema = z.object({
+	actorPath: z.string().optional(),
+	message: nonEmptyStringSchema.optional(),
+	objectPath: z.string().optional(),
+	ok: z.literal(true),
+	operationCount: z.number().int().min(0),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	triangleCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_RUN_GEOMETRY_SCRIPT_REQUEST_TYPE),
+	version: z.literal(2),
+	vertexCount: z.number().int().min(0)
+});
+const bridgeDataLayerSchema = z.object({
+	dataLayerAsset: z.string(),
+	editorVisible: z.boolean(),
+	initialRuntimeState: dataLayerRuntimeStateSchema,
+	isRuntime: z.boolean(),
+	loadedInEditor: z.boolean(),
+	name: z.string(),
+	runtimeState: dataLayerRuntimeStateSchema
+});
+const bridgeListDataLayersSuccessResponseSchema = z.object({
+	dataLayers: z.array(bridgeDataLayerSchema).max(100),
+	isWorldPartition: z.boolean(),
+	message: nonEmptyStringSchema.optional(),
+	nextCursor: assetCursorSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	totalCount: z.number().int().min(0),
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_LIST_DATA_LAYERS_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine((value) => value.isWorldPartition || value.dataLayers.length === 0, {
+	message: "A non-World-Partition list_data_layers response must carry no data layers.",
+	path: ["dataLayers"]
+});
+const bridgeDataLayerResultSchema = z.object({
+	dataLayerAsset: z.string(),
+	error: z.string().optional(),
+	index: z.number().int().min(0),
+	ok: z.boolean()
+});
+const bridgeSetDataLayerStateSuccessResponseSchema = z.object({
+	failureCount: z.number().int().min(0),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	results: z.array(bridgeDataLayerResultSchema).max(32),
+	state: creativeEditStateSchema,
+	successCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_SET_DATA_LAYER_STATE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeLoadWpRegionSuccessResponseSchema = z.object({
+	action: wpRegionActionSchema,
+	loadedActorCount: z.number().int().min(0),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	pinnedRegionCount: z.number().int().min(0),
+	regionId: wpRegionIdSchema.optional(),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_LOAD_WP_REGION_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine((value) => value.action !== "pin" || value.state !== "applied" || value.regionId !== void 0, {
+	message: "An applied 'pin' load_wp_region response must carry a regionId.",
+	path: ["regionId"]
+});
+const bridgeListAssetFactoriesResponseSchema = z.union([bridgeListAssetFactoriesSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCreateAssetResponseSchema = z.union([bridgeCreateAssetSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeDuplicateAssetResponseSchema = z.union([bridgeDuplicateAssetSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeRenameAssetResponseSchema = z.union([bridgeRenameAssetSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeMoveAssetResponseSchema = z.union([bridgeMoveAssetSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeDeleteAssetResponseSchema = z.union([bridgeDeleteAssetSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSaveAssetResponseSchema = z.union([bridgeSaveAssetSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCreateFolderResponseSchema = z.union([bridgeCreateFolderSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetAssetMetadataResponseSchema = z.union([bridgeGetAssetMetadataSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeListGraphNodesResponseSchema = z.union([bridgeListGraphNodesSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddGraphNodeResponseSchema = z.union([bridgeAddGraphNodeSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeRemoveGraphNodeResponseSchema = z.union([bridgeRemoveGraphNodeSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeConnectPinsResponseSchema = z.union([bridgeConnectPinsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeDisconnectPinsResponseSchema = z.union([bridgeDisconnectPinsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetPinDefaultResponseSchema = z.union([bridgeSetPinDefaultSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeListAvailableNodesResponseSchema = z.union([bridgeListAvailableNodesSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetViewportCameraResponseSchema = z.union([bridgeSetViewportCameraSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeFocusActorsResponseSchema = z.union([bridgeFocusActorsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetViewModeResponseSchema = z.union([bridgeSetViewModeSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeToggleShowFlagsResponseSchema = z.union([bridgeToggleShowFlagsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeHighResScreenshotResponseSchema = z.union([bridgeHighResScreenshotSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeDuplicateActorResponseSchema = z.union([bridgeDuplicateActorSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAttachActorResponseSchema = z.union([bridgeAttachActorSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddActorComponentResponseSchema = z.union([bridgeAddActorComponentSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetActorTagsResponseSchema = z.union([bridgeSetActorTagsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeMoveToFolderResponseSchema = z.union([bridgeMoveToFolderSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgePlaceAssetResponseSchema = z.union([bridgePlaceAssetSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeReplaceActorsResponseSchema = z.union([bridgeReplaceActorsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeStartEditorBuildResponseSchema = z.union([bridgeStartEditorBuildSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetBuildJobStatusResponseSchema = z.union([bridgeGetBuildJobStatusSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCreateGameplayTagResponseSchema = z.union([bridgeCreateGameplayTagSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeListGameplayTagsResponseSchema = z.union([bridgeListGameplayTagsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCreateLandscapeResponseSchema = z.union([bridgeCreateLandscapeSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSculptLandscapeResponseSchema = z.union([bridgeSculptLandscapeSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgePaintLandscapeLayerResponseSchema = z.union([bridgePaintLandscapeLayerSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeRunGeometryScriptResponseSchema = z.union([bridgeRunGeometryScriptSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeListDataLayersResponseSchema = z.union([bridgeListDataLayersSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetDataLayerStateResponseSchema = z.union([bridgeSetDataLayerStateSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeLoadWpRegionResponseSchema = z.union([bridgeLoadWpRegionSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeListAssetFactoriesRequest(options = {}, requestId = randomUUID()) {
+	return bridgeListAssetFactoriesRequestSchema.parse({
+		cursor: options.cursor,
+		maxResults: options.maxResults,
+		nameFilter: options.nameFilter,
+		requestId,
+		type: BRIDGE_LIST_ASSET_FACTORIES_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCreateAssetRequest(assetClass, assetName, packagePath, options = {}, requestId = randomUUID()) {
+	return bridgeCreateAssetRequestSchema.parse({
+		assetClass,
+		assetName,
+		factoryClass: options.factoryClass,
+		options: options.options,
+		packagePath,
+		requestId,
+		type: BRIDGE_CREATE_ASSET_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeDuplicateAssetRequest(sourceAssetPath, destinationPath, destinationName, requestId = randomUUID()) {
+	return bridgeDuplicateAssetRequestSchema.parse({
+		destinationName,
+		destinationPath,
+		requestId,
+		sourceAssetPath,
+		type: BRIDGE_DUPLICATE_ASSET_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeRenameAssetRequest(assetPath, newName, requestId = randomUUID()) {
+	return bridgeRenameAssetRequestSchema.parse({
+		assetPath,
+		newName,
+		requestId,
+		type: BRIDGE_RENAME_ASSET_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeMoveAssetRequest(assetPath, destinationPath, options = {}, requestId = randomUUID()) {
+	return bridgeMoveAssetRequestSchema.parse({
+		assetPath,
+		destinationPath,
+		newName: options.newName,
+		requestId,
+		type: BRIDGE_MOVE_ASSET_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeDeleteAssetRequest(assetPath, options = {}, requestId = randomUUID()) {
+	return bridgeDeleteAssetRequestSchema.parse({
+		assetPath,
+		force: options.force,
+		requestId,
+		type: BRIDGE_DELETE_ASSET_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSaveAssetRequest(assetPaths, requestId = randomUUID()) {
+	return bridgeSaveAssetRequestSchema.parse({
+		assetPaths,
+		requestId,
+		type: BRIDGE_SAVE_ASSET_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCreateFolderRequest(folderPath, requestId = randomUUID()) {
+	return bridgeCreateFolderRequestSchema.parse({
+		folderPath,
+		requestId,
+		type: BRIDGE_CREATE_FOLDER_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeGetAssetMetadataRequest(assetPath, requestId = randomUUID()) {
+	return bridgeGetAssetMetadataRequestSchema.parse({
+		assetPath,
+		requestId,
+		type: BRIDGE_GET_ASSET_METADATA_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeListGraphNodesRequest(assetPath, graphName, options = {}, requestId = randomUUID()) {
+	return bridgeListGraphNodesRequestSchema.parse({
+		assetPath,
+		cursor: options.cursor,
+		graphName,
+		loadIfNeeded: options.loadIfNeeded,
+		maxResults: options.maxResults,
+		requestId,
+		type: BRIDGE_LIST_GRAPH_NODES_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddGraphNodeRequest(assetPath, graphName, kind, options = {}, requestId = randomUUID()) {
+	return bridgeAddGraphNodeRequestSchema.parse({
+		assetPath,
+		graphName,
+		kind,
+		memberName: options.memberName,
+		memberParentClass: options.memberParentClass,
+		nodeClass: options.nodeClass,
+		pinDefaults: options.pinDefaults,
+		position: options.position,
+		requestId,
+		type: BRIDGE_ADD_GRAPH_NODE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeRemoveGraphNodeRequest(assetPath, graphName, nodeGuid, requestId = randomUUID()) {
+	return bridgeRemoveGraphNodeRequestSchema.parse({
+		assetPath,
+		graphName,
+		nodeGuid,
+		requestId,
+		type: BRIDGE_REMOVE_GRAPH_NODE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeConnectPinsRequest(assetPath, graphName, source, target, requestId = randomUUID()) {
+	return bridgeConnectPinsRequestSchema.parse({
+		assetPath,
+		graphName,
+		requestId,
+		sourceNodeGuid: source.nodeGuid,
+		sourcePinName: source.pinName,
+		targetNodeGuid: target.nodeGuid,
+		targetPinName: target.pinName,
+		type: BRIDGE_CONNECT_PINS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeDisconnectPinsRequest(assetPath, graphName, source, target, requestId = randomUUID()) {
+	return bridgeDisconnectPinsRequestSchema.parse({
+		assetPath,
+		graphName,
+		requestId,
+		sourceNodeGuid: source.nodeGuid,
+		sourcePinName: source.pinName,
+		targetNodeGuid: target.nodeGuid,
+		targetPinName: target.pinName,
+		type: BRIDGE_DISCONNECT_PINS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSetPinDefaultRequest(assetPath, graphName, nodeGuid, pinName, value, requestId = randomUUID()) {
+	return bridgeSetPinDefaultRequestSchema.parse({
+		assetPath,
+		graphName,
+		nodeGuid,
+		pinName,
+		requestId,
+		type: BRIDGE_SET_PIN_DEFAULT_REQUEST_TYPE,
+		value,
+		version: 2
+	});
+}
+function createBridgeListAvailableNodesRequest(assetPath, graphName, options = {}, requestId = randomUUID()) {
+	return bridgeListAvailableNodesRequestSchema.parse({
+		assetPath,
+		cursor: options.cursor,
+		graphName,
+		maxResults: options.maxResults,
+		nameFilter: options.nameFilter,
+		requestId,
+		type: BRIDGE_LIST_AVAILABLE_NODES_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSetViewportCameraRequest(options = {}, requestId = randomUUID()) {
+	return bridgeSetViewportCameraRequestSchema.parse({
+		fov: options.fov,
+		location: options.location,
+		orthoWidth: options.orthoWidth,
+		requestId,
+		rotation: options.rotation,
+		type: BRIDGE_SET_VIEWPORT_CAMERA_REQUEST_TYPE,
+		version: 2,
+		viewType: options.viewType
+	});
+}
+function createBridgeFocusActorsRequest(actorPaths, options = {}, requestId = randomUUID()) {
+	return bridgeFocusActorsRequestSchema.parse({
+		actorPaths,
+		instant: options.instant,
+		requestId,
+		type: BRIDGE_FOCUS_ACTORS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSetViewModeRequest(viewMode, requestId = randomUUID()) {
+	return bridgeSetViewModeRequestSchema.parse({
+		requestId,
+		type: BRIDGE_SET_VIEW_MODE_REQUEST_TYPE,
+		version: 2,
+		viewMode
+	});
+}
+function createBridgeToggleShowFlagsRequest(flags, requestId = randomUUID()) {
+	return bridgeToggleShowFlagsRequestSchema.parse({
+		flags,
+		requestId,
+		type: BRIDGE_TOGGLE_SHOW_FLAGS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeHighResScreenshotRequest(options = {}, requestId = randomUUID()) {
+	return bridgeHighResScreenshotRequestSchema.parse({
+		fileName: options.fileName,
+		includeUi: options.includeUi,
+		multiplier: options.multiplier,
+		requestId,
+		type: BRIDGE_HIGH_RES_SCREENSHOT_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeDuplicateActorRequest(actors, options = {}, requestId = randomUUID()) {
+	return bridgeDuplicateActorRequestSchema.parse({
+		actors,
+		dryRun: options.dryRun,
+		requestId,
+		type: BRIDGE_DUPLICATE_ACTOR_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAttachActorRequest(attachments, options = {}, requestId = randomUUID()) {
+	return bridgeAttachActorRequestSchema.parse({
+		attachments,
+		dryRun: options.dryRun,
+		requestId,
+		type: BRIDGE_ATTACH_ACTOR_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddActorComponentRequest(components, options = {}, requestId = randomUUID()) {
+	return bridgeAddActorComponentRequestSchema.parse({
+		components,
+		dryRun: options.dryRun,
+		requestId,
+		type: BRIDGE_ADD_ACTOR_COMPONENT_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSetActorTagsRequest(entries, options = {}, requestId = randomUUID()) {
+	return bridgeSetActorTagsRequestSchema.parse({
+		dryRun: options.dryRun,
+		entries,
+		requestId,
+		type: BRIDGE_SET_ACTOR_TAGS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeMoveToFolderRequest(entries, options = {}, requestId = randomUUID()) {
+	return bridgeMoveToFolderRequestSchema.parse({
+		dryRun: options.dryRun,
+		entries,
+		requestId,
+		type: BRIDGE_MOVE_TO_FOLDER_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgePlaceAssetRequest(placements, options = {}, requestId = randomUUID()) {
+	return bridgePlaceAssetRequestSchema.parse({
+		dryRun: options.dryRun,
+		placements,
+		requestId,
+		type: BRIDGE_PLACE_ASSET_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeReplaceActorsRequest(actorPaths, replacement, options = {}, requestId = randomUUID()) {
+	return bridgeReplaceActorsRequestSchema.parse({
+		actorPaths,
+		dryRun: options.dryRun,
+		replacementAssetPath: replacement.assetPath,
+		replacementClass: replacement.className,
+		requestId,
+		type: BRIDGE_REPLACE_ACTORS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeStartEditorBuildRequest(buildKind, options = {}, requestId = randomUUID()) {
+	return bridgeStartEditorBuildRequestSchema.parse({
+		buildKind,
+		hlodAction: options.hlodAction,
+		quality: options.quality,
+		requestId,
+		type: BRIDGE_START_EDITOR_BUILD_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeGetBuildJobStatusRequest(buildJobId, requestId = randomUUID()) {
+	return bridgeGetBuildJobStatusRequestSchema.parse({
+		buildJobId,
+		requestId,
+		type: BRIDGE_GET_BUILD_JOB_STATUS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCreateGameplayTagRequest(tagName, options = {}, requestId = randomUUID()) {
+	return bridgeCreateGameplayTagRequestSchema.parse({
+		comment: options.comment,
+		requestId,
+		source: options.source,
+		tagName,
+		type: BRIDGE_CREATE_GAMEPLAY_TAG_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeListGameplayTagsRequest(options = {}, requestId = randomUUID()) {
+	return bridgeListGameplayTagsRequestSchema.parse({
+		cursor: options.cursor,
+		maxResults: options.maxResults,
+		prefix: options.prefix,
+		requestId,
+		type: BRIDGE_LIST_GAMEPLAY_TAGS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCreateLandscapeRequest(sizing, options = {}, requestId = randomUUID()) {
+	return bridgeCreateLandscapeRequestSchema.parse({
+		componentCountX: sizing.componentCountX,
+		componentCountY: sizing.componentCountY,
+		heightmapFilePath: options.heightmapFilePath,
+		label: options.label,
+		location: options.location,
+		quadsPerSection: sizing.quadsPerSection,
+		requestId,
+		rotation: options.rotation,
+		scale: options.scale,
+		sectionsPerComponent: sizing.sectionsPerComponent,
+		type: BRIDGE_CREATE_LANDSCAPE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSculptLandscapeRequest(actorPath, mode, region, options = {}, requestId = randomUUID()) {
+	return bridgeSculptLandscapeRequestSchema.parse({
+		actorPath,
+		height: options.height,
+		heightmapFilePath: options.heightmapFilePath,
+		mode,
+		noiseAmplitude: options.noiseAmplitude,
+		noiseFrequency: options.noiseFrequency,
+		noiseSeed: options.noiseSeed,
+		rampAxis: options.rampAxis,
+		rampEndHeight: options.rampEndHeight,
+		rampStartHeight: options.rampStartHeight,
+		region,
+		requestId,
+		type: BRIDGE_SCULPT_LANDSCAPE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgePaintLandscapeLayerRequest(actorPath, layerName, region, weight, requestId = randomUUID()) {
+	return bridgePaintLandscapeLayerRequestSchema.parse({
+		actorPath,
+		layerName,
+		region,
+		requestId,
+		type: BRIDGE_PAINT_LANDSCAPE_LAYER_REQUEST_TYPE,
+		version: 2,
+		weight
+	});
+}
+function createBridgeRunGeometryScriptRequest(operations, output, options = {}, requestId = randomUUID()) {
+	return bridgeRunGeometryScriptRequestSchema.parse({
+		actorTransform: options.actorTransform,
+		assetName: options.assetName,
+		assetPath: options.assetPath,
+		label: options.label,
+		operations,
+		output,
+		requestId,
+		type: BRIDGE_RUN_GEOMETRY_SCRIPT_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeListDataLayersRequest(options = {}, requestId = randomUUID()) {
+	return bridgeListDataLayersRequestSchema.parse({
+		cursor: options.cursor,
+		maxResults: options.maxResults,
+		requestId,
+		type: BRIDGE_LIST_DATA_LAYERS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSetDataLayerStateRequest(entries, requestId = randomUUID()) {
+	return bridgeSetDataLayerStateRequestSchema.parse({
+		entries,
+		requestId,
+		type: BRIDGE_SET_DATA_LAYER_STATE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeLoadWpRegionRequest(action, options = {}, requestId = randomUUID()) {
+	return bridgeLoadWpRegionRequestSchema.parse({
+		action,
+		region: options.region,
+		regionId: options.regionId,
+		requestId,
+		type: BRIDGE_LOAD_WP_REGION_REQUEST_TYPE,
+		version: 2
+	});
+}
 //#endregion
 //#region src/bridgeSocketClient.ts
 var BridgeSocketError = class extends Error {
@@ -3141,6 +4738,123 @@ async function sendBridgeCheckoutAssetsRequest(request, options) {
 async function sendBridgeGetSourceControlJobStatusRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetSourceControlJobStatusResponseSchema, request.requestId);
 }
+async function sendBridgeListAssetFactoriesRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeListAssetFactoriesResponseSchema, request.requestId);
+}
+async function sendBridgeCreateAssetRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateAssetResponseSchema, request.requestId);
+}
+async function sendBridgeDuplicateAssetRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeDuplicateAssetResponseSchema, request.requestId);
+}
+async function sendBridgeRenameAssetRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeRenameAssetResponseSchema, request.requestId);
+}
+async function sendBridgeMoveAssetRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeMoveAssetResponseSchema, request.requestId);
+}
+async function sendBridgeDeleteAssetRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeDeleteAssetResponseSchema, request.requestId);
+}
+async function sendBridgeSaveAssetRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSaveAssetResponseSchema, request.requestId);
+}
+async function sendBridgeCreateFolderRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateFolderResponseSchema, request.requestId);
+}
+async function sendBridgeGetAssetMetadataRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetAssetMetadataResponseSchema, request.requestId);
+}
+async function sendBridgeListGraphNodesRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeListGraphNodesResponseSchema, request.requestId);
+}
+async function sendBridgeAddGraphNodeRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddGraphNodeResponseSchema, request.requestId);
+}
+async function sendBridgeRemoveGraphNodeRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeRemoveGraphNodeResponseSchema, request.requestId);
+}
+async function sendBridgeConnectPinsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeConnectPinsResponseSchema, request.requestId);
+}
+async function sendBridgeDisconnectPinsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeDisconnectPinsResponseSchema, request.requestId);
+}
+async function sendBridgeSetPinDefaultRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetPinDefaultResponseSchema, request.requestId);
+}
+async function sendBridgeListAvailableNodesRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeListAvailableNodesResponseSchema, request.requestId);
+}
+async function sendBridgeSetViewportCameraRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetViewportCameraResponseSchema, request.requestId);
+}
+async function sendBridgeFocusActorsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeFocusActorsResponseSchema, request.requestId);
+}
+async function sendBridgeSetViewModeRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetViewModeResponseSchema, request.requestId);
+}
+async function sendBridgeToggleShowFlagsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeToggleShowFlagsResponseSchema, request.requestId);
+}
+async function sendBridgeHighResScreenshotRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeHighResScreenshotResponseSchema, request.requestId);
+}
+async function sendBridgeDuplicateActorRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeDuplicateActorResponseSchema, request.requestId);
+}
+async function sendBridgeAttachActorRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAttachActorResponseSchema, request.requestId);
+}
+async function sendBridgeAddActorComponentRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddActorComponentResponseSchema, request.requestId);
+}
+async function sendBridgeSetActorTagsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetActorTagsResponseSchema, request.requestId);
+}
+async function sendBridgeMoveToFolderRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeMoveToFolderResponseSchema, request.requestId);
+}
+async function sendBridgePlaceAssetRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgePlaceAssetResponseSchema, request.requestId);
+}
+async function sendBridgeReplaceActorsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeReplaceActorsResponseSchema, request.requestId);
+}
+async function sendBridgeStartEditorBuildRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeStartEditorBuildResponseSchema, request.requestId);
+}
+async function sendBridgeGetBuildJobStatusRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetBuildJobStatusResponseSchema, request.requestId);
+}
+async function sendBridgeCreateGameplayTagRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateGameplayTagResponseSchema, request.requestId);
+}
+async function sendBridgeListGameplayTagsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeListGameplayTagsResponseSchema, request.requestId);
+}
+async function sendBridgeCreateLandscapeRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateLandscapeResponseSchema, request.requestId);
+}
+async function sendBridgeSculptLandscapeRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSculptLandscapeResponseSchema, request.requestId);
+}
+async function sendBridgePaintLandscapeLayerRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgePaintLandscapeLayerResponseSchema, request.requestId);
+}
+async function sendBridgeRunGeometryScriptRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeRunGeometryScriptResponseSchema, request.requestId);
+}
+async function sendBridgeListDataLayersRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeListDataLayersResponseSchema, request.requestId);
+}
+async function sendBridgeSetDataLayerStateRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetDataLayerStateResponseSchema, request.requestId);
+}
+async function sendBridgeLoadWpRegionRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeLoadWpRegionResponseSchema, request.requestId);
+}
 async function sendBridgeGetAssetDependenciesRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetAssetDependenciesResponseSchema, request.requestId);
 }
@@ -5445,6 +7159,7 @@ function percentile(sortedValues, fraction) {
 //#region src/mcpTools.ts
 const EDITOR_WORK_TIMEOUT_MS = 1e4;
 const WAIT_FOR_JOB_KINDS = [
+	"build",
 	"compile",
 	"create_class",
 	"pie",
@@ -5453,6 +7168,7 @@ const WAIT_FOR_JOB_KINDS = [
 ];
 const WAIT_FOR_JOB_MAX_TIMEOUT_MS = 6e5;
 const WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS = {
+	build: WAIT_FOR_JOB_MAX_TIMEOUT_MS,
 	compile: 12e4,
 	create_class: 6e4,
 	pie: 3e4,
@@ -5460,6 +7176,10 @@ const WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS = {
 	test_run: 3e5
 };
 const WAIT_FOR_JOB_POLL_CADENCE_MS = {
+	build: {
+		capMs: 15e3,
+		initialMs: 1e3
+	},
 	compile: {
 		capMs: 2e3,
 		initialMs: 250
@@ -6472,843 +8192,1397 @@ function registerMcpTools(server, dependencies) {
 	}, async ({ projectPath }) => {
 		return toToolSuccess(await getProjectIdForPath(projectPath, dependencies.projectIdResolver));
 	});
-	server.registerTool("add_module", {
-		description: "Scaffold a new Unreal C++ module (Source/<moduleName> with Build.cs, Public/<moduleName>.h, Private/<moduleName>.cpp) and register it in a .uproject or .uplugin descriptor. Pure filesystem scaffold; run generate_project_files + build_target afterward to compile it.",
-		inputSchema: addModuleInputSchema,
-		title: "Add Module"
-	}, async ({ descriptorPath, loadingPhase, moduleName, moduleType, privateDependencyModuleNames, publicDependencyModuleNames }) => {
-		return toToolSuccess(await addModule({
-			descriptorPath,
-			loadingPhase,
+	server.registerTool("add_module", {
+		description: "Scaffold a new Unreal C++ module (Source/<moduleName> with Build.cs, Public/<moduleName>.h, Private/<moduleName>.cpp) and register it in a .uproject or .uplugin descriptor. Pure filesystem scaffold; run generate_project_files + build_target afterward to compile it.",
+		inputSchema: addModuleInputSchema,
+		title: "Add Module"
+	}, async ({ descriptorPath, loadingPhase, moduleName, moduleType, privateDependencyModuleNames, publicDependencyModuleNames }) => {
+		return toToolSuccess(await addModule({
+			descriptorPath,
+			loadingPhase,
+			moduleName,
+			moduleType,
+			privateDependencyModuleNames,
+			publicDependencyModuleNames
+		}, dependencies));
+	});
+	server.registerTool("ping_project", {
+		description: "Ping the registered Unreal engine bridge for a projectId and evict stale registrations after retries.",
+		inputSchema: pingProjectInputSchema,
+		title: "Ping Project"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await pingProject(projectId, dependencies));
+	});
+	server.registerTool("list_registered_projects", {
+		description: "List every Unreal Editor currently registered with this server (projectId, projectName, projectPath, host, port, pid, registeredAt, lastSeenAt). Call this first to discover which editors are running and which projectId to pass to the other tools. Reads the registry only and performs no network I/O unless verify is true, which pings each entry once and adds reachable/reason. Never evicts a registration — use ping_project for that.",
+		inputSchema: listRegisteredProjectsInputSchema,
+		title: "List Registered Projects"
+	}, async ({ maxResults, verify }) => {
+		return toToolSuccess(await listRegisteredProjects({
+			maxResults,
+			verify
+		}, dependencies));
+	});
+	server.registerTool("trigger_live_compile", {
+		description: "Trigger an Unreal Live Coding recompile of patched modules for a projectId; tail stream_output_log (LogLiveCoding) for build output.",
+		inputSchema: triggerLiveCompileInputSchema,
+		title: "Trigger Live Compile"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await triggerLiveCompile(projectId, dependencies));
+	});
+	server.registerTool("trigger_hot_reload", {
+		description: "Trigger an Unreal Hot Reload recompile-and-reload of the loaded game modules for a projectId. Use on macOS and Linux, where Live Coding does not exist; on Windows prefer trigger_live_compile. Poll with get_compile_status. Tail stream_output_log (LogHotReload) for build output.",
+		inputSchema: triggerHotReloadInputSchema,
+		title: "Trigger Hot Reload"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await triggerHotReload(projectId, dependencies));
+	});
+	server.registerTool("get_compile_status", {
+		description: "Poll a compile job started by trigger_live_compile or trigger_hot_reload for a projectId; returns state (compiling, succeeded, failed, unknown_job), error/warning counts and items, and timing once finished. Hot Reload jobs also report restartRequired/restartReason when the change looks structural. Tail stream_output_log (LogLiveCoding, LogHotReload) for detailed build lines.",
+		inputSchema: getCompileStatusInputSchema,
+		title: "Get Compile Status"
+	}, async ({ compileJobId, projectId }) => {
+		return toToolSuccess(await getCompileStatus({
+			compileJobId,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("get_crash_callstack", {
+		description: "Report structured call stacks for ensures and fatal errors captured in the running editor for a projectId, newest first. Each record carries the failure message, the capturing thread, and per-frame module, symbol and file/line where symbols resolve.",
+		inputSchema: getCrashCallstackInputSchema,
+		title: "Get Crash Callstack"
+	}, async ({ maxFrames, maxRecords, projectId }) => {
+		return toToolSuccess(await getCrashCallstack({
+			maxFrames,
+			maxRecords,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("build_target", {
+		description: "Run a full UnrealBuildTool build for a target/configuration/platform as a child process and return pass/fail with parsed error and warning diagnostics. Use for structural changes Live Coding cannot handle (new UPROPERTY/UCLASS, layout changes). Server-side; does not require a running editor.",
+		inputSchema: buildTargetInputSchema,
+		title: "Build Target"
+	}, async (input) => {
+		return toToolSuccess(await buildTarget(input, dependencies));
+	});
+	server.registerTool("generate_project_files", {
+		description: "Regenerate IDE project files with UnrealBuildTool (-projectfiles) so newly added modules and classes appear in the project. Returns success and any UBT errors. Server-side; does not require a running editor.",
+		inputSchema: generateProjectFilesInputSchema,
+		title: "Generate Project Files"
+	}, async (input) => {
+		return toToolSuccess(await generateProjectFiles(input, dependencies));
+	});
+	server.registerTool("clean_build", {
+		description: "Clean build artifacts (Intermediate/Binaries) for a target with UnrealBuildTool (-Clean) to recover from stale-build issues. Returns the result and any UBT errors. Chain with build_target to rebuild. Server-side; does not require a running editor.",
+		inputSchema: cleanBuildInputSchema,
+		title: "Clean Build"
+	}, async (input) => {
+		return toToolSuccess(await cleanBuild(input, dependencies));
+	});
+	server.registerTool("cook_content", {
+		description: "Start a full offline cook (UnrealEditor-Cmd -run=Cook) for a target platform and return a packageJobId immediately; poll it with get_package_status. Unlike launch_on_device (cook-on-the-fly) this proves the content actually cooks, surfacing missing references, unfixed redirectors and platform shader failures. Runs for minutes to tens of minutes. Refuses while the project editor is running unless force is true. Server-side; no running editor required.",
+		inputSchema: cookContentInputSchema,
+		title: "Cook Content"
+	}, async (input) => {
+		return toToolSuccess(await cookContent(input, dependencies));
+	});
+	server.registerTool("package_project", {
+		description: "Start a full package via RunUAT BuildCookRun (build + cook + stage + pak + archive) for a platform, configuration and archive directory, returning a packageJobId immediately; poll it with get_package_status. Runs for minutes to tens of minutes. Refuses while the project editor is running unless force is true. Server-side; no running editor required.",
+		inputSchema: packageProjectInputSchema,
+		title: "Package Project"
+	}, async (input) => {
+		return toToolSuccess(await packageProject(input, dependencies));
+	});
+	server.registerTool("run_editor_commandlet", {
+		description: "Start an editor commandlet (UnrealEditor-Cmd -run=<name>) with an argv array and return a packageJobId; poll it with get_package_status. Unlocks the maintenance commandlets you reach for after a failed cook — ResavePackages, FixupRedirects, DataValidation. The commandlet name must be identifier characters only and arguments are passed as separate argv entries without a shell; -run= and -Project= are set by the tool and rejected as arguments. A commandlet can modify or delete project assets, so it refuses to run while the project editor is running unless force is true.",
+		inputSchema: runEditorCommandletInputSchema,
+		title: "Run Editor Commandlet"
+	}, async (input) => {
+		return toToolSuccess(await runEditorCommandlet(input, dependencies));
+	});
+	server.registerTool("analyze_trace", {
+		description: "Analyze a completed .utrace (the path stop_insights_trace returns) headlessly with the engine's Unreal Insights analyzer and return a bounded, readable summary: frame-time p50/p90/p99, the worst N hitches with timestamps, a CPU vs GPU time split, and top-N timing scopes by inclusive and exclusive time. Memory and LLM-tag totals are deliberately not reported — they need a separate analysis pass. Resolve the engine with engineVersion or projectPath. Every list is top-N and the response is byte-capped, with truncated naming what was shortened. Returns state 'unsupported' when the installed engine ships no Insights analyzer for this host.",
+		inputSchema: analyzeTraceInputSchema,
+		title: "Analyze Trace"
+	}, async (input) => {
+		return toToolSuccess(await analyzeTrace(input, dependencies));
+	});
+	server.registerTool("get_package_status", {
+		description: "Poll a job started by cook_content, package_project, or run_editor_commandlet. Returns state ('running', 'succeeded', 'failed', 'cancelled', or 'unknown_job' for an unknown/evicted id), structured cook/UAT error and warning diagnostics, truncation flags, exit code, and timing once finished.",
+		inputSchema: getPackageStatusInputSchema,
+		title: "Get Package Status"
+	}, async ({ packageJobId }) => {
+		return toToolSuccess(getPackageStatus({ packageJobId }, dependencies));
+	});
+	server.registerTool("cancel_package_job", {
+		description: "Abort an in-flight cook, package, or commandlet job by its packageJobId. Returns cancelled=true (state cancelled) when a live job was killed, or cancelled=false with the job current state (or unknown_job) otherwise.",
+		inputSchema: cancelPackageJobInputSchema,
+		title: "Cancel Package Job"
+	}, async ({ packageJobId }) => {
+		return toToolSuccess(cancelPackageJob({ packageJobId }, dependencies));
+	});
+	server.registerTool("run_clang_tidy", {
+		description: "Run clang-tidy over a project's synced compile_commands.json and return structured findings (file, line, column, check, severity, message), catching issues before a compile. Report only; does not apply fixes. Server-side; does not require a running editor.",
+		inputSchema: runClangTidyInputSchema,
+		title: "Run clang-tidy"
+	}, async (input) => {
+		return toToolSuccess(await runClangTidy(input, dependencies));
+	});
+	server.registerTool("create_cpp_class", {
+		description: "Scaffold a new C++ class in a projectId the way the editor New C++ Class wizard does (header, source, GENERATED_BODY, module API macro, project files). Generation is scheduled on the editor game thread and returns a createClassJobId; poll it with get_create_class_status.",
+		inputSchema: createCppClassInputSchema,
+		title: "Create C++ Class"
+	}, async ({ className, classPath, moduleName, parentClass, projectId }) => {
+		return toToolSuccess(await createCppClass({
+			className,
+			classPath,
 			moduleName,
-			moduleType,
-			privateDependencyModuleNames,
-			publicDependencyModuleNames
+			parentClass,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("get_create_class_status", {
+		description: "Poll a C++ class generation job started by create_cpp_class for a projectId; returns state (creating, succeeded, failed, unknown_job), the generated headerPath and sourcePath, whether the editor hot-reloaded the class, and timing once finished.",
+		inputSchema: getCreateClassStatusInputSchema,
+		title: "Get Create Class Status"
+	}, async ({ createClassJobId, projectId }) => {
+		return toToolSuccess(await getCreateClassStatus({
+			createClassJobId,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("stream_output_log", {
+		description: "Poll a bounded batch of Unreal Output Log events for a project and continue by calling again with the returned cursor.",
+		inputSchema: streamOutputLogInputSchema,
+		title: "Stream Output Log"
+	}, async ({ categoryAllow, categoryDeny, cursor, maxEvents, minVerbosity, projectId, textContains, textPattern }) => {
+		return toToolSuccess(await streamLogs({
+			cursor,
+			filters: {
+				categoryAllow,
+				categoryDeny,
+				minVerbosity,
+				textContains,
+				textPattern
+			},
+			maxEvents,
+			projectId,
+			registry: dependencies.registry,
+			sessionManager: dependencies.logSessionManager,
+			source: "output_log"
+		}));
+	});
+	server.registerTool("stream_message_log", {
+		description: "Poll a bounded batch from a named Unreal Message Log listing and continue by calling again with the returned cursor.",
+		inputSchema: streamMessageLogInputSchema,
+		title: "Stream Message Log"
+	}, async ({ cursor, listingName, maxEvents, minSeverity, projectId, textContains, textPattern }) => {
+		return toToolSuccess(await streamLogs({
+			cursor,
+			filters: {
+				listingName,
+				minSeverity,
+				textContains,
+				textPattern
+			},
+			maxEvents,
+			projectId,
+			registry: dependencies.registry,
+			sessionManager: dependencies.logSessionManager,
+			source: "message_log"
+		}));
+	});
+	server.registerTool("stream_device_output_log", {
+		description: "Poll a bounded batch of Unreal device-output log events and continue by calling again with the returned cursor.",
+		inputSchema: streamDeviceOutputLogInputSchema,
+		title: "Stream Device Output Log"
+	}, async ({ cursor, deviceId, deviceName, maxEvents, projectId, textContains, textPattern }) => {
+		return toToolSuccess(await streamLogs({
+			cursor,
+			filters: {
+				deviceId,
+				deviceName,
+				textContains,
+				textPattern
+			},
+			maxEvents,
+			projectId,
+			registry: dependencies.registry,
+			sessionManager: dependencies.logSessionManager,
+			source: "device_output_log"
+		}));
+	});
+	server.registerTool("start_pie", {
+		description: "Start a Play-in-Editor session in the registered Unreal editor for a project; play begins on the next editor tick (async). Returns starting/running/unsupported.",
+		inputSchema: startPieInputSchema,
+		title: "Start Play-in-Editor"
+	}, async ({ map, mode, netMode, numClients, projectId, runUnderOneProcess }) => {
+		return toToolSuccess(await startPie({
+			map,
+			mode,
+			netMode,
+			numClients,
+			projectId,
+			runUnderOneProcess
+		}, dependencies));
+	});
+	server.registerTool("get_pie_status", {
+		description: "Report the state of the Play-in-Editor session started by start_pie for a project: starting, running, stopped, or none. Reports running only after PIE has actually begun.",
+		inputSchema: getPieStatusInputSchema,
+		title: "Get Play-in-Editor Status"
+	}, async ({ pieSessionId, projectId }) => {
+		return toToolSuccess(await getPieStatus({
+			pieSessionId,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("stop_pie", {
+		description: "End the active Play-in-Editor session for a project. Returns stopped=true when a session was ended, or stopped=false (state none) when nothing was playing.",
+		inputSchema: stopPieInputSchema,
+		title: "Stop Play-in-Editor"
+	}, async ({ pieSessionId, projectId }) => {
+		return toToolSuccess(await stopPie({
+			pieSessionId,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("list_launch_devices", {
+		description: "List the target devices the registered Unreal editor can launch onto (iOS, Android, etc.), with each device id, name, platform, and connected/authorized state. Pick a deviceId for launch_on_device.",
+		inputSchema: listLaunchDevicesInputSchema,
+		title: "List Launch Devices"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await listLaunchDevices({ projectId }, dependencies));
+	});
+	server.registerTool("launch_on_device", {
+		description: "Launch (cook-on-the-fly + deploy, not package) the current project onto a connected target device by deviceId from list_launch_devices. Returns a launchSessionId and starting/unsupported state; deploy proceeds asynchronously.",
+		inputSchema: launchOnDeviceInputSchema,
+		title: "Launch On Device"
+	}, async ({ deviceId, map, projectId }) => {
+		return toToolSuccess(await launchOnDevice({
+			deviceId,
+			map,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("list_automation_tests", {
+		description: "List the automation tests registered in a project's running Unreal Editor, with optional name and flag filters; returns each test's full name, display name, flags, and test type.",
+		inputSchema: listAutomationTestsInputSchema,
+		title: "List Automation Tests"
+	}, async ({ cursor, flags, maxResults, nameFilter, projectId }) => {
+		return toToolSuccess(await listAutomationTests({
+			cursor,
+			flags,
+			maxResults,
+			nameFilter,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("run_automation_tests", {
+		description: "Start an Unreal automation run (unit, smoke, and functional/BP scene tests) for a project and return a testRunId; requires at least one of testNames or nameFilter. Poll progress separately via stream_message_log on the AutomationTesting listing.",
+		inputSchema: runAutomationTestsInputSchema,
+		title: "Run Automation Tests"
+	}, async ({ flags, nameFilter, projectId, testNames }) => {
+		return toToolSuccess(await runAutomationTests({
+			flags,
+			nameFilter,
+			projectId,
+			testNames
 		}, dependencies));
 	});
-	server.registerTool("ping_project", {
-		description: "Ping the registered Unreal engine bridge for a projectId and evict stale registrations after retries.",
-		inputSchema: pingProjectInputSchema,
-		title: "Ping Project"
-	}, async ({ projectId }) => {
-		return toToolSuccess(await pingProject(projectId, dependencies));
-	});
-	server.registerTool("list_registered_projects", {
-		description: "List every Unreal Editor currently registered with this server (projectId, projectName, projectPath, host, port, pid, registeredAt, lastSeenAt). Call this first to discover which editors are running and which projectId to pass to the other tools. Reads the registry only and performs no network I/O unless verify is true, which pings each entry once and adds reachable/reason. Never evicts a registration — use ping_project for that.",
-		inputSchema: listRegisteredProjectsInputSchema,
-		title: "List Registered Projects"
-	}, async ({ maxResults, verify }) => {
-		return toToolSuccess(await listRegisteredProjects({
+	server.registerTool("get_test_run_status", {
+		description: "Poll an automation run started by run_automation_tests by its testRunId; returns the run state ('running', 'complete', or 'unknown_run' for an unknown/expired id), aggregate pass/fail/skip counts, and structured per-test results with their log entries. Results are paged: pass the previous response nextCursor to fetch the next page (totalCount reports the full result count).",
+		inputSchema: getTestRunStatusInputSchema,
+		title: "Get Test Run Status"
+	}, async ({ cursor, maxResults, projectId, testRunId }) => {
+		return toToolSuccess(await getTestRunStatus({
+			cursor,
 			maxResults,
-			verify
+			projectId,
+			testRunId
 		}, dependencies));
 	});
-	server.registerTool("trigger_live_compile", {
-		description: "Trigger an Unreal Live Coding recompile of patched modules for a projectId; tail stream_output_log (LogLiveCoding) for build output.",
-		inputSchema: triggerLiveCompileInputSchema,
-		title: "Trigger Live Compile"
-	}, async ({ projectId }) => {
-		return toToolSuccess(await triggerLiveCompile(projectId, dependencies));
+	server.registerTool("wait_for_job", {
+		description: `Block server-side until an async job reaches a terminal state, then return the payload its get_*_status tool would have returned under 'status'. Use instead of a poll loop after trigger_live_compile, trigger_hot_reload (kind 'compile'), create_cpp_class ('create_class'), run_automation_tests ('test_run'), or start_pie ('pie'). kind is required — job ids carry no type tag. outcome is 'completed', 'timed_out' (the last observed status is still returned; call again or poll), or 'unknown_job' (unknown/expired/cancelled id, returned immediately). timeoutMs defaults per kind (compile ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.compile)}ms, create_class ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.create_class)}ms, pie ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.pie)}ms, test_run ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.test_run)}ms) and is clamped to ${String(WAIT_FOR_JOB_MAX_TIMEOUT_MS)}ms, so a long automation run may need more than one call. For kind 'test_run' the returned status.results is the first page only — page the rest with get_test_run_status and nextCursor. For kind 'pie' only 'starting' keeps waiting; 'running', 'stopped' and 'none' are all terminal.`,
+		inputSchema: waitForJobInputSchema,
+		title: "Wait For Job"
+	}, async ({ jobId, kind, projectId, timeoutMs }) => {
+		return toToolSuccess(await waitForJob({
+			jobId,
+			kind,
+			projectId,
+			timeoutMs
+		}, dependencies));
 	});
-	server.registerTool("trigger_hot_reload", {
-		description: "Trigger an Unreal Hot Reload recompile-and-reload of the loaded game modules for a projectId. Use on macOS and Linux, where Live Coding does not exist; on Windows prefer trigger_live_compile. Poll with get_compile_status. Tail stream_output_log (LogHotReload) for build output.",
-		inputSchema: triggerHotReloadInputSchema,
-		title: "Trigger Hot Reload"
+	server.registerTool("cancel_test_run", {
+		description: "Abort an in-progress Unreal automation run for a project by its testRunId. Returns cancelled=true (state cancelled) when a live run was aborted, or cancelled=false (state not_found) when the run is unknown or already finished.",
+		inputSchema: cancelTestRunInputSchema,
+		title: "Cancel Test Run"
+	}, async ({ projectId, testRunId }) => {
+		return toToolSuccess(await cancelTestRun({
+			projectId,
+			testRunId
+		}, dependencies));
+	});
+	server.registerTool("get_editor_state", {
+		description: "Report the registered Unreal Editor's current state for a project: the open map name and package path, the selected actors as { actorPath, label } objects whose actorPath the level tools accept directly, the active editor modes, and whether Play-in-Editor is running. Selected actors are capped per response; selectedActorCount reports the full selection size. activeModes is empty until the level editor has finished initializing, so an empty list right after the editor starts means 'not ready yet', not 'no mode'.",
+		inputSchema: getEditorStateInputSchema,
+		title: "Get Editor State"
 	}, async ({ projectId }) => {
-		return toToolSuccess(await triggerHotReload(projectId, dependencies));
+		return toToolSuccess(await getEditorState({ projectId }, dependencies));
 	});
-	server.registerTool("get_compile_status", {
-		description: "Poll a compile job started by trigger_live_compile or trigger_hot_reload for a projectId; returns state (compiling, succeeded, failed, unknown_job), error/warning counts and items, and timing once finished. Hot Reload jobs also report restartRequired/restartReason when the change looks structural. Tail stream_output_log (LogLiveCoding, LogHotReload) for detailed build lines.",
-		inputSchema: getCompileStatusInputSchema,
-		title: "Get Compile Status"
-	}, async ({ compileJobId, projectId }) => {
-		return toToolSuccess(await getCompileStatus({
-			compileJobId,
+	server.registerTool("exec_console_command", {
+		description: "Run an arbitrary Unreal console command in a project's running editor and return the captured console output. Targets the active Play-in-Editor world when PIE is running and the editor world otherwise. This runs with full editor authority — commands such as 'quit' will act on the live editor.",
+		inputSchema: execConsoleCommandInputSchema,
+		title: "Execute Console Command"
+	}, async ({ command, projectId }) => {
+		return toToolSuccess(await execConsoleCommand({
+			command,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("get_crash_callstack", {
-		description: "Report structured call stacks for ensures and fatal errors captured in the running editor for a projectId, newest first. Each record carries the failure message, the capturing thread, and per-frame module, symbol and file/line where symbols resolve.",
-		inputSchema: getCrashCallstackInputSchema,
-		title: "Get Crash Callstack"
-	}, async ({ maxFrames, maxRecords, projectId }) => {
-		return toToolSuccess(await getCrashCallstack({
-			maxFrames,
-			maxRecords,
-			projectId
+	server.registerTool("get_config_value", {
+		description: "Read one project config value through the running editor's config system, which resolves the full Base*/Default*/Saved hierarchy. Returns the resolved value, the ini it came from, and resolvedFrom ('engine_base', 'project_default', 'saved_user'), and reports present=false for an unset key so an absent value is distinguishable from a present-but-empty one. file is a closed set of known ini names, not a path.",
+		inputSchema: getConfigValueInputSchema,
+		title: "Get Config Value"
+	}, async ({ file, key, projectId, section }) => {
+		return toToolSuccess(await getConfigValue({
+			file,
+			key,
+			projectId,
+			section
 		}, dependencies));
 	});
-	server.registerTool("build_target", {
-		description: "Run a full UnrealBuildTool build for a target/configuration/platform as a child process and return pass/fail with parsed error and warning diagnostics. Use for structural changes Live Coding cannot handle (new UPROPERTY/UCLASS, layout changes). Server-side; does not require a running editor.",
-		inputSchema: buildTargetInputSchema,
-		title: "Build Target"
-	}, async (input) => {
-		return toToolSuccess(await buildTarget(input, dependencies));
-	});
-	server.registerTool("generate_project_files", {
-		description: "Regenerate IDE project files with UnrealBuildTool (-projectfiles) so newly added modules and classes appear in the project. Returns success and any UBT errors. Server-side; does not require a running editor.",
-		inputSchema: generateProjectFilesInputSchema,
-		title: "Generate Project Files"
-	}, async (input) => {
-		return toToolSuccess(await generateProjectFiles(input, dependencies));
-	});
-	server.registerTool("clean_build", {
-		description: "Clean build artifacts (Intermediate/Binaries) for a target with UnrealBuildTool (-Clean) to recover from stale-build issues. Returns the result and any UBT errors. Chain with build_target to rebuild. Server-side; does not require a running editor.",
-		inputSchema: cleanBuildInputSchema,
-		title: "Clean Build"
-	}, async (input) => {
-		return toToolSuccess(await cleanBuild(input, dependencies));
+	server.registerTool("set_config_value", {
+		description: "Write one project config value through the running editor's config system and flush it to disk, so the ini is normalised the way the engine expects and the live editor picks the change up without a restart. Writes Config/Default<File>.ini by default, or the Saved/Config user override with scope 'saved_user'. Returns the previous value as the editor resolved it across the whole hierarchy, which is not necessarily what the target layer held: if it came from an engine or default layer, writing it back leaves the key materialised in the layer this tool wrote. Requires a registered editor: a raw file write behind a running editor is clobbered when the editor saves its own config.",
+		inputSchema: setConfigValueInputSchema,
+		title: "Set Config Value"
+	}, async ({ file, key, projectId, scope, section, value }) => {
+		return toToolSuccess(await setConfigValue({
+			file,
+			key,
+			projectId,
+			scope,
+			section,
+			value
+		}, dependencies));
 	});
-	server.registerTool("cook_content", {
-		description: "Start a full offline cook (UnrealEditor-Cmd -run=Cook) for a target platform and return a packageJobId immediately; poll it with get_package_status. Unlike launch_on_device (cook-on-the-fly) this proves the content actually cooks, surfacing missing references, unfixed redirectors and platform shader failures. Runs for minutes to tens of minutes. Refuses while the project editor is running unless force is true. Server-side; no running editor required.",
-		inputSchema: cookContentInputSchema,
-		title: "Cook Content"
-	}, async (input) => {
-		return toToolSuccess(await cookContent(input, dependencies));
+	server.registerTool("list_config_section", {
+		description: "Dump one config section as key/value pairs as the running editor resolves it. Paged: pass the previous response nextCursor for the next page; totalCount reports the full key count.",
+		inputSchema: listConfigSectionInputSchema,
+		title: "List Config Section"
+	}, async ({ cursor, file, maxResults, projectId, section }) => {
+		return toToolSuccess(await listConfigSection({
+			cursor,
+			file,
+			maxResults,
+			projectId,
+			section
+		}, dependencies));
 	});
-	server.registerTool("package_project", {
-		description: "Start a full package via RunUAT BuildCookRun (build + cook + stage + pak + archive) for a platform, configuration and archive directory, returning a packageJobId immediately; poll it with get_package_status. Runs for minutes to tens of minutes. Refuses while the project editor is running unless force is true. Server-side; no running editor required.",
-		inputSchema: packageProjectInputSchema,
-		title: "Package Project"
-	}, async (input) => {
-		return toToolSuccess(await packageProject(input, dependencies));
+	server.registerTool("get_class_reflection", {
+		description: "Reflect a UCLASS or USTRUCT in a project's running Unreal Editor: parent type, implemented interfaces, class flags, and the declared properties (name, C++ type, UPROPERTY specifiers, metadata) and functions (UFUNCTION specifiers, parameters, metadata). Use it to learn a type's API without reading headers. Properties and functions page independently — pass the previous response nextPropertyCursor/nextFunctionCursor to continue.",
+		inputSchema: getClassReflectionInputSchema,
+		title: "Get Class Reflection"
+	}, async ({ className, functionCursor, includeInherited, maxFunctions, maxProperties, projectId, propertyCursor }) => {
+		return toToolSuccess(await getClassReflection({
+			className,
+			functionCursor,
+			includeInherited,
+			maxFunctions,
+			maxProperties,
+			projectId,
+			propertyCursor
+		}, dependencies));
 	});
-	server.registerTool("run_editor_commandlet", {
-		description: "Start an editor commandlet (UnrealEditor-Cmd -run=<name>) with an argv array and return a packageJobId; poll it with get_package_status. Unlocks the maintenance commandlets you reach for after a failed cook — ResavePackages, FixupRedirects, DataValidation. The commandlet name must be identifier characters only and arguments are passed as separate argv entries without a shell; -run= and -Project= are set by the tool and rejected as arguments. A commandlet can modify or delete project assets, so it refuses to run while the project editor is running unless force is true.",
-		inputSchema: runEditorCommandletInputSchema,
-		title: "Run Editor Commandlet"
-	}, async (input) => {
-		return toToolSuccess(await runEditorCommandlet(input, dependencies));
+	server.registerTool("save_dirty_packages", {
+		description: "Save the unsaved (dirty) map and content packages in the registered Unreal Editor for a project, so changes made by other tools are persisted to disk. Returns which packages were saved and which are still dirty. Packages that have never been written to disk are skipped rather than prompting the editor for a filename.",
+		inputSchema: saveDirtyPackagesInputSchema,
+		title: "Save Dirty Packages"
+	}, async ({ projectId, saveContentPackages, saveMapPackages }) => {
+		return toToolSuccess(await saveDirtyPackages({
+			projectId,
+			saveContentPackages,
+			saveMapPackages
+		}, dependencies));
 	});
-	server.registerTool("analyze_trace", {
-		description: "Analyze a completed .utrace (the path stop_insights_trace returns) headlessly with the engine's Unreal Insights analyzer and return a bounded, readable summary: frame-time p50/p90/p99, the worst N hitches with timestamps, a CPU vs GPU time split, and top-N timing scopes by inclusive and exclusive time. Memory and LLM-tag totals are deliberately not reported — they need a separate analysis pass. Resolve the engine with engineVersion or projectPath. Every list is top-N and the response is byte-capped, with truncated naming what was shortened. Returns state 'unsupported' when the installed engine ships no Insights analyzer for this host.",
-		inputSchema: analyzeTraceInputSchema,
-		title: "Analyze Trace"
-	}, async (input) => {
-		return toToolSuccess(await analyzeTrace(input, dependencies));
+	server.registerTool("get_stat_snapshot", {
+		description: "Sample a project's running Unreal editor for core performance counters: frames per second, frame time, game/render thread times, and process memory usage. Single snapshot — call again to sample a later frame.",
+		inputSchema: getStatSnapshotInputSchema,
+		title: "Get Stat Snapshot"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await getStatSnapshot(projectId, dependencies));
 	});
-	server.registerTool("get_package_status", {
-		description: "Poll a job started by cook_content, package_project, or run_editor_commandlet. Returns state ('running', 'succeeded', 'failed', 'cancelled', or 'unknown_job' for an unknown/evicted id), structured cook/UAT error and warning diagnostics, truncation flags, exit code, and timing once finished.",
-		inputSchema: getPackageStatusInputSchema,
-		title: "Get Package Status"
-	}, async ({ packageJobId }) => {
-		return toToolSuccess(getPackageStatus({ packageJobId }, dependencies));
+	server.registerTool("capture_viewport", {
+		description: "Capture the registered Unreal Editor's active viewport to a PNG on the editor host and return the absolute file path plus the image dimensions. The image bytes are never inlined in the response.",
+		inputSchema: captureViewportInputSchema,
+		title: "Capture Viewport"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await captureViewport({ projectId }, dependencies));
 	});
-	server.registerTool("cancel_package_job", {
-		description: "Abort an in-flight cook, package, or commandlet job by its packageJobId. Returns cancelled=true (state cancelled) when a live job was killed, or cancelled=false with the job current state (or unknown_job) otherwise.",
-		inputSchema: cancelPackageJobInputSchema,
-		title: "Cancel Package Job"
-	}, async ({ packageJobId }) => {
-		return toToolSuccess(cancelPackageJob({ packageJobId }, dependencies));
+	server.registerTool("start_insights_trace", {
+		description: "Start an Unreal Insights trace capture in a project's running editor and return the .utrace file path being written. Returns already_tracing (with the current path) when a capture is already running.",
+		inputSchema: startInsightsTraceInputSchema,
+		title: "Start Insights Trace"
+	}, async ({ channels, fileName, projectId }) => {
+		return toToolSuccess(await startInsightsTrace({
+			channels,
+			fileName,
+			projectId
+		}, dependencies));
 	});
-	server.registerTool("run_clang_tidy", {
-		description: "Run clang-tidy over a project's synced compile_commands.json and return structured findings (file, line, column, check, severity, message), catching issues before a compile. Report only; does not apply fixes. Server-side; does not require a running editor.",
-		inputSchema: runClangTidyInputSchema,
-		title: "Run clang-tidy"
-	}, async (input) => {
-		return toToolSuccess(await runClangTidy(input, dependencies));
+	server.registerTool("stop_insights_trace", {
+		description: "Stop the Unreal Insights trace running in a project's editor and return the completed .utrace file path. Returns not_tracing when no capture was running, and fails with trace_not_ready (retryable) when called before the capture has finished opening.",
+		inputSchema: stopInsightsTraceInputSchema,
+		title: "Stop Insights Trace"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await stopInsightsTrace(projectId, dependencies));
 	});
-	server.registerTool("create_cpp_class", {
-		description: "Scaffold a new C++ class in a projectId the way the editor New C++ Class wizard does (header, source, GENERATED_BODY, module API macro, project files). Generation is scheduled on the editor game thread and returns a createClassJobId; poll it with get_create_class_status.",
-		inputSchema: createCppClassInputSchema,
-		title: "Create C++ Class"
-	}, async ({ className, classPath, moduleName, parentClass, projectId }) => {
-		return toToolSuccess(await createCppClass({
+	server.registerTool("get_cdo_defaults", {
+		description: "Read the Class Default Object property values for a UCLASS in a project's running Unreal Editor, so configured defaults are visible without opening the asset or header. Values are exported as Unreal property text, so nested structs and arrays come back fully expanded. Results are paged: pass the previous response nextCursor to fetch the next page.",
+		inputSchema: getCdoDefaultsInputSchema,
+		title: "Get CDO Defaults"
+	}, async ({ className, cursor, includeInherited, maxResults, nameFilter, projectId }) => {
+		return toToolSuccess(await getCdoDefaults({
 			className,
-			classPath,
-			moduleName,
-			parentClass,
+			cursor,
+			includeInherited,
+			maxResults,
+			nameFilter,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("get_create_class_status", {
-		description: "Poll a C++ class generation job started by create_cpp_class for a projectId; returns state (creating, succeeded, failed, unknown_job), the generated headerPath and sourcePath, whether the editor hot-reloaded the class, and timing once finished.",
-		inputSchema: getCreateClassStatusInputSchema,
-		title: "Get Create Class Status"
-	}, async ({ createClassJobId, projectId }) => {
-		return toToolSuccess(await getCreateClassStatus({
-			createClassJobId,
-			projectId
+	server.registerTool("list_actors", {
+		description: "Enumerate actors in the editor's currently loaded level(s), optionally filtered by class, name substring, tag, or level. Returns each actor's canonical actorPath (the identifier every other level tool takes), display label, class, level, and World Outliner folder. Results are paged: pass the previous response nextCursor to fetch the next page, and totalCount reports the full match count even when a page truncates. Use this to find an actor before calling get_actor_details.",
+		inputSchema: listActorsInputSchema,
+		title: "List Actors"
+	}, async ({ classNames, cursor, levelName, maxResults, nameFilter, projectId, tag }) => {
+		return toToolSuccess(await listActors({
+			classNames,
+			cursor,
+			levelName,
+			maxResults,
+			nameFilter,
+			projectId,
+			tag
 		}, dependencies));
 	});
-	server.registerTool("stream_output_log", {
-		description: "Poll a bounded batch of Unreal Output Log events for a project and continue by calling again with the returned cursor.",
-		inputSchema: streamOutputLogInputSchema,
-		title: "Stream Output Log"
-	}, async ({ categoryAllow, categoryDeny, cursor, maxEvents, minVerbosity, projectId, textContains, textPattern }) => {
-		return toToolSuccess(await streamLogs({
-			cursor,
-			filters: {
-				categoryAllow,
-				categoryDeny,
-				minVerbosity,
-				textContains,
-				textPattern
-			},
-			maxEvents,
+	server.registerTool("get_actor_details", {
+		description: "Inspect one actor in the loaded level by its actorPath: world transform, attached component hierarchy (each component's name, class, attachment parent, and relative transform), and reflected UPROPERTY values. Property values use the same ExportText format get_cdo_defaults emits, so a value read here can be written back verbatim. Components and properties page independently — pass nextComponentCursor / nextPropertyCursor to continue each list. Inherited properties are excluded unless includeInherited is true.",
+		inputSchema: getActorDetailsInputSchema,
+		title: "Get Actor Details"
+	}, async ({ actorPath, componentCursor, includeInherited, maxResults, projectId, propertyCursor }) => {
+		return toToolSuccess(await getActorDetails({
+			actorPath,
+			componentCursor,
+			includeInherited,
+			maxResults,
 			projectId,
-			registry: dependencies.registry,
-			sessionManager: dependencies.logSessionManager,
-			source: "output_log"
-		}));
+			propertyCursor
+		}, dependencies));
 	});
-	server.registerTool("stream_message_log", {
-		description: "Poll a bounded batch from a named Unreal Message Log listing and continue by calling again with the returned cursor.",
-		inputSchema: streamMessageLogInputSchema,
-		title: "Stream Message Log"
-	}, async ({ cursor, listingName, maxEvents, minSeverity, projectId, textContains, textPattern }) => {
-		return toToolSuccess(await streamLogs({
-			cursor,
-			filters: {
-				listingName,
-				minSeverity,
-				textContains,
-				textPattern
-			},
-			maxEvents,
+	server.registerTool("get_current_level", {
+		description: "Report the level the editor currently has open — its short name and package path — plus every streaming level registered on that world with its loaded and visible state. worldPartition=true means the map streams cells through World Partition rather than through the listed ULevelStreaming entries, so the streamingLevels list will usually be empty for such a map. Returns no level fields when the editor has no world loaded.",
+		inputSchema: getCurrentLevelInputSchema,
+		title: "Get Current Level"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await getCurrentLevel({ projectId }, dependencies));
+	});
+	server.registerTool("spawn_actor", {
+		description: "Spawn one or more actors into the editor's loaded level. Each entry takes a classPath (native or Blueprint generated class) and an optional transform, label, outliner folder, and tags. The whole batch runs inside a single editor transaction, so a human pressing Ctrl+Z removes every actor the call spawned as one step, and save_dirty_packages will report the level afterwards. Returns a per-entry result carrying the new actorPath or the reason that entry failed; a failed entry does not abort the rest of the batch. Pass dryRun: true to validate the batch and see what would be spawned without changing anything.",
+		inputSchema: spawnActorInputSchema,
+		title: "Spawn Actor"
+	}, async ({ dryRun, projectId, spawns }) => {
+		return toToolSuccess(await spawnActor({
+			dryRun,
 			projectId,
-			registry: dependencies.registry,
-			sessionManager: dependencies.logSessionManager,
-			source: "message_log"
-		}));
+			spawns
+		}, dependencies));
 	});
-	server.registerTool("stream_device_output_log", {
-		description: "Poll a bounded batch of Unreal device-output log events and continue by calling again with the returned cursor.",
-		inputSchema: streamDeviceOutputLogInputSchema,
-		title: "Stream Device Output Log"
-	}, async ({ cursor, deviceId, deviceName, maxEvents, projectId, textContains, textPattern }) => {
-		return toToolSuccess(await streamLogs({
-			cursor,
-			filters: {
-				deviceId,
-				deviceName,
-				textContains,
-				textPattern
-			},
-			maxEvents,
+	server.registerTool("destroy_actor", {
+		description: "Destroy one or more actors in the loaded level, addressed by the actorPath list_actors returns. The whole batch runs inside a single editor transaction, so Ctrl+Z restores every actor the call destroyed as one step. Returns a per-entry result; an actorPath that no longer resolves fails only its own entry. Pass dryRun: true to check the paths and see what would be destroyed without changing anything.",
+		inputSchema: destroyActorInputSchema,
+		title: "Destroy Actor"
+	}, async ({ actorPaths, dryRun, projectId }) => {
+		return toToolSuccess(await destroyActor({
+			actorPaths,
+			dryRun,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("set_actor_transform", {
+		description: "Move, rotate, and/or scale one or more actors in the loaded level. Each entry addresses an actor by actorPath and supplies any of location, rotation, and scale — an omitted component keeps its current value. The whole batch runs inside a single editor transaction, so Ctrl+Z restores every original transform as one step. Returns a per-entry result; pass dryRun: true to check the paths without moving anything.",
+		inputSchema: setActorTransformInputSchema,
+		title: "Set Actor Transform"
+	}, async ({ dryRun, projectId, transforms }) => {
+		return toToolSuccess(await setActorTransform({
+			dryRun,
 			projectId,
-			registry: dependencies.registry,
-			sessionManager: dependencies.logSessionManager,
-			source: "device_output_log"
-		}));
+			transforms
+		}, dependencies));
 	});
-	server.registerTool("start_pie", {
-		description: "Start a Play-in-Editor session in the registered Unreal editor for a project; play begins on the next editor tick (async). Returns starting/running/unsupported.",
-		inputSchema: startPieInputSchema,
-		title: "Start Play-in-Editor"
-	}, async ({ map, mode, netMode, numClients, projectId, runUnderOneProcess }) => {
-		return toToolSuccess(await startPie({
-			map,
-			mode,
-			netMode,
-			numClients,
+	server.registerTool("set_actor_property", {
+		description: "Write reflected UPROPERTY values on actors or their components in the loaded level. Each entry takes an actorPath, a propertyPath ('bHidden' on the actor, 'StaticMeshComponent.RelativeScale3D' on a component), and a value in the same ExportText format get_actor_details and get_cdo_defaults emit — so you can read a value, edit it, and write it back without translating. Properties marked EditConst or not exposed for editing are rejected with an explicit error rather than silently ignored. The whole batch runs in one transaction; pass dryRun: true to resolve paths and check coercion without writing.",
+		inputSchema: setActorPropertyInputSchema,
+		title: "Set Actor Property"
+	}, async ({ dryRun, projectId, properties }) => {
+		return toToolSuccess(await setActorProperty({
+			dryRun,
 			projectId,
-			runUnderOneProcess
+			properties
 		}, dependencies));
 	});
-	server.registerTool("get_pie_status", {
-		description: "Report the state of the Play-in-Editor session started by start_pie for a project: starting, running, stopped, or none. Reports running only after PIE has actually begun.",
-		inputSchema: getPieStatusInputSchema,
-		title: "Get Play-in-Editor Status"
-	}, async ({ pieSessionId, projectId }) => {
-		return toToolSuccess(await getPieStatus({
-			pieSessionId,
+	server.registerTool("select_actors", {
+		description: "Set the editor's actor selection — the write-side counterpart to get_editor_state, using the same actorPath identifiers list_actors returns. An empty actorPaths list clears the selection; addToSelection adds to it instead of replacing it. Runs inside a transaction, so Ctrl+Z restores the previous selection. Returns the resulting selectedActorCount plus a per-entry result for any path that no longer resolves.",
+		inputSchema: selectActorsInputSchema,
+		title: "Select Actors"
+	}, async ({ actorPaths, addToSelection, dryRun, projectId }) => {
+		return toToolSuccess(await selectActors({
+			actorPaths,
+			addToSelection,
+			dryRun,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("stop_pie", {
-		description: "End the active Play-in-Editor session for a project. Returns stopped=true when a session was ended, or stopped=false (state none) when nothing was playing.",
-		inputSchema: stopPieInputSchema,
-		title: "Stop Play-in-Editor"
-	}, async ({ pieSessionId, projectId }) => {
-		return toToolSuccess(await stopPie({
-			pieSessionId,
+	server.registerTool("undo", {
+		description: "Undo the editor's most recent transaction — the same action as pressing Ctrl+Z in the editor — and report the title of the transaction that was undone. Use this to roll back your own level edits without a human in the loop. Returns state 'nothing_to_undo' when the transaction buffer is empty. Note this undoes whatever is at the head of the buffer, which may be a human's edit rather than yours, so check the returned transactionTitle.",
+		inputSchema: undoInputSchema,
+		title: "Undo"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await undo({ projectId }, dependencies));
+	});
+	server.registerTool("redo", {
+		description: "Redo the editor's most recently undone transaction — the same action as pressing Ctrl+Y in the editor — and report the title of the transaction that was redone. Returns state 'nothing_to_redo' when there is nothing to reapply.",
+		inputSchema: redoInputSchema,
+		title: "Redo"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await redo({ projectId }, dependencies));
+	});
+	server.registerTool("open_level", {
+		description: "Open a level in the editor by package name. Loading a map tears down and rebuilds the world, which takes far longer than a bridge request can wait, so this only accepts the job: it returns state 'opening' with an openLevelJobId to poll with get_open_level_status. Unsaved changes in the current world are discarded unless saveDirtyPackages is true. This is NOT undoable — loading a map clears the editor's transaction buffer, so undo cannot bring the previous level back.",
+		inputSchema: openLevelInputSchema,
+		title: "Open Level"
+	}, async ({ dryRun, levelPath, projectId, saveDirtyPackages }) => {
+		return toToolSuccess(await openLevel({
+			dryRun,
+			levelPath,
+			projectId,
+			saveDirtyPackages
+		}, dependencies));
+	});
+	server.registerTool("get_open_level_status", {
+		description: "Poll a level load started by open_level for a projectId; returns state (opening, succeeded, failed, unknown_job), the loaded levelPath, and timing once finished. Poll until the state leaves 'opening' before issuing further level tools — actor paths from the previous world do not survive the load.",
+		inputSchema: getOpenLevelStatusInputSchema,
+		title: "Get Open Level Status"
+	}, async ({ openLevelJobId, projectId }) => {
+		return toToolSuccess(await getOpenLevelStatus({
+			openLevelJobId,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("list_launch_devices", {
-		description: "List the target devices the registered Unreal editor can launch onto (iOS, Android, etc.), with each device id, name, platform, and connected/authorized state. Pick a deviceId for launch_on_device.",
-		inputSchema: listLaunchDevicesInputSchema,
-		title: "List Launch Devices"
-	}, async ({ projectId }) => {
-		return toToolSuccess(await listLaunchDevices({ projectId }, dependencies));
+	server.registerTool("get_source_control_status", {
+		description: "Report the editor's source control provider and the per-file state of up to 64 assets. Answered from the provider's state cache, so it costs no network round trip and returns inline. enabled distinguishes 'no source control configured' from 'configured, and this file is simply not checked out'; per-file state is one of checked_out_by_me, checked_out_by_other (with checkedOutBy naming the holder), marked_for_add, not_checked_out, not_in_depot, unknown. A file the editor has never queried reports 'unknown' — call refresh_source_control_status to fetch its real state from the server. Call this before any asset write on a team project: under Perforce or Git-LFS file locking a .uasset stays read-only until checked out, and the write otherwise fails later at save time.",
+		inputSchema: getSourceControlStatusInputSchema,
+		title: "Get Source Control Status"
+	}, async ({ assetPaths, projectId }) => {
+		return toToolSuccess(await getSourceControlStatus({
+			assetPaths,
+			projectId
+		}, dependencies));
 	});
-	server.registerTool("launch_on_device", {
-		description: "Launch (cook-on-the-fly + deploy, not package) the current project onto a connected target device by deviceId from list_launch_devices. Returns a launchSessionId and starting/unsupported state; deploy proceeds asynchronously.",
-		inputSchema: launchOnDeviceInputSchema,
-		title: "Launch On Device"
-	}, async ({ deviceId, map, projectId }) => {
-		return toToolSuccess(await launchOnDevice({
-			deviceId,
-			map,
+	server.registerTool("refresh_source_control_status", {
+		description: "Re-read the depot state of up to 64 assets from the source control server, so a later get_source_control_status reports something better than 'unknown'. This is a network round trip to the provider and runs far past what a bridge request can wait for, so it only accepts the job: it returns state 'accepted' with a sourceControlJobId to poll with get_source_control_job_status (or wait_for_job with kind source_control).",
+		inputSchema: refreshSourceControlStatusInputSchema,
+		title: "Refresh Source Control Status"
+	}, async ({ assetPaths, projectId }) => {
+		return toToolSuccess(await refreshSourceControlStatus({
+			assetPaths,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("list_automation_tests", {
-		description: "List the automation tests registered in a project's running Unreal Editor, with optional name and flag filters; returns each test's full name, display name, flags, and test type.",
-		inputSchema: listAutomationTestsInputSchema,
-		title: "List Automation Tests"
-	}, async ({ cursor, flags, maxResults, nameFilter, projectId }) => {
-		return toToolSuccess(await listAutomationTests({
-			cursor,
-			flags,
-			maxResults,
-			nameFilter,
+	server.registerTool("checkout_assets", {
+		description: "Check up to 64 assets out of source control so they become writable. This is a network round trip to the provider and runs far past what a bridge request can wait for, so it only accepts the job: it returns state 'accepted' with a sourceControlJobId to poll with get_source_control_job_status (or wait_for_job with kind source_control). The poll reports per-item results with successCount / failureCount — one asset the provider refuses does not abort the rest. This checks out only; it never submits, and a checked-out asset stays checked out until a human submits or reverts it.",
+		inputSchema: checkoutAssetsInputSchema,
+		title: "Checkout Assets"
+	}, async ({ assetPaths, projectId }) => {
+		return toToolSuccess(await checkoutAssets({
+			assetPaths,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("run_automation_tests", {
-		description: "Start an Unreal automation run (unit, smoke, and functional/BP scene tests) for a project and return a testRunId; requires at least one of testNames or nameFilter. Poll progress separately via stream_message_log on the AutomationTesting listing.",
-		inputSchema: runAutomationTestsInputSchema,
-		title: "Run Automation Tests"
-	}, async ({ flags, nameFilter, projectId, testNames }) => {
-		return toToolSuccess(await runAutomationTests({
-			flags,
-			nameFilter,
+	server.registerTool("get_source_control_job_status", {
+		description: "Poll a source control job started by checkout_assets or refresh_source_control_status for a projectId; returns state (running, succeeded, failed, unknown_job), which operation it was, and once finished the per-file results with successCount / failureCount and timing. Poll until the state leaves 'running' before writing to any asset in the batch.",
+		inputSchema: getSourceControlJobStatusInputSchema,
+		title: "Get Source Control Job Status"
+	}, async ({ projectId, sourceControlJobId }) => {
+		return toToolSuccess(await getSourceControlJobStatus({
 			projectId,
-			testNames
+			sourceControlJobId
 		}, dependencies));
 	});
-	server.registerTool("get_test_run_status", {
-		description: "Poll an automation run started by run_automation_tests by its testRunId; returns the run state ('running', 'complete', or 'unknown_run' for an unknown/expired id), aggregate pass/fail/skip counts, and structured per-test results with their log entries. Results are paged: pass the previous response nextCursor to fetch the next page (totalCount reports the full result count).",
-		inputSchema: getTestRunStatusInputSchema,
-		title: "Get Test Run Status"
-	}, async ({ cursor, maxResults, projectId, testRunId }) => {
-		return toToolSuccess(await getTestRunStatus({
+	server.registerTool("find_assets", {
+		description: "Query a project's Unreal Asset Registry for assets by class and/or content path, without loading them; returns each match's name, class, package name, package path, and object path. Requires at least one of classNames or packagePaths — an unfiltered query would stall the editor enumerating every asset. Results are paged: pass the previous response nextCursor to fetch the next page (totalCount reports the full match count). scanning=true means the registry is still indexing, so an empty result does not prove the asset is absent.",
+		inputSchema: findAssetsInputSchema,
+		title: "Find Assets"
+	}, async ({ classNames, cursor, maxResults, nameFilter, packagePaths, projectId, recursiveClasses, recursivePaths }) => {
+		return toToolSuccess(await findAssets({
+			classNames,
 			cursor,
 			maxResults,
+			nameFilter,
+			packagePaths,
 			projectId,
-			testRunId
+			recursiveClasses,
+			recursivePaths
 		}, dependencies));
 	});
-	server.registerTool("wait_for_job", {
-		description: `Block server-side until an async job reaches a terminal state, then return the payload its get_*_status tool would have returned under 'status'. Use instead of a poll loop after trigger_live_compile, trigger_hot_reload (kind 'compile'), create_cpp_class ('create_class'), run_automation_tests ('test_run'), or start_pie ('pie'). kind is required — job ids carry no type tag. outcome is 'completed', 'timed_out' (the last observed status is still returned; call again or poll), or 'unknown_job' (unknown/expired/cancelled id, returned immediately). timeoutMs defaults per kind (compile ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.compile)}ms, create_class ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.create_class)}ms, pie ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.pie)}ms, test_run ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.test_run)}ms) and is clamped to ${String(WAIT_FOR_JOB_MAX_TIMEOUT_MS)}ms, so a long automation run may need more than one call. For kind 'test_run' the returned status.results is the first page only — page the rest with get_test_run_status and nextCursor. For kind 'pie' only 'starting' keeps waiting; 'running', 'stopped' and 'none' are all terminal.`,
-		inputSchema: waitForJobInputSchema,
-		title: "Wait For Job"
-	}, async ({ jobId, kind, projectId, timeoutMs }) => {
-		return toToolSuccess(await waitForJob({
-			jobId,
-			kind,
+	server.registerTool("read_data_table", {
+		description: "Read a DataTable asset's contents: the row struct it is typed on, its ordered column list (name plus the same type rendering get_class_reflection emits), and its rows as column-name-to-value maps. Values are ExportText, the format write_data_table_row accepts back, so a value read here round-trips. Rows are paged by name order: pass the previous response nextCursor to fetch the next page (totalRowCount reports the full count). A DataTable is a binary .uasset with no Asset Registry tags describing its rows, so there is no way to read one off disk instead — this tool loads it.",
+		inputSchema: readDataTableInputSchema,
+		title: "Read Data Table"
+	}, async ({ assetPath, cursor, loadIfNeeded, maxRows, projectId, rowNameFilter }) => {
+		return toToolSuccess(await readDataTable({
+			assetPath,
+			cursor,
+			loadIfNeeded,
+			maxRows,
 			projectId,
-			timeoutMs
+			rowNameFilter
 		}, dependencies));
 	});
-	server.registerTool("cancel_test_run", {
-		description: "Abort an in-progress Unreal automation run for a project by its testRunId. Returns cancelled=true (state cancelled) when a live run was aborted, or cancelled=false (state not_found) when the run is unknown or already finished.",
-		inputSchema: cancelTestRunInputSchema,
-		title: "Cancel Test Run"
-	}, async ({ projectId, testRunId }) => {
-		return toToolSuccess(await cancelTestRun({
+	server.registerTool("write_data_table_row", {
+		description: "Insert, update, or delete a single DataTable row. Every column name and value is validated against the row struct before anything is written — an unknown column or a value that will not parse rejects the whole write with an error naming the field, so a row is never partially applied and there is no silent coercion. The write runs inside one transaction, so a human at the editor can Ctrl+Z it, and it marks the package dirty without saving: call save_dirty_packages to persist. Deleting a row that does not exist reports rowExisted=false rather than failing. Use dryRun to validate first. For a whole-table replace use import_data_table instead.",
+		inputSchema: writeDataTableRowInputSchema,
+		title: "Write Data Table Row"
+	}, async ({ assetPath, dryRun, operation, projectId, rowName, values }) => {
+		return toToolSuccess(await writeDataTableRow({
+			assetPath,
+			dryRun,
+			operation,
 			projectId,
-			testRunId
+			rowName,
+			values
 		}, dependencies));
 	});
-	server.registerTool("get_editor_state", {
-		description: "Report the registered Unreal Editor's current state for a project: the open map name and package path, the selected actors as { actorPath, label } objects whose actorPath the level tools accept directly, the active editor modes, and whether Play-in-Editor is running. Selected actors are capped per response; selectedActorCount reports the full selection size. activeModes is empty until the level editor has finished initializing, so an empty list right after the editor starts means 'not ready yet', not 'no mode'.",
-		inputSchema: getEditorStateInputSchema,
-		title: "Get Editor State"
-	}, async ({ projectId }) => {
-		return toToolSuccess(await getEditorState({ projectId }, dependencies));
+	server.registerTool("export_data_table", {
+		description: "Serialize a whole DataTable through the engine's own JSON or CSV exporter. Returned in chunks by character offset because the engine produces one string rather than something row-addressable: concatenate the chunks in cursor order to reassemble, and note a single chunk is not valid JSON or CSV on its own. Use read_data_table when you want structured, per-row access; use this when you want the table in the same text form the editor's own export produces.",
+		inputSchema: exportDataTableInputSchema,
+		title: "Export Data Table"
+	}, async ({ assetPath, cursor, format, loadIfNeeded, projectId }) => {
+		return toToolSuccess(await exportDataTable({
+			assetPath,
+			cursor,
+			format,
+			loadIfNeeded,
+			projectId
+		}, dependencies));
 	});
-	server.registerTool("exec_console_command", {
-		description: "Run an arbitrary Unreal console command in a project's running editor and return the captured console output. Targets the active Play-in-Editor world when PIE is running and the editor world otherwise. This runs with full editor authority — commands such as 'quit' will act on the live editor.",
-		inputSchema: execConsoleCommandInputSchema,
-		title: "Execute Console Command"
-	}, async ({ command, projectId }) => {
-		return toToolSuccess(await execConsoleCommand({
-			command,
+	server.registerTool("import_data_table", {
+		description: "REPLACE every row of a DataTable from a JSON or CSV payload, using the engine's own importer. This is destructive: any row not present in the content is deleted, so it is the wrong tool for changing one value — use write_data_table_row for that. The whole payload travels in one bridge frame, so a table beyond the content character bound cannot be imported this way. Runs inside one transaction (Ctrl+Z reverses it) and marks the package dirty without saving. Rows the importer rejects come back in problems while the rest still apply, so check problemCount even on success; dryRun reports the row count and problems without replacing anything.",
+		inputSchema: importDataTableInputSchema,
+		title: "Import Data Table"
+	}, async ({ assetPath, content, dryRun, format, projectId }) => {
+		return toToolSuccess(await importDataTable({
+			assetPath,
+			content,
+			dryRun,
+			format,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("get_config_value", {
-		description: "Read one project config value through the running editor's config system, which resolves the full Base*/Default*/Saved hierarchy. Returns the resolved value, the ini it came from, and resolvedFrom ('engine_base', 'project_default', 'saved_user'), and reports present=false for an unset key so an absent value is distinguishable from a present-but-empty one. file is a closed set of known ini names, not a path.",
-		inputSchema: getConfigValueInputSchema,
-		title: "Get Config Value"
-	}, async ({ file, key, projectId, section }) => {
-		return toToolSuccess(await getConfigValue({
-			file,
-			key,
+	server.registerTool("create_data_table", {
+		description: "Create a new empty DataTable asset backed by a row struct. The struct is fixed at creation — UDataTable can have its RowStruct swapped later, but that reinterprets existing rows through the new layout, so the bridge does not expose it; create a new table instead. The struct must derive FTableRowBase, and creation fails if an asset already exists at the path. The new table is marked dirty but not written to disk: call save_dirty_packages to persist it, or it disappears when the editor closes. Use read_data_table to confirm the column set the struct produced.",
+		inputSchema: createDataTableInputSchema,
+		title: "Create Data Table"
+	}, async ({ assetPath, dryRun, projectId, rowStructPath }) => {
+		return toToolSuccess(await createDataTable({
+			assetPath,
+			dryRun,
 			projectId,
-			section
+			rowStructPath
 		}, dependencies));
 	});
-	server.registerTool("set_config_value", {
-		description: "Write one project config value through the running editor's config system and flush it to disk, so the ini is normalised the way the engine expects and the live editor picks the change up without a restart. Writes Config/Default<File>.ini by default, or the Saved/Config user override with scope 'saved_user'. Returns the previous value as the editor resolved it across the whole hierarchy, which is not necessarily what the target layer held: if it came from an engine or default layer, writing it back leaves the key materialised in the layer this tool wrote. Requires a registered editor: a raw file write behind a running editor is clobbered when the editor saves its own config.",
-		inputSchema: setConfigValueInputSchema,
-		title: "Set Config Value"
-	}, async ({ file, key, projectId, scope, section, value }) => {
-		return toToolSuccess(await setConfigValue({
-			file,
-			key,
+	server.registerTool("rename_data_table", {
+		description: "Rename a DataTable, move it to another package path, or both. Goes through the editor's asset tools, so references from other assets are fixed up and a redirector is left at the old path to keep hard references resolving. Renaming is not a transaction the editor can Ctrl+Z — it rewrites packages on disk. Use dryRun to check the destination is free first.",
+		inputSchema: renameDataTableInputSchema,
+		title: "Rename Data Table"
+	}, async ({ assetPath, destinationPath, dryRun, newName, projectId }) => {
+		return toToolSuccess(await renameDataTable({
+			assetPath,
+			destinationPath,
+			dryRun,
+			newName,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("delete_data_table", {
+		description: "Delete a DataTable asset from the project. This is the one DataTable tool that cannot be undone — asset deletion is not a transaction, so there is no Ctrl+Z and no dirty-package step to reconsider at. A table other assets still reference is refused, and those referencers are reported; force deletes anyway and breaks them. Always dryRun first on a table you did not create: it reports the referencers without touching anything.",
+		inputSchema: deleteDataTableInputSchema,
+		title: "Delete Data Table"
+	}, async ({ assetPath, dryRun, force, projectId }) => {
+		return toToolSuccess(await deleteDataTable({
+			assetPath,
+			dryRun,
+			force,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("rename_data_table_row", {
+		description: "Rename a single row, keeping its position in the table and its values intact. Not the same as an upsert under the new name followed by a delete of the old one: that pair costs two transactions and moves the row to the end. Fails if the row does not exist or the new name is already taken. Runs inside one transaction (Ctrl+Z reverses it) and marks the package dirty without saving. Note that row names are how other assets address rows, so a rename breaks any FDataTableRowHandle pointing at the old name — nothing fixes those up.",
+		inputSchema: renameDataTableRowInputSchema,
+		title: "Rename Data Table Row"
+	}, async ({ assetPath, dryRun, newRowName, projectId, rowName }) => {
+		return toToolSuccess(await renameDataTableRow({
+			assetPath,
+			dryRun,
+			newRowName,
 			projectId,
-			scope,
-			section,
-			value
+			rowName
 		}, dependencies));
 	});
-	server.registerTool("list_config_section", {
-		description: "Dump one config section as key/value pairs as the running editor resolves it. Paged: pass the previous response nextCursor for the next page; totalCount reports the full key count.",
-		inputSchema: listConfigSectionInputSchema,
-		title: "List Config Section"
-	}, async ({ cursor, file, maxResults, projectId, section }) => {
-		return toToolSuccess(await listConfigSection({
-			cursor,
-			file,
+	server.registerTool("get_asset_dependencies", {
+		description: "Report an asset's package-level dependencies (what it needs) and referencers (what needs it) from the Unreal Asset Registry — the Reference Viewer data — so you can judge the blast radius before changing it. Depth is 1: transitive links are not walked. Each list pages independently via nextDependencyCursor / nextReferencerCursor.",
+		inputSchema: getAssetDependenciesInputSchema,
+		title: "Get Asset Dependencies"
+	}, async ({ assetPath, categories, dependencyCursor, linkage, maxResults, projectId, referencerCursor }) => {
+		return toToolSuccess(await getAssetDependencies({
+			assetPath,
+			categories,
+			dependencyCursor,
+			linkage,
 			maxResults,
 			projectId,
-			section
+			referencerCursor
 		}, dependencies));
 	});
-	server.registerTool("get_class_reflection", {
-		description: "Reflect a UCLASS or USTRUCT in a project's running Unreal Editor: parent type, implemented interfaces, class flags, and the declared properties (name, C++ type, UPROPERTY specifiers, metadata) and functions (UFUNCTION specifiers, parameters, metadata). Use it to learn a type's API without reading headers. Properties and functions page independently — pass the previous response nextPropertyCursor/nextFunctionCursor to continue.",
-		inputSchema: getClassReflectionInputSchema,
-		title: "Get Class Reflection"
-	}, async ({ className, functionCursor, includeInherited, maxFunctions, maxProperties, projectId, propertyCursor }) => {
-		return toToolSuccess(await getClassReflection({
+	server.registerTool("find_blueprint_references", {
+		description: "Report which Blueprint assets depend on a C++ class, so you can judge whether renaming or removing it will break content. Each hit is either 'subclass' (the Blueprint's parent chain reaches the class) or 'module_dependency' (the Blueprint's package depends on the class's /Script module, which may be through this class or another type in it). Answers from Asset Registry metadata only — no Blueprints are loaded, so per-function and per-property usage is not resolved.",
+		inputSchema: findBlueprintReferencesInputSchema,
+		title: "Find Blueprint References"
+	}, async ({ className, cursor, maxResults, projectId, referenceKinds }) => {
+		return toToolSuccess(await findBlueprintReferences({
 			className,
-			functionCursor,
-			includeInherited,
-			maxFunctions,
-			maxProperties,
+			cursor,
+			maxResults,
 			projectId,
-			propertyCursor
+			referenceKinds
 		}, dependencies));
 	});
-	server.registerTool("save_dirty_packages", {
-		description: "Save the unsaved (dirty) map and content packages in the registered Unreal Editor for a project, so changes made by other tools are persisted to disk. Returns which packages were saved and which are still dirty. Packages that have never been written to disk are skipped rather than prompting the editor for a filename.",
-		inputSchema: saveDirtyPackagesInputSchema,
-		title: "Save Dirty Packages"
-	}, async ({ projectId, saveContentPackages, saveMapPackages }) => {
-		return toToolSuccess(await saveDirtyPackages({
+	server.registerTool("get_blueprint_summary", {
+		description: "Describe what is inside a Blueprint asset: parent class, implemented interfaces, its component hierarchy from the Simple Construction Script, its variables (type, default, category, replication), its functions/events/macros with signatures, and an inventory of its graphs. Use the returned graph names with get_blueprint_graph. By default nothing is loaded — an unloaded Blueprint answers from Asset Registry metadata (parent and generated class only) and reports loaded=false; pass loadIfNeeded to read the full contents. Each list pages independently.",
+		inputSchema: getBlueprintSummaryInputSchema,
+		title: "Get Blueprint Summary"
+	}, async ({ blueprintPath, componentCursor, functionCursor, graphCursor, loadIfNeeded, maxResults, projectId, variableCursor }) => {
+		return toToolSuccess(await getBlueprintSummary({
+			blueprintPath,
+			componentCursor,
+			functionCursor,
+			graphCursor,
+			loadIfNeeded,
+			maxResults,
 			projectId,
-			saveContentPackages,
-			saveMapPackages
+			variableCursor
 		}, dependencies));
 	});
-	server.registerTool("get_stat_snapshot", {
-		description: "Sample a project's running Unreal editor for core performance counters: frames per second, frame time, game/render thread times, and process memory usage. Single snapshot — call again to sample a later frame.",
-		inputSchema: getStatSnapshotInputSchema,
-		title: "Get Stat Snapshot"
-	}, async ({ projectId }) => {
-		return toToolSuccess(await getStatSnapshot(projectId, dependencies));
-	});
-	server.registerTool("capture_viewport", {
-		description: "Capture the registered Unreal Editor's active viewport to a PNG on the editor host and return the absolute file path plus the image dimensions. The image bytes are never inlined in the response.",
-		inputSchema: captureViewportInputSchema,
-		title: "Capture Viewport"
-	}, async ({ projectId }) => {
-		return toToolSuccess(await captureViewport({ projectId }, dependencies));
-	});
-	server.registerTool("start_insights_trace", {
-		description: "Start an Unreal Insights trace capture in a project's running editor and return the .utrace file path being written. Returns already_tracing (with the current path) when a capture is already running.",
-		inputSchema: startInsightsTraceInputSchema,
-		title: "Start Insights Trace"
-	}, async ({ channels, fileName, projectId }) => {
-		return toToolSuccess(await startInsightsTrace({
-			channels,
-			fileName,
+	server.registerTool("get_blueprint_graph", {
+		description: "Dump one Blueprint graph as nodes and connections: each node reports its title, node class and pins, and each pin reports its name, direction, type, default value and the node/pin ids it links to. Get valid graph names from get_blueprint_summary first. Reading a graph requires the Blueprint in memory, so pass loadIfNeeded for an unloaded asset. Nodes are ordered by their stable GUID and paged via nextNodeCursor.",
+		inputSchema: getBlueprintGraphInputSchema,
+		title: "Get Blueprint Graph"
+	}, async ({ blueprintPath, graphName, loadIfNeeded, maxNodes, nodeCursor, projectId }) => {
+		return toToolSuccess(await getBlueprintGraph({
+			blueprintPath,
+			graphName,
+			loadIfNeeded,
+			maxNodes,
+			nodeCursor,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("stop_insights_trace", {
-		description: "Stop the Unreal Insights trace running in a project's editor and return the completed .utrace file path. Returns not_tracing when no capture was running, and fails with trace_not_ready (retryable) when called before the capture has finished opening.",
-		inputSchema: stopInsightsTraceInputSchema,
-		title: "Stop Insights Trace"
-	}, async ({ projectId }) => {
-		return toToolSuccess(await stopInsightsTrace(projectId, dependencies));
-	});
-	server.registerTool("get_cdo_defaults", {
-		description: "Read the Class Default Object property values for a UCLASS in a project's running Unreal Editor, so configured defaults are visible without opening the asset or header. Values are exported as Unreal property text, so nested structs and arrays come back fully expanded. Results are paged: pass the previous response nextCursor to fetch the next page.",
-		inputSchema: getCdoDefaultsInputSchema,
-		title: "Get CDO Defaults"
-	}, async ({ className, cursor, includeInherited, maxResults, nameFilter, projectId }) => {
-		return toToolSuccess(await getCdoDefaults({
-			className,
+	server.registerTool("get_blueprint_compile_errors", {
+		description: "Report each Blueprint's compile status (up_to_date, warnings, error, dirty, unknown, not_loaded, not_found) plus the errors and warnings from the last compile this bridge ran, including the node each message was attached to. hasDiagnostics=false means this bridge has not compiled that Blueprint in this editor session, so empty lists do not mean it is clean — run compile_blueprint first to get diagnostics.",
+		inputSchema: getBlueprintCompileErrorsInputSchema,
+		title: "Get Blueprint Compile Errors"
+	}, async ({ blueprintPaths, cursor, maxResults, projectId }) => {
+		return toToolSuccess(await getBlueprintCompileErrors({
+			blueprintPaths,
 			cursor,
-			includeInherited,
 			maxResults,
-			nameFilter,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("list_actors", {
-		description: "Enumerate actors in the editor's currently loaded level(s), optionally filtered by class, name substring, tag, or level. Returns each actor's canonical actorPath (the identifier every other level tool takes), display label, class, level, and World Outliner folder. Results are paged: pass the previous response nextCursor to fetch the next page, and totalCount reports the full match count even when a page truncates. Use this to find an actor before calling get_actor_details.",
-		inputSchema: listActorsInputSchema,
-		title: "List Actors"
-	}, async ({ classNames, cursor, levelName, maxResults, nameFilter, projectId, tag }) => {
-		return toToolSuccess(await listActors({
-			classNames,
+	server.registerTool("compile_blueprint", {
+		description: "Compile one or more Blueprints in the running editor so content breakage is caught after a C++ change that altered a base class or a UFUNCTION signature. Compiling is asynchronous: this returns a compileJobId to poll with get_blueprint_compile_status, which reports the per-Blueprint diagnostics. Blueprints are loaded as needed and their assets are modified in memory — save them with save_dirty_packages if you want the result on disk.",
+		inputSchema: compileBlueprintInputSchema,
+		title: "Compile Blueprint"
+	}, async ({ blueprintPaths, projectId }) => {
+		return toToolSuccess(await compileBlueprint({
+			blueprintPaths,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("get_blueprint_compile_status", {
+		description: "Poll a compile_blueprint job. Reports 'compiling' while it runs, then 'succeeded' or 'failed' with per-Blueprint errors and warnings (each carrying the node the compiler blamed); 'unknown_job' means the id was never issued or has been evicted.",
+		inputSchema: getBlueprintCompileStatusInputSchema,
+		title: "Get Blueprint Compile Status"
+	}, async ({ compileJobId, cursor, maxResults, projectId }) => {
+		return toToolSuccess(await getBlueprintCompileStatus({
+			compileJobId,
 			cursor,
-			levelName,
 			maxResults,
-			nameFilter,
-			projectId,
-			tag
+			projectId
 		}, dependencies));
 	});
-	server.registerTool("get_actor_details", {
-		description: "Inspect one actor in the loaded level by its actorPath: world transform, attached component hierarchy (each component's name, class, attachment parent, and relative transform), and reflected UPROPERTY values. Property values use the same ExportText format get_cdo_defaults emits, so a value read here can be written back verbatim. Components and properties page independently — pass nextComponentCursor / nextPropertyCursor to continue each list. Inherited properties are excluded unless includeInherited is true.",
-		inputSchema: getActorDetailsInputSchema,
-		title: "Get Actor Details"
-	}, async ({ actorPath, componentCursor, includeInherited, maxResults, projectId, propertyCursor }) => {
-		return toToolSuccess(await getActorDetails({
-			actorPath,
-			componentCursor,
-			includeInherited,
+	server.registerTool("list_asset_factories", {
+		description: "List every asset type the editor can create, with the UFactory behind it, the class it produces, its Content Browser menu category, and the requiredOptions create_asset must be given for it to run without opening a modal dialog. Use this to discover valid assetClass names instead of guessing them. Results are paged: pass the previous response nextCursor for the next page, and nameFilter to narrow by factory, asset class or category.",
+		inputSchema: listAssetFactoriesInputSchema,
+		title: "List Asset Factories"
+	}, async ({ cursor, maxResults, nameFilter, projectId }) => {
+		return toToolSuccess(await listAssetFactories({
+			cursor,
 			maxResults,
-			projectId,
-			propertyCursor
+			nameFilter,
+			projectId
 		}, dependencies));
 	});
-	server.registerTool("get_current_level", {
-		description: "Report the level the editor currently has open — its short name and package path — plus every streaming level registered on that world with its loaded and visible state. worldPartition=true means the map streams cells through World Partition rather than through the listed ULevelStreaming entries, so the streamingLevels list will usually be empty for such a map. Returns no level fields when the editor has no world loaded.",
-		inputSchema: getCurrentLevelInputSchema,
-		title: "Get Current Level"
-	}, async ({ projectId }) => {
-		return toToolSuccess(await getCurrentLevel({ projectId }, dependencies));
+	server.registerTool("create_asset", {
+		description: "Create a content asset through its UFactory — anything in the Content Browser's Add menu: DataTables, Materials, Input Actions, Blueprints, Behavior Trees, widgets. Discover valid assetClass names with list_asset_factories first. A factory that would open a modal picker (a Blueprint parent class, a blend space skeleton) is configured headlessly through options instead; if a required option is missing the call fails naming exactly which ones. packagePath must be under /Game. Creates the asset empty — populating it is a separate call.",
+		inputSchema: createAssetInputSchema,
+		title: "Create Asset"
+	}, async ({ assetClass, assetName, factoryClass, options, packagePath, projectId }) => {
+		return toToolSuccess(await createAsset({
+			assetClass,
+			assetName,
+			factoryClass,
+			options,
+			packagePath,
+			projectId
+		}, dependencies));
 	});
-	server.registerTool("spawn_actor", {
-		description: "Spawn one or more actors into the editor's loaded level. Each entry takes a classPath (native or Blueprint generated class) and an optional transform, label, outliner folder, and tags. The whole batch runs inside a single editor transaction, so a human pressing Ctrl+Z removes every actor the call spawned as one step, and save_dirty_packages will report the level afterwards. Returns a per-entry result carrying the new actorPath or the reason that entry failed; a failed entry does not abort the rest of the batch. Pass dryRun: true to validate the batch and see what would be spawned without changing anything.",
-		inputSchema: spawnActorInputSchema,
-		title: "Spawn Actor"
-	}, async ({ dryRun, projectId, spawns }) => {
-		return toToolSuccess(await spawnActor({
-			dryRun,
+	server.registerTool("duplicate_asset", {
+		description: "Copy an asset to a new name and folder. Iterating on content usually means copying a base asset rather than authoring one from scratch, so this is the cheaper path to a variant than create_asset plus a fresh setup. Returns the new object path.",
+		inputSchema: duplicateAssetInputSchema,
+		title: "Duplicate Asset"
+	}, async ({ destinationName, destinationPath, projectId, sourceAssetPath }) => {
+		return toToolSuccess(await duplicateAsset({
+			destinationName,
+			destinationPath,
 			projectId,
-			spawns
+			sourceAssetPath
 		}, dependencies));
 	});
-	server.registerTool("destroy_actor", {
-		description: "Destroy one or more actors in the loaded level, addressed by the actorPath list_actors returns. The whole batch runs inside a single editor transaction, so Ctrl+Z restores every actor the call destroyed as one step. Returns a per-entry result; an actorPath that no longer resolves fails only its own entry. Pass dryRun: true to check the paths and see what would be destroyed without changing anything.",
-		inputSchema: destroyActorInputSchema,
-		title: "Destroy Actor"
-	}, async ({ actorPaths, dryRun, projectId }) => {
-		return toToolSuccess(await destroyActor({
-			actorPaths,
-			dryRun,
+	server.registerTool("rename_asset", {
+		description: "Rename an asset in place, fixing up every referencer and leaving a redirector behind, so a Blueprint pointing at it still resolves afterwards. Refuses anything outside /Game.",
+		inputSchema: renameAssetInputSchema,
+		title: "Rename Asset"
+	}, async ({ assetPath, newName, projectId }) => {
+		return toToolSuccess(await renameAsset({
+			assetPath,
+			newName,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("set_actor_transform", {
-		description: "Move, rotate, and/or scale one or more actors in the loaded level. Each entry addresses an actor by actorPath and supplies any of location, rotation, and scale — an omitted component keeps its current value. The whole batch runs inside a single editor transaction, so Ctrl+Z restores every original transform as one step. Returns a per-entry result; pass dryRun: true to check the paths without moving anything.",
-		inputSchema: setActorTransformInputSchema,
-		title: "Set Actor Transform"
-	}, async ({ dryRun, projectId, transforms }) => {
-		return toToolSuccess(await setActorTransform({
-			dryRun,
-			projectId,
-			transforms
+	server.registerTool("move_asset", {
+		description: "Move an asset to another content folder, optionally renaming it, fixing up referencers and leaving a redirector behind. Refuses anything outside /Game.",
+		inputSchema: moveAssetInputSchema,
+		title: "Move Asset"
+	}, async ({ assetPath, destinationPath, newName, projectId }) => {
+		return toToolSuccess(await moveAsset({
+			assetPath,
+			destinationPath,
+			newName,
+			projectId
 		}, dependencies));
 	});
-	server.registerTool("set_actor_property", {
-		description: "Write reflected UPROPERTY values on actors or their components in the loaded level. Each entry takes an actorPath, a propertyPath ('bHidden' on the actor, 'StaticMeshComponent.RelativeScale3D' on a component), and a value in the same ExportText format get_actor_details and get_cdo_defaults emit — so you can read a value, edit it, and write it back without translating. Properties marked EditConst or not exposed for editing are rejected with an explicit error rather than silently ignored. The whole batch runs in one transaction; pass dryRun: true to resolve paths and check coercion without writing.",
-		inputSchema: setActorPropertyInputSchema,
-		title: "Set Actor Property"
-	}, async ({ dryRun, projectId, properties }) => {
-		return toToolSuccess(await setActorProperty({
-			dryRun,
-			projectId,
-			properties
+	server.registerTool("delete_asset", {
+		description: "Delete an asset. Without force this first asks the Asset Registry who references it and refuses with that list rather than leaving dangling references — state 'blocked' plus referencers. Pass force only when breaking those references is the intent. Refuses anything outside /Game.",
+		inputSchema: deleteAssetInputSchema,
+		title: "Delete Asset"
+	}, async ({ assetPath, force, projectId }) => {
+		return toToolSuccess(await deleteAsset({
+			assetPath,
+			force,
+			projectId
 		}, dependencies));
 	});
-	server.registerTool("select_actors", {
-		description: "Set the editor's actor selection — the write-side counterpart to get_editor_state, using the same actorPath identifiers list_actors returns. An empty actorPaths list clears the selection; addToSelection adds to it instead of replacing it. Runs inside a transaction, so Ctrl+Z restores the previous selection. Returns the resulting selectedActorCount plus a per-entry result for any path that no longer resolves.",
-		inputSchema: selectActorsInputSchema,
-		title: "Select Actors"
-	}, async ({ actorPaths, addToSelection, dryRun, projectId }) => {
-		return toToolSuccess(await selectActors({
-			actorPaths,
-			addToSelection,
-			dryRun,
+	server.registerTool("save_asset", {
+		description: "Save specific asset packages to disk — the narrow counterpart to save_dirty_packages, for when only the assets you just wrote should be committed. Per-item results report which were actually dirty; an already-clean package reports ok with saved false rather than an error.",
+		inputSchema: saveAssetInputSchema,
+		title: "Save Asset"
+	}, async ({ assetPaths, projectId }) => {
+		return toToolSuccess(await saveAsset({
+			assetPaths,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("undo", {
-		description: "Undo the editor's most recent transaction — the same action as pressing Ctrl+Z in the editor — and report the title of the transaction that was undone. Use this to roll back your own level edits without a human in the loop. Returns state 'nothing_to_undo' when the transaction buffer is empty. Note this undoes whatever is at the head of the buffer, which may be a human's edit rather than yours, so check the returned transactionTitle.",
-		inputSchema: undoInputSchema,
-		title: "Undo"
-	}, async ({ projectId }) => {
-		return toToolSuccess(await undo({ projectId }, dependencies));
-	});
-	server.registerTool("redo", {
-		description: "Redo the editor's most recently undone transaction — the same action as pressing Ctrl+Y in the editor — and report the title of the transaction that was redone. Returns state 'nothing_to_redo' when there is nothing to reapply.",
-		inputSchema: redoInputSchema,
-		title: "Redo"
-	}, async ({ projectId }) => {
-		return toToolSuccess(await redo({ projectId }, dependencies));
-	});
-	server.registerTool("open_level", {
-		description: "Open a level in the editor by package name. Loading a map tears down and rebuilds the world, which takes far longer than a bridge request can wait, so this only accepts the job: it returns state 'opening' with an openLevelJobId to poll with get_open_level_status. Unsaved changes in the current world are discarded unless saveDirtyPackages is true. This is NOT undoable — loading a map clears the editor's transaction buffer, so undo cannot bring the previous level back.",
-		inputSchema: openLevelInputSchema,
-		title: "Open Level"
-	}, async ({ dryRun, levelPath, projectId, saveDirtyPackages }) => {
-		return toToolSuccess(await openLevel({
-			dryRun,
-			levelPath,
-			projectId,
-			saveDirtyPackages
+	server.registerTool("create_folder", {
+		description: "Create a Content Browser folder under /Game. Reports state 'exists' rather than failing when the folder is already there, since that is the state the caller wanted.",
+		inputSchema: createFolderInputSchema,
+		title: "Create Folder"
+	}, async ({ folderPath, projectId }) => {
+		return toToolSuccess(await createFolder({
+			folderPath,
+			projectId
 		}, dependencies));
 	});
-	server.registerTool("get_open_level_status", {
-		description: "Poll a level load started by open_level for a projectId; returns state (opening, succeeded, failed, unknown_job), the loaded levelPath, and timing once finished. Poll until the state leaves 'opening' before issuing further level tools — actor paths from the previous world do not survive the load.",
-		inputSchema: getOpenLevelStatusInputSchema,
-		title: "Get Open Level Status"
-	}, async ({ openLevelJobId, projectId }) => {
-		return toToolSuccess(await getOpenLevelStatus({
-			openLevelJobId,
+	server.registerTool("get_asset_metadata", {
+		description: "Report an asset's class, package, on-disk size and Asset Registry tag map without loading it. Use this to inspect content cheaply — the tags carry a Blueprint's parent class, a texture's dimensions, a DataTable's row struct and so on, none of which needs the package in memory. loaded reports whether it happens to be in memory already; false is normal.",
+		inputSchema: getAssetMetadataInputSchema,
+		title: "Get Asset Metadata"
+	}, async ({ assetPath, projectId }) => {
+		return toToolSuccess(await getAssetMetadata({
+			assetPath,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("get_source_control_status", {
-		description: "Report the editor's source control provider and the per-file state of up to 64 assets. Answered from the provider's state cache, so it costs no network round trip and returns inline. enabled distinguishes 'no source control configured' from 'configured, and this file is simply not checked out'; per-file state is one of checked_out_by_me, checked_out_by_other (with checkedOutBy naming the holder), marked_for_add, not_checked_out, not_in_depot, unknown. A file the editor has never queried reports 'unknown' — call refresh_source_control_status to fetch its real state from the server. Call this before any asset write on a team project: under Perforce or Git-LFS file locking a .uasset stays read-only until checked out, and the write otherwise fails later at save time.",
-		inputSchema: getSourceControlStatusInputSchema,
-		title: "Get Source Control Status"
-	}, async ({ assetPaths, projectId }) => {
-		return toToolSuccess(await getSourceControlStatus({
-			assetPaths,
+	server.registerTool("list_graph_nodes", {
+		description: "List the nodes in any UEdGraph — a Blueprint event graph or function, an Animation Blueprint AnimGraph, a Material graph, a Behavior Tree — with each node's GUID, class, title and pins. The GUID is what every other graph tool addresses a node by; it survives adding and removing other nodes, which an index does not. Results are paged by nextCursor.",
+		inputSchema: listGraphNodesInputSchema,
+		title: "List Graph Nodes"
+	}, async ({ assetPath, cursor, graphName, loadIfNeeded, maxResults, projectId }) => {
+		return toToolSuccess(await listGraphNodes({
+			assetPath,
+			cursor,
+			graphName,
+			loadIfNeeded,
+			maxResults,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("refresh_source_control_status", {
-		description: "Re-read the depot state of up to 64 assets from the source control server, so a later get_source_control_status reports something better than 'unknown'. This is a network round trip to the provider and runs far past what a bridge request can wait for, so it only accepts the job: it returns state 'accepted' with a sourceControlJobId to poll with get_source_control_job_status (or wait_for_job with kind source_control).",
-		inputSchema: refreshSourceControlStatusInputSchema,
-		title: "Refresh Source Control Status"
-	}, async ({ assetPaths, projectId }) => {
-		return toToolSuccess(await refreshSourceControlStatus({
-			assetPaths,
+	server.registerTool("add_graph_node", {
+		description: "Add a node to a UEdGraph and return it with its pins, so it can be wired without a follow-up read. kind 'class' places a node type directly (K2Node_IfThenElse for a Branch); 'function' places a call to memberName on memberParentClass; 'variable_get' / 'variable_set' place a variable accessor. Use list_available_nodes to discover what this graph's schema accepts rather than guessing class names. pinDefaults configures the node in the same call. The Blueprint is marked structurally modified, so compile_blueprint afterwards picks the change up.",
+		inputSchema: addGraphNodeInputSchema,
+		title: "Add Graph Node"
+	}, async ({ assetPath, graphName, kind, memberName, memberParentClass, nodeClass, pinDefaults, position, projectId }) => {
+		return toToolSuccess(await addGraphNode({
+			assetPath,
+			graphName,
+			kind,
+			memberName,
+			memberParentClass,
+			nodeClass,
+			pinDefaults,
+			position,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("checkout_assets", {
-		description: "Check up to 64 assets out of source control so they become writable. This is a network round trip to the provider and runs far past what a bridge request can wait for, so it only accepts the job: it returns state 'accepted' with a sourceControlJobId to poll with get_source_control_job_status (or wait_for_job with kind source_control). The poll reports per-item results with successCount / failureCount — one asset the provider refuses does not abort the rest. This checks out only; it never submits, and a checked-out asset stays checked out until a human submits or reverts it.",
-		inputSchema: checkoutAssetsInputSchema,
-		title: "Checkout Assets"
-	}, async ({ assetPaths, projectId }) => {
-		return toToolSuccess(await checkoutAssets({
-			assetPaths,
+	server.registerTool("remove_graph_node", {
+		description: "Remove a node from a UEdGraph by its GUID, breaking its connections. Reports removed false when the GUID is not in the graph, which is already the desired state.",
+		inputSchema: removeGraphNodeInputSchema,
+		title: "Remove Graph Node"
+	}, async ({ assetPath, graphName, nodeGuid, projectId }) => {
+		return toToolSuccess(await removeGraphNode({
+			assetPath,
+			graphName,
+			nodeGuid,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("get_source_control_job_status", {
-		description: "Poll a source control job started by checkout_assets or refresh_source_control_status for a projectId; returns state (running, succeeded, failed, unknown_job), which operation it was, and once finished the per-file results with successCount / failureCount and timing. Poll until the state leaves 'running' before writing to any asset in the batch.",
-		inputSchema: getSourceControlJobStatusInputSchema,
-		title: "Get Source Control Job Status"
-	}, async ({ projectId, sourceControlJobId }) => {
-		return toToolSuccess(await getSourceControlJobStatus({
+	server.registerTool("connect_pins", {
+		description: "Wire two pins together. The connection goes through the graph schema's own CanCreateConnection rules, so an illegal pairing — wrong type, wrong direction, would create a cycle — is refused with the schema's own reason string rather than producing a corrupt graph.",
+		inputSchema: connectPinsInputSchema,
+		title: "Connect Pins"
+	}, async ({ assetPath, graphName, projectId, sourceNodeGuid, sourcePinName, targetNodeGuid, targetPinName }) => {
+		return toToolSuccess(await connectPins({
+			assetPath,
+			graphName,
 			projectId,
-			sourceControlJobId
+			sourceNodeGuid,
+			sourcePinName,
+			targetNodeGuid,
+			targetPinName
 		}, dependencies));
 	});
-	server.registerTool("find_assets", {
-		description: "Query a project's Unreal Asset Registry for assets by class and/or content path, without loading them; returns each match's name, class, package name, package path, and object path. Requires at least one of classNames or packagePaths — an unfiltered query would stall the editor enumerating every asset. Results are paged: pass the previous response nextCursor to fetch the next page (totalCount reports the full match count). scanning=true means the registry is still indexing, so an empty result does not prove the asset is absent.",
-		inputSchema: findAssetsInputSchema,
-		title: "Find Assets"
-	}, async ({ classNames, cursor, maxResults, nameFilter, packagePaths, projectId, recursiveClasses, recursivePaths }) => {
-		return toToolSuccess(await findAssets({
-			classNames,
+	server.registerTool("disconnect_pins", {
+		description: "Break the wire between two pins. Reports disconnected false when they were not linked, which is already the desired state.",
+		inputSchema: disconnectPinsInputSchema,
+		title: "Disconnect Pins"
+	}, async ({ assetPath, graphName, projectId, sourceNodeGuid, sourcePinName, targetNodeGuid, targetPinName }) => {
+		return toToolSuccess(await disconnectPins({
+			assetPath,
+			graphName,
+			projectId,
+			sourceNodeGuid,
+			sourcePinName,
+			targetNodeGuid,
+			targetPinName
+		}, dependencies));
+	});
+	server.registerTool("set_pin_default", {
+		description: "Set an unconnected pin's default value. The write goes through the schema's TrySetDefaultValue, so a value the pin type cannot hold is refused rather than stored. Returns the value the schema actually stored, which for a struct pin is normalized rather than echoed back.",
+		inputSchema: setPinDefaultInputSchema,
+		title: "Set Pin Default"
+	}, async ({ assetPath, graphName, nodeGuid, pinName, projectId, value }) => {
+		return toToolSuccess(await setPinDefault({
+			assetPath,
+			graphName,
+			nodeGuid,
+			pinName,
+			projectId,
+			value
+		}, dependencies));
+	});
+	server.registerTool("list_available_nodes", {
+		description: "List what is legal to place in a specific graph, from the Blueprint action database filtered by that graph's own schema — not a global list. Each action reports the kind, class and member name add_graph_node needs. Pass nameFilter: unfiltered, a Blueprint graph offers thousands of actions.",
+		inputSchema: listAvailableNodesInputSchema,
+		title: "List Available Nodes"
+	}, async ({ assetPath, cursor, graphName, maxResults, nameFilter, projectId }) => {
+		return toToolSuccess(await listAvailableNodes({
+			assetPath,
 			cursor,
+			graphName,
 			maxResults,
 			nameFilter,
-			packagePaths,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("set_viewport_camera", {
+		description: "Aim the active level editor viewport: position, rotation, field of view, and perspective or one of the six orthographic view types. Without this, capture_viewport photographs wherever the user last left the view. Refused with a clear message when no level editor viewport exists, such as a -nullrhi run.",
+		inputSchema: setViewportCameraInputSchema,
+		title: "Set Viewport Camera"
+	}, async ({ fov, location, orthoWidth, projectId, rotation, viewType }) => {
+		return toToolSuccess(await setViewportCamera({
+			fov,
+			location,
+			orthoWidth,
 			projectId,
-			recursiveClasses,
-			recursivePaths
+			rotation,
+			viewType
 		}, dependencies));
 	});
-	server.registerTool("read_data_table", {
-		description: "Read a DataTable asset's contents: the row struct it is typed on, its ordered column list (name plus the same type rendering get_class_reflection emits), and its rows as column-name-to-value maps. Values are ExportText, the format write_data_table_row accepts back, so a value read here round-trips. Rows are paged by name order: pass the previous response nextCursor to fetch the next page (totalRowCount reports the full count). A DataTable is a binary .uasset with no Asset Registry tags describing its rows, so there is no way to read one off disk instead — this tool loads it.",
-		inputSchema: readDataTableInputSchema,
-		title: "Read Data Table"
-	}, async ({ assetPath, cursor, loadIfNeeded, maxRows, projectId, rowNameFilter }) => {
-		return toToolSuccess(await readDataTable({
-			assetPath,
-			cursor,
-			loadIfNeeded,
-			maxRows,
+	server.registerTool("focus_actors", {
+		description: "Frame the given actors in the viewport, exactly as the editor's F key does — a bounds box over all of them with the usual padding. focusedCount reports how many resolved; a path that resolved to nothing is reported there rather than failing the framing. Follow with capture_viewport to look at the result.",
+		inputSchema: focusActorsInputSchema,
+		title: "Focus Actors"
+	}, async ({ actorPaths, instant, projectId }) => {
+		return toToolSuccess(await focusActors({
+			actorPaths,
+			instant,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("set_view_mode", {
+		description: "Switch the active viewport view mode — lit to judge composition, wireframe to judge density, lightmap_density to judge a bake, shader_complexity or quad_overdraw to judge cost, visualize_nanite and visualize_lumen for the UE5 pipelines. Pair with capture_viewport to read the result back.",
+		inputSchema: setViewModeInputSchema,
+		title: "Set View Mode"
+	}, async ({ projectId, viewMode }) => {
+		return toToolSuccess(await setViewMode({
 			projectId,
-			rowNameFilter
+			viewMode
 		}, dependencies));
 	});
-	server.registerTool("write_data_table_row", {
-		description: "Insert, update, or delete a single DataTable row. Every column name and value is validated against the row struct before anything is written — an unknown column or a value that will not parse rejects the whole write with an error naming the field, so a row is never partially applied and there is no silent coercion. The write runs inside one transaction, so a human at the editor can Ctrl+Z it, and it marks the package dirty without saving: call save_dirty_packages to persist. Deleting a row that does not exist reports rowExisted=false rather than failing. Use dryRun to validate first. For a whole-table replace use import_data_table instead.",
-		inputSchema: writeDataTableRowInputSchema,
-		title: "Write Data Table Row"
-	}, async ({ assetPath, dryRun, operation, projectId, rowName, values }) => {
-		return toToolSuccess(await writeDataTableRow({
-			assetPath,
+	server.registerTool("toggle_show_flags", {
+		description: "Turn viewport show flags on or off by FEngineShowFlags name, so any of the engine's roughly three hundred flags is reachable without a per-flag tool. An unknown name is reported per entry with near matches, not as a failure of the whole batch.",
+		inputSchema: toggleShowFlagsInputSchema,
+		title: "Toggle Show Flags"
+	}, async ({ flags, projectId }) => {
+		return toToolSuccess(await toggleShowFlags({
+			flags,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("high_res_screenshot", {
+		description: "Queue a multiplier-scaled screenshot written to the project's Saved/Screenshots — the on-disk counterpart to capture_viewport, which returns image bytes in-band and is therefore capped by the bridge frame budget. The capture happens on the next rendered frame, so the response reports where the file will be rather than waiting for it.",
+		inputSchema: highResScreenshotInputSchema,
+		title: "High Res Screenshot"
+	}, async ({ fileName, includeUi, multiplier, projectId }) => {
+		return toToolSuccess(await highResScreenshot({
+			fileName,
+			includeUi,
+			multiplier,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("duplicate_actor", {
+		description: "Duplicate up to 64 actors in one undo entry, each optionally offset from its original — the cheap way to build a row, a grid or a variant set without respawning and reconfiguring every copy. dryRun resolves every entry without duplicating anything.",
+		inputSchema: duplicateActorInputSchema,
+		title: "Duplicate Actor"
+	}, async ({ actors, dryRun, projectId }) => {
+		return toToolSuccess(await duplicateActor({
+			actors,
 			dryRun,
-			operation,
-			projectId,
-			rowName,
-			values
+			projectId
 		}, dependencies));
 	});
-	server.registerTool("export_data_table", {
-		description: "Serialize a whole DataTable through the engine's own JSON or CSV exporter. Returned in chunks by character offset because the engine produces one string rather than something row-addressable: concatenate the chunks in cursor order to reassemble, and note a single chunk is not valid JSON or CSV on its own. Use read_data_table when you want structured, per-row access; use this when you want the table in the same text form the editor's own export produces.",
-		inputSchema: exportDataTableInputSchema,
-		title: "Export Data Table"
-	}, async ({ assetPath, cursor, format, loadIfNeeded, projectId }) => {
-		return toToolSuccess(await exportDataTable({
-			assetPath,
-			cursor,
-			format,
-			loadIfNeeded,
+	server.registerTool("attach_actor", {
+		description: "Attach actors to parents with explicit transform rules, or detach them by passing an empty parentActorPath. Attaching an actor to itself or to one of its own descendants is refused per entry rather than corrupting the world. One undo entry for the whole batch.",
+		inputSchema: attachActorInputSchema,
+		title: "Attach Actor"
+	}, async ({ attachments, dryRun, projectId }) => {
+		return toToolSuccess(await attachActor({
+			attachments,
+			dryRun,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("import_data_table", {
-		description: "REPLACE every row of a DataTable from a JSON or CSV payload, using the engine's own importer. This is destructive: any row not present in the content is deleted, so it is the wrong tool for changing one value — use write_data_table_row for that. The whole payload travels in one bridge frame, so a table beyond the content character bound cannot be imported this way. Runs inside one transaction (Ctrl+Z reverses it) and marks the package dirty without saving. Rows the importer rejects come back in problems while the rest still apply, so check problemCount even on success; dryRun reports the row count and problems without replacing anything.",
-		inputSchema: importDataTableInputSchema,
-		title: "Import Data Table"
-	}, async ({ assetPath, content, dryRun, format, projectId }) => {
-		return toToolSuccess(await importDataTable({
-			assetPath,
-			content,
+	server.registerTool("add_actor_component", {
+		description: "Add instance components to placed actors — a point light on a prop, a collision box on a blockout. These are real instance components: they show in the details panel and survive a level save and reload, unlike a transient runtime component.",
+		inputSchema: addActorComponentInputSchema,
+		title: "Add Actor Component"
+	}, async ({ components, dryRun, projectId }) => {
+		return toToolSuccess(await addActorComponent({
+			components,
 			dryRun,
-			format,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("create_data_table", {
-		description: "Create a new empty DataTable asset backed by a row struct. The struct is fixed at creation — UDataTable can have its RowStruct swapped later, but that reinterprets existing rows through the new layout, so the bridge does not expose it; create a new table instead. The struct must derive FTableRowBase, and creation fails if an asset already exists at the path. The new table is marked dirty but not written to disk: call save_dirty_packages to persist it, or it disappears when the editor closes. Use read_data_table to confirm the column set the struct produced.",
-		inputSchema: createDataTableInputSchema,
-		title: "Create Data Table"
-	}, async ({ assetPath, dryRun, projectId, rowStructPath }) => {
-		return toToolSuccess(await createDataTable({
-			assetPath,
+	server.registerTool("set_actor_tags", {
+		description: "Write actor tags in bulk. mode 'set' replaces the actor's tag list, 'add' unions with it, 'remove' subtracts. Tags are what list_actors filters on, so this is how a batch of actors is made addressable as a group.",
+		inputSchema: setActorTagsInputSchema,
+		title: "Set Actor Tags"
+	}, async ({ dryRun, entries, projectId }) => {
+		return toToolSuccess(await setActorTags({
 			dryRun,
-			projectId,
-			rowStructPath
+			entries,
+			projectId
 		}, dependencies));
 	});
-	server.registerTool("rename_data_table", {
-		description: "Rename a DataTable, move it to another package path, or both. Goes through the editor's asset tools, so references from other assets are fixed up and a redirector is left at the old path to keep hard references resolving. Renaming is not a transaction the editor can Ctrl+Z — it rewrites packages on disk. Use dryRun to check the destination is free first.",
-		inputSchema: renameDataTableInputSchema,
-		title: "Rename Data Table"
-	}, async ({ assetPath, destinationPath, dryRun, newName, projectId }) => {
-		return toToolSuccess(await renameDataTable({
-			assetPath,
-			destinationPath,
+	server.registerTool("move_to_folder", {
+		description: "Move actors into World Outliner folders, creating the folder if it does not exist. An empty folderPath moves an actor back to the outliner root.",
+		inputSchema: moveToFolderInputSchema,
+		title: "Move To Folder"
+	}, async ({ dryRun, entries, projectId }) => {
+		return toToolSuccess(await moveToFolder({
 			dryRun,
-			newName,
+			entries,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("delete_data_table", {
-		description: "Delete a DataTable asset from the project. This is the one DataTable tool that cannot be undone — asset deletion is not a transaction, so there is no Ctrl+Z and no dirty-package step to reconsider at. A table other assets still reference is refused, and those referencers are reported; force deletes anyway and breaks them. Always dryRun first on a table you did not create: it reports the referencers without touching anything.",
-		inputSchema: deleteDataTableInputSchema,
-		title: "Delete Data Table"
-	}, async ({ assetPath, dryRun, force, projectId }) => {
-		return toToolSuccess(await deleteDataTable({
-			assetPath,
+	server.registerTool("place_asset", {
+		description: "Place assets into the level, letting the editor's actor factory pick the actor class — a static mesh becomes a StaticMeshActor, a Blueprint becomes its own class, a particle system becomes an emitter, a sound becomes an ambient sound. Use this instead of spawn_actor whenever the thing being placed is an asset rather than a bare class.",
+		inputSchema: placeAssetInputSchema,
+		title: "Place Asset"
+	}, async ({ dryRun, placements, projectId }) => {
+		return toToolSuccess(await placeAsset({
 			dryRun,
-			force,
+			placements,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("rename_data_table_row", {
-		description: "Rename a single row, keeping its position in the table and its values intact. Not the same as an upsert under the new name followed by a delete of the old one: that pair costs two transactions and moves the row to the end. Fails if the row does not exist or the new name is already taken. Runs inside one transaction (Ctrl+Z reverses it) and marks the package dirty without saving. Note that row names are how other assets address rows, so a rename breaks any FDataTableRowHandle pointing at the old name — nothing fixes those up.",
-		inputSchema: renameDataTableRowInputSchema,
-		title: "Rename Data Table Row"
-	}, async ({ assetPath, dryRun, newRowName, projectId, rowName }) => {
-		return toToolSuccess(await renameDataTableRow({
-			assetPath,
+	server.registerTool("replace_actors", {
+		description: "Replace up to 64 actors with a different asset or class, preserving each original transform and, where the types line up, its matching properties. Give exactly one of replacementAssetPath or replacementClass. One undo entry for the whole batch.",
+		inputSchema: replaceActorsInputSchema,
+		title: "Replace Actors"
+	}, async ({ actorPaths, dryRun, projectId, replacementAssetPath, replacementClass }) => {
+		return toToolSuccess(await replaceActors({
+			actorPaths,
 			dryRun,
-			newRowName,
 			projectId,
-			rowName
+			replacementAssetPath,
+			replacementClass
 		}, dependencies));
 	});
-	server.registerTool("get_asset_dependencies", {
-		description: "Report an asset's package-level dependencies (what it needs) and referencers (what needs it) from the Unreal Asset Registry — the Reference Viewer data — so you can judge the blast radius before changing it. Depth is 1: transitive links are not walked. Each list pages independently via nextDependencyCursor / nextReferencerCursor.",
-		inputSchema: getAssetDependenciesInputSchema,
-		title: "Get Asset Dependencies"
-	}, async ({ assetPath, categories, dependencyCursor, linkage, maxResults, projectId, referencerCursor }) => {
-		return toToolSuccess(await getAssetDependencies({
-			assetPath,
-			categories,
-			dependencyCursor,
-			linkage,
-			maxResults,
+	server.registerTool("build_lighting", {
+		description: "Run the editor's Build Lighting for the loaded level. Lightmass runs for minutes to hours, so this only accepts the job: it returns a buildJobId to poll with get_build_job_status (or wait_for_job with kind build). A Lightmass or Swarm failure surfaces its own error text and ends the job as failed, never as succeeded-with-warnings.",
+		inputSchema: buildLightingInputSchema,
+		title: "Build Lighting"
+	}, async ({ projectId, quality }) => {
+		return toToolSuccess(await startEditorBuild({
+			buildKind: "lighting",
 			projectId,
-			referencerCursor
+			quality
 		}, dependencies));
 	});
-	server.registerTool("find_blueprint_references", {
-		description: "Report which Blueprint assets depend on a C++ class, so you can judge whether renaming or removing it will break content. Each hit is either 'subclass' (the Blueprint's parent chain reaches the class) or 'module_dependency' (the Blueprint's package depends on the class's /Script module, which may be through this class or another type in it). Answers from Asset Registry metadata only — no Blueprints are loaded, so per-function and per-property usage is not resolved.",
-		inputSchema: findBlueprintReferencesInputSchema,
-		title: "Find Blueprint References"
-	}, async ({ className, cursor, maxResults, projectId, referenceKinds }) => {
-		return toToolSuccess(await findBlueprintReferences({
-			className,
+	server.registerTool("build_navigation", {
+		description: "Rebuild the navmesh for the loaded level. Returns a buildJobId to poll with get_build_job_status or wait_for_job with kind build. Without this an assistant-built level has no navigation and every AI pawn stands still.",
+		inputSchema: buildOnlyInputSchema,
+		title: "Build Navigation"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await startEditorBuild({
+			buildKind: "navigation",
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("build_hlod", {
+		description: "Build Hierarchical LOD clusters and proxy meshes for the loaded level. hlodAction picks which pass to run, since clusters and proxy meshes are separate steps in the editor and a caller usually wants one of them. Returns a buildJobId to poll with get_build_job_status or wait_for_job with kind build.",
+		inputSchema: buildHlodInputSchema,
+		title: "Build HLOD"
+	}, async ({ hlodAction, projectId }) => {
+		return toToolSuccess(await startEditorBuild({
+			buildKind: "hlod",
+			hlodAction,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("build_reflection_captures", {
+		description: "Rebuild reflection captures for the loaded level. Returns a buildJobId to poll with get_build_job_status or wait_for_job with kind build. Missing captures are the usual reason an assistant-built interior reads as flat.",
+		inputSchema: buildOnlyInputSchema,
+		title: "Build Reflection Captures"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await startEditorBuild({
+			buildKind: "reflection_captures",
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("build_geometry", {
+		description: "Rebuild BSP geometry for the loaded level. Returns a buildJobId to poll with get_build_job_status or wait_for_job with kind build.",
+		inputSchema: buildOnlyInputSchema,
+		title: "Build Geometry"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await startEditorBuild({
+			buildKind: "geometry",
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("build_texture_streaming", {
+		description: "Rebuild texture streaming data for the loaded level. Returns a buildJobId to poll with get_build_job_status or wait_for_job with kind build.",
+		inputSchema: buildOnlyInputSchema,
+		title: "Build Texture Streaming"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await startEditorBuild({
+			buildKind: "texture_streaming",
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("build_virtual_textures", {
+		description: "Rebuild runtime virtual texture data for the loaded level. Returns a buildJobId to poll with get_build_job_status or wait_for_job with kind build.",
+		inputSchema: buildOnlyInputSchema,
+		title: "Build Virtual Textures"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await startEditorBuild({
+			buildKind: "virtual_textures",
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("precompute_visibility", {
+		description: "Turn on the loaded level's precomputed visibility and run the lighting build that generates it. Returns a buildJobId to poll with get_build_job_status or wait_for_job with kind build. The level needs precomputed visibility volumes placed for this to produce anything.",
+		inputSchema: buildOnlyInputSchema,
+		title: "Precompute Visibility"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await startEditorBuild({
+			buildKind: "precomputed_visibility",
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("get_build_job_status", {
+		description: "Poll a build job started by any of the build_* tools; returns state (running, succeeded, failed, cancelled, unknown_job), which build kind it was, the real Lightmass / Swarm / builder error and warning text, and once finished the timing. A build a human aborted from the editor's own progress dialog reports 'cancelled', not 'failed'.",
+		inputSchema: getBuildJobStatusInputSchema,
+		title: "Get Build Job Status"
+	}, async ({ buildJobId, projectId }) => {
+		return toToolSuccess(await getBuildJobStatus({
+			buildJobId,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("create_gameplay_tag", {
+		description: "Declare a gameplay tag in a project config file, so it appears in the editor's tag picker without a restart. The response names the .ini that was written, which is the file to put under source control. A malformed hierarchical name is rejected before anything is written — a corrupted tag table is painful to unpick. Reports state 'exists' rather than failing for a tag that is already declared.",
+		inputSchema: createGameplayTagInputSchema,
+		title: "Create Gameplay Tag"
+	}, async ({ comment, projectId, source, tagName }) => {
+		return toToolSuccess(await createGameplayTag({
+			comment,
+			projectId,
+			source,
+			tagName
+		}, dependencies));
+	});
+	server.registerTool("list_gameplay_tags", {
+		description: "List the gameplay tags the project knows about, with the source that declared each one and its comment, optionally filtered to a prefix and everything under it. Check here before create_gameplay_tag: a tag that already exists under a slightly different spelling is the usual cause of a GAS setup that silently never matches.",
+		inputSchema: listGameplayTagsInputSchema,
+		title: "List Gameplay Tags"
+	}, async ({ cursor, maxResults, prefix, projectId }) => {
+		return toToolSuccess(await listGameplayTags({
 			cursor,
 			maxResults,
+			prefix,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("create_landscape", {
+		description: "Create a landscape actor in the loaded level with explicit component sizing, optionally importing a heightmap from a file on disk. quadsPerSection and sectionsPerComponent are the engine's own constrained values; the response reports the resulting vertex resolution, which is the coordinate space sculpt_landscape and paint_landscape_layer regions are expressed in. Heightmaps are always read from a path — they are orders of magnitude too large to travel in a bridge frame.",
+		inputSchema: createLandscapeInputSchema,
+		title: "Create Landscape"
+	}, async ({ componentCountX, componentCountY, heightmapFilePath, label, location, projectId, quadsPerSection, rotation, scale, sectionsPerComponent }) => {
+		return toToolSuccess(await createLandscape({
+			componentCountX,
+			componentCountY,
+			heightmapFilePath,
+			label,
+			location,
 			projectId,
-			referenceKinds
+			quadsPerSection,
+			rotation,
+			scale,
+			sectionsPerComponent
 		}, dependencies));
 	});
-	server.registerTool("get_blueprint_summary", {
-		description: "Describe what is inside a Blueprint asset: parent class, implemented interfaces, its component hierarchy from the Simple Construction Script, its variables (type, default, category, replication), its functions/events/macros with signatures, and an inventory of its graphs. Use the returned graph names with get_blueprint_graph. By default nothing is loaded — an unloaded Blueprint answers from Asset Registry metadata (parent and generated class only) and reports loaded=false; pass loadIfNeeded to read the full contents. Each list pages independently.",
-		inputSchema: getBlueprintSummaryInputSchema,
-		title: "Get Blueprint Summary"
-	}, async ({ blueprintPath, componentCursor, functionCursor, graphCursor, loadIfNeeded, maxResults, projectId, variableCursor }) => {
-		return toToolSuccess(await getBlueprintSummary({
-			blueprintPath,
-			componentCursor,
-			functionCursor,
-			graphCursor,
-			loadIfNeeded,
-			maxResults,
+	server.registerTool("sculpt_landscape", {
+		description: "Write landscape heights over a rectangular region: flatten to a height, ramp between two, apply noise, or import a heightmap file. This edits an explicit region rather than simulating brush strokes, so the result is reproducible. Region coordinates are landscape vertices, as create_landscape reports through resolutionX / resolutionY.",
+		inputSchema: sculptLandscapeInputSchema,
+		title: "Sculpt Landscape"
+	}, async ({ actorPath, height, heightmapFilePath, mode, noiseAmplitude, noiseFrequency, noiseSeed, projectId, rampAxis, rampEndHeight, rampStartHeight, region }) => {
+		return toToolSuccess(await sculptLandscape({
+			actorPath,
+			height,
+			heightmapFilePath,
+			mode,
+			noiseAmplitude,
+			noiseFrequency,
+			noiseSeed,
 			projectId,
-			variableCursor
+			rampAxis,
+			rampEndHeight,
+			rampStartHeight,
+			region
 		}, dependencies));
 	});
-	server.registerTool("get_blueprint_graph", {
-		description: "Dump one Blueprint graph as nodes and connections: each node reports its title, node class and pins, and each pin reports its name, direction, type, default value and the node/pin ids it links to. Get valid graph names from get_blueprint_summary first. Reading a graph requires the Blueprint in memory, so pass loadIfNeeded for an unloaded asset. Nodes are ordered by their stable GUID and paged via nextNodeCursor.",
-		inputSchema: getBlueprintGraphInputSchema,
-		title: "Get Blueprint Graph"
-	}, async ({ blueprintPath, graphName, loadIfNeeded, maxNodes, nodeCursor, projectId }) => {
-		return toToolSuccess(await getBlueprintGraph({
-			blueprintPath,
-			graphName,
-			loadIfNeeded,
-			maxNodes,
-			nodeCursor,
+	server.registerTool("paint_landscape_layer", {
+		description: "Write a landscape weight layer over a rectangular region, so the layer shows through the landscape material. The layer must already exist in the landscape's target layer list. Region coordinates are landscape vertices.",
+		inputSchema: paintLandscapeLayerInputSchema,
+		title: "Paint Landscape Layer"
+	}, async ({ actorPath, layerName, projectId, region, weight }) => {
+		return toToolSuccess(await paintLandscapeLayer({
+			actorPath,
+			layerName,
+			projectId,
+			region,
+			weight
+		}, dependencies));
+	});
+	server.registerTool("run_geometry_script", {
+		description: "Generate geometry with Geometry Script: an ordered list of operations run against one dynamic mesh, so a whole shape — a box minus a cylinder, a swept profile, a displaced sphere — is built in a single call. Bake the result to a static mesh asset, or leave it on a placed dynamic mesh actor to keep iterating. Returns triangle and vertex counts so the shape can be sanity-checked without opening the editor. An operation that fails names its index in the list. Requires the Geometry Script plugin enabled in the project; if it is not, the call says so by name.",
+		inputSchema: runGeometryScriptInputSchema,
+		title: "Run Geometry Script"
+	}, async ({ actorTransform, assetName, assetPath, label, operations, output, projectId }) => {
+		return toToolSuccess(await runGeometryScript({
+			actorTransform,
+			assetName,
+			assetPath,
+			label,
+			operations,
+			output,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("get_blueprint_compile_errors", {
-		description: "Report each Blueprint's compile status (up_to_date, warnings, error, dirty, unknown, not_loaded, not_found) plus the errors and warnings from the last compile this bridge ran, including the node each message was attached to. hasDiagnostics=false means this bridge has not compiled that Blueprint in this editor session, so empty lists do not mean it is clean — run compile_blueprint first to get diagnostics.",
-		inputSchema: getBlueprintCompileErrorsInputSchema,
-		title: "Get Blueprint Compile Errors"
-	}, async ({ blueprintPaths, cursor, maxResults, projectId }) => {
-		return toToolSuccess(await getBlueprintCompileErrors({
-			blueprintPaths,
+	server.registerTool("list_data_layers", {
+		description: "List the World Partition data layers of the loaded map, each with its editor loaded and visible state and its runtime state. isWorldPartition false means the map is not World Partition at all, so the empty list means there are none rather than none loaded.",
+		inputSchema: listDataLayersInputSchema,
+		title: "List Data Layers"
+	}, async ({ cursor, maxResults, projectId }) => {
+		return toToolSuccess(await listDataLayers({
 			cursor,
 			maxResults,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("compile_blueprint", {
-		description: "Compile one or more Blueprints in the running editor so content breakage is caught after a C++ change that altered a base class or a UFUNCTION signature. Compiling is asynchronous: this returns a compileJobId to poll with get_blueprint_compile_status, which reports the per-Blueprint diagnostics. Blueprints are loaded as needed and their assets are modified in memory — save them with save_dirty_packages if you want the result on disk.",
-		inputSchema: compileBlueprintInputSchema,
-		title: "Compile Blueprint"
-	}, async ({ blueprintPaths, projectId }) => {
-		return toToolSuccess(await compileBlueprint({
-			blueprintPaths,
+	server.registerTool("set_data_layer_state", {
+		description: "Set World Partition data layer state: editor loaded, editor visible, and runtime state where the layer is a runtime layer. Every field is optional per entry, so an omitted one is left alone rather than reset.",
+		inputSchema: setDataLayerStateInputSchema,
+		title: "Set Data Layer State"
+	}, async ({ entries, projectId }) => {
+		return toToolSuccess(await setDataLayerState({
+			entries,
 			projectId
 		}, dependencies));
 	});
-	server.registerTool("get_blueprint_compile_status", {
-		description: "Poll a compile_blueprint job. Reports 'compiling' while it runs, then 'succeeded' or 'failed' with per-Blueprint errors and warnings (each carrying the node the compiler blamed); 'unknown_job' means the id was never issued or has been evicted.",
-		inputSchema: getBlueprintCompileStatusInputSchema,
-		title: "Get Blueprint Compile Status"
-	}, async ({ compileJobId, cursor, maxResults, projectId }) => {
-		return toToolSuccess(await getBlueprintCompileStatus({
-			compileJobId,
-			cursor,
-			maxResults,
-			projectId
+	server.registerTool("load_wp_region", {
+		description: "Pin a spatial region of a World Partition map into editor memory so the actors inside it become visible to list_actors and editable by the level tools. This matters for correctness, not convenience: in a World Partition map, actors in unloaded cells are simply not in memory, so list_actors under-reports and every edit tool silently no-ops on them. Unpin regions when done — a session that keeps pinning will run out of memory. pinnedRegionCount reports what is currently held.",
+		inputSchema: loadWpRegionInputSchema,
+		title: "Load World Partition Region"
+	}, async ({ action, projectId, region, regionId }) => {
+		return toToolSuccess(await loadWpRegion({
+			action,
+			projectId,
+			region,
+			regionId
 		}, dependencies));
 	});
 }
@@ -8997,6 +11271,10 @@ function clampWaitForJobTimeoutMs(kind, timeoutMs) {
 }
 async function pollJobStatus(kind, jobId, projectId, dependencies) {
 	switch (kind) {
+		case "build": return await getBuildJobStatus({
+			buildJobId: jobId,
+			projectId
+		}, dependencies);
 		case "compile": return await getCompileStatus({
 			compileJobId: jobId,
 			projectId
@@ -9021,6 +11299,7 @@ async function pollJobStatus(kind, jobId, projectId, dependencies) {
 }
 function classifyJobStatus(kind, status) {
 	switch (kind) {
+		case "build": return status.state === "running" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
 		case "compile": return status.state === "compiling" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
 		case "create_class": return status.state === "creating" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
 		case "pie": return status.state === "starting" ? "pending" : "completed";
@@ -9064,6 +11343,495 @@ async function sleep(delayMs) {
 		setTimeout(resolve, delayMs);
 	});
 }
+const CREATIVE_RESPONSE_ENVELOPE_FIELDS = /* @__PURE__ */ new Set([
+	"ok",
+	"requestId",
+	"type",
+	"version"
+]);
+function toCreativeResult(response, projectId) {
+	const result = { projectId };
+	for (const [key, value] of Object.entries(response)) if (!CREATIVE_RESPONSE_ENVELOPE_FIELDS.has(key)) result[key] = value;
+	return result;
+}
+async function exchangeCreativeRequest(request, send, requestType, projectId, dependencies) {
+	const entry = dependencies.registry.getProject(projectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${projectId}'.`);
+	const response = await send(request, {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) {
+		const { error } = response;
+		throw new Error(`Bridge ${requestType} failed (${error.code}): ${error.message}`);
+	}
+	return toCreativeResult(response, entry.projectId);
+}
+const creativeProjectIdSchema = projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should run this request.");
+const listAssetFactoriesInputSchema = {
+	cursor: bridgeListAssetFactoriesRequestSchema.shape.cursor.describe("nextCursor from a previous response, to fetch the following page."),
+	maxResults: bridgeListAssetFactoriesRequestSchema.shape.maxResults.describe(`Maximum factories per page (1-${String(100)}). Defaults to ${String(50)}.`),
+	nameFilter: bridgeListAssetFactoriesRequestSchema.shape.nameFilter.describe("Case-insensitive substring matched against the factory class, the produced asset class and the menu category, e.g. 'material' or 'input'."),
+	projectId: creativeProjectIdSchema
+};
+const createAssetInputSchema = {
+	assetClass: bridgeCreateAssetRequestSchema.shape.assetClass.describe("Class of asset to create, as list_asset_factories reports it (e.g. 'DataTable', 'Material', 'InputAction')."),
+	assetName: bridgeCreateAssetRequestSchema.shape.assetName.describe("Name of the new asset, a single path segment with no '/' or '.' (e.g. 'DT_Weapons')."),
+	factoryClass: bridgeCreateAssetRequestSchema.shape.factoryClass.describe("Factory class to use, when more than one produces assetClass. Omit to let the editor pick."),
+	options: bridgeCreateAssetRequestSchema.shape.options.describe("Reflected properties set on the factory before it runs, as name-to-ExportText pairs (e.g. { ParentClass: \"/Script/Engine.Actor\" }). This is how a factory that would otherwise open a modal picker is configured. list_asset_factories reports each factory's requiredOptions."),
+	packagePath: bridgeCreateAssetRequestSchema.shape.packagePath.describe("Content folder the asset is created in (e.g. '/Game/Data'). Must be under /Game."),
+	projectId: creativeProjectIdSchema
+};
+const duplicateAssetInputSchema = {
+	destinationName: bridgeDuplicateAssetRequestSchema.shape.destinationName.describe("Name of the copy, a single path segment."),
+	destinationPath: bridgeDuplicateAssetRequestSchema.shape.destinationPath.describe("Content folder the copy is written to (e.g. '/Game/Weapons')."),
+	projectId: creativeProjectIdSchema,
+	sourceAssetPath: bridgeDuplicateAssetRequestSchema.shape.sourceAssetPath.describe("Package name or object path of the asset to copy.")
+};
+const renameAssetInputSchema = {
+	assetPath: bridgeRenameAssetRequestSchema.shape.assetPath.describe("Package name or object path of the asset to rename."),
+	newName: bridgeRenameAssetRequestSchema.shape.newName.describe("New name, a single path segment."),
+	projectId: creativeProjectIdSchema
+};
+const moveAssetInputSchema = {
+	assetPath: bridgeMoveAssetRequestSchema.shape.assetPath.describe("Package name or object path of the asset to move."),
+	destinationPath: bridgeMoveAssetRequestSchema.shape.destinationPath.describe("Content folder to move it into (e.g. '/Game/Weapons/Rifles')."),
+	newName: bridgeMoveAssetRequestSchema.shape.newName.describe("Optional new name; omit to keep the current one."),
+	projectId: creativeProjectIdSchema
+};
+const deleteAssetInputSchema = {
+	assetPath: bridgeDeleteAssetRequestSchema.shape.assetPath.describe("Package name or object path of the asset to delete."),
+	force: bridgeDeleteAssetRequestSchema.shape.force.describe("Delete even when other assets reference it, leaving those references dangling. Defaults to false, which refuses and reports the referencers instead."),
+	projectId: creativeProjectIdSchema
+};
+const saveAssetInputSchema = {
+	assetPaths: bridgeSaveAssetRequestSchema.shape.assetPaths.describe(`Package names or object paths of the assets to save (1-${String(64)}).`),
+	projectId: creativeProjectIdSchema
+};
+const createFolderInputSchema = {
+	folderPath: bridgeCreateFolderRequestSchema.shape.folderPath.describe("Content folder to create (e.g. '/Game/Weapons/Rifles'). Must be under /Game."),
+	projectId: creativeProjectIdSchema
+};
+const getAssetMetadataInputSchema = {
+	assetPath: bridgeGetAssetMetadataRequestSchema.shape.assetPath.describe("Package name or object path of the asset to inspect."),
+	projectId: creativeProjectIdSchema
+};
+const listGraphNodesInputSchema = {
+	assetPath: bridgeListGraphNodesRequestSchema.shape.assetPath.describe("Package name or object path of the asset owning the graph."),
+	cursor: bridgeListGraphNodesRequestSchema.shape.cursor.describe("nextCursor from a previous response, to fetch the following page."),
+	graphName: bridgeListGraphNodesRequestSchema.shape.graphName.describe("Graph to read, as get_blueprint_summary reports it (e.g. 'EventGraph')."),
+	loadIfNeeded: bridgeListGraphNodesRequestSchema.shape.loadIfNeeded.describe("Load the asset when it is not already in memory. Defaults to true; false reports 'blueprint_not_loaded' instead, which is the cheaper answer when a large Blueprint's load could outrun the request budget."),
+	maxResults: bridgeListGraphNodesRequestSchema.shape.maxResults.describe(`Maximum nodes per page (1-${String(100)}). Defaults to ${String(25)}.`),
+	projectId: creativeProjectIdSchema
+};
+const addGraphNodeInputSchema = {
+	assetPath: bridgeAddGraphNodeRequestFieldsSchema.shape.assetPath.describe("Package name or object path of the asset owning the graph."),
+	graphName: bridgeAddGraphNodeRequestFieldsSchema.shape.graphName.describe("Graph to add the node to."),
+	kind: bridgeAddGraphNodeRequestFieldsSchema.shape.kind.describe("How the node is named: 'class' places a node type directly, 'function' places a call, 'variable_get' / 'variable_set' place a variable accessor."),
+	memberName: bridgeAddGraphNodeRequestFieldsSchema.shape.memberName.describe("Function or variable name, required for every kind except 'class'."),
+	memberParentClass: bridgeAddGraphNodeRequestFieldsSchema.shape.memberParentClass.describe("Class owning memberName; omit for a call or variable on the Blueprint itself."),
+	nodeClass: bridgeAddGraphNodeRequestFieldsSchema.shape.nodeClass.describe("UEdGraphNode subclass to place, required for kind 'class' (e.g. 'K2Node_IfThenElse'). list_available_nodes reports what this graph's schema accepts."),
+	pinDefaults: bridgeAddGraphNodeRequestFieldsSchema.shape.pinDefaults.describe("Pin name to ExportText default value, applied after the node is created so one call produces a configured node."),
+	position: bridgeAddGraphNodeRequestFieldsSchema.shape.position.describe("Graph-space position for the node; defaults to the origin."),
+	projectId: creativeProjectIdSchema
+};
+const removeGraphNodeInputSchema = {
+	assetPath: bridgeRemoveGraphNodeRequestSchema.shape.assetPath.describe("Package name or object path of the asset owning the graph."),
+	graphName: bridgeRemoveGraphNodeRequestSchema.shape.graphName.describe("Graph the node lives in."),
+	nodeGuid: bridgeRemoveGraphNodeRequestSchema.shape.nodeGuid.describe("nodeId from list_graph_nodes or add_graph_node. Nodes are addressed by GUID, never by index."),
+	projectId: creativeProjectIdSchema
+};
+const connectPinsInputSchema = {
+	assetPath: bridgeConnectPinsRequestSchema.shape.assetPath.describe("Package name or object path of the asset owning the graph."),
+	graphName: bridgeConnectPinsRequestSchema.shape.graphName.describe("Graph both nodes live in."),
+	projectId: creativeProjectIdSchema,
+	sourceNodeGuid: bridgeConnectPinsRequestSchema.shape.sourceNodeGuid.describe("nodeId of the node the wire leaves."),
+	sourcePinName: bridgeConnectPinsRequestSchema.shape.sourcePinName.describe("Pin name on the source node."),
+	targetNodeGuid: bridgeConnectPinsRequestSchema.shape.targetNodeGuid.describe("nodeId of the node the wire enters."),
+	targetPinName: bridgeConnectPinsRequestSchema.shape.targetPinName.describe("Pin name on the target node.")
+};
+const disconnectPinsInputSchema = {
+	assetPath: bridgeDisconnectPinsRequestSchema.shape.assetPath.describe("Package name or object path of the asset owning the graph."),
+	graphName: bridgeDisconnectPinsRequestSchema.shape.graphName.describe("Graph both nodes live in."),
+	projectId: creativeProjectIdSchema,
+	sourceNodeGuid: bridgeDisconnectPinsRequestSchema.shape.sourceNodeGuid.describe("nodeId of one end of the wire."),
+	sourcePinName: bridgeDisconnectPinsRequestSchema.shape.sourcePinName.describe("Pin name on the source node."),
+	targetNodeGuid: bridgeDisconnectPinsRequestSchema.shape.targetNodeGuid.describe("nodeId of the other end."),
+	targetPinName: bridgeDisconnectPinsRequestSchema.shape.targetPinName.describe("Pin name on the target node.")
+};
+const setPinDefaultInputSchema = {
+	assetPath: bridgeSetPinDefaultRequestSchema.shape.assetPath.describe("Package name or object path of the asset owning the graph."),
+	graphName: bridgeSetPinDefaultRequestSchema.shape.graphName.describe("Graph the node lives in."),
+	nodeGuid: bridgeSetPinDefaultRequestSchema.shape.nodeGuid.describe("nodeId of the node holding the pin."),
+	pinName: bridgeSetPinDefaultRequestSchema.shape.pinName.describe("Pin to set."),
+	projectId: creativeProjectIdSchema,
+	value: bridgeSetPinDefaultRequestSchema.shape.value.describe("ExportText value, the same format get_actor_details emits and set_actor_property accepts.")
+};
+const listAvailableNodesInputSchema = {
+	assetPath: bridgeListAvailableNodesRequestSchema.shape.assetPath.describe("Package name or object path of the asset owning the graph."),
+	cursor: bridgeListAvailableNodesRequestSchema.shape.cursor.describe("nextCursor from a previous response, to fetch the following page."),
+	graphName: bridgeListAvailableNodesRequestSchema.shape.graphName.describe("Graph whose schema decides what is legal to place."),
+	maxResults: bridgeListAvailableNodesRequestSchema.shape.maxResults.describe(`Maximum actions per page (1-${String(100)}). Defaults to ${String(25)}.`),
+	nameFilter: bridgeListAvailableNodesRequestSchema.shape.nameFilter.describe("Case-insensitive substring matched against the action title, category and keywords. Strongly recommended: an unfiltered Blueprint action database runs to thousands of entries."),
+	projectId: creativeProjectIdSchema
+};
+const setViewportCameraInputSchema = {
+	fov: bridgeSetViewportCameraRequestSchema.shape.fov.describe(`Field of view in degrees (${String(5)}-${String(170)}); perspective views only.`),
+	location: bridgeSetViewportCameraRequestSchema.shape.location.describe("World-space camera position."),
+	orthoWidth: bridgeSetViewportCameraRequestSchema.shape.orthoWidth.describe("Orthographic width in world units; ignored for a perspective view type."),
+	projectId: creativeProjectIdSchema,
+	rotation: bridgeSetViewportCameraRequestSchema.shape.rotation.describe("Camera rotation in degrees."),
+	viewType: bridgeSetViewportCameraRequestSchema.shape.viewType.describe("Projection to switch the viewport to; omit to keep the current one.")
+};
+const focusActorsInputSchema = {
+	actorPaths: bridgeFocusActorsRequestSchema.shape.actorPaths.describe(`Actor object paths to frame (1-${String(64)}), as list_actors reports them.`),
+	instant: bridgeFocusActorsRequestSchema.shape.instant.describe("Skip the editor easing animation so a capture taken right after this request already shows the framed result. Defaults to true."),
+	projectId: creativeProjectIdSchema
+};
+const setViewModeInputSchema = {
+	projectId: creativeProjectIdSchema,
+	viewMode: bridgeSetViewModeRequestSchema.shape.viewMode.describe("View mode to switch the active viewport to.")
+};
+const toggleShowFlagsInputSchema = {
+	flags: bridgeToggleShowFlagsRequestSchema.shape.flags.describe(`Show flags to set, by FEngineShowFlags name (1-${String(32)}), e.g. [{ name: 'Bounds', enabled: true }].`),
+	projectId: creativeProjectIdSchema
+};
+const highResScreenshotInputSchema = {
+	fileName: bridgeHighResScreenshotRequestSchema.shape.fileName.describe("File name only, no path — the capture always lands under the project's Saved/Screenshots."),
+	includeUi: bridgeHighResScreenshotRequestSchema.shape.includeUi.describe("Include editor UI in the capture. Defaults to false."),
+	multiplier: bridgeHighResScreenshotRequestSchema.shape.multiplier.describe(`Resolution multiplier over the viewport's own size (1-${String(8)}). Defaults to 1.`),
+	projectId: creativeProjectIdSchema
+};
+const duplicateActorInputSchema = {
+	actors: bridgeDuplicateActorRequestSchema.shape.actors.describe(`Actors to duplicate (1-${String(64)}), each optionally with a world-space offset applied to the copy.`),
+	dryRun: bridgeDuplicateActorRequestSchema.shape.dryRun.describe("Resolve every entry without duplicating anything, so a batch can be validated first."),
+	projectId: creativeProjectIdSchema
+};
+const attachActorInputSchema = {
+	attachments: bridgeAttachActorRequestSchema.shape.attachments.describe(`Attachments to apply (1-${String(64)}). An empty parentActorPath detaches the child instead.`),
+	dryRun: bridgeAttachActorRequestSchema.shape.dryRun.describe("Resolve every entry without attaching anything."),
+	projectId: creativeProjectIdSchema
+};
+const addActorComponentInputSchema = {
+	components: bridgeAddActorComponentRequestSchema.shape.components.describe(`Instance components to add (1-${String(64)}).`),
+	dryRun: bridgeAddActorComponentRequestSchema.shape.dryRun.describe("Resolve every entry without adding anything."),
+	projectId: creativeProjectIdSchema
+};
+const setActorTagsInputSchema = {
+	dryRun: bridgeSetActorTagsRequestSchema.shape.dryRun.describe("Resolve every entry without writing anything."),
+	entries: bridgeSetActorTagsRequestSchema.shape.entries.describe(`Tag writes (1-${String(64)}). mode 'set' replaces the actor's tags, 'add' unions, 'remove' subtracts.`),
+	projectId: creativeProjectIdSchema
+};
+const moveToFolderInputSchema = {
+	dryRun: bridgeMoveToFolderRequestSchema.shape.dryRun.describe("Resolve every entry without moving anything."),
+	entries: bridgeMoveToFolderRequestSchema.shape.entries.describe(`Outliner folder moves (1-${String(64)}). An empty folderPath moves the actor to the outliner root.`),
+	projectId: creativeProjectIdSchema
+};
+const placeAssetInputSchema = {
+	dryRun: bridgePlaceAssetRequestSchema.shape.dryRun.describe("Resolve every entry without placing anything."),
+	placements: bridgePlaceAssetRequestSchema.shape.placements.describe(`Assets to place in the level (1-${String(64)}). The actor factory picks the actor class, so a static mesh becomes a StaticMeshActor and a Blueprint becomes its own class.`),
+	projectId: creativeProjectIdSchema
+};
+const replaceActorsInputSchema = {
+	actorPaths: bridgeReplaceActorsRequestFieldsSchema.shape.actorPaths.describe(`Actors to replace (1-${String(64)}).`),
+	dryRun: bridgeReplaceActorsRequestFieldsSchema.shape.dryRun.describe("Resolve every entry without replacing anything."),
+	projectId: creativeProjectIdSchema,
+	replacementAssetPath: bridgeReplaceActorsRequestFieldsSchema.shape.replacementAssetPath.describe("Asset the replacements are built from, routed through the same actor factory place_asset uses. Give exactly one of replacementAssetPath or replacementClass."),
+	replacementClass: bridgeReplaceActorsRequestFieldsSchema.shape.replacementClass.describe("Actor class to replace with, for a replacement that has no asset behind it.")
+};
+const startEditorBuildInputSchema = {
+	hlodAction: bridgeStartEditorBuildRequestSchema.shape.hlodAction.describe("What a HLOD build should do; ignored by every other build kind. Defaults to 'build_all'."),
+	projectId: creativeProjectIdSchema,
+	quality: bridgeStartEditorBuildRequestSchema.shape.quality.describe("Lightmass quality preset; lighting builds only. Defaults to 'preview'.")
+};
+const getBuildJobStatusInputSchema = {
+	buildJobId: bridgeGetBuildJobStatusRequestSchema.shape.buildJobId.describe("buildJobId returned by one of the build_* tools."),
+	projectId: creativeProjectIdSchema
+};
+const createGameplayTagInputSchema = {
+	comment: bridgeCreateGameplayTagRequestSchema.shape.comment.describe("Developer comment stored alongside the tag, shown in the editor's tag picker."),
+	projectId: creativeProjectIdSchema,
+	source: bridgeCreateGameplayTagRequestSchema.shape.source.describe("Tag source .ini basename (e.g. 'Abilities.ini' under Config/Tags). Omit to write to DefaultGameplayTags.ini."),
+	tagName: bridgeCreateGameplayTagRequestSchema.shape.tagName.describe("Hierarchical tag name, dot-separated (e.g. 'Ability.Melee.Heavy').")
+};
+const listGameplayTagsInputSchema = {
+	cursor: bridgeListGameplayTagsRequestSchema.shape.cursor.describe("nextCursor from a previous response, to fetch the following page."),
+	maxResults: bridgeListGameplayTagsRequestSchema.shape.maxResults.describe(`Maximum tags per page (1-${String(200)}). Defaults to ${String(50)}.`),
+	prefix: bridgeListGameplayTagsRequestSchema.shape.prefix.describe("Return only this tag and everything under it (e.g. 'Ability' matches 'Ability.Melee.Heavy')."),
+	projectId: creativeProjectIdSchema
+};
+const createLandscapeInputSchema = {
+	componentCountX: bridgeCreateLandscapeRequestSchema.shape.componentCountX.describe(`Landscape components along X (1-${String(32)}).`),
+	componentCountY: bridgeCreateLandscapeRequestSchema.shape.componentCountY.describe(`Landscape components along Y (1-${String(32)}).`),
+	heightmapFilePath: bridgeCreateLandscapeRequestSchema.shape.heightmapFilePath.describe("Absolute path to a 16-bit greyscale PNG or raw .r16 to import as the starting heights. Heightmaps never travel inline — they do not fit in a bridge frame."),
+	label: bridgeCreateLandscapeRequestSchema.shape.label.describe("Outliner label for the new landscape actor."),
+	location: bridgeCreateLandscapeRequestSchema.shape.location.describe("World-space origin of the landscape."),
+	projectId: creativeProjectIdSchema,
+	quadsPerSection: bridgeCreateLandscapeRequestSchema.shape.quadsPerSection.describe("Quads per landscape section. The engine only accepts 7, 15, 31, 63, 127 or 255."),
+	rotation: bridgeCreateLandscapeRequestSchema.shape.rotation.describe("Rotation of the landscape actor."),
+	scale: bridgeCreateLandscapeRequestSchema.shape.scale.describe("Draw scale; Z scales the height range. Defaults to 100,100,100."),
+	sectionsPerComponent: bridgeCreateLandscapeRequestSchema.shape.sectionsPerComponent.describe("Sections per component: 1 or 4.")
+};
+const sculptLandscapeInputSchema = {
+	actorPath: bridgeSculptLandscapeRequestFieldsSchema.shape.actorPath.describe("Object path of the landscape actor to sculpt."),
+	height: bridgeSculptLandscapeRequestFieldsSchema.shape.height.describe("Target height in landscape units; required for mode 'flatten'."),
+	heightmapFilePath: bridgeSculptLandscapeRequestFieldsSchema.shape.heightmapFilePath.describe("Absolute path to a 16-bit heightmap; required for mode 'heightmap_file'."),
+	mode: bridgeSculptLandscapeRequestFieldsSchema.shape.mode.describe("How the new heights are derived."),
+	noiseAmplitude: bridgeSculptLandscapeRequestFieldsSchema.shape.noiseAmplitude.describe("Peak-to-centre noise height; required for mode 'noise'."),
+	noiseFrequency: bridgeSculptLandscapeRequestFieldsSchema.shape.noiseFrequency.describe("Noise frequency per vertex (0-1). Defaults to 0.05."),
+	noiseSeed: bridgeSculptLandscapeRequestFieldsSchema.shape.noiseSeed.describe("Seed, so the same request reproduces the same terrain."),
+	projectId: creativeProjectIdSchema,
+	rampAxis: bridgeSculptLandscapeRequestFieldsSchema.shape.rampAxis.describe("Axis the ramp runs along; defaults to 'x'."),
+	rampEndHeight: bridgeSculptLandscapeRequestFieldsSchema.shape.rampEndHeight.describe("Height at the far edge of the region; required for mode 'ramp'."),
+	rampStartHeight: bridgeSculptLandscapeRequestFieldsSchema.shape.rampStartHeight.describe("Height at the near edge of the region; required for mode 'ramp'."),
+	region: bridgeSculptLandscapeRequestFieldsSchema.shape.region.describe("Inclusive rectangle in landscape vertex coordinates, as create_landscape reports through resolutionX / resolutionY.")
+};
+const paintLandscapeLayerInputSchema = {
+	actorPath: bridgePaintLandscapeLayerRequestSchema.shape.actorPath.describe("Object path of the landscape actor to paint."),
+	layerName: bridgePaintLandscapeLayerRequestSchema.shape.layerName.describe("Weight layer to write, as it appears in the landscape's target layer list."),
+	projectId: creativeProjectIdSchema,
+	region: bridgePaintLandscapeLayerRequestSchema.shape.region.describe("Inclusive rectangle in landscape vertex coordinates."),
+	weight: bridgePaintLandscapeLayerRequestSchema.shape.weight.describe("Layer weight to write across the region (0-1).")
+};
+const runGeometryScriptInputSchema = {
+	actorTransform: bridgeRunGeometryScriptRequestFieldsSchema.shape.actorTransform.describe("Where the actor is placed; output 'dynamic_mesh_actor' only."),
+	assetName: bridgeRunGeometryScriptRequestFieldsSchema.shape.assetName.describe("Name of the baked static mesh asset; required for output 'static_mesh'."),
+	assetPath: bridgeRunGeometryScriptRequestFieldsSchema.shape.assetPath.describe("Content folder the baked asset is written to; required for output 'static_mesh'."),
+	label: bridgeRunGeometryScriptRequestFieldsSchema.shape.label.describe("Outliner label; output 'dynamic_mesh_actor' only."),
+	operations: bridgeRunGeometryScriptRequestFieldsSchema.shape.operations.describe("Ordered operations run against one dynamic mesh. append_* adds a primitive, subtract_* / intersect_* boolean one against the working mesh, and the rest transform or clean it up. Each carries a numeric params map (box: dimensionX/dimensionY/dimensionZ; sphere: radius, stepsPhi, stepsTheta; cylinder and cone: radius, height, radialSteps; torus: majorRadius, minorRadius, majorSteps, minorSteps; translate/scale: x, y, z; rotate: pitch, roll, yaw; apply_displace_noise: magnitude, frequency, seed; simplify_to_triangle_count: triangleCount) plus an optional transform placing the primitive."),
+	output: bridgeRunGeometryScriptRequestFieldsSchema.shape.output.describe("Where the finished mesh lands: baked into a static mesh asset, or left on a placed dynamic mesh actor to keep iterating on."),
+	projectId: creativeProjectIdSchema
+};
+const listDataLayersInputSchema = {
+	cursor: bridgeListDataLayersRequestSchema.shape.cursor.describe("nextCursor from a previous response, to fetch the following page."),
+	maxResults: bridgeListDataLayersRequestSchema.shape.maxResults.describe(`Maximum data layers per page (1-${String(100)}). Defaults to ${String(50)}.`),
+	projectId: creativeProjectIdSchema
+};
+const setDataLayerStateInputSchema = {
+	entries: bridgeSetDataLayerStateRequestSchema.shape.entries.describe(`Data layer state writes (1-${String(32)}). Every field is optional per entry — omitted leaves that aspect alone.`),
+	projectId: creativeProjectIdSchema
+};
+const loadWpRegionInputSchema = {
+	action: bridgeLoadWpRegionRequestFieldsSchema.shape.action.describe("'pin' loads a spatial region's cells and holds them, 'unpin' releases one by regionId, 'unpin_all' releases every region this bridge pinned."),
+	projectId: creativeProjectIdSchema,
+	region: bridgeLoadWpRegionRequestFieldsSchema.shape.region.describe("World-space box to load; required for action 'pin'."),
+	regionId: bridgeLoadWpRegionRequestFieldsSchema.shape.regionId.describe("Handle returned by a previous pin; required for action 'unpin'.")
+};
+async function listAssetFactories(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeListAssetFactoriesRequest({
+		cursor: input.cursor,
+		maxResults: input.maxResults,
+		nameFilter: input.nameFilter
+	}), sendBridgeListAssetFactoriesRequest, BRIDGE_LIST_ASSET_FACTORIES_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function createAsset(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateAssetRequest(input.assetClass, input.assetName, input.packagePath, {
+		factoryClass: input.factoryClass,
+		options: input.options
+	}), sendBridgeCreateAssetRequest, BRIDGE_CREATE_ASSET_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function duplicateAsset(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeDuplicateAssetRequest(input.sourceAssetPath, input.destinationPath, input.destinationName), sendBridgeDuplicateAssetRequest, BRIDGE_DUPLICATE_ASSET_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function renameAsset(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeRenameAssetRequest(input.assetPath, input.newName), sendBridgeRenameAssetRequest, BRIDGE_RENAME_ASSET_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function moveAsset(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeMoveAssetRequest(input.assetPath, input.destinationPath, { newName: input.newName }), sendBridgeMoveAssetRequest, BRIDGE_MOVE_ASSET_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function deleteAsset(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeDeleteAssetRequest(input.assetPath, { force: input.force }), sendBridgeDeleteAssetRequest, BRIDGE_DELETE_ASSET_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function saveAsset(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSaveAssetRequest(input.assetPaths), sendBridgeSaveAssetRequest, BRIDGE_SAVE_ASSET_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function createFolder(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateFolderRequest(input.folderPath), sendBridgeCreateFolderRequest, BRIDGE_CREATE_FOLDER_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function getAssetMetadata(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeGetAssetMetadataRequest(input.assetPath), sendBridgeGetAssetMetadataRequest, BRIDGE_GET_ASSET_METADATA_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function listGraphNodes(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeListGraphNodesRequest(input.assetPath, input.graphName, {
+		cursor: input.cursor,
+		loadIfNeeded: input.loadIfNeeded,
+		maxResults: input.maxResults
+	}), sendBridgeListGraphNodesRequest, BRIDGE_LIST_GRAPH_NODES_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addGraphNode(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddGraphNodeRequest(input.assetPath, input.graphName, input.kind, {
+		memberName: input.memberName,
+		memberParentClass: input.memberParentClass,
+		nodeClass: input.nodeClass,
+		pinDefaults: input.pinDefaults,
+		position: input.position
+	}), sendBridgeAddGraphNodeRequest, BRIDGE_ADD_GRAPH_NODE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function removeGraphNode(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeRemoveGraphNodeRequest(input.assetPath, input.graphName, input.nodeGuid), sendBridgeRemoveGraphNodeRequest, BRIDGE_REMOVE_GRAPH_NODE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function connectPins(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeConnectPinsRequest(input.assetPath, input.graphName, {
+		nodeGuid: input.sourceNodeGuid,
+		pinName: input.sourcePinName
+	}, {
+		nodeGuid: input.targetNodeGuid,
+		pinName: input.targetPinName
+	}), sendBridgeConnectPinsRequest, BRIDGE_CONNECT_PINS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function disconnectPins(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeDisconnectPinsRequest(input.assetPath, input.graphName, {
+		nodeGuid: input.sourceNodeGuid,
+		pinName: input.sourcePinName
+	}, {
+		nodeGuid: input.targetNodeGuid,
+		pinName: input.targetPinName
+	}), sendBridgeDisconnectPinsRequest, BRIDGE_DISCONNECT_PINS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function setPinDefault(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSetPinDefaultRequest(input.assetPath, input.graphName, input.nodeGuid, input.pinName, input.value), sendBridgeSetPinDefaultRequest, BRIDGE_SET_PIN_DEFAULT_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function listAvailableNodes(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeListAvailableNodesRequest(input.assetPath, input.graphName, {
+		cursor: input.cursor,
+		maxResults: input.maxResults,
+		nameFilter: input.nameFilter
+	}), sendBridgeListAvailableNodesRequest, BRIDGE_LIST_AVAILABLE_NODES_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function setViewportCamera(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSetViewportCameraRequest({
+		fov: input.fov,
+		location: input.location,
+		orthoWidth: input.orthoWidth,
+		rotation: input.rotation,
+		viewType: input.viewType
+	}), sendBridgeSetViewportCameraRequest, BRIDGE_SET_VIEWPORT_CAMERA_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function focusActors(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeFocusActorsRequest(input.actorPaths, { instant: input.instant }), sendBridgeFocusActorsRequest, BRIDGE_FOCUS_ACTORS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function setViewMode(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSetViewModeRequest(input.viewMode), sendBridgeSetViewModeRequest, BRIDGE_SET_VIEW_MODE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function toggleShowFlags(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeToggleShowFlagsRequest(input.flags), sendBridgeToggleShowFlagsRequest, BRIDGE_TOGGLE_SHOW_FLAGS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function highResScreenshot(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeHighResScreenshotRequest({
+		fileName: input.fileName,
+		includeUi: input.includeUi,
+		multiplier: input.multiplier
+	}), sendBridgeHighResScreenshotRequest, BRIDGE_HIGH_RES_SCREENSHOT_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function duplicateActor(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeDuplicateActorRequest(input.actors, { dryRun: input.dryRun }), sendBridgeDuplicateActorRequest, BRIDGE_DUPLICATE_ACTOR_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function attachActor(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAttachActorRequest(input.attachments, { dryRun: input.dryRun }), sendBridgeAttachActorRequest, BRIDGE_ATTACH_ACTOR_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addActorComponent(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddActorComponentRequest(input.components, { dryRun: input.dryRun }), sendBridgeAddActorComponentRequest, BRIDGE_ADD_ACTOR_COMPONENT_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function setActorTags(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSetActorTagsRequest(input.entries, { dryRun: input.dryRun }), sendBridgeSetActorTagsRequest, BRIDGE_SET_ACTOR_TAGS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function moveToFolder(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeMoveToFolderRequest(input.entries, { dryRun: input.dryRun }), sendBridgeMoveToFolderRequest, BRIDGE_MOVE_TO_FOLDER_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function placeAsset(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgePlaceAssetRequest(input.placements, { dryRun: input.dryRun }), sendBridgePlaceAssetRequest, BRIDGE_PLACE_ASSET_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function replaceActors(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeReplaceActorsRequest(input.actorPaths, {
+		assetPath: input.replacementAssetPath,
+		className: input.replacementClass
+	}, { dryRun: input.dryRun }), sendBridgeReplaceActorsRequest, BRIDGE_REPLACE_ACTORS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function startEditorBuild(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeStartEditorBuildRequest(input.buildKind, {
+		hlodAction: input.hlodAction,
+		quality: input.quality
+	}), sendBridgeStartEditorBuildRequest, BRIDGE_START_EDITOR_BUILD_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function getBuildJobStatus(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeGetBuildJobStatusRequest(input.buildJobId), sendBridgeGetBuildJobStatusRequest, BRIDGE_GET_BUILD_JOB_STATUS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function createGameplayTag(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateGameplayTagRequest(input.tagName, {
+		comment: input.comment,
+		source: input.source
+	}), sendBridgeCreateGameplayTagRequest, BRIDGE_CREATE_GAMEPLAY_TAG_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function listGameplayTags(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeListGameplayTagsRequest({
+		cursor: input.cursor,
+		maxResults: input.maxResults,
+		prefix: input.prefix
+	}), sendBridgeListGameplayTagsRequest, BRIDGE_LIST_GAMEPLAY_TAGS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function createLandscape(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateLandscapeRequest({
+		componentCountX: input.componentCountX,
+		componentCountY: input.componentCountY,
+		quadsPerSection: input.quadsPerSection,
+		sectionsPerComponent: input.sectionsPerComponent
+	}, {
+		heightmapFilePath: input.heightmapFilePath,
+		label: input.label,
+		location: input.location,
+		rotation: input.rotation,
+		scale: input.scale
+	}), sendBridgeCreateLandscapeRequest, BRIDGE_CREATE_LANDSCAPE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function sculptLandscape(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSculptLandscapeRequest(input.actorPath, input.mode, input.region, {
+		height: input.height,
+		heightmapFilePath: input.heightmapFilePath,
+		noiseAmplitude: input.noiseAmplitude,
+		noiseFrequency: input.noiseFrequency,
+		noiseSeed: input.noiseSeed,
+		rampAxis: input.rampAxis,
+		rampEndHeight: input.rampEndHeight,
+		rampStartHeight: input.rampStartHeight
+	}), sendBridgeSculptLandscapeRequest, BRIDGE_SCULPT_LANDSCAPE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function paintLandscapeLayer(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgePaintLandscapeLayerRequest(input.actorPath, input.layerName, input.region, input.weight), sendBridgePaintLandscapeLayerRequest, BRIDGE_PAINT_LANDSCAPE_LAYER_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function runGeometryScript(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeRunGeometryScriptRequest(input.operations, input.output, {
+		actorTransform: input.actorTransform,
+		assetName: input.assetName,
+		assetPath: input.assetPath,
+		label: input.label
+	}), sendBridgeRunGeometryScriptRequest, BRIDGE_RUN_GEOMETRY_SCRIPT_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function listDataLayers(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeListDataLayersRequest({
+		cursor: input.cursor,
+		maxResults: input.maxResults
+	}), sendBridgeListDataLayersRequest, BRIDGE_LIST_DATA_LAYERS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function setDataLayerState(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSetDataLayerStateRequest(input.entries), sendBridgeSetDataLayerStateRequest, BRIDGE_SET_DATA_LAYER_STATE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function loadWpRegion(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeLoadWpRegionRequest(input.action, {
+		region: input.region,
+		regionId: input.regionId
+	}), sendBridgeLoadWpRegionRequest, BRIDGE_LOAD_WP_REGION_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+const buildLightingInputSchema = {
+	projectId: creativeProjectIdSchema,
+	quality: startEditorBuildInputSchema.quality
+};
+const buildHlodInputSchema = {
+	hlodAction: startEditorBuildInputSchema.hlodAction,
+	projectId: creativeProjectIdSchema
+};
+const buildOnlyInputSchema = { projectId: creativeProjectIdSchema };
 //#endregion
 //#region src/projectId.ts
 const GENERAL_PROJECT_SETTINGS_SECTION = "[/Script/EngineSettings.GeneralProjectSettings]";
@@ -9281,7 +12049,7 @@ function isMissingFileError(error) {
 //#endregion
 //#region src/server.ts
 const SERVER_NAME = "ue-mcp-server";
-const SERVER_VERSION = "1.2.0";
+const SERVER_VERSION = "1.3.0";
 const logger = createModuleLogger("bootstrap");
 const enginePingLogger = createModuleLogger("engine-ping");
 const httpApiLogger = createModuleLogger("http-api");