@uemcp/server 1.10.0 → 1.11.0

package/README.md

@@ -131,6 +131,14 @@ The MCP tool surface currently exposes:
 - `scaffold_class_template`
 - `get_live_compile_details`
 - `run_editor_python`
+- `set_navmesh_settings`
+- `set_nav_agents`
+- `set_crowd_settings`
+- `create_nav_area`
+- `add_nav_modifier_volume`
+- `add_nav_link`
+- `find_path`
+- `test_reachability`
 
 ## Project Identity
 
@@ -661,6 +669,27 @@ This is intended to let an MCP client resolve the canonical Unreal project ident
 - An editor whose Python Script Plugin is absent or disabled returns `state: 'unsupported'` with the reason, which is a different answer from a script that ran and failed
 - The whole script runs inside one `FScopedTransaction`, so a successful run is a single editor undo; a failed run cancels the transaction rather than leaving half its effects behind
 - `executionMode` is `script` (default: a whole block of Python, or a `.py` path with arguments), `statement` (exactly one statement) or `evaluate` (one expression, whose value comes back in `result`). `script` is the default because the engine reports a traceback line by line only in that mode; the two statement modes put it in `result` instead. Commands are capped at 16,384 characters, and output and error lines at 200 lines each, with `truncated` set
+### `set_navmesh_settings` / `set_nav_agents` / `set_crowd_settings`
+
+- Navmesh generation settings are written onto the level's `RecastNavMesh` actor and only reach the navmesh on the next build, so the response reports `rebuildRequired` and the caller follows with `build_navigation`. Rebuilding here instead would be a minutes-long job on a socket with a seconds-long read budget
+- `cellSize`, `cellHeight` and `agentMaxStepHeight` live per resolution since UE 5.4 — the same-named members on the actor are deprecated and no longer read by the generator — so `resolution` names which of the three sets is being written, and `appliedSettings` reports exactly which fields the write touched
+- The response reports every setting as it stands **after** the write, read back off the actor, so a value the navmesh clamped is visible rather than echoed back as requested
+- `set_nav_agents` replaces the project's whole `SupportedAgents` list, which is what gives a level one navmesh per agent size. It is read once when the navigation system starts, so the response reports `restartRequired` rather than pretending a running editor picked it up
+- `set_crowd_settings` writes the Detour crowd manager and the RVO avoidance manager, both config defaults rather than per-level state. Only the manager a request actually names is saved, so a crowd-only call leaves the avoidance section alone
+
+### `create_nav_area` / `add_nav_modifier_volume` / `add_nav_link`
+
+- `create_nav_area` makes a nav area Blueprint under `NavArea` (or one of the stock parents) and reports `generatedClassPath` — the class, not the asset, is what a modifier volume or a link references
+- `add_nav_modifier_volume` places an `ANavModifierVolume` and builds its cube brush through the same actor factory the place-actor panel uses. Without that brush the volume covers nothing, so a non-positive extent is refused rather than placed
+- `add_nav_link` replaces the proxy's default link with the ones the request carries. `left` and `right` are offsets from the actor, the space the level editor's own link handles move in, and the response reports them in world space so a link and the `find_path` that crosses it can be compared directly
+- All three leave the navmesh untouched until the next `build_navigation`, and say so through `rebuildRequired`
+
+### `find_path` / `test_reachability`
+
+- Synchronous navmesh queries against the editor world, which is what makes "is this level traversable" answerable without entering PIE
+- A destination nothing can reach comes back as `reachable: false` with a partial path, not as an error: that is the answer, and a tool that threw would make the check unusable in a sweep. `queryResult` carries the engine's own `ENavigationQueryResult` so an off-navmesh endpoint stays distinguishable from a walled-off one
+- `reachable` means a path that actually arrives. A partial path proves the goal is **not** reachable however far along it got, so it never counts as reachable in `find_path`
+- `test_reachability` answers a batch of pairs without returning path geometry, and fails one pair rather than the request when an actor path no longer resolves — a sweep of spawn points against objectives is worth answering for the pairs that did resolve
 
 ## MCP Resources
 

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",
@@ -480,6 +492,12 @@ const TOOL_METADATA = {
 	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_sound_cue: mutates("audio", "create_sound_cue"),
 	create_state_tree: mutates("ai", "create_state_tree"),
@@ -532,6 +550,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",
@@ -720,7 +745,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 +794,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",
@@ -3300,11 +3349,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,
@@ -10483,8 +10532,492 @@ function createBridgeSetDefaultGamemodeRequest(scope, gameModePath, options = {}
 	});
 }
 //#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
+	});
+}
+//#endregion
 //#region src/version.ts
-const SERVER_VERSION = "1.10.0";
+const SERVER_VERSION = "1.11.0";
 //#endregion
 //#region src/bridgeSocketClient.ts
 var BridgeSocketError = class extends Error {
@@ -11416,6 +11949,30 @@ 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);
+}
 //#endregion
 //#region src/enginePing.ts
 async function pingRegistryEntry$1(entry, options) {
@@ -22476,6 +23033,278 @@ 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
+};
+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);
+}
+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));
+	});
+}
+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"
+	]
+};
+//#endregion
 //#region src/tools/pcg.ts
 const createPcgGraphInputSchema = {
 	assetName: bridgeCreatePcgGraphRequestFieldsSchema.shape.assetName.describe("Name of the new PCG graph, e.g. 'PCG_Forest'."),
@@ -24464,7 +25293,8 @@ const TOOL_CATALOG = [
 	renderToolDomain,
 	vfxToolDomain,
 	pcgToolDomain,
-	projectSettingsToolDomain
+	projectSettingsToolDomain,
+	navigationToolDomain
 ];
 //#endregion
 //#region src/mcpTools.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uemcp/server",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "MCP server for making Unreal Engine and C++ development easier",
   "type": "module",
   "main": "dist/index.mjs",