@uemcp/server 1.10.0 → 1.12.0

package/dist/index.mjs

@@ -362,6 +362,18 @@ const TOOL_METADATA = {
 		"source",
 		"build.cs"
 	]),
+	add_nav_link: mutates("level", "add_nav_link", [
+		"navmesh",
+		"navigation",
+		"nav link",
+		"jump"
+	]),
+	add_nav_modifier_volume: mutates("level", "add_nav_modifier_volume", [
+		"navmesh",
+		"navigation",
+		"nav area",
+		"block"
+	]),
 	add_post_process_material: mutates("fx", "add_post_process_material"),
 	add_reflected_member: mutates("build", void 0, [
 		"uproperty",
@@ -372,6 +384,11 @@ const TOOL_METADATA = {
 	add_sequence_binding: mutates("sequence", "add_sequence_binding"),
 	add_sequence_keys: mutates("sequence", "add_sequence_keys"),
 	add_sequence_track: mutates("sequence", "add_sequence_track"),
+	add_smart_object_component: idempotentMutates("ai", "add_smart_object_component", [
+		"smart object",
+		"slot",
+		"claim"
+	]),
 	add_state_tree_component: mutates("ai", "add_state_tree_component"),
 	add_state_tree_state: mutates("ai", "add_state_tree_state"),
 	add_stimuli_source: mutates("ai", "add_stimuli_source", [
@@ -477,10 +494,27 @@ const TOOL_METADATA = {
 	create_landscape: mutates("level", "create_landscape"),
 	create_level_sequence: mutates("sequence", "create_level_sequence"),
 	create_material_instance: mutates("fx", "create_material_instance"),
+	create_mass_entity_config: mutates("ai", "create_mass_entity_config", [
+		"mass",
+		"crowd",
+		"entity config",
+		"trait"
+	]),
 	create_metasound: mutates("audio", "create_metasound"),
 	create_montage: mutates("anim", "create_montage"),
 	create_pcg_graph: mutates("fx", "create_pcg_graph"),
+	create_nav_area: mutates("level", "create_nav_area", [
+		"navmesh",
+		"navigation",
+		"nav area",
+		"cost"
+	]),
 	create_post_process_volume: mutates("fx", "create_post_process_volume"),
+	create_smart_object_definition: mutates("ai", "create_smart_object_definition", [
+		"smart object",
+		"slot",
+		"activity"
+	]),
 	create_sound_cue: mutates("audio", "create_sound_cue"),
 	create_state_tree: mutates("ai", "create_state_tree"),
 	create_struct: mutates("blueprint", "create_struct"),
@@ -494,6 +528,13 @@ const TOOL_METADATA = {
 	delete_asset: destroys("asset", "delete_asset"),
 	delete_data_table: destroys("asset", "delete_data_table"),
 	destroy_actor: destroys("level", "destroy_actor"),
+	diagnose_navmesh: readOnly("level", "diagnose_navmesh", [
+		"navmesh",
+		"navigation",
+		"island",
+		"spawn",
+		"reachable"
+	]),
 	disconnect_pins: mutates("blueprint", "disconnect_pins"),
 	doctor: readOnly("core", void 0, [
 		"diagnose",
@@ -509,6 +550,12 @@ const TOOL_METADATA = {
 		"generator",
 		"score"
 	]),
+	edit_mass_entity_config: mutates("ai", "edit_mass_entity_config", [
+		"mass",
+		"crowd",
+		"entity config",
+		"trait"
+	]),
 	enable_toolset: idempotentMutates("core", void 0, [
 		"toolset",
 		"tools",
@@ -532,6 +579,13 @@ const TOOL_METADATA = {
 		"registry"
 	]),
 	find_blueprint_references: readOnly("blueprint", "find_blueprint_references"),
+	find_path: readOnly("level", "find_path", [
+		"navmesh",
+		"navigation",
+		"path",
+		"pathfinding",
+		"reachable"
+	]),
 	find_symbol: readOnly("build", void 0, [
 		"symbol",
 		"definition",
@@ -595,6 +649,12 @@ const TOOL_METADATA = {
 	get_editor_state: readOnly("core", "get_editor_state"),
 	get_eqs_query: readOnly("ai", "get_eqs_query"),
 	get_import_job_status: readOnly("asset", "get_import_job_status"),
+	get_mass_entity_config: readOnly("ai", "get_mass_entity_config", [
+		"mass",
+		"crowd",
+		"entity config",
+		"trait"
+	]),
 	get_net_stats: readOnly("test", "get_net_stats", [
 		"network",
 		"multiplayer",
@@ -606,6 +666,7 @@ const TOOL_METADATA = {
 	get_pie_status: readOnly("test", "get_pie_status"),
 	get_project_id: readOnly("core", void 0, ["projectid", "identity"]),
 	get_render_job_status: readOnly("sequence", "get_render_job_status"),
+	get_smart_object_definition: readOnly("ai", "get_smart_object_definition", ["smart object", "slot"]),
 	get_source_control_job_status: readOnly("asset", "get_source_control_job_status"),
 	get_source_control_status: readOnly("asset", "get_source_control_status"),
 	get_state_tree: readOnly("ai", "get_state_tree"),
@@ -629,6 +690,12 @@ const TOOL_METADATA = {
 		"enhanced input"
 	]),
 	launch_on_device: reachesOutside("test", false, "launch_on_device"),
+	layout_graph: idempotentMutates("blueprint", "layout_graph", [
+		"arrange",
+		"tidy",
+		"overlap",
+		"format"
+	]),
 	link_state_tree_state: mutates("ai", "link_state_tree_state", ["subtree", "linked"]),
 	list_actors: readOnly("core", "list_actors"),
 	list_asset_factories: readOnly("asset", "list_asset_factories"),
@@ -674,6 +741,11 @@ const TOOL_METADATA = {
 	refresh_source_control_status: idempotentMutates("asset", "refresh_source_control_status"),
 	reimport_asset: reachesOutside("asset", false, "reimport_asset"),
 	remove_graph_node: destroys("blueprint", "remove_graph_node"),
+	remove_state_tree_elements: destroys("ai", "remove_state_tree_elements", [
+		"delete",
+		"state",
+		"transition"
+	]),
 	rename_asset: mutates("asset", "rename_asset"),
 	rename_data_table: mutates("asset", "rename_data_table"),
 	rename_data_table_row: mutates("asset", "rename_data_table_row"),
@@ -720,7 +792,25 @@ const TOOL_METADATA = {
 	set_import_settings: idempotentMutates("asset", "set_import_settings"),
 	set_material_params: idempotentMutates("fx", "set_material_params"),
 	set_metasound_graph: idempotentMutates("audio", "set_metasound_graph"),
+	set_crowd_settings: idempotentMutates("level", "set_crowd_settings", [
+		"crowd",
+		"avoidance",
+		"rvo",
+		"detour"
+	]),
 	set_montage_sections: idempotentMutates("anim", "set_montage_sections"),
+	set_nav_agents: idempotentMutates("level", "set_nav_agents", [
+		"navmesh",
+		"navigation",
+		"agent",
+		"radius"
+	]),
+	set_navmesh_settings: idempotentMutates("level", "set_navmesh_settings", [
+		"navmesh",
+		"navigation",
+		"recast",
+		"cell size"
+	]),
 	set_niagara_params: idempotentMutates("fx", "set_niagara_params"),
 	set_pin_default: idempotentMutates("blueprint", "set_pin_default"),
 	set_post_process_settings: idempotentMutates("fx", "set_post_process_settings"),
@@ -751,6 +841,12 @@ const TOOL_METADATA = {
 		"output",
 		"tail"
 	]),
+	test_reachability: readOnly("level", "test_reachability", [
+		"navmesh",
+		"navigation",
+		"reachable",
+		"sweep"
+	]),
 	toggle_show_flags: idempotentMutates("level", "toggle_show_flags"),
 	trace_state_tree: mutates("ai", "trace_state_tree", [
 		"pie",
@@ -760,6 +856,17 @@ const TOOL_METADATA = {
 	trigger_hot_reload: mutates("build", "start_hot_reload"),
 	trigger_live_compile: mutates("build", "start_live_compile", ["live coding", "recompile"]),
 	undo: mutates("core", "undo"),
+	validate_mass_entity_config: readOnly("ai", "validate_mass_entity_config", [
+		"mass",
+		"crowd",
+		"entity config",
+		"trait"
+	]),
+	update_state_tree_elements: mutates("ai", "update_state_tree_elements", [
+		"edit",
+		"rename",
+		"retarget"
+	]),
 	wait_for_job: readOnly("core", void 0, [
 		"poll",
 		"block",
@@ -1352,6 +1459,10 @@ const bridgeBlueprintNodeSchema = z.object({
 	nodeId: z.string(),
 	pinCount: z.number().int().min(0),
 	pins: z.array(bridgeBlueprintPinSchema),
+	position: z.object({
+		x: z.number().int(),
+		y: z.number().int()
+	}).optional(),
 	title: z.string()
 });
 const bridgeErrorResponseSchema = z.object({
@@ -2575,6 +2686,7 @@ 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_LAYOUT_GRAPH_REQUEST_TYPE = "layout_graph";
 const BRIDGE_GRAPH_PIN_VALUE_MAX_CHARS = 4096;
 const BRIDGE_GRAPH_NODE_POSITION_LIMIT = 1e6;
 const BRIDGE_GRAPH_NODE_KINDS = [
@@ -2592,6 +2704,10 @@ 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 graphNodePlacedPositionSchema = z.object({
+	x: z.number().int(),
+	y: z.number().int()
+});
 const bridgeListGraphNodesRequestSchema = z.object({
 	assetPath: assetPathSchema,
 	cursor: assetCursorSchema.optional(),
@@ -2604,6 +2720,7 @@ const bridgeListGraphNodesRequestSchema = z.object({
 });
 const bridgeAddGraphNodeRequestFieldsSchema = z.object({
 	assetPath: assetPathSchema,
+	autoLayout: z.boolean().optional(),
 	graphName: graphNameSchema,
 	nodeClass: assetPathSchema.optional(),
 	kind: graphNodeKindSchema,
@@ -2655,6 +2772,13 @@ const bridgeSetPinDefaultRequestSchema = z.object({
 	value: graphPinValueSchema,
 	version: z.literal(2)
 });
+const bridgeLayoutGraphRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	graphName: graphNameSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_LAYOUT_GRAPH_REQUEST_TYPE),
+	version: z.literal(2)
+});
 const bridgeListAvailableNodesRequestSchema = z.object({
 	assetPath: assetPathSchema,
 	cursor: assetCursorSchema.optional(),
@@ -2683,6 +2807,7 @@ const bridgeAddGraphNodeSuccessResponseSchema = z.object({
 	message: nonEmptyStringSchema.optional(),
 	node: bridgeBlueprintNodeSchema,
 	ok: z.literal(true),
+	position: graphNodePlacedPositionSchema.optional(),
 	requestId: requestIdSchema,
 	state: creativeEditStateSchema,
 	type: z.literal(BRIDGE_ADD_GRAPH_NODE_REQUEST_TYPE),
@@ -2758,6 +2883,20 @@ const bridgeListAvailableNodesSuccessResponseSchema = z.object({
 	type: z.literal(BRIDGE_LIST_AVAILABLE_NODES_REQUEST_TYPE),
 	version: z.literal(2)
 });
+const bridgeLayoutGraphSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	graphName: z.string(),
+	layerCount: z.number().int().min(0),
+	message: nonEmptyStringSchema.optional(),
+	movedCount: z.number().int().min(0),
+	nodeCount: z.number().int().min(0),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	skippedCount: z.number().int().min(0),
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_LAYOUT_GRAPH_REQUEST_TYPE),
+	version: z.literal(2)
+});
 const bridgeListGraphNodesResponseSchema = z.union([bridgeListGraphNodesSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeAddGraphNodeResponseSchema = z.union([bridgeAddGraphNodeSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeRemoveGraphNodeResponseSchema = z.union([bridgeRemoveGraphNodeSuccessResponseSchema, bridgeErrorResponseSchema]);
@@ -2765,6 +2904,7 @@ const bridgeConnectPinsResponseSchema = z.union([bridgeConnectPinsSuccessRespons
 const bridgeDisconnectPinsResponseSchema = z.union([bridgeDisconnectPinsSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeSetPinDefaultResponseSchema = z.union([bridgeSetPinDefaultSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeListAvailableNodesResponseSchema = z.union([bridgeListAvailableNodesSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeLayoutGraphResponseSchema = z.union([bridgeLayoutGraphSuccessResponseSchema, bridgeErrorResponseSchema]);
 function createBridgeListGraphNodesRequest(assetPath, graphName, options = {}, requestId = randomUUID()) {
 	return bridgeListGraphNodesRequestSchema.parse({
 		assetPath,
@@ -2780,6 +2920,7 @@ function createBridgeListGraphNodesRequest(assetPath, graphName, options = {}, r
 function createBridgeAddGraphNodeRequest(assetPath, graphName, kind, options = {}, requestId = randomUUID()) {
 	return bridgeAddGraphNodeRequestSchema.parse({
 		assetPath,
+		autoLayout: options.autoLayout,
 		graphName,
 		kind,
 		memberName: options.memberName,
@@ -2852,6 +2993,15 @@ function createBridgeListAvailableNodesRequest(assetPath, graphName, options = {
 		version: 2
 	});
 }
+function createBridgeLayoutGraphRequest(assetPath, graphName, requestId = randomUUID()) {
+	return bridgeLayoutGraphRequestSchema.parse({
+		assetPath,
+		graphName,
+		requestId,
+		type: BRIDGE_LAYOUT_GRAPH_REQUEST_TYPE,
+		version: 2
+	});
+}
 //#endregion
 //#region src/protocol/debugger.ts
 const BRIDGE_SET_BLUEPRINT_BREAKPOINT_REQUEST_TYPE = "set_blueprint_breakpoint";
@@ -3300,11 +3450,11 @@ const createClassJobIdSchema = z.string().trim().min(1);
 const classNameSchema = z.string().trim().min(1).max(128).regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
 const parentClassSchema = z.string().trim().min(1).max(128);
 const moduleNameSchema = z.string().trim().min(1).max(128);
-const classPathSchema = z.string().trim().min(1).max(512);
+const classPathSchema$1 = z.string().trim().min(1).max(512);
 const sourceFilePathSchema = z.string().trim().min(1);
 const bridgeCreateCppClassRequestSchema = z.object({
 	className: classNameSchema,
-	classPath: classPathSchema.optional(),
+	classPath: classPathSchema$1.optional(),
 	moduleName: moduleNameSchema.optional(),
 	parentClass: parentClassSchema,
 	requestId: requestIdSchema,
@@ -7392,6 +7542,7 @@ const bridgeStateTreeNodeReportSchema = z.object({
 const bridgeStateTreeTransitionReportSchema = z.object({
 	eventTag: z.string().optional(),
 	id: z.string(),
+	targetStateId: z.string().optional(),
 	targetStateName: z.string().optional(),
 	targetType: z.string(),
 	trigger: z.string()
@@ -7639,6 +7790,141 @@ function createBridgeTraceStateTreeRequest(action, options = {}, requestId = ran
 		version: 2
 	});
 }
+const BRIDGE_UPDATE_STATE_TREE_ELEMENTS_REQUEST_TYPE = "update_state_tree_elements";
+const BRIDGE_REMOVE_STATE_TREE_ELEMENTS_REQUEST_TYPE = "remove_state_tree_elements";
+const BRIDGE_STATE_TREE_ELEMENT_KINDS = [
+	"state",
+	"task",
+	"transition"
+];
+const BRIDGE_STATE_TREE_EDITABLE_STATE_TYPES = [
+	"state",
+	"group",
+	"subtree"
+];
+const BRIDGE_STATE_TREE_TRANSITION_TARGET_TYPES = [
+	"none",
+	"succeeded",
+	"failed",
+	"next_state",
+	"goto_state"
+];
+const stateTreeElementIdSchema = z.string().trim().regex(/^[{(]?[0-9A-Fa-f]{8}-?[0-9A-Fa-f]{4}-?[0-9A-Fa-f]{4}-?[0-9A-Fa-f]{4}-?[0-9A-Fa-f]{12}[)}]?$/);
+const stateTreeElementKindSchema = z.enum(BRIDGE_STATE_TREE_ELEMENT_KINDS);
+const stateTreeEditableStateTypeSchema = z.enum(BRIDGE_STATE_TREE_EDITABLE_STATE_TYPES);
+const stateTreeTransitionTargetTypeSchema = z.enum(BRIDGE_STATE_TREE_TRANSITION_TARGET_TYPES);
+const stateTreeEditableTriggerSchema = z.enum(BRIDGE_STATE_TREE_TRANSITION_TRIGGERS);
+const bridgeStateTreeElementUpdateSchema = z.discriminatedUnion("kind", [
+	z.object({
+		enabled: z.boolean().optional(),
+		id: stateTreeElementIdSchema,
+		kind: z.literal("state"),
+		name: userTypeIdentifierSchema.optional(),
+		selectionBehavior: stateTreeSelectionBehaviorSchema.optional(),
+		stateType: stateTreeEditableStateTypeSchema.optional()
+	}),
+	z.object({
+		id: stateTreeElementIdSchema,
+		kind: z.literal("task"),
+		params: eqsParamsSchema
+	}),
+	z.object({
+		enabled: z.boolean().optional(),
+		eventTag: boundedStringSchema.optional(),
+		id: stateTreeElementIdSchema,
+		kind: z.literal("transition"),
+		targetStateId: stateTreeElementIdSchema.optional(),
+		targetType: stateTreeTransitionTargetTypeSchema.optional(),
+		trigger: stateTreeEditableTriggerSchema.optional()
+	})
+]).superRefine((update, ctx) => {
+	if (update.kind === "task") {
+		if (Object.keys(update.params).length === 0) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "A task update must set at least one param.",
+			path: ["params"]
+		});
+		return;
+	}
+	const { id: _id, kind: _kind, ...fields } = update;
+	if (Object.values(fields).every((value) => value === void 0)) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: `A ${update.kind} update must change at least one field.`
+	});
+	if (update.kind !== "transition") return;
+	if (update.targetType === "goto_state" && update.targetStateId === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "A 'goto_state' transition must name its targetStateId.",
+		path: ["targetStateId"]
+	});
+	if (update.targetStateId !== void 0 && update.targetType !== void 0 && update.targetType !== "goto_state") ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "Only a 'goto_state' transition names a targetStateId.",
+		path: ["targetStateId"]
+	});
+});
+const bridgeUpdateStateTreeElementsRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	compile: z.boolean().default(true),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_UPDATE_STATE_TREE_ELEMENTS_REQUEST_TYPE),
+	updates: z.array(bridgeStateTreeElementUpdateSchema).min(1).max(32),
+	version: z.literal(2)
+});
+const bridgeUpdateStateTreeElementsSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	compileMessages: z.array(z.string()).max(25),
+	compiled: z.boolean(),
+	type: z.literal(BRIDGE_UPDATE_STATE_TREE_ELEMENTS_REQUEST_TYPE)
+});
+const bridgeStateTreeElementRemovalSchema = z.object({
+	id: stateTreeElementIdSchema,
+	kind: stateTreeElementKindSchema
+});
+const bridgeRemoveStateTreeElementsRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	compile: z.boolean().default(true),
+	removals: z.array(bridgeStateTreeElementRemovalSchema).min(1).max(32),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_REMOVE_STATE_TREE_ELEMENTS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeStateTreeRemovedTransitionSchema = z.object({
+	id: z.string(),
+	ownerStateId: z.string(),
+	ownerStateName: z.string(),
+	targetStateName: z.string()
+});
+const bridgeRemoveStateTreeElementsSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	compileMessages: z.array(z.string()).max(25),
+	compiled: z.boolean(),
+	removedTransitionCount: z.number().int().min(0),
+	removedTransitions: z.array(bridgeStateTreeRemovedTransitionSchema).max(128),
+	type: z.literal(BRIDGE_REMOVE_STATE_TREE_ELEMENTS_REQUEST_TYPE)
+});
+const bridgeUpdateStateTreeElementsResponseSchema = z.union([bridgeUpdateStateTreeElementsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeRemoveStateTreeElementsResponseSchema = z.union([bridgeRemoveStateTreeElementsSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeUpdateStateTreeElementsRequest(assetPath, updates, options = {}, requestId = randomUUID()) {
+	return bridgeUpdateStateTreeElementsRequestSchema.parse({
+		assetPath,
+		compile: options.compile,
+		requestId,
+		type: BRIDGE_UPDATE_STATE_TREE_ELEMENTS_REQUEST_TYPE,
+		updates,
+		version: 2
+	});
+}
+function createBridgeRemoveStateTreeElementsRequest(assetPath, removals, options = {}, requestId = randomUUID()) {
+	return bridgeRemoveStateTreeElementsRequestSchema.parse({
+		assetPath,
+		compile: options.compile,
+		removals,
+		requestId,
+		type: BRIDGE_REMOVE_STATE_TREE_ELEMENTS_REQUEST_TYPE,
+		version: 2
+	});
+}
 //#endregion
 //#region src/protocol/perception.ts
 const BRIDGE_CREATE_AI_CONTROLLER_REQUEST_TYPE = "create_ai_controller";
@@ -10461,30 +10747,871 @@ function createBridgeSetProjectSettingsRequest(options = {}, requestId = randomU
 	return bridgeSetProjectSettingsRequestSchema.parse({
 		properties: options.properties,
 		requestId,
-		sectionName: options.sectionName,
-		type: BRIDGE_SET_PROJECT_SETTINGS_REQUEST_TYPE,
+		sectionName: options.sectionName,
+		type: BRIDGE_SET_PROJECT_SETTINGS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSetDefaultGamemodeRequest(scope, gameModePath, options = {}, requestId = randomUUID()) {
+	return bridgeSetDefaultGamemodeRequestSchema.parse({
+		defaultPawnClassPath: options.defaultPawnClassPath,
+		gameModePath,
+		gameStateClassPath: options.gameStateClassPath,
+		hudClassPath: options.hudClassPath,
+		levelPath: options.levelPath,
+		playerControllerClassPath: options.playerControllerClassPath,
+		playerStateClassPath: options.playerStateClassPath,
+		requestId,
+		scope,
+		startupMapPath: options.startupMapPath,
+		type: BRIDGE_SET_DEFAULT_GAMEMODE_REQUEST_TYPE,
+		version: 2
+	});
+}
+//#endregion
+//#region src/protocol/navigation.ts
+const classPathSchema = z.string().trim().min(1).max(512);
+const BRIDGE_SET_NAVMESH_SETTINGS_REQUEST_TYPE = "set_navmesh_settings";
+const BRIDGE_SET_NAV_AGENTS_REQUEST_TYPE = "set_nav_agents";
+const BRIDGE_SET_CROWD_SETTINGS_REQUEST_TYPE = "set_crowd_settings";
+const BRIDGE_CREATE_NAV_AREA_REQUEST_TYPE = "create_nav_area";
+const BRIDGE_ADD_NAV_MODIFIER_VOLUME_REQUEST_TYPE = "add_nav_modifier_volume";
+const BRIDGE_ADD_NAV_LINK_REQUEST_TYPE = "add_nav_link";
+const BRIDGE_FIND_PATH_REQUEST_TYPE = "find_path";
+const BRIDGE_TEST_REACHABILITY_REQUEST_TYPE = "test_reachability";
+const BRIDGE_NAV_RUNTIME_GENERATION_MODES = [
+	"static",
+	"dynamic_modifiers_only",
+	"dynamic"
+];
+const BRIDGE_NAV_DATA_RESOLUTIONS = [
+	"low",
+	"default",
+	"high"
+];
+const BRIDGE_NAV_LINK_DIRECTIONS = [
+	"both_ways",
+	"left_to_right",
+	"right_to_left"
+];
+const BRIDGE_NAV_QUERY_RESULTS = [
+	"invalid",
+	"error",
+	"fail",
+	"success"
+];
+const BRIDGE_NAV_QUERY_STATES = ["reported", "unsupported"];
+const BRIDGE_NAV_MAX_AGENT_SIZE = 1e5;
+const BRIDGE_NAV_MAX_CELL_SIZE = 1024;
+const BRIDGE_NAV_MAX_TILE_SIZE = 1e5;
+const BRIDGE_NAV_MAX_REGION_SIZE = 1e7;
+const BRIDGE_NAV_MAX_AREA_COST = 1e6;
+const navRuntimeGenerationSchema = z.enum(BRIDGE_NAV_RUNTIME_GENERATION_MODES);
+const navDataResolutionSchema = z.enum(BRIDGE_NAV_DATA_RESOLUTIONS);
+const navLinkDirectionSchema = z.enum(BRIDGE_NAV_LINK_DIRECTIONS);
+const navQueryResultSchema = z.enum(BRIDGE_NAV_QUERY_RESULTS);
+const navQueryStateSchema = z.enum(BRIDGE_NAV_QUERY_STATES);
+const navPointSchema = z.object({
+	x: z.number(),
+	y: z.number(),
+	z: z.number()
+});
+const navAgentSizeSchema = z.number().min(0).max(BRIDGE_NAV_MAX_AGENT_SIZE);
+const navCellSchema = z.number().min(1).max(BRIDGE_NAV_MAX_CELL_SIZE);
+const navRegionSizeSchema = z.number().min(0).max(BRIDGE_NAV_MAX_REGION_SIZE);
+const navAreaCostSchema = z.number().min(0).max(BRIDGE_NAV_MAX_AREA_COST);
+const navStepHeightSchema = z.number().min(0).max(1e4);
+const navColorChannelSchema = z.number().int().min(0).max(255);
+const navColorSchema = z.object({
+	a: navColorChannelSchema.default(255),
+	b: navColorChannelSchema,
+	g: navColorChannelSchema,
+	r: navColorChannelSchema
+});
+const navColorResponseSchema = z.object({
+	a: navColorChannelSchema,
+	b: navColorChannelSchema,
+	g: navColorChannelSchema,
+	r: navColorChannelSchema
+});
+const navExtentSchema = z.object({
+	x: z.number().positive().default(200),
+	y: z.number().positive().default(200),
+	z: z.number().positive().default(200)
+});
+const bridgeSetNavmeshSettingsRequestFieldsSchema = z.object({
+	agentHeight: navAgentSizeSchema.optional(),
+	agentMaxSlope: z.number().min(0).max(89).optional(),
+	agentMaxStepHeight: navStepHeightSchema.optional(),
+	agentRadius: navAgentSizeSchema.optional(),
+	cellHeight: navCellSchema.optional(),
+	cellSize: navCellSchema.optional(),
+	mergeRegionSize: navRegionSizeSchema.optional(),
+	minRegionArea: navRegionSizeSchema.optional(),
+	navMeshActorPath: actorPathSchema.optional(),
+	requestId: requestIdSchema,
+	resolution: navDataResolutionSchema.default("default"),
+	runtimeGeneration: navRuntimeGenerationSchema.optional(),
+	tileSizeUU: z.number().min(300).max(BRIDGE_NAV_MAX_TILE_SIZE).optional(),
+	type: z.literal(BRIDGE_SET_NAVMESH_SETTINGS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSetNavmeshSettingsRequestSchema = bridgeSetNavmeshSettingsRequestFieldsSchema.refine((request) => request.agentHeight !== void 0 || request.agentMaxSlope !== void 0 || request.agentMaxStepHeight !== void 0 || request.agentRadius !== void 0 || request.cellHeight !== void 0 || request.cellSize !== void 0 || request.mergeRegionSize !== void 0 || request.minRegionArea !== void 0 || request.runtimeGeneration !== void 0 || request.tileSizeUU !== void 0, { message: "A set_navmesh_settings request must carry at least one setting to write." });
+const bridgeNavAgentSchema = z.object({
+	height: navAgentSizeSchema,
+	maxStepHeight: navStepHeightSchema.optional(),
+	name: requiredBoundedStringSchema,
+	navDataClass: classPathSchema.optional(),
+	radius: navAgentSizeSchema
+});
+const bridgeSetNavAgentsRequestSchema = z.object({
+	agents: z.array(bridgeNavAgentSchema).min(1).max(16),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_SET_NAV_AGENTS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCrowdSettingsSchema = z.object({
+	maxAgentRadius: z.number().min(0).max(1e4).optional(),
+	maxAgents: z.number().int().min(1).max(1e4).optional(),
+	maxAvoidedAgents: z.number().int().min(0).max(64).optional(),
+	maxAvoidedWalls: z.number().int().min(0).max(64).optional(),
+	navmeshCheckInterval: z.number().min(0).max(60).optional(),
+	pathOffsetRadiusMultiplier: z.number().min(0).max(100).optional(),
+	pathOptimizationInterval: z.number().min(0).max(60).optional(),
+	resolveCollisions: z.boolean().optional(),
+	separationDirClamp: z.number().min(-1).max(1).optional()
+});
+const bridgeRvoSettingsSchema = z.object({
+	artificialRadiusExpansion: z.number().min(0).max(100).optional(),
+	defaultTimeToLive: z.number().min(0).max(600).optional(),
+	deltaTimeToPredict: z.number().min(0).max(60).optional(),
+	heightCheckMargin: z.number().min(0).max(1e3).optional(),
+	lockTimeAfterAvoid: z.number().min(0).max(60).optional(),
+	lockTimeAfterClean: z.number().min(0).max(60).optional()
+});
+const bridgeSetCrowdSettingsRequestFieldsSchema = z.object({
+	crowd: bridgeCrowdSettingsSchema.optional(),
+	requestId: requestIdSchema,
+	rvo: bridgeRvoSettingsSchema.optional(),
+	type: z.literal(BRIDGE_SET_CROWD_SETTINGS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSetCrowdSettingsRequestSchema = bridgeSetCrowdSettingsRequestFieldsSchema.refine((request) => Object.values(request.crowd ?? {}).some((value) => value !== void 0) || Object.values(request.rvo ?? {}).some((value) => value !== void 0), { message: "A set_crowd_settings request must carry at least one crowd or rvo setting." });
+const bridgeCreateNavAreaRequestSchema = z.object({
+	assetName: requiredBoundedStringSchema,
+	defaultCost: navAreaCostSchema.optional(),
+	drawColor: navColorSchema.optional(),
+	fixedAreaEnteringCost: navAreaCostSchema.optional(),
+	packagePath: requiredBoundedStringSchema,
+	parentClass: classPathSchema.default("NavArea"),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_CREATE_NAV_AREA_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddNavModifierVolumeRequestSchema = z.object({
+	actorLabel: boundedStringSchema.optional(),
+	areaClass: classPathSchema,
+	areaClassToReplace: classPathSchema.optional(),
+	extent: navExtentSchema.default({
+		x: 200,
+		y: 200,
+		z: 200
+	}),
+	folderPath: boundedStringSchema.optional(),
+	location: vectorInputSchema.default({
+		x: 0,
+		y: 0,
+		z: 0
+	}),
+	requestId: requestIdSchema,
+	rotation: rotatorInputSchema.default({
+		pitch: 0,
+		roll: 0,
+		yaw: 0
+	}),
+	type: z.literal(BRIDGE_ADD_NAV_MODIFIER_VOLUME_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeNavLinkSchema = z.object({
+	areaClass: classPathSchema.optional(),
+	description: boundedStringSchema.optional(),
+	direction: navLinkDirectionSchema.default("both_ways"),
+	left: vectorInputSchema.default({
+		x: 0,
+		y: -50,
+		z: 0
+	}),
+	leftProjectHeight: z.number().min(0).max(1e4).optional(),
+	maxFallDownLength: z.number().min(0).max(1e4).optional(),
+	right: vectorInputSchema.default({
+		x: 0,
+		y: 50,
+		z: 0
+	}),
+	snapHeight: z.number().min(1).max(1e4).optional(),
+	snapRadius: z.number().min(1).max(1e4).optional()
+});
+const bridgeAddNavLinkRequestSchema = z.object({
+	actorLabel: boundedStringSchema.optional(),
+	folderPath: boundedStringSchema.optional(),
+	links: z.array(bridgeNavLinkSchema).min(1).max(16),
+	location: vectorInputSchema.default({
+		x: 0,
+		y: 0,
+		z: 0
+	}),
+	requestId: requestIdSchema,
+	rotation: rotatorInputSchema.default({
+		pitch: 0,
+		roll: 0,
+		yaw: 0
+	}),
+	smartLinkEnabled: z.boolean().default(false),
+	type: z.literal(BRIDGE_ADD_NAV_LINK_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const navEndpointFields = {
+	end: navPointSchema.optional(),
+	endActorPath: actorPathSchema.optional(),
+	start: navPointSchema.optional(),
+	startActorPath: actorPathSchema.optional()
+};
+const addNavEndpointIssues = (endpoints, ctx, pathPrefix) => {
+	if (endpoints.start === void 0 === (endpoints.startActorPath === void 0)) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "Give exactly one of start or startActorPath.",
+		path: [...pathPrefix, "start"]
+	});
+	if (endpoints.end === void 0 === (endpoints.endActorPath === void 0)) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "Give exactly one of end or endActorPath.",
+		path: [...pathPrefix, "end"]
+	});
+};
+const bridgeFindPathRequestFieldsSchema = z.object({
+	...navEndpointFields,
+	allowPartial: z.boolean().default(true),
+	maxPathPoints: z.number().int().min(1).max(256).default(64),
+	navMeshActorPath: actorPathSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_FIND_PATH_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeFindPathRequestSchema = bridgeFindPathRequestFieldsSchema.superRefine((request, ctx) => {
+	addNavEndpointIssues(request, ctx, []);
+});
+const bridgeReachabilityPairSchema = z.object(navEndpointFields);
+const bridgeTestReachabilityRequestFieldsSchema = z.object({
+	allowPartial: z.boolean().default(false),
+	navMeshActorPath: actorPathSchema.optional(),
+	pairs: z.array(bridgeReachabilityPairSchema).min(1).max(64),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_TEST_REACHABILITY_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeTestReachabilityRequestSchema = bridgeTestReachabilityRequestFieldsSchema.superRefine((request, ctx) => {
+	request.pairs.forEach((pair, index) => {
+		addNavEndpointIssues(pair, ctx, ["pairs", index]);
+	});
+});
+const bridgeSetNavmeshSettingsSuccessResponseSchema = z.object({
+	agentHeight: z.number(),
+	agentMaxSlope: z.number(),
+	agentMaxStepHeight: z.number(),
+	agentRadius: z.number(),
+	appliedSettings: z.array(z.string()).max(32),
+	cellHeight: z.number(),
+	cellSize: z.number(),
+	mergeRegionSize: z.number(),
+	message: nonEmptyStringSchema.optional(),
+	minRegionArea: z.number(),
+	navMeshActorPath: z.string(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	rebuildRequired: z.boolean(),
+	requestId: requestIdSchema,
+	resolution: navDataResolutionSchema,
+	runtimeGeneration: navRuntimeGenerationSchema,
+	state: creativeEditStateSchema,
+	tileSizeUU: z.number(),
+	type: z.literal(BRIDGE_SET_NAVMESH_SETTINGS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSetNavAgentsSuccessResponseSchema = z.object({
+	agentCount: z.number().int().min(0),
+	agents: z.array(z.object({
+		height: z.number(),
+		name: z.string(),
+		radius: z.number()
+	})).max(16),
+	configFilePath: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	restartRequired: z.boolean(),
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_SET_NAV_AGENTS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSetCrowdSettingsSuccessResponseSchema = z.object({
+	appliedCount: z.number().int().min(0),
+	configFilePaths: z.array(z.string()).max(2),
+	failureCount: z.number().int().min(0),
+	items: z.array(bridgeAuthoringItemResultSchema).max(32),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	requestId: requestIdSchema,
+	restartRequired: z.boolean(),
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_SET_CROWD_SETTINGS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateNavAreaSuccessResponseSchema = z.object({
+	...createdUserAssetResponseFields,
+	defaultCost: z.number(),
+	drawColor: navColorResponseSchema,
+	fixedAreaEnteringCost: z.number(),
+	generatedClassPath: z.string(),
+	parentClass: z.string(),
+	type: z.literal(BRIDGE_CREATE_NAV_AREA_REQUEST_TYPE)
+});
+const bridgeAddNavModifierVolumeSuccessResponseSchema = z.object({
+	actorPath: z.string(),
+	areaClass: z.string(),
+	areaClassToReplace: z.string().optional(),
+	extent: navPointSchema,
+	location: navPointSchema,
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	rebuildRequired: z.boolean(),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_ADD_NAV_MODIFIER_VOLUME_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddNavLinkSuccessResponseSchema = z.object({
+	actorPath: z.string(),
+	linkCount: z.number().int().min(0),
+	links: z.array(z.object({
+		direction: navLinkDirectionSchema,
+		left: navPointSchema,
+		right: navPointSchema
+	})).max(16),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	rebuildRequired: z.boolean(),
+	requestId: requestIdSchema,
+	smartLinkEnabled: z.boolean(),
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_ADD_NAV_LINK_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeFindPathSuccessResponseSchema = z.object({
+	endLocation: navPointSchema,
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	partial: z.boolean(),
+	pathCost: z.number(),
+	pathLength: z.number(),
+	pathPointCount: z.number().int().min(0),
+	pathPoints: z.array(navPointSchema).max(256),
+	queryResult: navQueryResultSchema,
+	reachable: z.boolean(),
+	requestId: requestIdSchema,
+	startLocation: navPointSchema,
+	state: navQueryStateSchema,
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_FIND_PATH_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeTestReachabilitySuccessResponseSchema = z.object({
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	pairs: z.array(z.object({
+		error: z.string().optional(),
+		index: z.number().int().min(0),
+		partial: z.boolean(),
+		pathLength: z.number(),
+		reachable: z.boolean()
+	})).max(64),
+	reachableCount: z.number().int().min(0),
+	requestId: requestIdSchema,
+	state: navQueryStateSchema,
+	type: z.literal(BRIDGE_TEST_REACHABILITY_REQUEST_TYPE),
+	unreachableCount: z.number().int().min(0),
+	version: z.literal(2)
+});
+const bridgeSetNavmeshSettingsResponseSchema = z.union([bridgeSetNavmeshSettingsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetNavAgentsResponseSchema = z.union([bridgeSetNavAgentsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetCrowdSettingsResponseSchema = z.union([bridgeSetCrowdSettingsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCreateNavAreaResponseSchema = z.union([bridgeCreateNavAreaSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddNavModifierVolumeResponseSchema = z.union([bridgeAddNavModifierVolumeSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddNavLinkResponseSchema = z.union([bridgeAddNavLinkSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeFindPathResponseSchema = z.union([bridgeFindPathSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeTestReachabilityResponseSchema = z.union([bridgeTestReachabilitySuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeSetNavmeshSettingsRequest(options = {}, requestId = randomUUID()) {
+	return bridgeSetNavmeshSettingsRequestSchema.parse({
+		agentHeight: options.agentHeight,
+		agentMaxSlope: options.agentMaxSlope,
+		agentMaxStepHeight: options.agentMaxStepHeight,
+		agentRadius: options.agentRadius,
+		cellHeight: options.cellHeight,
+		cellSize: options.cellSize,
+		mergeRegionSize: options.mergeRegionSize,
+		minRegionArea: options.minRegionArea,
+		navMeshActorPath: options.navMeshActorPath,
+		requestId,
+		resolution: options.resolution,
+		runtimeGeneration: options.runtimeGeneration,
+		tileSizeUU: options.tileSizeUU,
+		type: BRIDGE_SET_NAVMESH_SETTINGS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSetNavAgentsRequest(agents, requestId = randomUUID()) {
+	return bridgeSetNavAgentsRequestSchema.parse({
+		agents,
+		requestId,
+		type: BRIDGE_SET_NAV_AGENTS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSetCrowdSettingsRequest(options = {}, requestId = randomUUID()) {
+	return bridgeSetCrowdSettingsRequestSchema.parse({
+		crowd: options.crowd,
+		requestId,
+		rvo: options.rvo,
+		type: BRIDGE_SET_CROWD_SETTINGS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCreateNavAreaRequest(assetName, packagePath, options = {}, requestId = randomUUID()) {
+	return bridgeCreateNavAreaRequestSchema.parse({
+		assetName,
+		defaultCost: options.defaultCost,
+		drawColor: options.drawColor,
+		fixedAreaEnteringCost: options.fixedAreaEnteringCost,
+		packagePath,
+		parentClass: options.parentClass,
+		requestId,
+		type: BRIDGE_CREATE_NAV_AREA_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddNavModifierVolumeRequest(areaClass, options = {}, requestId = randomUUID()) {
+	return bridgeAddNavModifierVolumeRequestSchema.parse({
+		actorLabel: options.actorLabel,
+		areaClass,
+		areaClassToReplace: options.areaClassToReplace,
+		extent: options.extent,
+		folderPath: options.folderPath,
+		location: options.location,
+		requestId,
+		rotation: options.rotation,
+		type: BRIDGE_ADD_NAV_MODIFIER_VOLUME_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddNavLinkRequest(links, options = {}, requestId = randomUUID()) {
+	return bridgeAddNavLinkRequestSchema.parse({
+		actorLabel: options.actorLabel,
+		folderPath: options.folderPath,
+		links,
+		location: options.location,
+		requestId,
+		rotation: options.rotation,
+		smartLinkEnabled: options.smartLinkEnabled,
+		type: BRIDGE_ADD_NAV_LINK_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeFindPathRequest(endpoints, options = {}, requestId = randomUUID()) {
+	return bridgeFindPathRequestSchema.parse({
+		allowPartial: options.allowPartial,
+		end: endpoints.end,
+		endActorPath: endpoints.endActorPath,
+		maxPathPoints: options.maxPathPoints,
+		navMeshActorPath: options.navMeshActorPath,
+		requestId,
+		start: endpoints.start,
+		startActorPath: endpoints.startActorPath,
+		type: BRIDGE_FIND_PATH_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeTestReachabilityRequest(pairs, options = {}, requestId = randomUUID()) {
+	return bridgeTestReachabilityRequestSchema.parse({
+		allowPartial: options.allowPartial,
+		navMeshActorPath: options.navMeshActorPath,
+		pairs,
+		requestId,
+		type: BRIDGE_TEST_REACHABILITY_REQUEST_TYPE,
+		version: 2
+	});
+}
+const BRIDGE_DIAGNOSE_NAVMESH_REQUEST_TYPE = "diagnose_navmesh";
+const BRIDGE_NAV_DIAGNOSTIC_ISSUE_CODES = [
+	"missing_nav_bounds",
+	"nav_bounds_empty",
+	"no_navigation_data",
+	"navmesh_empty",
+	"no_spawn_points",
+	"island_without_spawn",
+	"spawn_not_found",
+	"spawn_off_navmesh",
+	"spawn_unreachable"
+];
+const BRIDGE_NAV_SPAWN_POINT_KINDS = ["player_start", "actor"];
+const bridgeDiagnoseNavmeshRequestSchema = z.object({
+	includePlayerStarts: z.boolean().default(true),
+	maxIslands: z.number().int().min(1).max(64).default(16),
+	navMeshActorPath: actorPathSchema.optional(),
+	requestId: requestIdSchema,
+	spawnActorPaths: z.array(actorPathSchema).max(64).default([]),
+	type: z.literal(BRIDGE_DIAGNOSE_NAVMESH_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const navDiagnosticIslandSchema = z.object({
+	area: z.number().min(0),
+	bounds: z.object({
+		max: navPointSchema,
+		min: navPointSchema
+	}),
+	index: z.number().int().min(0),
+	polyCount: z.number().int().min(0),
+	spawnPointCount: z.number().int().min(0)
+});
+const navDiagnosticSpawnPointSchema = z.object({
+	actorPath: z.string(),
+	error: z.string().optional(),
+	islandIndex: z.number().int().min(0).optional(),
+	kind: z.enum(BRIDGE_NAV_SPAWN_POINT_KINDS),
+	location: navPointSchema,
+	onNavMesh: z.boolean(),
+	pathLength: z.number().optional(),
+	projectedLocation: navPointSchema.optional(),
+	reachableFromAnchor: z.boolean()
+});
+const navDiagnosticIssueSchema = z.object({
+	actorPath: z.string().optional(),
+	code: z.enum(BRIDGE_NAV_DIAGNOSTIC_ISSUE_CODES),
+	islandIndex: z.number().int().min(0).optional(),
+	message: z.string()
+});
+const bridgeDiagnoseNavmeshSuccessResponseSchema = z.object({
+	anchorActorPath: z.string().optional(),
+	healthy: z.boolean(),
+	islandCount: z.number().int().min(0),
+	islands: z.array(navDiagnosticIslandSchema).max(64),
+	islandsTruncated: z.boolean(),
+	issueCount: z.number().int().min(0),
+	issues: z.array(navDiagnosticIssueSchema).max(64),
+	issuesTruncated: z.boolean(),
+	message: nonEmptyStringSchema.optional(),
+	navBoundsVolumeCount: z.number().int().min(0),
+	navMeshActorPath: z.string(),
+	ok: z.literal(true),
+	polyCount: z.number().int().min(0),
+	requestId: requestIdSchema,
+	spawnPointCount: z.number().int().min(0),
+	spawnPoints: z.array(navDiagnosticSpawnPointSchema).max(64),
+	spawnPointsTruncated: z.boolean(),
+	state: navQueryStateSchema,
+	type: z.literal(BRIDGE_DIAGNOSE_NAVMESH_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeDiagnoseNavmeshResponseSchema = z.union([bridgeDiagnoseNavmeshSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeDiagnoseNavmeshRequest(options = {}, requestId = randomUUID()) {
+	return bridgeDiagnoseNavmeshRequestSchema.parse({
+		includePlayerStarts: options.includePlayerStarts,
+		maxIslands: options.maxIslands,
+		navMeshActorPath: options.navMeshActorPath,
+		requestId,
+		spawnActorPaths: options.spawnActorPaths,
+		type: BRIDGE_DIAGNOSE_NAVMESH_REQUEST_TYPE,
+		version: 2
+	});
+}
+//#endregion
+//#region src/protocol/smartObjects.ts
+const BRIDGE_CREATE_SMART_OBJECT_DEFINITION_REQUEST_TYPE = "create_smart_object_definition";
+const BRIDGE_GET_SMART_OBJECT_DEFINITION_REQUEST_TYPE = "get_smart_object_definition";
+const BRIDGE_ADD_SMART_OBJECT_COMPONENT_REQUEST_TYPE = "add_smart_object_component";
+const BRIDGE_SMART_OBJECT_COMPONENT_TARGETS = ["blueprint", "actor"];
+const bridgeSmartObjectBehaviorDefinitionSchema = z.object({
+	behaviorClass: assetPathSchema,
+	params: instancedObjectParamsSchema
+});
+const activityTagsSchema = z.array(gameplayTagNameSchema).max(16).default([]);
+const behaviorDefinitionsSchema = z.array(bridgeSmartObjectBehaviorDefinitionSchema).max(8).default([]);
+const bridgeSmartObjectSlotSchema = z.object({
+	activityTags: activityTagsSchema,
+	behaviorDefinitions: behaviorDefinitionsSchema,
+	enabled: z.boolean().default(true),
+	name: requiredBoundedStringSchema.optional(),
+	offset: bridgeVectorSchema.optional(),
+	rotation: bridgeRotatorSchema.optional()
+});
+const bridgeCreateSmartObjectDefinitionRequestSchema = z.object({
+	activityTags: activityTagsSchema,
+	assetName: assetNameSchema,
+	defaultBehaviorDefinitions: behaviorDefinitionsSchema,
+	packagePath: contentPathSchema,
+	requestId: requestIdSchema,
+	slots: z.array(bridgeSmartObjectSlotSchema).min(1).max(32),
+	type: z.literal(BRIDGE_CREATE_SMART_OBJECT_DEFINITION_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeGetSmartObjectDefinitionRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_SMART_OBJECT_DEFINITION_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddSmartObjectComponentRequestFieldsSchema = z.object({
+	actorPath: actorPathSchema.optional(),
+	blueprintPath: assetPathSchema.optional(),
+	componentName: requiredBoundedStringSchema.optional(),
+	definitionPath: assetPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_ADD_SMART_OBJECT_COMPONENT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddSmartObjectComponentRequestSchema = bridgeAddSmartObjectComponentRequestFieldsSchema.refine((request) => request.actorPath === void 0 !== (request.blueprintPath === void 0), {
+	message: "An add_smart_object_component request names exactly one of blueprintPath or actorPath.",
+	path: ["blueprintPath"]
+});
+const bridgeSmartObjectSlotReportSchema = z.object({
+	activityTags: z.array(z.string()).max(16),
+	behaviorDefinitions: z.array(z.string()).max(8),
+	enabled: z.boolean(),
+	index: z.number().int().min(0),
+	name: z.string(),
+	offset: bridgeVectorSchema,
+	rotation: bridgeRotatorSchema
+});
+const smartObjectDefinitionReportFields = {
+	activityTags: z.array(z.string()).max(16),
+	defaultBehaviorDefinitions: z.array(z.string()).max(8),
+	slots: z.array(bridgeSmartObjectSlotReportSchema).max(32),
+	valid: z.boolean(),
+	validationMessages: z.array(z.string()).max(32)
+};
+const bridgeCreateSmartObjectDefinitionSuccessResponseSchema = z.object({
+	...createdUserAssetResponseFields,
+	...smartObjectDefinitionReportFields,
+	type: z.literal(BRIDGE_CREATE_SMART_OBJECT_DEFINITION_REQUEST_TYPE)
+});
+const bridgeGetSmartObjectDefinitionSuccessResponseSchema = z.object({
+	...smartObjectDefinitionReportFields,
+	assetPath: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	state: aiReportStateSchema,
+	type: z.literal(BRIDGE_GET_SMART_OBJECT_DEFINITION_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddSmartObjectComponentSuccessResponseSchema = z.object({
+	componentName: z.string(),
+	created: z.boolean(),
+	definitionPath: z.string(),
+	definitionValid: z.boolean(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	target: z.enum(BRIDGE_SMART_OBJECT_COMPONENT_TARGETS),
+	targetPath: z.string(),
+	type: z.literal(BRIDGE_ADD_SMART_OBJECT_COMPONENT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateSmartObjectDefinitionResponseSchema = z.union([bridgeCreateSmartObjectDefinitionSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetSmartObjectDefinitionResponseSchema = z.union([bridgeGetSmartObjectDefinitionSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddSmartObjectComponentResponseSchema = z.union([bridgeAddSmartObjectComponentSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeCreateSmartObjectDefinitionRequest(assetName, packagePath, slots, options = {}, requestId = randomUUID()) {
+	return bridgeCreateSmartObjectDefinitionRequestSchema.parse({
+		activityTags: options.activityTags,
+		assetName,
+		defaultBehaviorDefinitions: options.defaultBehaviorDefinitions,
+		packagePath,
+		requestId,
+		slots,
+		type: BRIDGE_CREATE_SMART_OBJECT_DEFINITION_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeGetSmartObjectDefinitionRequest(assetPath, requestId = randomUUID()) {
+	return bridgeGetSmartObjectDefinitionRequestSchema.parse({
+		assetPath,
+		requestId,
+		type: BRIDGE_GET_SMART_OBJECT_DEFINITION_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddSmartObjectComponentRequest(definitionPath, target, options = {}, requestId = randomUUID()) {
+	return bridgeAddSmartObjectComponentRequestSchema.parse({
+		actorPath: target.actorPath,
+		blueprintPath: target.blueprintPath,
+		componentName: options.componentName,
+		definitionPath,
+		requestId,
+		type: BRIDGE_ADD_SMART_OBJECT_COMPONENT_REQUEST_TYPE,
+		version: 2
+	});
+}
+//#endregion
+//#region src/protocol/mass.ts
+const BRIDGE_CREATE_MASS_ENTITY_CONFIG_REQUEST_TYPE = "create_mass_entity_config";
+const BRIDGE_EDIT_MASS_ENTITY_CONFIG_REQUEST_TYPE = "edit_mass_entity_config";
+const BRIDGE_GET_MASS_ENTITY_CONFIG_REQUEST_TYPE = "get_mass_entity_config";
+const BRIDGE_VALIDATE_MASS_ENTITY_CONFIG_REQUEST_TYPE = "validate_mass_entity_config";
+const BRIDGE_MASS_TRAIT_OPERATIONS = [
+	"add",
+	"remove",
+	"set"
+];
+const BRIDGE_MASS_READ_STATES = ["reported", "unsupported"];
+const BRIDGE_MASS_VALIDATION_SEVERITIES = ["error", "warning"];
+const massReadStateSchema = z.enum(BRIDGE_MASS_READ_STATES);
+const traitClassSchema = z.string().trim().min(1).max(512);
+const bridgeMassTraitEditSchema = z.object({
+	operation: z.enum(BRIDGE_MASS_TRAIT_OPERATIONS),
+	properties: z.array(bridgeAssetPropertyEntrySchema).max(32).optional(),
+	traitClass: traitClassSchema
+}).superRefine((edit, context) => {
+	const count = edit.properties?.length ?? 0;
+	if (edit.operation === "set" && count === 0) context.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "A 'set' trait edit must carry at least one property.",
+		path: ["properties"]
+	});
+	if (edit.operation === "remove" && count > 0) context.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "A 'remove' trait edit cannot carry properties.",
+		path: ["properties"]
+	});
+});
+const bridgeCreateMassEntityConfigRequestSchema = z.object({
+	assetName: assetNameSchema,
+	packagePath: contentPathSchema,
+	parentConfigPath: assetPathSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_CREATE_MASS_ENTITY_CONFIG_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeEditMassEntityConfigRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	edits: z.array(bridgeMassTraitEditSchema).min(1).max(16),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_EDIT_MASS_ENTITY_CONFIG_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeGetMassEntityConfigRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_MASS_ENTITY_CONFIG_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeValidateMassEntityConfigRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_VALIDATE_MASS_ENTITY_CONFIG_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateMassEntityConfigSuccessResponseSchema = z.object({
+	...createdUserAssetResponseFields,
+	parentConfigPath: z.string().optional(),
+	type: z.literal(BRIDGE_CREATE_MASS_ENTITY_CONFIG_REQUEST_TYPE)
+});
+const bridgeEditMassEntityConfigSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	traits: z.array(z.string()).max(64),
+	type: z.literal(BRIDGE_EDIT_MASS_ENTITY_CONFIG_REQUEST_TYPE)
+});
+const bridgeMassTraitReportSchema = z.object({
+	index: z.number().int().min(0),
+	properties: z.record(z.string(), z.string()),
+	traitClass: z.string(),
+	traitName: z.string()
+});
+const bridgeGetMassEntityConfigSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	parentConfigPath: z.string().optional(),
+	requestId: requestIdSchema,
+	state: massReadStateSchema,
+	traits: z.array(bridgeMassTraitReportSchema).max(64),
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_GET_MASS_ENTITY_CONFIG_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeMassValidationMessageSchema = z.object({
+	category: z.string(),
+	severity: z.enum(BRIDGE_MASS_VALIDATION_SEVERITIES),
+	text: z.string()
+});
+const bridgeValidateMassEntityConfigSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	errorCount: z.number().int().min(0),
+	message: nonEmptyStringSchema.optional(),
+	messages: z.array(bridgeMassValidationMessageSchema).max(32),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	state: massReadStateSchema,
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_VALIDATE_MASS_ENTITY_CONFIG_REQUEST_TYPE),
+	valid: z.boolean(),
+	version: z.literal(2),
+	warningCount: z.number().int().min(0)
+});
+const bridgeCreateMassEntityConfigResponseSchema = z.union([bridgeCreateMassEntityConfigSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeEditMassEntityConfigResponseSchema = z.union([bridgeEditMassEntityConfigSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetMassEntityConfigResponseSchema = z.union([bridgeGetMassEntityConfigSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeValidateMassEntityConfigResponseSchema = z.union([bridgeValidateMassEntityConfigSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeCreateMassEntityConfigRequest(assetName, packagePath, options = {}, requestId = randomUUID()) {
+	return bridgeCreateMassEntityConfigRequestSchema.parse({
+		assetName,
+		packagePath,
+		parentConfigPath: options.parentConfigPath,
+		requestId,
+		type: BRIDGE_CREATE_MASS_ENTITY_CONFIG_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeEditMassEntityConfigRequest(assetPath, edits, requestId = randomUUID()) {
+	return bridgeEditMassEntityConfigRequestSchema.parse({
+		assetPath,
+		edits,
+		requestId,
+		type: BRIDGE_EDIT_MASS_ENTITY_CONFIG_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeGetMassEntityConfigRequest(assetPath, requestId = randomUUID()) {
+	return bridgeGetMassEntityConfigRequestSchema.parse({
+		assetPath,
+		requestId,
+		type: BRIDGE_GET_MASS_ENTITY_CONFIG_REQUEST_TYPE,
 		version: 2
 	});
 }
-function createBridgeSetDefaultGamemodeRequest(scope, gameModePath, options = {}, requestId = randomUUID()) {
-	return bridgeSetDefaultGamemodeRequestSchema.parse({
-		defaultPawnClassPath: options.defaultPawnClassPath,
-		gameModePath,
-		gameStateClassPath: options.gameStateClassPath,
-		hudClassPath: options.hudClassPath,
-		levelPath: options.levelPath,
-		playerControllerClassPath: options.playerControllerClassPath,
-		playerStateClassPath: options.playerStateClassPath,
+function createBridgeValidateMassEntityConfigRequest(assetPath, requestId = randomUUID()) {
+	return bridgeValidateMassEntityConfigRequestSchema.parse({
+		assetPath,
 		requestId,
-		scope,
-		startupMapPath: options.startupMapPath,
-		type: BRIDGE_SET_DEFAULT_GAMEMODE_REQUEST_TYPE,
+		type: BRIDGE_VALIDATE_MASS_ENTITY_CONFIG_REQUEST_TYPE,
 		version: 2
 	});
 }
 //#endregion
 //#region src/version.ts
-const SERVER_VERSION = "1.10.0";
+const SERVER_VERSION = "1.12.0";
 //#endregion
 //#region src/bridgeSocketClient.ts
 var BridgeSocketError = class extends Error {
@@ -10720,6 +11847,9 @@ async function sendBridgeSetPinDefaultRequest(request, options) {
 async function sendBridgeListAvailableNodesRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeListAvailableNodesResponseSchema, request.requestId);
 }
+async function sendBridgeLayoutGraphRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeLayoutGraphResponseSchema, request.requestId);
+}
 async function sendBridgeSetViewportCameraRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetViewportCameraResponseSchema, request.requestId);
 }
@@ -11416,6 +12546,60 @@ async function sendBridgeSetStateTreeGlobalsRequest(request, options) {
 async function sendBridgeTraceStateTreeRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeTraceStateTreeResponseSchema, request.requestId);
 }
+async function sendBridgeSetNavmeshSettingsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetNavmeshSettingsResponseSchema, request.requestId);
+}
+async function sendBridgeSetNavAgentsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetNavAgentsResponseSchema, request.requestId);
+}
+async function sendBridgeSetCrowdSettingsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetCrowdSettingsResponseSchema, request.requestId);
+}
+async function sendBridgeCreateNavAreaRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateNavAreaResponseSchema, request.requestId);
+}
+async function sendBridgeAddNavModifierVolumeRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddNavModifierVolumeResponseSchema, request.requestId);
+}
+async function sendBridgeAddNavLinkRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddNavLinkResponseSchema, request.requestId);
+}
+async function sendBridgeFindPathRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeFindPathResponseSchema, request.requestId);
+}
+async function sendBridgeTestReachabilityRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeTestReachabilityResponseSchema, request.requestId);
+}
+async function sendBridgeCreateSmartObjectDefinitionRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateSmartObjectDefinitionResponseSchema, request.requestId);
+}
+async function sendBridgeGetSmartObjectDefinitionRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetSmartObjectDefinitionResponseSchema, request.requestId);
+}
+async function sendBridgeAddSmartObjectComponentRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddSmartObjectComponentResponseSchema, request.requestId);
+}
+async function sendBridgeCreateMassEntityConfigRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateMassEntityConfigResponseSchema, request.requestId);
+}
+async function sendBridgeEditMassEntityConfigRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeEditMassEntityConfigResponseSchema, request.requestId);
+}
+async function sendBridgeGetMassEntityConfigRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetMassEntityConfigResponseSchema, request.requestId);
+}
+async function sendBridgeValidateMassEntityConfigRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeValidateMassEntityConfigResponseSchema, request.requestId);
+}
+async function sendBridgeDiagnoseNavmeshRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeDiagnoseNavmeshResponseSchema, request.requestId);
+}
+async function sendBridgeUpdateStateTreeElementsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeUpdateStateTreeElementsResponseSchema, request.requestId);
+}
+async function sendBridgeRemoveStateTreeElementsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeRemoveStateTreeElementsResponseSchema, request.requestId);
+}
 //#endregion
 //#region src/enginePing.ts
 async function pingRegistryEntry$1(entry, options) {
@@ -18242,6 +19426,7 @@ const debuggerToolDomain = {
 };
 //#endregion
 //#region src/traceAnalysis.ts
+const LLM_TAG_COUNTER_PATTERN = "STAT_*LLM";
 const SECONDS_TO_MS = 1e3;
 const FRAME_ROOT_TIMER_NAMES = /* @__PURE__ */ new Set(["FEngineLoop::Tick"]);
 function parseCsvRows(text) {
@@ -18334,6 +19519,9 @@ function summarizeTimerStatistics(rows, maxScopes) {
 		if (count !== void 0) scope.count = count;
 		scopes.push(scope);
 	}
+	return rankScopes(scopes, maxScopes);
+}
+function rankScopes(scopes, maxScopes) {
 	const byInclusiveTime = [...scopes].sort((left, right) => right.inclusiveTimeMs - left.inclusiveTimeMs);
 	return {
 		byExclusiveTime: [...scopes].sort((left, right) => right.exclusiveTimeMs - left.exclusiveTimeMs).slice(0, maxScopes),
@@ -18345,18 +19533,20 @@ function summarizeTimerStatistics(rows, maxScopes) {
 function isGpuThread(threadName) {
 	return threadName.toUpperCase().includes("GPU");
 }
-async function summarizeTimingEventStream(lines, options) {
+async function forEachTimingEvent(lines, visit) {
 	let headers;
 	let threadIndex = -1;
 	let timerIndex = -1;
 	let durationIndex = -1;
 	let startIndex = -1;
 	let depthIndex = -1;
-	let cpuTimeMs = 0;
-	let gpuTimeMs = 0;
-	const frameDurationsMs = [];
-	const worstHitches = [];
-	let hitchCount = 0;
+	const event = {
+		depth: 0,
+		durationMs: 0,
+		startTimeMs: 0,
+		threadName: "",
+		timerName: ""
+	};
 	for await (const rawLine of lines) {
 		const line = rawLine.trim();
 		if (line.length === 0) continue;
@@ -18369,36 +19559,160 @@ async function summarizeTimingEventStream(lines, options) {
 			durationIndex = columnIndex(headers, findColumn(headerRow, "Duration", "InclusiveTime"));
 			startIndex = columnIndex(headers, findColumn(headerRow, "StartTime", "Start"));
 			depthIndex = columnIndex(headers, findColumn(headerRow, "Depth"));
-			if (threadIndex < 0 || durationIndex < 0) break;
+			if (threadIndex < 0 || durationIndex < 0) return;
 			continue;
 		}
 		const duration = readNumber(values[durationIndex]);
 		const threadName = values[threadIndex];
 		if (duration === void 0 || threadName === void 0) continue;
-		if ((depthIndex < 0 ? 0 : readNumber(values[depthIndex]) ?? 0) !== 0) continue;
-		const durationMs = duration * SECONDS_TO_MS;
-		if (isGpuThread(threadName)) {
-			gpuTimeMs += durationMs;
-			continue;
+		event.depth = depthIndex < 0 ? 0 : readNumber(values[depthIndex]) ?? 0;
+		event.durationMs = duration * SECONDS_TO_MS;
+		event.startTimeMs = (startIndex < 0 ? 0 : readNumber(values[startIndex]) ?? 0) * SECONDS_TO_MS;
+		event.threadName = threadName;
+		event.timerName = timerIndex < 0 ? "" : values[timerIndex] ?? "";
+		visit(event);
+	}
+}
+var ScopeAncestry = class {
+	names = [];
+	threadName;
+	enter(event) {
+		if (event.threadName !== this.threadName) {
+			this.threadName = event.threadName;
+			this.names.length = 0;
+		}
+		this.names.length = Math.min(this.names.length, event.depth);
+		const parentName = event.depth > 0 ? this.names[event.depth - 1] : void 0;
+		this.names[event.depth] = event.timerName;
+		return parentName;
+	}
+	hasOpenAncestorNamed(event) {
+		return this.names.slice(0, event.depth).includes(event.timerName);
+	}
+};
+async function summarizeTimingEventStream(lines, options) {
+	let cpuTimeMs = 0;
+	let gpuTimeMs = 0;
+	const frameDurationsMs = [];
+	const worstHitches = [];
+	let hitchCount = 0;
+	const gpuScopeTotals = /* @__PURE__ */ new Map();
+	const gpuAncestry = new ScopeAncestry();
+	await forEachTimingEvent(lines, (event) => {
+		if (isGpuThread(event.threadName)) {
+			accumulateGpuScope(gpuScopeTotals, gpuAncestry, event);
+			if (event.depth === 0) gpuTimeMs += event.durationMs;
+			return;
 		}
-		cpuTimeMs += durationMs;
-		if (timerIndex < 0 || !FRAME_ROOT_TIMER_NAMES.has(values[timerIndex] ?? "")) continue;
-		frameDurationsMs.push(durationMs);
-		if (durationMs < options.hitchThresholdMs) continue;
+		if (event.depth !== 0) return;
+		cpuTimeMs += event.durationMs;
+		if (!FRAME_ROOT_TIMER_NAMES.has(event.timerName)) return;
+		frameDurationsMs.push(event.durationMs);
+		if (event.durationMs < options.hitchThresholdMs) return;
 		hitchCount += 1;
 		retainWorstHitch(worstHitches, options.maxHitches, {
-			durationMs,
-			startTimeMs: (startIndex < 0 ? 0 : readNumber(values[startIndex]) ?? 0) * SECONDS_TO_MS
+			durationMs: event.durationMs,
+			startTimeMs: event.startTimeMs,
+			topScopes: []
 		});
-	}
+	});
 	return {
 		frames: summarizeFrameDurations(frameDurationsMs, worstHitches, hitchCount, options),
+		gpuScopes: rankScopeTotals(gpuScopeTotals, options.maxScopes),
 		threads: {
 			cpuTimeMs,
 			gpuTimeMs
 		}
 	};
 }
+function accumulateGpuScope(totals, ancestry, event) {
+	const parentName = ancestry.enter(event);
+	const scope = scopeTotalsFor(totals, event.timerName);
+	scope.count += 1;
+	scope.exclusiveTimeMs += event.durationMs;
+	if (!ancestry.hasOpenAncestorNamed(event)) scope.inclusiveTimeMs += event.durationMs;
+	if (parentName !== void 0) scopeTotalsFor(totals, parentName).exclusiveTimeMs -= event.durationMs;
+}
+function scopeTotalsFor(totals, name) {
+	const existing = totals.get(name);
+	if (existing !== void 0) return existing;
+	const created = {
+		count: 0,
+		exclusiveTimeMs: 0,
+		inclusiveTimeMs: 0
+	};
+	totals.set(name, created);
+	return created;
+}
+function rankScopeTotals(totals, maxScopes) {
+	return rankScopes([...totals].map(([name, scope]) => ({
+		count: scope.count,
+		exclusiveTimeMs: scope.exclusiveTimeMs,
+		inclusiveTimeMs: scope.inclusiveTimeMs,
+		name
+	})), maxScopes);
+}
+const SCOPE_KEY_SEPARATOR = "\0";
+const IDLE_TIMER_NAMES = /* @__PURE__ */ new Set(["TaskWorkerIsLookingForWork", "WaitForTasks"]);
+async function attributeHitchScopes(lines, hitches, maxScopesPerHitch) {
+	if (hitches.length === 0) return [];
+	const windows = hitches.map((hitch) => ({
+		endTimeMs: hitch.startTimeMs + hitch.durationMs,
+		exclusiveByScope: /* @__PURE__ */ new Map(),
+		hitch,
+		startTimeMs: hitch.startTimeMs
+	})).sort((left, right) => left.startTimeMs - right.startTimeMs);
+	const ancestry = new ScopeAncestry();
+	await forEachTimingEvent(lines, (event) => {
+		if (isGpuThread(event.threadName)) return;
+		const parentName = ancestry.enter(event);
+		const eventEndMs = event.startTimeMs + event.durationMs;
+		for (let index = firstWindowEndingAfter(windows, event.startTimeMs); index < windows.length && (windows[index]?.startTimeMs ?? Number.POSITIVE_INFINITY) < eventEndMs; index += 1) {
+			const window = windows[index];
+			if (window === void 0) break;
+			const overlapMs = Math.min(eventEndMs, window.endTimeMs) - Math.max(event.startTimeMs, window.startTimeMs);
+			if (overlapMs <= 0) continue;
+			addScopeTime(window.exclusiveByScope, event.threadName, event.timerName, overlapMs);
+			if (parentName !== void 0) addScopeTime(window.exclusiveByScope, event.threadName, parentName, -overlapMs);
+		}
+	});
+	return hitches.map((hitch) => {
+		const window = windows.find((candidate) => candidate.hitch === hitch);
+		return {
+			...hitch,
+			topScopes: window === void 0 ? [] : topHitchScopes(window, maxScopesPerHitch)
+		};
+	});
+}
+function firstWindowEndingAfter(windows, timeMs) {
+	let low = 0;
+	let high = windows.length;
+	while (low < high) {
+		const middle = low + high >>> 1;
+		if ((windows[middle]?.endTimeMs ?? Number.POSITIVE_INFINITY) <= timeMs) low = middle + 1;
+		else high = middle;
+	}
+	return low;
+}
+function addScopeTime(exclusiveByScope, threadName, timerName, ms) {
+	const key = `${threadName}${SCOPE_KEY_SEPARATOR}${timerName}`;
+	exclusiveByScope.set(key, (exclusiveByScope.get(key) ?? 0) + ms);
+}
+function topHitchScopes(window, maxScopes) {
+	const scopes = [];
+	for (const [key, exclusiveTimeMs] of window.exclusiveByScope) {
+		if (exclusiveTimeMs <= 1e-6) continue;
+		const separatorAt = key.indexOf(SCOPE_KEY_SEPARATOR);
+		const name = key.slice(separatorAt + 1);
+		if (IDLE_TIMER_NAMES.has(name)) continue;
+		scopes.push({
+			exclusiveTimeMs,
+			name,
+			threadName: key.slice(0, separatorAt)
+		});
+	}
+	return scopes.sort((left, right) => right.exclusiveTimeMs - left.exclusiveTimeMs).slice(0, maxScopes);
+}
 function retainWorstHitch(worstHitches, maxHitches, hitch) {
 	if (worstHitches.length >= maxHitches) {
 		const weakest = worstHitches[worstHitches.length - 1];
@@ -18434,16 +19748,53 @@ function percentile(sortedValues, fraction) {
 	if (sortedValues.length === 0) return 0;
 	return sortedValues[Math.min(sortedValues.length - 1, Math.max(0, Math.ceil(fraction * sortedValues.length) - 1))] ?? 0;
 }
+function llmTagNameFromCounter(counterName) {
+	return counterName.replace(/^STAT_/u, "").replace(/LLM$/u, "");
+}
+async function summarizeMemoryTagCounter(name, lines) {
+	let valueIndex = -1;
+	let finalBytes;
+	let peakBytes = Number.NEGATIVE_INFINITY;
+	let sawHeader = false;
+	for await (const rawLine of lines) {
+		const line = rawLine.trim();
+		if (line.length === 0) continue;
+		const values = parseCsvLine(line);
+		if (!sawHeader) {
+			sawHeader = true;
+			valueIndex = values.findIndex((header) => header.toLowerCase() === "value");
+			if (valueIndex < 0) return;
+			continue;
+		}
+		const value = readNumber(values[valueIndex]);
+		if (value === void 0) continue;
+		finalBytes = value;
+		peakBytes = Math.max(peakBytes, value);
+	}
+	return finalBytes === void 0 ? void 0 : {
+		finalBytes,
+		name,
+		peakBytes
+	};
+}
+function rankMemoryTags(tags, maxTags) {
+	return {
+		tags: [...tags].sort((left, right) => right.peakBytes - left.peakBytes).slice(0, maxTags),
+		totalTagCount: tags.length,
+		truncated: tags.length > maxTags
+	};
+}
 //#endregion
 //#region src/tools/diagnostics.ts
 const ANALYZE_TRACE_DEFAULT_TIMEOUT_MS = 6e5;
 const ANALYZE_TRACE_DEFAULT_HITCH_THRESHOLD_MS = 33.4;
 const ANALYZE_TRACE_MAX_RESPONSE_BYTES = 32768;
+const LLM_COUNTER_FILE_PREFIX = "llm-";
 const analyzeTraceInputSchema = {
 	engineVersion: engineVersionSchema,
 	hitchThresholdMs: z.number().min(1).max(1e4).optional().describe(`Frame duration at or above which a frame counts as a hitch (default ${String(ANALYZE_TRACE_DEFAULT_HITCH_THRESHOLD_MS)}ms, about two frames at 60Hz).`),
 	maxHitches: z.number().int().min(1).max(50).optional().describe(`Maximum worst-hitch entries to return (default ${String(10)}, max ${String(50)}).`),
-	maxScopes: z.number().int().min(1).max(100).optional().describe(`Maximum timing scopes to return per ranking (default ${String(20)}, max ${String(100)}).`),
+	maxScopes: z.number().int().min(1).max(100).optional().describe(`Maximum timing scopes, GPU scopes and memory tags to return per ranking (default ${String(20)}, max ${String(100)}).`),
 	projectPath: z.string().trim().min(1).optional().describe("Project whose EngineAssociation selects the analyzer engine. Omit when engineVersion is given."),
 	timeoutMs: z.number().int().min(1e3).max(MAX_PROCESS_TIMEOUT_MS).optional().describe(`Hard timeout in milliseconds for the analyzer run (default ${String(ANALYZE_TRACE_DEFAULT_TIMEOUT_MS)}).`),
 	tracePath: z.string().trim().min(1).describe("Path to the .utrace file produced by stop_insights_trace.")
@@ -18459,8 +19810,10 @@ async function analyzeTrace(input, dependencies, context = createEngineToolchain
 		engineVersion: engine.engineVersion,
 		hitchThresholdMs,
 		hitches: [],
+		memoryTags: [],
 		reason: `UnrealInsights was not found under ${path.join(engine.engineRoot, "Engine", "Binaries")}; the installed UE ${engine.engineVersion} does not ship the trace analyzer for this host.`,
 		state: "unsupported",
+		topGpuScopes: [],
 		topScopesByExclusiveTime: [],
 		topScopesByInclusiveTime: [],
 		tracePath,
@@ -18472,7 +19825,11 @@ async function analyzeTrace(input, dependencies, context = createEngineToolchain
 	const timingEventsPath = path.join(exportDirectory, "timing-events.csv");
 	const commandFilePath = path.join(exportDirectory, "export.rsp");
 	try {
-		await context.writeFile(commandFilePath, [`TimingInsights.ExportTimerStatistics ${quoteConsoleArgument(timerStatisticsPath)}`, `TimingInsights.ExportTimingEvents ${quoteConsoleArgument(timingEventsPath)} -columns=ThreadName,TimerName,StartTime,Duration,Depth`].join("\n"));
+		await context.writeFile(commandFilePath, [
+			`TimingInsights.ExportTimerStatistics ${quoteConsoleArgument(timerStatisticsPath)}`,
+			`TimingInsights.ExportTimingEvents ${quoteConsoleArgument(timingEventsPath)} -columns=ThreadName,TimerName,StartTime,Duration,Depth`,
+			`TimingInsights.ExportCounterValues ${quoteConsoleArgument(path.join(exportDirectory, `${LLM_COUNTER_FILE_PREFIX}{counter}.csv`))} -counter=${LLM_TAG_COUNTER_PATTERN}`
+		].join("\n"));
 		dependencies.logger.info({
 			engineVersion: engine.engineVersion,
 			tracePath
@@ -18492,16 +19849,24 @@ async function analyzeTrace(input, dependencies, context = createEngineToolchain
 		});
 		if (run.timedOut) throw new EngineToolchainError(`Unreal Insights did not finish analyzing ${tracePath} within ${String(timeoutMs)}ms; raise timeoutMs or trim the trace.`);
 		if (run.exitCode !== 0) throw new EngineToolchainError(`Unreal Insights exited with code ${String(run.exitCode)} while analyzing ${tracePath}: ${run.combinedOutput.slice(-1e3).trim()}`);
-		const scopeSummaries = summarizeTimerStatistics(await readCsvRows(timerStatisticsPath, context), input.maxScopes ?? 20);
-		const timingEvents = await summarizeTimingEventStream(await context.fileExists(timingEventsPath) ? context.readTextLines(timingEventsPath) : emptyTextLines(), {
+		const maxScopes = input.maxScopes ?? 20;
+		const scopeSummaries = summarizeTimerStatistics(await readCsvRows(timerStatisticsPath, context), maxScopes);
+		const hasTimingEvents = await context.fileExists(timingEventsPath);
+		const readTimingEventLines = () => hasTimingEvents ? context.readTextLines(timingEventsPath) : emptyTextLines();
+		const timingEvents = await summarizeTimingEventStream(readTimingEventLines(), {
 			hitchThresholdMs,
-			maxHitches: input.maxHitches ?? 10
+			maxHitches: input.maxHitches ?? 10,
+			maxScopes
 		});
 		const frames = timingEvents.frames;
 		const threadTimes = timingEvents.threads;
+		const hitches = await attributeHitchScopes(readTimingEventLines(), frames.hitches, 5);
+		const memoryTags = await summarizeMemoryTags(exportDirectory, maxScopes, context);
 		const truncated = [];
 		if (scopeSummaries.truncated) truncated.push("topScopes");
 		if (frames.hitchesTruncated) truncated.push("hitches");
+		if (timingEvents.gpuScopes.truncated) truncated.push("topGpuScopes");
+		if (memoryTags.truncated) truncated.push("memoryTags");
 		const result = {
 			analyzerPath,
 			cpuTimeMs: threadTimes.cpuTimeMs,
@@ -18511,10 +19876,14 @@ async function analyzeTrace(input, dependencies, context = createEngineToolchain
 			frameCount: frames.frameCount,
 			gpuTimeMs: threadTimes.gpuTimeMs,
 			hitchThresholdMs,
-			hitches: frames.hitches,
+			hitches,
+			memoryTags: memoryTags.tags,
 			state: "analyzed",
+			topGpuScopes: timingEvents.gpuScopes.byExclusiveTime,
 			topScopesByExclusiveTime: scopeSummaries.byExclusiveTime,
 			topScopesByInclusiveTime: scopeSummaries.byInclusiveTime,
+			totalGpuScopeCount: timingEvents.gpuScopes.totalScopeCount,
+			totalMemoryTagCount: memoryTags.totalTagCount,
 			totalScopeCount: scopeSummaries.totalScopeCount,
 			tracePath,
 			truncated
@@ -18560,22 +19929,42 @@ function boundAnalyzeTraceResult(result) {
 		truncated: [...result.truncated]
 	};
 	while (JSON.stringify(bounded).length > ANALYZE_TRACE_MAX_RESPONSE_BYTES) {
-		const longestListLength = Math.max(bounded.topScopesByInclusiveTime.length, bounded.topScopesByExclusiveTime.length, bounded.hitches.length);
+		const topScopesLength = Math.max(bounded.topScopesByInclusiveTime.length, bounded.topScopesByExclusiveTime.length);
+		const longestListLength = Math.max(topScopesLength, bounded.hitches.length, bounded.topGpuScopes.length, bounded.memoryTags.length);
 		if (longestListLength <= 1) {
 			addTruncationReason(bounded, "responseBytesExceeded");
 			return bounded;
 		}
-		if (bounded.topScopesByInclusiveTime.length === longestListLength) {
+		if (topScopesLength === longestListLength) {
 			bounded.topScopesByInclusiveTime = bounded.topScopesByInclusiveTime.slice(0, longestListLength - 1);
 			bounded.topScopesByExclusiveTime = bounded.topScopesByExclusiveTime.slice(0, longestListLength - 1);
 			addTruncationReason(bounded, "topScopes");
 			continue;
 		}
+		if (bounded.topGpuScopes.length === longestListLength) {
+			bounded.topGpuScopes = bounded.topGpuScopes.slice(0, longestListLength - 1);
+			addTruncationReason(bounded, "topGpuScopes");
+			continue;
+		}
+		if (bounded.memoryTags.length === longestListLength) {
+			bounded.memoryTags = bounded.memoryTags.slice(0, longestListLength - 1);
+			addTruncationReason(bounded, "memoryTags");
+			continue;
+		}
 		bounded.hitches = bounded.hitches.slice(0, bounded.hitches.length - 1);
 		addTruncationReason(bounded, "hitches");
 	}
 	return bounded;
 }
+async function summarizeMemoryTags(exportDirectory, maxTags, context) {
+	const counterFiles = (await context.listDirectory(exportDirectory)).filter((fileName) => fileName.startsWith(LLM_COUNTER_FILE_PREFIX) && fileName.endsWith(".csv"));
+	const tags = [];
+	for (const fileName of counterFiles) {
+		const tag = await summarizeMemoryTagCounter(llmTagNameFromCounter(fileName.slice(4, -4)), context.readTextLines(path.join(exportDirectory, fileName)));
+		if (tag !== void 0) tags.push(tag);
+	}
+	return rankMemoryTags(tags, maxTags);
+}
 function addTruncationReason(result, reason) {
 	if (!result.truncated.includes(reason)) result.truncated.push(reason);
 }
@@ -18713,7 +20102,7 @@ function registerDiagnosticsTools(server, dependencies) {
 		}, 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.",
+		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 and each hitch's top 5 CPU scopes by exclusive time inside its window (with thread names, task-system idle waits left out), a CPU vs GPU time split, top-N timing scopes by inclusive and exclusive time, top-N GPU scopes by exclusive time, and LLM memory tags with their final and peak bytes. Memory tags are only present when the trace was captured with LLM enabled (-llm) and the stats channel. 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) => {
@@ -19554,6 +20943,7 @@ const listGraphNodesInputSchema = {
 };
 const addGraphNodeInputSchema = {
 	assetPath: bridgeAddGraphNodeRequestFieldsSchema.shape.assetPath.describe("Package name or object path of the asset owning the graph."),
+	autoLayout: bridgeAddGraphNodeRequestFieldsSchema.shape.autoLayout.describe("Move the new node clear of the graph's existing nodes. Starts from position when given (sliding down until it overlaps nothing), otherwise from just right of the graph's current nodes. Only the new node moves; call layout_graph to rearrange the whole 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'."),
@@ -19595,6 +20985,11 @@ const setPinDefaultInputSchema = {
 	projectId: creativeProjectIdSchema,
 	value: bridgeSetPinDefaultRequestSchema.shape.value.describe("ExportText value, the same format get_actor_details emits and set_actor_property accepts.")
 };
+const layoutGraphInputSchema = {
+	assetPath: bridgeLayoutGraphRequestSchema.shape.assetPath.describe("Package name or object path of the Blueprint owning the graph."),
+	graphName: bridgeLayoutGraphRequestSchema.shape.graphName.describe("Graph to arrange, as get_blueprint_summary reports it (e.g. 'EventGraph')."),
+	projectId: creativeProjectIdSchema
+};
 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."),
@@ -19612,6 +21007,7 @@ async function listGraphNodes(input, dependencies) {
 }
 async function addGraphNode(input, dependencies) {
 	return await exchangeCreativeRequest(createBridgeAddGraphNodeRequest(input.assetPath, input.graphName, input.kind, {
+		autoLayout: input.autoLayout,
 		memberName: input.memberName,
 		memberParentClass: input.memberParentClass,
 		nodeClass: input.nodeClass,
@@ -19650,6 +21046,9 @@ async function listAvailableNodes(input, dependencies) {
 		nameFilter: input.nameFilter
 	}), sendBridgeListAvailableNodesRequest, BRIDGE_LIST_AVAILABLE_NODES_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
 }
+async function layoutGraph(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeLayoutGraphRequest(input.assetPath, input.graphName), sendBridgeLayoutGraphRequest, BRIDGE_LAYOUT_GRAPH_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
 function registerGraphTools(server, dependencies) {
 	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.",
@@ -19666,12 +21065,13 @@ function registerGraphTools(server, dependencies) {
 		}, dependencies));
 	});
 	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.",
+		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. autoLayout moves only the new node clear of the existing ones and reports where it landed in position; layout_graph rearranges the whole graph. 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 }) => {
+	}, async ({ assetPath, autoLayout, graphName, kind, memberName, memberParentClass, nodeClass, pinDefaults, position, projectId }) => {
 		return toToolSuccess(await addGraphNode({
 			assetPath,
+			autoLayout,
 			graphName,
 			kind,
 			memberName,
@@ -19752,6 +21152,17 @@ function registerGraphTools(server, dependencies) {
 			projectId
 		}, dependencies));
 	});
+	server.registerTool("layout_graph", {
+		description: "Auto-arrange a Blueprint graph so no two nodes overlap: exec flow is layered left to right from each event, branches fan out downward, and pure (data) nodes sit in the column left of the node that consumes them. Comment boxes stay where they are. Node sizes are estimated from title and pin count, since an editor without the graph open has no rendered widget to measure. The whole rearrangement is one undo step. Use it after building a graph with add_graph_node; Material graphs are not supported.",
+		inputSchema: layoutGraphInputSchema,
+		title: "Layout Graph"
+	}, async ({ assetPath, graphName, projectId }) => {
+		return toToolSuccess(await layoutGraph({
+			assetPath,
+			graphName,
+			projectId
+		}, dependencies));
+	});
 }
 const graphToolDomain = {
 	domain: "graph",
@@ -19763,7 +21174,8 @@ const graphToolDomain = {
 		"connect_pins",
 		"disconnect_pins",
 		"set_pin_default",
-		"list_available_nodes"
+		"list_available_nodes",
+		"layout_graph"
 	]
 };
 //#endregion
@@ -22275,6 +23687,95 @@ const logsToolDomain = {
 	]
 };
 //#endregion
+//#region src/tools/mass.ts
+const MASS_TRAIT_HINT = "Traits are named by class: 'MassMovementTrait' or 'MassSimpleMovementTrait' (movement), 'MassLODCollectorTrait' or 'MassSimulationLODTrait' (LOD), 'MassVisualizationTrait' or 'MassMovableVisualizationTrait' (representation), 'MassStateTreeTrait' (StateTree behaviour, needs the MassAI plugin), or a '/Script/Module.Class' path.";
+const createMassEntityConfigInputSchema = {
+	assetName: bridgeCreateMassEntityConfigRequestSchema.shape.assetName.describe("Name of the new MassEntityConfig asset, e.g. 'DA_CrowdAgent'."),
+	packagePath: bridgeCreateMassEntityConfigRequestSchema.shape.packagePath.describe("Content folder to create the config in, e.g. /Game/Mass."),
+	parentConfigPath: bridgeCreateMassEntityConfigRequestSchema.shape.parentConfigPath.describe("Optional MassEntityConfig to inherit traits from; this config overrides any trait of the same class."),
+	projectId: creativeProjectIdSchema
+};
+const editMassEntityConfigInputSchema = {
+	assetPath: bridgeEditMassEntityConfigRequestSchema.shape.assetPath.describe("MassEntityConfig asset to edit."),
+	edits: bridgeEditMassEntityConfigRequestSchema.shape.edits.describe(`Trait edits applied in order. 'add' adds the trait (or configures the existing one of that class) and may carry properties; 'set' writes properties on a trait the config owns; 'remove' drops it. properties are { propertyPath, value } pairs in exported-text form, e.g. { propertyPath: 'Movement.MaxSpeed', value: '300' }. ${MASS_TRAIT_HINT}`),
+	projectId: creativeProjectIdSchema
+};
+const getMassEntityConfigInputSchema = {
+	assetPath: bridgeGetMassEntityConfigRequestSchema.shape.assetPath.describe("MassEntityConfig asset to read."),
+	projectId: creativeProjectIdSchema
+};
+const validateMassEntityConfigInputSchema = {
+	assetPath: bridgeValidateMassEntityConfigRequestSchema.shape.assetPath.describe("MassEntityConfig asset to validate."),
+	projectId: creativeProjectIdSchema
+};
+async function createMassEntityConfig(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateMassEntityConfigRequest(input.assetName, input.packagePath, { parentConfigPath: input.parentConfigPath }), sendBridgeCreateMassEntityConfigRequest, BRIDGE_CREATE_MASS_ENTITY_CONFIG_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function editMassEntityConfig(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeEditMassEntityConfigRequest(input.assetPath, input.edits), sendBridgeEditMassEntityConfigRequest, BRIDGE_EDIT_MASS_ENTITY_CONFIG_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function getMassEntityConfig(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeGetMassEntityConfigRequest(input.assetPath), sendBridgeGetMassEntityConfigRequest, BRIDGE_GET_MASS_ENTITY_CONFIG_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function validateMassEntityConfig(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeValidateMassEntityConfigRequest(input.assetPath), sendBridgeValidateMassEntityConfigRequest, BRIDGE_VALIDATE_MASS_ENTITY_CONFIG_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+function registerMassTools(server, dependencies) {
+	server.registerTool("create_mass_entity_config", {
+		description: "Create a MassEntityConfig data asset — the trait list a Mass crowd agent is spawned from — optionally inheriting from a parent config. Add traits with edit_mass_entity_config. Returns state 'unsupported' with a reason when the Mass plugins are not loaded.",
+		inputSchema: createMassEntityConfigInputSchema,
+		title: "Create Mass Entity Config"
+	}, async ({ assetName, packagePath, parentConfigPath, projectId }) => {
+		return toToolSuccess(await createMassEntityConfig({
+			assetName,
+			packagePath,
+			parentConfigPath,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("edit_mass_entity_config", {
+		description: "Add, remove and configure the traits of a MassEntityConfig (movement, LOD, representation, StateTree and any other Mass trait). Each edit reports its own outcome, and traits lists the config's own trait classes afterwards. The package is left dirty; save it with save_dirty_packages. Run validate_mass_entity_config to check the result.",
+		inputSchema: editMassEntityConfigInputSchema,
+		title: "Edit Mass Entity Config"
+	}, async ({ assetPath, edits, projectId }) => {
+		return toToolSuccess(await editMassEntityConfig({
+			assetPath,
+			edits,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("get_mass_entity_config", {
+		description: "Read a MassEntityConfig back: its parent config and each of its own traits with the trait's editable properties as exported text, which edit_mass_entity_config accepts unchanged.",
+		inputSchema: getMassEntityConfigInputSchema,
+		title: "Get Mass Entity Config"
+	}, async ({ assetPath, projectId }) => {
+		return toToolSuccess(await getMassEntityConfig({
+			assetPath,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("validate_mass_entity_config", {
+		description: "Build the config's entity template the way the asset editor's Validate button does and report whether it is valid, with the engine's own error and warning lines verbatim (for example a trait missing a fragment another trait must provide).",
+		inputSchema: validateMassEntityConfigInputSchema,
+		title: "Validate Mass Entity Config"
+	}, async ({ assetPath, projectId }) => {
+		return toToolSuccess(await validateMassEntityConfig({
+			assetPath,
+			projectId
+		}, dependencies));
+	});
+}
+const massToolDomain = {
+	domain: "mass",
+	register: registerMassTools,
+	toolNames: [
+		"create_mass_entity_config",
+		"edit_mass_entity_config",
+		"get_mass_entity_config",
+		"validate_mass_entity_config"
+	]
+};
+//#endregion
 //#region src/tools/material.ts
 const createMaterialInstanceInputSchema = {
 	assetName: bridgeCreateMaterialInstanceRequestSchema.shape.assetName.describe("Name of the new instance, e.g. 'MI_Rock_Mossy'."),
@@ -22476,6 +23977,307 @@ const meshToolDomain = {
 	]
 };
 //#endregion
+//#region src/tools/navigation.ts
+const setNavmeshSettingsInputSchema = {
+	agentHeight: bridgeSetNavmeshSettingsRequestFieldsSchema.shape.agentHeight.describe("Height of the tallest agent that will path on this navmesh, in cm."),
+	agentMaxSlope: bridgeSetNavmeshSettingsRequestFieldsSchema.shape.agentMaxSlope.describe("Steepest ground an agent can walk, in degrees from horizontal (0-89)."),
+	agentMaxStepHeight: bridgeSetNavmeshSettingsRequestFieldsSchema.shape.agentMaxStepHeight.describe("Tallest step an agent can climb, in cm. Written into the resolution named by resolution."),
+	agentRadius: bridgeSetNavmeshSettingsRequestFieldsSchema.shape.agentRadius.describe("Radius of the smallest agent that will path on this navmesh, in cm. Widening it pulls the navmesh further from every wall."),
+	cellHeight: bridgeSetNavmeshSettingsRequestFieldsSchema.shape.cellHeight.describe("Vertical voxel size, in cm. Written into the resolution named by resolution."),
+	cellSize: bridgeSetNavmeshSettingsRequestFieldsSchema.shape.cellSize.describe("Horizontal voxel size, in cm. Smaller is more precise and much slower to build."),
+	mergeRegionSize: bridgeSetNavmeshSettingsRequestFieldsSchema.shape.mergeRegionSize.describe("Regions up to this size are merged into a bigger neighbour (watershed partitioning only)."),
+	minRegionArea: bridgeSetNavmeshSettingsRequestFieldsSchema.shape.minRegionArea.describe("Islands smaller than this are discarded instead of becoming unreachable navmesh."),
+	navMeshActorPath: bridgeSetNavmeshSettingsRequestFieldsSchema.shape.navMeshActorPath.describe("Actor path of the RecastNavMesh to write. Omit to use the level's main navigation data."),
+	projectId: creativeProjectIdSchema,
+	resolution: bridgeSetNavmeshSettingsRequestFieldsSchema.shape.resolution.describe("Which resolution's voxel parameters cellSize, cellHeight and agentMaxStepHeight are written into. Defaults to 'default'."),
+	runtimeGeneration: bridgeSetNavmeshSettingsRequestFieldsSchema.shape.runtimeGeneration.describe("'static' bakes once, 'dynamic_modifiers_only' rebuilds for nav modifiers, 'dynamic' rebuilds for geometry changes too."),
+	tileSizeUU: bridgeSetNavmeshSettingsRequestFieldsSchema.shape.tileSizeUU.describe("Side of one navmesh tile, in cm. Smaller tiles rebuild faster but cost more memory.")
+};
+const setNavAgentsInputSchema = {
+	agents: bridgeSetNavAgentsRequestSchema.shape.agents.describe(`Supported agent types, each { name, radius, height, maxStepHeight?, navDataClass? } (max ${String(16)}). This replaces the project's whole list.`),
+	projectId: creativeProjectIdSchema
+};
+const setCrowdSettingsInputSchema = {
+	crowd: bridgeSetCrowdSettingsRequestFieldsSchema.shape.crowd.describe("Detour crowd manager settings: maxAgents, maxAgentRadius, maxAvoidedAgents, maxAvoidedWalls, navmeshCheckInterval, pathOptimizationInterval, separationDirClamp, pathOffsetRadiusMultiplier, resolveCollisions."),
+	projectId: creativeProjectIdSchema,
+	rvo: bridgeSetCrowdSettingsRequestFieldsSchema.shape.rvo.describe("RVO avoidance manager settings: defaultTimeToLive, lockTimeAfterAvoid, lockTimeAfterClean, deltaTimeToPredict, artificialRadiusExpansion, heightCheckMargin.")
+};
+const createNavAreaInputSchema = {
+	assetName: bridgeCreateNavAreaRequestSchema.shape.assetName.describe("Name of the new nav area, e.g. 'NA_Mud'."),
+	defaultCost: bridgeCreateNavAreaRequestSchema.shape.defaultCost.describe("Travel cost multiplier for distance through this area. 1 is neutral; higher makes pathfinding avoid it."),
+	drawColor: bridgeCreateNavAreaRequestSchema.shape.drawColor.describe("Colour this area is drawn in the navigation view, as { r, g, b, a? } 0-255."),
+	fixedAreaEnteringCost: bridgeCreateNavAreaRequestSchema.shape.fixedAreaEnteringCost.describe("Flat cost paid once on entering the area, independent of how far the path runs through it."),
+	packagePath: bridgeCreateNavAreaRequestSchema.shape.packagePath.describe("Content folder to create the nav area Blueprint in."),
+	parentClass: bridgeCreateNavAreaRequestSchema.shape.parentClass.describe("Nav area class to derive from: 'NavArea' (default), 'NavArea_Null', 'NavArea_Obstacle', 'NavArea_LowHeight', or the class path of another one."),
+	projectId: creativeProjectIdSchema
+};
+const addNavModifierVolumeInputSchema = {
+	actorLabel: bridgeAddNavModifierVolumeRequestSchema.shape.actorLabel.describe("Display label for the placed volume."),
+	areaClass: bridgeAddNavModifierVolumeRequestSchema.shape.areaClass.describe("Nav area to apply inside the volume — 'NavArea_Null' to cut the navmesh away, 'NavArea_Obstacle' to make it expensive, or a class path from create_nav_area."),
+	areaClassToReplace: bridgeAddNavModifierVolumeRequestSchema.shape.areaClassToReplace.describe("When given, only surfaces already marked with this area are replaced by areaClass instead of everything inside the volume."),
+	extent: bridgeAddNavModifierVolumeRequestSchema.shape.extent.describe("Box half-extent of the volume in cm. Every axis must be positive."),
+	folderPath: bridgeAddNavModifierVolumeRequestSchema.shape.folderPath.describe("World Outliner folder to place the volume in."),
+	location: bridgeAddNavModifierVolumeRequestSchema.shape.location.describe("World location of the volume centre."),
+	projectId: creativeProjectIdSchema,
+	rotation: bridgeAddNavModifierVolumeRequestSchema.shape.rotation.describe("World rotation of the volume.")
+};
+const addNavLinkInputSchema = {
+	actorLabel: bridgeAddNavLinkRequestSchema.shape.actorLabel.describe("Display label for the placed link actor."),
+	folderPath: bridgeAddNavLinkRequestSchema.shape.folderPath.describe("World Outliner folder to place the link actor in."),
+	links: bridgeAddNavLinkRequestSchema.shape.links.describe(`Point links carried by this actor (max ${String(16)}), each { left, right, direction?, snapRadius?, snapHeight?, leftProjectHeight?, maxFallDownLength?, areaClass?, description? }. left and right are offsets from the actor, not world positions.`),
+	location: bridgeAddNavLinkRequestSchema.shape.location.describe("World location of the link actor."),
+	projectId: creativeProjectIdSchema,
+	rotation: bridgeAddNavLinkRequestSchema.shape.rotation.describe("World rotation of the link actor."),
+	smartLinkEnabled: bridgeAddNavLinkRequestSchema.shape.smartLinkEnabled.describe("Mark the smart link component on this actor navigation-relevant, so it can be toggled at runtime without a rebuild.")
+};
+const findPathInputSchema = {
+	allowPartial: bridgeFindPathRequestFieldsSchema.shape.allowPartial.describe("Accept a path that stops short of the goal. Defaults to true, so a blocked destination reports partial rather than nothing."),
+	end: bridgeFindPathRequestFieldsSchema.shape.end.describe("World location to path to. Give this or endActorPath."),
+	endActorPath: bridgeFindPathRequestFieldsSchema.shape.endActorPath.describe("Actor whose location is the goal. Give this or end."),
+	maxPathPoints: bridgeFindPathRequestFieldsSchema.shape.maxPathPoints.describe(`Maximum path points to return (1-${String(256)}). pathPointCount stays the full count and truncated says whether the list was cut.`),
+	navMeshActorPath: bridgeFindPathRequestFieldsSchema.shape.navMeshActorPath.describe("Actor path of the RecastNavMesh to query. Omit to use the level's main navigation data."),
+	projectId: creativeProjectIdSchema,
+	start: bridgeFindPathRequestFieldsSchema.shape.start.describe("World location to path from. Give this or startActorPath."),
+	startActorPath: bridgeFindPathRequestFieldsSchema.shape.startActorPath.describe("Actor whose location is the start. Give this or start.")
+};
+const testReachabilityInputSchema = {
+	allowPartial: bridgeTestReachabilityRequestFieldsSchema.shape.allowPartial.describe("Report how far an unreachable pair got, as pathLength on a partial path. Defaults to false. A partial path is reported unreachable either way."),
+	navMeshActorPath: bridgeTestReachabilityRequestFieldsSchema.shape.navMeshActorPath.describe("Actor path of the RecastNavMesh to query. Omit to use the level's main navigation data."),
+	pairs: bridgeTestReachabilityRequestFieldsSchema.shape.pairs.describe(`Start/end pairs to test (max ${String(64)}), each naming exactly one of start/startActorPath and one of end/endActorPath.`),
+	projectId: creativeProjectIdSchema
+};
+const diagnoseNavmeshInputSchema = {
+	includePlayerStarts: bridgeDiagnoseNavmeshRequestSchema.shape.includePlayerStarts.describe("Check every PlayerStart in the level as a spawn point. Defaults to true."),
+	maxIslands: bridgeDiagnoseNavmeshRequestSchema.shape.maxIslands.describe(`Most islands to list, largest area first (1-${String(64)}). islandCount stays the full count.`),
+	navMeshActorPath: bridgeDiagnoseNavmeshRequestSchema.shape.navMeshActorPath.describe("Actor path of the RecastNavMesh to inspect. Omit to use the level's main navigation data."),
+	projectId: creativeProjectIdSchema,
+	spawnActorPaths: bridgeDiagnoseNavmeshRequestSchema.shape.spawnActorPaths.describe(`Extra spawn actors to check alongside the player starts, such as AI spawners (max ${String(64)}).`)
+};
+async function setNavmeshSettings(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSetNavmeshSettingsRequest({
+		agentHeight: input.agentHeight,
+		agentMaxSlope: input.agentMaxSlope,
+		agentMaxStepHeight: input.agentMaxStepHeight,
+		agentRadius: input.agentRadius,
+		cellHeight: input.cellHeight,
+		cellSize: input.cellSize,
+		mergeRegionSize: input.mergeRegionSize,
+		minRegionArea: input.minRegionArea,
+		navMeshActorPath: input.navMeshActorPath,
+		resolution: input.resolution,
+		runtimeGeneration: input.runtimeGeneration,
+		tileSizeUU: input.tileSizeUU
+	}), sendBridgeSetNavmeshSettingsRequest, BRIDGE_SET_NAVMESH_SETTINGS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function setNavAgents(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSetNavAgentsRequest(input.agents), sendBridgeSetNavAgentsRequest, BRIDGE_SET_NAV_AGENTS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function setCrowdSettings(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSetCrowdSettingsRequest({
+		crowd: input.crowd,
+		rvo: input.rvo
+	}), sendBridgeSetCrowdSettingsRequest, BRIDGE_SET_CROWD_SETTINGS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function createNavArea(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateNavAreaRequest(input.assetName, input.packagePath, {
+		defaultCost: input.defaultCost,
+		drawColor: input.drawColor,
+		fixedAreaEnteringCost: input.fixedAreaEnteringCost,
+		parentClass: input.parentClass
+	}), sendBridgeCreateNavAreaRequest, BRIDGE_CREATE_NAV_AREA_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addNavModifierVolume(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddNavModifierVolumeRequest(input.areaClass, {
+		actorLabel: input.actorLabel,
+		areaClassToReplace: input.areaClassToReplace,
+		extent: input.extent,
+		folderPath: input.folderPath,
+		location: input.location,
+		rotation: input.rotation
+	}), sendBridgeAddNavModifierVolumeRequest, BRIDGE_ADD_NAV_MODIFIER_VOLUME_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addNavLink(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddNavLinkRequest(input.links, {
+		actorLabel: input.actorLabel,
+		folderPath: input.folderPath,
+		location: input.location,
+		rotation: input.rotation,
+		smartLinkEnabled: input.smartLinkEnabled
+	}), sendBridgeAddNavLinkRequest, BRIDGE_ADD_NAV_LINK_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function findPath(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeFindPathRequest({
+		end: input.end,
+		endActorPath: input.endActorPath,
+		start: input.start,
+		startActorPath: input.startActorPath
+	}, {
+		allowPartial: input.allowPartial,
+		maxPathPoints: input.maxPathPoints,
+		navMeshActorPath: input.navMeshActorPath
+	}), sendBridgeFindPathRequest, BRIDGE_FIND_PATH_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function testReachability(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeTestReachabilityRequest(input.pairs, {
+		allowPartial: input.allowPartial,
+		navMeshActorPath: input.navMeshActorPath
+	}), sendBridgeTestReachabilityRequest, BRIDGE_TEST_REACHABILITY_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function diagnoseNavmesh(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeDiagnoseNavmeshRequest({
+		includePlayerStarts: input.includePlayerStarts,
+		maxIslands: input.maxIslands,
+		navMeshActorPath: input.navMeshActorPath,
+		spawnActorPaths: input.spawnActorPaths
+	}), sendBridgeDiagnoseNavmeshRequest, BRIDGE_DIAGNOSE_NAVMESH_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+function registerNavigationTools(server, dependencies) {
+	server.registerTool("set_navmesh_settings", {
+		description: "Write the level's navmesh generation settings — agent radius and height, max slope and step height, voxel cell size, tile size and runtime generation mode. The values only reach the navmesh on the next build, so follow this with build_navigation. Returns every setting as it stands after the write, so a clamped value is visible.",
+		inputSchema: setNavmeshSettingsInputSchema,
+		title: "Set Navmesh Settings"
+	}, async ({ agentHeight, agentMaxSlope, agentMaxStepHeight, agentRadius, cellHeight, cellSize, mergeRegionSize, minRegionArea, navMeshActorPath, projectId, resolution, runtimeGeneration, tileSizeUU }) => {
+		return toToolSuccess(await setNavmeshSettings({
+			agentHeight,
+			agentMaxSlope,
+			agentMaxStepHeight,
+			agentRadius,
+			cellHeight,
+			cellSize,
+			mergeRegionSize,
+			minRegionArea,
+			navMeshActorPath,
+			projectId,
+			resolution,
+			runtimeGeneration,
+			tileSizeUU
+		}, dependencies));
+	});
+	server.registerTool("set_nav_agents", {
+		description: "Replace the project's list of supported navigation agents, each with its own radius, height and step height. One navmesh is generated per agent type, so this is how a level gets separate navigation for, say, a human and a vehicle. Written to DefaultEngine.ini and read once at startup, so it reports restartRequired.",
+		inputSchema: setNavAgentsInputSchema,
+		title: "Set Nav Agents"
+	}, async ({ agents, projectId }) => {
+		return toToolSuccess(await setNavAgents({
+			agents,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("set_crowd_settings", {
+		description: "Write the project-wide Detour crowd manager and RVO avoidance settings that decide how AI agents steer around each other. Both are config defaults read at startup, so the response reports restartRequired rather than pretending a running crowd picked them up.",
+		inputSchema: setCrowdSettingsInputSchema,
+		title: "Set Crowd Settings"
+	}, async ({ crowd, projectId, rvo }) => {
+		return toToolSuccess(await setCrowdSettings({
+			crowd,
+			projectId,
+			rvo
+		}, dependencies));
+	});
+	server.registerTool("create_nav_area", {
+		description: "Create a nav area Blueprint with its own travel cost, entering cost and debug colour. Returns generatedClassPath, which is what add_nav_modifier_volume and add_nav_link take to reference the area.",
+		inputSchema: createNavAreaInputSchema,
+		title: "Create Nav Area"
+	}, async ({ assetName, defaultCost, drawColor, fixedAreaEnteringCost, packagePath, parentClass, projectId }) => {
+		return toToolSuccess(await createNavArea({
+			assetName,
+			defaultCost,
+			drawColor,
+			fixedAreaEnteringCost,
+			packagePath,
+			parentClass,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("add_nav_modifier_volume", {
+		description: "Place a nav modifier volume that applies a nav area to whatever navmesh falls inside it — NavArea_Null to carve a hole an agent will never path through, or a custom area to make the ground expensive rather than impassable. Takes effect on the next build_navigation.",
+		inputSchema: addNavModifierVolumeInputSchema,
+		title: "Add Nav Modifier Volume"
+	}, async ({ actorLabel, areaClass, areaClassToReplace, extent, folderPath, location, projectId, rotation }) => {
+		return toToolSuccess(await addNavModifierVolume({
+			actorLabel,
+			areaClass,
+			areaClassToReplace,
+			extent,
+			folderPath,
+			location,
+			projectId,
+			rotation
+		}, dependencies));
+	});
+	server.registerTool("add_nav_link", {
+		description: "Place a nav link proxy carrying one or more point links, which is what lets an agent jump or drop between navmesh islands that do not touch. Each link names its two ends as offsets from the actor plus a direction; the response reports them in world space. Takes effect on the next build_navigation.",
+		inputSchema: addNavLinkInputSchema,
+		title: "Add Nav Link"
+	}, async ({ actorLabel, folderPath, links, location, projectId, rotation, smartLinkEnabled }) => {
+		return toToolSuccess(await addNavLink({
+			actorLabel,
+			folderPath,
+			links,
+			location,
+			projectId,
+			rotation,
+			smartLinkEnabled
+		}, dependencies));
+	});
+	server.registerTool("find_path", {
+		description: "Run a synchronous navmesh path query in the editor world between two points or actors, returning the path points, its length and cost, and whether it reached the goal. A destination nothing can reach comes back with reachable false and a partial path rather than an error, so this is the way to prove a level is traversable before shipping it.",
+		inputSchema: findPathInputSchema,
+		title: "Find Path"
+	}, async ({ allowPartial, end, endActorPath, maxPathPoints, navMeshActorPath, projectId, start, startActorPath }) => {
+		return toToolSuccess(await findPath({
+			allowPartial,
+			end,
+			endActorPath,
+			maxPathPoints,
+			navMeshActorPath,
+			projectId,
+			start,
+			startActorPath
+		}, dependencies));
+	});
+	server.registerTool("test_reachability", {
+		description: "Answer reachable / not reachable for a batch of start-end pairs in one call, without returning any path geometry. Use it to sweep spawn points against objectives; use find_path when the route itself matters.",
+		inputSchema: testReachabilityInputSchema,
+		title: "Test Reachability"
+	}, async ({ allowPartial, navMeshActorPath, pairs, projectId }) => {
+		return toToolSuccess(await testReachability({
+			allowPartial,
+			navMeshActorPath,
+			pairs,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("diagnose_navmesh", {
+		description: "Audit the editor level's navmesh without changing it: missing nav bounds, an empty navmesh, disconnected islands (poly count, area and bounds, largest area first), and player starts or named AI spawn actors that sit off the navmesh or cannot path to the first spawn point. Each finding is listed in issues with a code; healthy is true when there are none.",
+		inputSchema: diagnoseNavmeshInputSchema,
+		title: "Diagnose Navmesh"
+	}, async ({ includePlayerStarts, maxIslands, navMeshActorPath, projectId, spawnActorPaths }) => {
+		return toToolSuccess(await diagnoseNavmesh({
+			includePlayerStarts,
+			maxIslands,
+			navMeshActorPath,
+			projectId,
+			spawnActorPaths
+		}, dependencies));
+	});
+}
+const navigationToolDomain = {
+	domain: "navigation",
+	register: registerNavigationTools,
+	toolNames: [
+		"set_navmesh_settings",
+		"set_nav_agents",
+		"set_crowd_settings",
+		"create_nav_area",
+		"add_nav_modifier_volume",
+		"add_nav_link",
+		"find_path",
+		"test_reachability",
+		"diagnose_navmesh"
+	]
+};
+//#endregion
 //#region src/tools/pcg.ts
 const createPcgGraphInputSchema = {
 	assetName: bridgeCreatePcgGraphRequestFieldsSchema.shape.assetName.describe("Name of the new PCG graph, e.g. 'PCG_Forest'."),
@@ -23389,6 +25191,90 @@ const sequencerToolDomain = {
 	]
 };
 //#endregion
+//#region src/tools/smartObjects.ts
+const createSmartObjectDefinitionInputSchema = {
+	activityTags: bridgeCreateSmartObjectDefinitionRequestSchema.shape.activityTags.describe("Gameplay tags describing what the whole object offers, e.g. 'Activity.Sit'. Every tag must already be registered."),
+	assetName: bridgeCreateSmartObjectDefinitionRequestSchema.shape.assetName.describe("Name of the new Smart Object definition, e.g. 'SOD_Bench'."),
+	defaultBehaviorDefinitions: bridgeCreateSmartObjectDefinitionRequestSchema.shape.defaultBehaviorDefinitions.describe("Behavior definitions every slot without its own falls back to, each { behaviorClass, params? }. behaviorClass names a concrete USmartObjectBehaviorDefinition subclass, e.g. '/Script/GameplayBehaviorSmartObjectsModule.GameplayBehaviorSmartObjectBehaviorDefinition'. A slot with no behavior and no default leaves the definition invalid, and an invalid definition never registers."),
+	packagePath: bridgeCreateSmartObjectDefinitionRequestSchema.shape.packagePath.describe("Content folder to create the definition in."),
+	projectId: creativeProjectIdSchema,
+	slots: bridgeCreateSmartObjectDefinitionRequestSchema.shape.slots.describe("Slots users claim, each { name?, offset?: {x,y,z}, rotation?: {pitch,yaw,roll}, enabled?, activityTags?, behaviorDefinitions? }. Offset and rotation are relative to the owning actor.")
+};
+const getSmartObjectDefinitionInputSchema = {
+	assetPath: bridgeGetSmartObjectDefinitionRequestSchema.shape.assetPath.describe("Object path of the Smart Object definition to read."),
+	projectId: creativeProjectIdSchema
+};
+const addSmartObjectComponentInputSchema = {
+	actorPath: bridgeAddSmartObjectComponentRequestFieldsSchema.shape.actorPath.describe("Placed actor in the editor level to add the component to. Give this or blueprintPath, not both."),
+	blueprintPath: bridgeAddSmartObjectComponentRequestFieldsSchema.shape.blueprintPath.describe("Actor Blueprint to add the component to; the Blueprint is recompiled. Give this or actorPath, not both."),
+	componentName: bridgeAddSmartObjectComponentRequestFieldsSchema.shape.componentName.describe("Name of the component. Omitted reuses the existing Smart Object component, or names a new one SmartObject."),
+	definitionPath: bridgeAddSmartObjectComponentRequestFieldsSchema.shape.definitionPath.describe("Smart Object definition the component points at."),
+	projectId: creativeProjectIdSchema
+};
+async function createSmartObjectDefinition(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateSmartObjectDefinitionRequest(input.assetName, input.packagePath, input.slots, {
+		activityTags: input.activityTags,
+		defaultBehaviorDefinitions: input.defaultBehaviorDefinitions
+	}), sendBridgeCreateSmartObjectDefinitionRequest, BRIDGE_CREATE_SMART_OBJECT_DEFINITION_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function getSmartObjectDefinition(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeGetSmartObjectDefinitionRequest(input.assetPath), sendBridgeGetSmartObjectDefinitionRequest, BRIDGE_GET_SMART_OBJECT_DEFINITION_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addSmartObjectComponent(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddSmartObjectComponentRequest(input.definitionPath, {
+		actorPath: input.actorPath,
+		blueprintPath: input.blueprintPath
+	}, { componentName: input.componentName }), sendBridgeAddSmartObjectComponentRequest, BRIDGE_ADD_SMART_OBJECT_COMPONENT_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+function registerSmartObjectsTools(server, dependencies) {
+	server.registerTool("create_smart_object_definition", {
+		description: "Create a Smart Object definition with its slots — offsets, rotations, activity tags and behavior definitions — and read back what the asset holds, including whether it passes the engine's validation. An invalid definition never registers, so check 'valid' before placing it. Returns state 'unsupported' when the SmartObjects plugin is not loaded.",
+		inputSchema: createSmartObjectDefinitionInputSchema,
+		title: "Create Smart Object Definition"
+	}, async ({ activityTags, assetName, defaultBehaviorDefinitions, packagePath, projectId, slots }) => {
+		return toToolSuccess(await createSmartObjectDefinition({
+			activityTags,
+			assetName,
+			defaultBehaviorDefinitions,
+			packagePath,
+			projectId,
+			slots
+		}, dependencies));
+	});
+	server.registerTool("get_smart_object_definition", {
+		description: "Read a Smart Object definition: its slots, activity tags, behavior definitions and validation result. Returns state 'unsupported' when the SmartObjects plugin is not loaded.",
+		inputSchema: getSmartObjectDefinitionInputSchema,
+		title: "Get Smart Object Definition"
+	}, async ({ assetPath, projectId }) => {
+		return toToolSuccess(await getSmartObjectDefinition({
+			assetPath,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("add_smart_object_component", {
+		description: "Add a Smart Object component pointing at a definition to an actor Blueprint or a placed actor, or repoint the one already there. The component registers with the Smart Object subsystem when play begins, which needs a valid definition — 'definitionValid' says whether it will. Returns state 'unsupported' when the SmartObjects plugin is not loaded.",
+		inputSchema: addSmartObjectComponentInputSchema,
+		title: "Add Smart Object Component"
+	}, async ({ actorPath, blueprintPath, componentName, definitionPath, projectId }) => {
+		return toToolSuccess(await addSmartObjectComponent({
+			actorPath,
+			blueprintPath,
+			componentName,
+			definitionPath,
+			projectId
+		}, dependencies));
+	});
+}
+const smartObjectsToolDomain = {
+	domain: "smartObjects",
+	register: registerSmartObjectsTools,
+	toolNames: [
+		"create_smart_object_definition",
+		"get_smart_object_definition",
+		"add_smart_object_component"
+	]
+};
+//#endregion
 //#region src/tools/stateTree.ts
 const getStateTreeInputSchema = {
 	assetPath: bridgeGetStateTreeRequestSchema.shape.assetPath.describe("Object path of the StateTree asset to read."),
@@ -23427,6 +25313,18 @@ const traceStateTreeInputSchema = {
 	maxEvents: bridgeTraceStateTreeRequestSchema.shape.maxEvents.describe("Maximum events to return in one poll (1-200, default 50)."),
 	projectId: creativeProjectIdSchema
 };
+const updateStateTreeElementsInputSchema = {
+	assetPath: bridgeUpdateStateTreeElementsRequestSchema.shape.assetPath.describe("Object path of the StateTree asset to edit."),
+	compile: bridgeUpdateStateTreeElementsRequestSchema.shape.compile.describe("Run the StateTree compiler after the edits. Defaults true; its messages come back verbatim in compileMessages."),
+	projectId: creativeProjectIdSchema,
+	updates: bridgeUpdateStateTreeElementsRequestSchema.shape.updates.describe("Edits addressed by the ids get_state_tree reports. { kind: 'state', id, name?, stateType?, selectionBehavior?, enabled? } renames or retypes a state (renaming keeps transitions pointing at it); { kind: 'task', id, params } writes ExportText values onto a task; { kind: 'transition', id, trigger?, targetType?, targetStateId?, eventTag?, enabled? } points a transition at a new target or trigger. A targetStateId alone implies targetType 'goto_state'.")
+};
+const removeStateTreeElementsInputSchema = {
+	assetPath: bridgeRemoveStateTreeElementsRequestSchema.shape.assetPath.describe("Object path of the StateTree asset to edit."),
+	compile: bridgeRemoveStateTreeElementsRequestSchema.shape.compile.describe("Run the StateTree compiler after the removals. Defaults true; its messages come back verbatim in compileMessages."),
+	projectId: creativeProjectIdSchema,
+	removals: bridgeRemoveStateTreeElementsRequestSchema.shape.removals.describe("Elements to remove, each { kind, id } with kind 'state', 'task' or 'transition' and the id get_state_tree reports. Removing a state removes its children too.")
+};
 async function getStateTree(input, dependencies) {
 	return await exchangeCreativeRequest(createBridgeGetStateTreeRequest(input.assetPath), sendBridgeGetStateTreeRequest, BRIDGE_GET_STATE_TREE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
 }
@@ -23455,6 +25353,12 @@ async function traceStateTree(input, dependencies) {
 		maxEvents: input.maxEvents
 	}), sendBridgeTraceStateTreeRequest, BRIDGE_TRACE_STATE_TREE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
 }
+async function updateStateTreeElements(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeUpdateStateTreeElementsRequest(input.assetPath, input.updates, { compile: input.compile }), sendBridgeUpdateStateTreeElementsRequest, BRIDGE_UPDATE_STATE_TREE_ELEMENTS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function removeStateTreeElements(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeRemoveStateTreeElementsRequest(input.assetPath, input.removals, { compile: input.compile }), sendBridgeRemoveStateTreeElementsRequest, BRIDGE_REMOVE_STATE_TREE_ELEMENTS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
 function registerStateTreeTools(server, dependencies) {
 	server.registerTool("get_state_tree", {
 		description: "Read a StateTree back: its schema, parameters, evaluators, global tasks and the full state hierarchy with each state's tasks, enter conditions and transitions. Every state and node carries the id the edit tools address it by, so this is the call to make before editing a tree you did not author. compiled reports whether the asset carries runtime data — a tree that reads back correctly with compiled false is authored but will not run.",
@@ -23529,6 +25433,30 @@ function registerStateTreeTools(server, dependencies) {
 			projectId
 		}, dependencies));
 	});
+	server.registerTool("update_state_tree_elements", {
+		description: "Edit existing StateTree states, tasks and transitions by the ids get_state_tree reports: rename or retype a state, toggle it, change its selection behaviour; set a task's params; retarget, retrigger or toggle a transition. Each edit is reported per item, and the tree is recompiled by default with the compiler's own messages returned verbatim.",
+		inputSchema: updateStateTreeElementsInputSchema,
+		title: "Update StateTree Elements"
+	}, async ({ assetPath, compile, projectId, updates }) => {
+		return toToolSuccess(await updateStateTreeElements({
+			assetPath,
+			compile,
+			projectId,
+			updates
+		}, dependencies));
+	});
+	server.registerTool("remove_state_tree_elements", {
+		description: "Remove StateTree states, tasks and transitions by the ids get_state_tree reports. Removing a state removes its children and every transition elsewhere in the tree that targeted it; those transitions are listed in removedTransitions. The tree is recompiled by default with the compiler's own messages returned verbatim.",
+		inputSchema: removeStateTreeElementsInputSchema,
+		title: "Remove StateTree Elements"
+	}, async ({ assetPath, compile, projectId, removals }) => {
+		return toToolSuccess(await removeStateTreeElements({
+			assetPath,
+			compile,
+			projectId,
+			removals
+		}, dependencies));
+	});
 }
 const stateTreeToolDomain = {
 	domain: "stateTree",
@@ -23539,7 +25467,9 @@ const stateTreeToolDomain = {
 		"set_state_tree_considerations",
 		"link_state_tree_state",
 		"add_state_tree_component",
-		"trace_state_tree"
+		"trace_state_tree",
+		"update_state_tree_elements",
+		"remove_state_tree_elements"
 	]
 };
 //#endregion
@@ -24464,7 +26394,10 @@ const TOOL_CATALOG = [
 	renderToolDomain,
 	vfxToolDomain,
 	pcgToolDomain,
-	projectSettingsToolDomain
+	projectSettingsToolDomain,
+	navigationToolDomain,
+	smartObjectsToolDomain,
+	massToolDomain
 ];
 //#endregion
 //#region src/mcpTools.ts