@uemcp/server 1.11.0 → 1.12.0

package/dist/index.mjs

@@ -384,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", [
@@ -489,6 +494,12 @@ 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"),
@@ -499,6 +510,11 @@ const TOOL_METADATA = {
 		"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"),
@@ -512,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",
@@ -527,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",
@@ -620,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",
@@ -631,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"),
@@ -654,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"),
@@ -699,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"),
@@ -809,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",
@@ -1401,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({
@@ -2624,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 = [
@@ -2641,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(),
@@ -2653,6 +2720,7 @@ const bridgeListGraphNodesRequestSchema = z.object({
 });
 const bridgeAddGraphNodeRequestFieldsSchema = z.object({
 	assetPath: assetPathSchema,
+	autoLayout: z.boolean().optional(),
 	graphName: graphNameSchema,
 	nodeClass: assetPathSchema.optional(),
 	kind: graphNodeKindSchema,
@@ -2704,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(),
@@ -2732,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),
@@ -2807,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]);
@@ -2814,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,
@@ -2829,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,
@@ -2901,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";
@@ -7441,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()
@@ -7688,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";
@@ -11015,9 +11252,366 @@ function createBridgeTestReachabilityRequest(pairs, options = {}, requestId = ra
 		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 createBridgeValidateMassEntityConfigRequest(assetPath, requestId = randomUUID()) {
+	return bridgeValidateMassEntityConfigRequestSchema.parse({
+		assetPath,
+		requestId,
+		type: BRIDGE_VALIDATE_MASS_ENTITY_CONFIG_REQUEST_TYPE,
+		version: 2
+	});
+}
 //#endregion
 //#region src/version.ts
-const SERVER_VERSION = "1.11.0";
+const SERVER_VERSION = "1.12.0";
 //#endregion
 //#region src/bridgeSocketClient.ts
 var BridgeSocketError = class extends Error {
@@ -11253,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);
 }
@@ -11973,6 +12570,36 @@ async function sendBridgeFindPathRequest(request, options) {
 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) {
@@ -18799,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) {
@@ -18891,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),
@@ -18902,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;
@@ -18926,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;
 		}
-		cpuTimeMs += durationMs;
-		if (timerIndex < 0 || !FRAME_ROOT_TIMER_NAMES.has(values[timerIndex] ?? "")) continue;
-		frameDurationsMs.push(durationMs);
-		if (durationMs < options.hitchThresholdMs) continue;
+		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;
+		}
+		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];
@@ -18991,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.")
@@ -19016,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,
@@ -19029,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
@@ -19049,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,
@@ -19068,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
@@ -19117,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);
 }
@@ -19270,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) => {
@@ -20111,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'."),
@@ -20152,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."),
@@ -20169,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,
@@ -20207,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.",
@@ -20223,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,
@@ -20309,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",
@@ -20320,7 +21174,8 @@ const graphToolDomain = {
 		"connect_pins",
 		"disconnect_pins",
 		"set_pin_default",
-		"list_available_nodes"
+		"list_available_nodes",
+		"layout_graph"
 	]
 };
 //#endregion
@@ -22832,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'."),
@@ -23102,6 +24046,13 @@ const testReachabilityInputSchema = {
 	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,
@@ -23172,6 +24123,14 @@ async function testReachability(input, dependencies) {
 		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.",
@@ -23289,6 +24248,19 @@ function registerNavigationTools(server, dependencies) {
 			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",
@@ -23301,7 +24273,8 @@ const navigationToolDomain = {
 		"add_nav_modifier_volume",
 		"add_nav_link",
 		"find_path",
-		"test_reachability"
+		"test_reachability",
+		"diagnose_navmesh"
 	]
 };
 //#endregion
@@ -24218,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."),
@@ -24256,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);
 }
@@ -24284,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.",
@@ -24358,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",
@@ -24368,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
@@ -25294,7 +26395,9 @@ const TOOL_CATALOG = [
 	vfxToolDomain,
 	pcgToolDomain,
 	projectSettingsToolDomain,
-	navigationToolDomain
+	navigationToolDomain,
+	smartObjectsToolDomain,
+	massToolDomain
 ];
 //#endregion
 //#region src/mcpTools.ts