@uemcp/server 1.7.0 → 1.8.0

package/dist/index.mjs

@@ -4,7 +4,7 @@ import path from "node:path";
 import { z } from "zod";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import net from "node:net";
 import Fastify from "fastify";
 import { Buffer as Buffer$1 } from "node:buffer";
@@ -362,6 +362,12 @@ const TOOL_METADATA = {
 		"build.cs"
 	]),
 	add_post_process_material: mutates("fx", "add_post_process_material"),
+	add_reflected_member: mutates("build", void 0, [
+		"uproperty",
+		"ufunction",
+		"header",
+		"member"
+	]),
 	add_sequence_binding: mutates("sequence", "add_sequence_binding"),
 	add_sequence_keys: mutates("sequence", "add_sequence_keys"),
 	add_sequence_track: mutates("sequence", "add_sequence_track"),
@@ -463,6 +469,12 @@ const TOOL_METADATA = {
 		"command",
 		"stat"
 	]),
+	export_blueprint_cpp: readOnly("blueprint", "get_blueprint_summary", [
+		"export",
+		"c++",
+		"skeleton",
+		"pseudocode"
+	]),
 	export_data_table: reachesOutside("asset", true, "export_data_table"),
 	find_assets: readOnly("core", "find_assets", [
 		"search",
@@ -470,6 +482,13 @@ const TOOL_METADATA = {
 		"registry"
 	]),
 	find_blueprint_references: readOnly("blueprint", "find_blueprint_references"),
+	find_symbol: readOnly("build", void 0, [
+		"symbol",
+		"definition",
+		"reference",
+		"c++",
+		"index"
+	]),
 	focus_actors: idempotentMutates("level", "focus_actors"),
 	generate_collision: idempotentMutates("asset", "generate_collision"),
 	generate_lods: idempotentMutates("asset", "generate_lods"),
@@ -498,6 +517,11 @@ const TOOL_METADATA = {
 		"reflection"
 	]),
 	get_compile_status: readOnly("build", "get_compile_status"),
+	get_live_compile_details: readOnly("build", "get_live_compile_details", [
+		"live coding",
+		"patch",
+		"module"
+	]),
 	get_config_value: readOnly("core", "get_config_value"),
 	get_crash_callstack: readOnly("core", "get_crash_callstack", [
 		"crash",
@@ -576,11 +600,22 @@ const TOOL_METADATA = {
 	replace_actors: destroys("level", "replace_actors"),
 	run_automation_tests: mutates("test", "start_automation_run"),
 	run_clang_tidy: readOnly("build", void 0, ["lint", "static analysis"]),
+	run_editor_python: destroys("core", "run_editor_python", [
+		"python",
+		"script",
+		"unreal"
+	]),
 	run_editor_commandlet: mutates("build"),
 	run_geometry_script: mutates("level", "run_geometry_script"),
 	run_pcg_generate: mutates("fx", "run_pcg_generate"),
 	save_asset: idempotentMutates("asset", "save_asset"),
 	save_dirty_packages: idempotentMutates("core", "save_dirty_packages"),
+	scaffold_class_template: mutates("build", void 0, [
+		"scaffold",
+		"template",
+		"c++",
+		"class"
+	]),
 	sculpt_landscape: mutates("level", "sculpt_landscape"),
 	search_tools: readOnly("core", void 0, ["discover", "find tool"]),
 	select_actors: idempotentMutates("level", "select_actors"),
@@ -1068,6 +1103,13 @@ function resolveDefaultRegistryFilePath(options = {}) {
 	if (platform === "win32") return joinPath(getAbsoluteDirectoryOverride(env.APPDATA, isAbsolutePath) ?? joinPath(homeDirectory, "AppData", "Roaming"), "MCPBridge", "registry.json");
 	return joinPath(getAbsoluteDirectoryOverride(env.XDG_STATE_HOME, isAbsolutePath) ?? joinPath(homeDirectory, ".local", "state"), "MCPBridge", "registry.json");
 }
+function resolveSymbolIndexCacheDirectory(options = {}) {
+	const env = options.env ?? process.env;
+	const pathModule = (options.platform ?? process.platform) === "win32" ? path.win32 : path.posix;
+	const configured = getAbsoluteDirectoryOverride(env.MCP_SERVER_SYMBOL_INDEX_DIR, pathModule.isAbsolute);
+	if (configured !== void 0) return configured;
+	return pathModule.join(pathModule.dirname(resolveDefaultRegistryFilePath(options)), "symbol-index");
+}
 function getConfiguredRegistryFilePath(env) {
 	for (const candidate of [env.MCP_SERVER_REGISTRY_FILE, env.MCP_REGISTRY_FILE]) if (candidate && candidate.trim().length > 0) return candidate.trim();
 }
@@ -1674,6 +1716,7 @@ function createBridgeLaunchOnDeviceRequest(deviceId, map, requestId = randomUUID
 const BRIDGE_START_LIVE_COMPILE_REQUEST_TYPE = "start_live_compile";
 const BRIDGE_START_HOT_RELOAD_REQUEST_TYPE = "start_hot_reload";
 const BRIDGE_GET_COMPILE_STATUS_REQUEST_TYPE = "get_compile_status";
+const BRIDGE_GET_LIVE_COMPILE_DETAILS_REQUEST_TYPE = "get_live_compile_details";
 const BRIDGE_LIVE_COMPILE_STATES = [
 	"compiling",
 	"already_compiling",
@@ -1710,6 +1753,12 @@ const bridgeGetCompileStatusRequestSchema = z.object({
 	type: z.literal(BRIDGE_GET_COMPILE_STATUS_REQUEST_TYPE),
 	version: z.literal(2)
 });
+const bridgeGetLiveCompileDetailsRequestSchema = z.object({
+	compileJobId: compileJobIdSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_LIVE_COMPILE_DETAILS_REQUEST_TYPE),
+	version: z.literal(2)
+});
 const bridgeStartLiveCompileSuccessResponseSchema = z.object({
 	compileJobId: z.string().trim().min(1),
 	message: z.string().trim().min(1).optional(),
@@ -1761,9 +1810,30 @@ const bridgeGetCompileStatusSuccessResponseSchema = z.object({
 		path: [field]
 	});
 });
+const bridgeGetLiveCompileDetailsSuccessResponseSchema = z.object({
+	compileJobId: compileJobIdSchema,
+	ok: z.literal(true),
+	patchedFunctions: z.array(z.string()),
+	patchedModules: z.array(z.string()),
+	rejections: z.array(z.string()),
+	requestId: requestIdSchema,
+	restartReason: z.string().trim().min(1).optional(),
+	restartRequired: z.boolean().optional(),
+	state: compileStatusStateSchema,
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_GET_LIVE_COMPILE_DETAILS_REQUEST_TYPE),
+	version: z.literal(2)
+}).superRefine((value, ctx) => {
+	if (value.restartReason !== void 0 && value.restartRequired !== true) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "restartReason must be absent unless restartRequired is true",
+		path: ["restartReason"]
+	});
+});
 const bridgeStartLiveCompileResponseSchema = z.union([bridgeStartLiveCompileSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeStartHotReloadResponseSchema = z.union([bridgeStartHotReloadSuccessResponseSchema, bridgeErrorResponseSchema]);
 const bridgeGetCompileStatusResponseSchema = z.union([bridgeGetCompileStatusSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetLiveCompileDetailsResponseSchema = z.union([bridgeGetLiveCompileDetailsSuccessResponseSchema, bridgeErrorResponseSchema]);
 function createBridgeStartLiveCompileRequest(requestId = randomUUID()) {
 	return {
 		requestId,
@@ -1786,6 +1856,59 @@ function createBridgeGetCompileStatusRequest(compileJobId, requestId = randomUUI
 		version: 2
 	});
 }
+function createBridgeGetLiveCompileDetailsRequest(compileJobId, requestId = randomUUID()) {
+	return bridgeGetLiveCompileDetailsRequestSchema.parse({
+		compileJobId,
+		requestId,
+		type: BRIDGE_GET_LIVE_COMPILE_DETAILS_REQUEST_TYPE,
+		version: 2
+	});
+}
+//#endregion
+//#region src/protocol/python.ts
+const BRIDGE_RUN_EDITOR_PYTHON_REQUEST_TYPE = "run_editor_python";
+const BRIDGE_PYTHON_EXECUTION_MODES = [
+	"script",
+	"statement",
+	"evaluate"
+];
+const BRIDGE_PYTHON_STATES = [
+	"succeeded",
+	"failed",
+	"disabled",
+	"unsupported"
+];
+const bridgeRunEditorPythonRequestSchema = z.object({
+	command: z.string().min(1).max(16384),
+	executionMode: z.enum(BRIDGE_PYTHON_EXECUTION_MODES),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_RUN_EDITOR_PYTHON_REQUEST_TYPE),
+	unattended: z.boolean(),
+	version: z.literal(2)
+});
+const bridgeRunEditorPythonSuccessResponseSchema = z.object({
+	errors: z.array(z.string()),
+	message: z.string().trim().min(1).optional(),
+	ok: z.literal(true),
+	output: z.array(z.string()),
+	requestId: requestIdSchema,
+	result: z.string().optional(),
+	state: z.enum(BRIDGE_PYTHON_STATES),
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_RUN_EDITOR_PYTHON_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeRunEditorPythonResponseSchema = z.union([bridgeRunEditorPythonSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeRunEditorPythonRequest(command, options = {}, requestId = randomUUID()) {
+	return bridgeRunEditorPythonRequestSchema.parse({
+		command,
+		executionMode: options.executionMode ?? "script",
+		requestId,
+		type: BRIDGE_RUN_EDITOR_PYTHON_REQUEST_TYPE,
+		unattended: options.unattended ?? true,
+		version: 2
+	});
+}
 //#endregion
 //#region src/protocol/editor.ts
 const BRIDGE_GET_EDITOR_STATE_REQUEST_TYPE = "get_editor_state";
@@ -9127,7 +9250,7 @@ function createBridgeSetDefaultGamemodeRequest(scope, gameModePath, options = {}
 }
 //#endregion
 //#region src/version.ts
-const SERVER_VERSION = "1.7.0";
+const SERVER_VERSION = "1.8.0";
 //#endregion
 //#region src/bridgeSocketClient.ts
 var BridgeSocketError = class extends Error {
@@ -9162,6 +9285,12 @@ async function sendBridgeStartHotReloadRequest(request, options) {
 async function sendBridgeGetCompileStatusRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetCompileStatusResponseSchema, request.requestId);
 }
+async function sendBridgeGetLiveCompileDetailsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetLiveCompileDetailsResponseSchema, request.requestId);
+}
+async function sendBridgeRunEditorPythonRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeRunEditorPythonResponseSchema, request.requestId);
+}
 async function sendBridgeGetCrashCallstackRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetCrashCallstackResponseSchema, request.requestId);
 }
@@ -13113,8 +13242,323 @@ const behaviorTreeToolDomain = {
 		"add_bt_service"
 	]
 };
-//#endregion
-//#region src/tools/blueprint.ts
+const EXEC_PIN_NAMES = /* @__PURE__ */ new Set(["execute", "then"]);
+const ENTRY_NODE_CLASSES = /* @__PURE__ */ new Set([
+	"K2Node_ComponentBoundEvent",
+	"K2Node_CustomEvent",
+	"K2Node_Event",
+	"K2Node_FunctionEntry",
+	"K2Node_InputAction",
+	"K2Node_InputKey",
+	"K2Node_Timeline"
+]);
+const HIDDEN_INPUT_PIN_NAMES = new Set(["self", "WorldContextObject"].map((name) => name.toLowerCase()));
+function firstTitleLine(node) {
+	const [first] = node.title.split(/\r?\n/u);
+	return (first ?? node.title).trim();
+}
+function isExecPin(pin) {
+	return pin.type.trim().toLowerCase() === "exec" || EXEC_PIN_NAMES.has(pin.name.toLowerCase());
+}
+function execOutputs(node) {
+	return node.pins.filter((pin) => pin.direction === "output" && isExecPin(pin));
+}
+function execInputs(node) {
+	return node.pins.filter((pin) => pin.direction === "input" && isExecPin(pin));
+}
+function dataInputs(node) {
+	return node.pins.filter((pin) => pin.direction === "input" && !isExecPin(pin) && !HIDDEN_INPUT_PIN_NAMES.has(pin.name.toLowerCase()));
+}
+function findPin(node, names) {
+	const wanted = new Set(names.map((name) => name.toLowerCase()));
+	return node.pins.find((pin) => wanted.has(pin.name.toLowerCase()));
+}
+function indent(depth) {
+	return "  ".repeat(depth);
+}
+var GraphWalker = class {
+	nodesById;
+	lines = [];
+	emitted = /* @__PURE__ */ new Set();
+	truncated = false;
+	constructor(nodes) {
+		this.nodesById = new Map(nodes.map((node) => [node.nodeId, node]));
+	}
+	render(nodes) {
+		for (const root of this.findRoots(nodes)) {
+			this.lines.push(`${this.entryHeader(root)} {`);
+			this.walkFrom(root, 1);
+			this.lines.push("}");
+			this.lines.push("");
+		}
+		while (this.lines.at(-1) === "") this.lines.pop();
+		return {
+			lines: this.lines,
+			truncated: this.truncated
+		};
+	}
+	findRoots(nodes) {
+		return nodes.filter((node) => {
+			if (ENTRY_NODE_CLASSES.has(node.nodeClass)) return true;
+			const inputs = execInputs(node);
+			return inputs.length > 0 && inputs.every((pin) => pin.linkedTo.length === 0) && execOutputs(node).length > 0;
+		}).sort((left, right) => {
+			const byTitle = firstTitleLine(left).localeCompare(firstTitleLine(right));
+			return byTitle === 0 ? left.nodeId.localeCompare(right.nodeId) : byTitle;
+		});
+	}
+	entryHeader(node) {
+		if (node.nodeClass === "K2Node_FunctionEntry") return `function ${firstTitleLine(node)}()`;
+		return `event ${firstTitleLine(node)}()`;
+	}
+	walkFrom(node, depth) {
+		const outputs = execOutputs(node);
+		if (outputs.length <= 1) {
+			const [only] = outputs;
+			if (only !== void 0) this.walkPin(only, depth);
+			return;
+		}
+		const then = findPin(node, ["then"]);
+		if (then !== void 0) {
+			this.walkPin(then, depth);
+			return;
+		}
+		for (const output of outputs) {
+			if (output.linkedTo.length === 0) continue;
+			this.lines.push(`${indent(depth)}// ${output.name}:`);
+			this.walkPin(output, depth + 1);
+		}
+	}
+	walkPin(pin, depth) {
+		const link = pin.linkedTo[0];
+		if (link === void 0) return;
+		const target = this.nodesById.get(link.nodeId);
+		if (target === void 0) {
+			this.truncated = true;
+			return;
+		}
+		this.walkNode(target, depth);
+	}
+	walkNode(node, depth) {
+		if (depth > 32) {
+			this.lines.push(`${indent(depth)}// nesting cap reached`);
+			this.truncated = true;
+			return;
+		}
+		if (this.emitted.has(node.nodeId)) {
+			this.lines.push(`${indent(depth)}goto ${firstTitleLine(node)};`);
+			this.truncated = true;
+			return;
+		}
+		this.emitted.add(node.nodeId);
+		if (node.nodeClass === "K2Node_IfThenElse") {
+			this.emitBranch(node, depth);
+			return;
+		}
+		if (node.nodeClass === "K2Node_ExecutionSequence") {
+			for (const output of execOutputs(node)) this.walkPin(output, depth);
+			return;
+		}
+		const loop = this.loopHeader(node);
+		if (loop !== void 0) {
+			this.lines.push(`${indent(depth)}${loop} {`);
+			const body = findPin(node, ["LoopBody", "Loop Body"]);
+			if (body !== void 0) this.walkPin(body, depth + 1);
+			this.lines.push(`${indent(depth)}}`);
+			const completed = findPin(node, ["Completed"]);
+			if (completed !== void 0) this.walkPin(completed, depth);
+			return;
+		}
+		this.lines.push(`${indent(depth)}${this.statement(node)};`);
+		this.walkFrom(node, depth);
+	}
+	emitBranch(node, depth) {
+		const condition = findPin(node, ["Condition"]);
+		this.lines.push(`${indent(depth)}if (${condition === void 0 ? "true" : this.expression(condition, 0)}) {`);
+		const trueBranch = findPin(node, ["then", "True"]);
+		if (trueBranch !== void 0) this.walkPin(trueBranch, depth + 1);
+		const falseBranch = findPin(node, ["else", "False"]);
+		if (falseBranch !== void 0 && falseBranch.linkedTo.length > 0) {
+			this.lines.push(`${indent(depth)}} else {`);
+			this.walkPin(falseBranch, depth + 1);
+		}
+		this.lines.push(`${indent(depth)}}`);
+	}
+	loopHeader(node) {
+		if (node.nodeClass !== "K2Node_MacroInstance") return;
+		const lowered = firstTitleLine(node).toLowerCase();
+		if (lowered.startsWith("while loop")) {
+			const condition = findPin(node, ["Condition"]);
+			return `while (${condition === void 0 ? "true" : this.expression(condition, 0)})`;
+		}
+		if (lowered.startsWith("for each loop")) {
+			const array = findPin(node, ["Array"]);
+			return `for (Element : ${array === void 0 ? "Array" : this.expression(array, 0)})`;
+		}
+		if (lowered.startsWith("for loop")) {
+			const first = findPin(node, ["First Index", "FirstIndex"]);
+			const last = findPin(node, ["Last Index", "LastIndex"]);
+			return `for (Index = ${first === void 0 ? "0" : this.expression(first, 0)}; Index <= ${last === void 0 ? "0" : this.expression(last, 0)}; Index++)`;
+		}
+	}
+	statement(node) {
+		if (node.nodeClass === "K2Node_VariableSet") {
+			const [assigned] = dataInputs(node);
+			return assigned === void 0 ? firstTitleLine(node) : `${assigned.name} = ${this.expression(assigned, 0)}`;
+		}
+		if (node.nodeClass === "K2Node_FunctionResult") {
+			const values = dataInputs(node).map((pin) => this.expression(pin, 0));
+			return values.length === 0 ? "return" : `return ${values.join(", ")}`;
+		}
+		return this.callExpression(node);
+	}
+	callExpression(node) {
+		const args = dataInputs(node).map((pin) => this.expression(pin, 0));
+		return `${firstTitleLine(node)}(${args.join(", ")})`;
+	}
+	expression(pin, depth) {
+		const link = pin.linkedTo[0];
+		if (link === void 0) {
+			const literal = pin.defaultValue?.trim();
+			return literal !== void 0 && literal.length > 0 ? literal : pin.name;
+		}
+		if (depth >= 8) {
+			this.truncated = true;
+			return pin.name;
+		}
+		const source = this.nodesById.get(link.nodeId);
+		if (source === void 0) {
+			this.truncated = true;
+			return pin.name;
+		}
+		if (source.nodeClass === "K2Node_VariableGet") return source.pins.find((candidate) => candidate.direction === "output" && !isExecPin(candidate))?.name ?? firstTitleLine(source);
+		const args = dataInputs(source).map((input) => this.expression(input, depth + 1));
+		if (args.length === 0 && execInputs(source).length === 0 && source.pins.every((candidate) => !isExecPin(candidate))) return `${firstTitleLine(source)}()`;
+		return `${firstTitleLine(source)}(${args.join(", ")})`;
+	}
+};
+function renderGraphPseudoCode(graph) {
+	const { lines, truncated } = new GraphWalker(graph.nodes).render(graph.nodes);
+	return {
+		graphKind: graph.graphKind,
+		graphName: graph.graphName,
+		lines,
+		truncated: truncated || graph.truncated
+	};
+}
+const BLUEPRINT_TYPE_TO_CPP = /* @__PURE__ */ new Map([
+	["boolean", "bool"],
+	["float (single-precision)", "float"],
+	["float (double-precision)", "double"],
+	["byte", "uint8"],
+	["integer", "int32"],
+	["integer64", "int64"],
+	["float", "double"],
+	["real", "double"],
+	["name", "FName"],
+	["string", "FString"],
+	["text", "FText"],
+	["vector", "FVector"],
+	["rotator", "FRotator"],
+	["transform", "FTransform"]
+]);
+function blueprintTypeToCpp(type) {
+	const trimmed = type.trim();
+	const arrayMatch = /^array of (?<inner>.+)$/iu.exec(trimmed);
+	if (arrayMatch?.groups?.inner !== void 0) return `TArray<${blueprintTypeToCpp(arrayMatch.groups.inner)}>`;
+	return BLUEPRINT_TYPE_TO_CPP.get(trimmed.toLowerCase()) ?? trimmed;
+}
+const ACTOR_DERIVED_PARENT_NAMES = new Set([
+	"Actor",
+	"AIController",
+	"Character",
+	"DefaultPawn",
+	"GameMode",
+	"GameModeBase",
+	"GameSession",
+	"GameState",
+	"GameStateBase",
+	"HUD",
+	"Pawn",
+	"PlayerController",
+	"PlayerState",
+	"SpectatorPawn",
+	"WorldSettings"
+].map((name) => name.toLowerCase()));
+function blueprintParentToCpp(parentClass) {
+	if (parentClass === void 0 || parentClass.trim().length === 0) return {
+		name: "UObject",
+		prefix: "U"
+	};
+	const sanitized = sanitizeIdentifier(parentClass);
+	if (ACTOR_DERIVED_PARENT_NAMES.has(sanitized.toLowerCase())) return {
+		name: `A${sanitized}`,
+		prefix: "A"
+	};
+	if (/^[AUI][A-Z]/u.test(sanitized)) return {
+		name: sanitized,
+		prefix: sanitized.startsWith("A") ? "A" : "U"
+	};
+	return {
+		name: `U${sanitized}`,
+		prefix: "U"
+	};
+}
+function sanitizeIdentifier(value) {
+	const cleaned = value.replace(/[^A-Za-z0-9_]/gu, "");
+	return cleaned.length === 0 ? "Unnamed" : cleaned;
+}
+function variableSpecifiers(variable) {
+	const specifiers = ["EditAnywhere", "BlueprintReadWrite"];
+	if (variable.replication === "replicated") specifiers.push("Replicated");
+	if (variable.replication === "rep_notify") specifiers.push(`ReplicatedUsing = OnRep_${sanitizeIdentifier(variable.name)}`);
+	if (variable.category !== void 0 && variable.category.trim().length > 0) specifiers.push(`Category = "${variable.category.trim()}"`);
+	return specifiers.join(", ");
+}
+function repNotifyDeclaration(variable) {
+	return ["	UFUNCTION()", `\tvoid OnRep_${sanitizeIdentifier(variable.name)}();`];
+}
+function functionDeclaration(member) {
+	const returnParameter = member.parameters.find((parameter) => parameter.isReturn);
+	const returnType = returnParameter === void 0 ? "void" : blueprintTypeToCpp(returnParameter.type);
+	const parameters = member.parameters.filter((parameter) => !parameter.isReturn).map((parameter) => {
+		const type = blueprintTypeToCpp(parameter.type);
+		return parameter.isOut ? `${type}& ${sanitizeIdentifier(parameter.name)}` : `${type} ${sanitizeIdentifier(parameter.name)}`;
+	});
+	return [`\tUFUNCTION(${member.kind === "event" ? "BlueprintCallable, Category = \"Events\"" : "BlueprintCallable"})`, `\t${returnType} ${sanitizeIdentifier(member.name)}(${parameters.join(", ")});`];
+}
+function renderCppSkeleton(source) {
+	const parent = blueprintParentToCpp(source.parentClass);
+	const lines = [
+		"#pragma once",
+		"",
+		"#include \"CoreMinimal.h\"",
+		"",
+		"UCLASS(BlueprintType, Blueprintable)",
+		`class ${`${parent.prefix}${sanitizeIdentifier(source.blueprintName)}`} : public ${parent.name}`,
+		"{",
+		"	GENERATED_BODY()",
+		"",
+		"public:"
+	];
+	for (const interfaceName of source.interfaces) lines.push(`\t// implements ${interfaceName}`);
+	for (const variable of source.variables) {
+		lines.push(`\tUPROPERTY(${variableSpecifiers(variable)})`);
+		lines.push(`\t${blueprintTypeToCpp(variable.type)} ${sanitizeIdentifier(variable.name)};`);
+		if (variable.replication === "rep_notify") {
+			lines.push("");
+			lines.push(...repNotifyDeclaration(variable));
+		}
+		lines.push("");
+	}
+	for (const member of source.functions) {
+		lines.push(...functionDeclaration(member));
+		lines.push("");
+	}
+	while (lines.at(-1) === "") lines.pop();
+	lines.push("};");
+	return lines.join("\n");
+}
 const findBlueprintReferencesInputSchema = {
 	className: bridgeFindBlueprintReferencesRequestSchema.shape.className.describe("C++ class to look for, as a class path (/Script/MyGame.MyActor) or a class name with or without its prefix (AMyActor, MyActor)."),
 	cursor: bridgeFindBlueprintReferencesRequestSchema.shape.cursor.describe("Offset into the stable-ordered reference list (default 0). Pass the previous response nextCursor to fetch the next page."),
@@ -13558,6 +14002,132 @@ function registerBlueprintTools(server, dependencies) {
 			transactionTitle
 		}, dependencies));
 	});
+	server.registerTool("export_blueprint_cpp", {
+		description: "Render a Blueprint as readable pseudo-code plus a C++ class skeleton, as the starting point for porting it to C++. Drains every page of the Blueprint summary and of each selected graph, walks exec pins into statements (branches, loops, function calls, variable assignment, returns), and declares each Blueprint variable and function as a UPROPERTY/UFUNCTION. The skeleton is a scaffold, not compilable nativization; types the editor spells differently from C++ are left verbatim.",
+		inputSchema: exportBlueprintCppInputSchema,
+		title: "Export Blueprint as C++"
+	}, async (input) => {
+		return toToolSuccess(await exportBlueprintCpp(input, dependencies));
+	});
+}
+const exportBlueprintCppInputSchema = {
+	blueprintPath: bridgeGetBlueprintGraphRequestSchema.shape.blueprintPath.describe("Package name or object path of the Blueprint to export."),
+	graphName: bridgeGetBlueprintGraphRequestSchema.shape.graphName.optional().describe("Export only this graph; defaults to every graph on the Blueprint, up to maxGraphs."),
+	loadIfNeeded: bridgeGetBlueprintGraphRequestSchema.shape.loadIfNeeded.describe("Load the Blueprint if it is not already in memory (default false). Graph contents require the asset in memory."),
+	maxGraphs: z.number().int().min(1).max(50).default(10).describe("Maximum graphs to render when graphName is not given (1-50, default 10)."),
+	maxNodesPerGraph: bridgeGetBlueprintGraphRequestSchema.shape.maxNodes.default(25).describe("Nodes fetched per bridge page while draining a graph (1-200, default 25)."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should read the Blueprint.")
+};
+async function collectBlueprintSummary(input, dependencies) {
+	const first = await getBlueprintSummary({
+		blueprintPath: input.blueprintPath,
+		...input.loadIfNeeded === void 0 ? {} : { loadIfNeeded: input.loadIfNeeded },
+		projectId: input.projectId
+	}, dependencies);
+	const summary = {
+		...first,
+		functions: [...first.functions],
+		graphs: [...first.graphs],
+		variables: [...first.variables]
+	};
+	let truncated = first.truncated;
+	let functionCursor = first.nextFunctionCursor;
+	let graphCursor = first.nextGraphCursor;
+	let variableCursor = first.nextVariableCursor;
+	for (let page = 0; page < 20; page += 1) {
+		if (functionCursor === void 0 && graphCursor === void 0 && variableCursor === void 0) return {
+			summary,
+			truncated
+		};
+		const next = await getBlueprintSummary({
+			blueprintPath: input.blueprintPath,
+			...functionCursor === void 0 ? {} : { functionCursor },
+			...graphCursor === void 0 ? {} : { graphCursor },
+			...input.loadIfNeeded === void 0 ? {} : { loadIfNeeded: input.loadIfNeeded },
+			projectId: input.projectId,
+			...variableCursor === void 0 ? {} : { variableCursor }
+		}, dependencies);
+		if (functionCursor !== void 0) summary.functions.push(...next.functions);
+		if (graphCursor !== void 0) summary.graphs.push(...next.graphs);
+		if (variableCursor !== void 0) summary.variables.push(...next.variables);
+		truncated = truncated || next.truncated;
+		functionCursor = functionCursor === void 0 ? void 0 : next.nextFunctionCursor;
+		graphCursor = graphCursor === void 0 ? void 0 : next.nextGraphCursor;
+		variableCursor = variableCursor === void 0 ? void 0 : next.nextVariableCursor;
+	}
+	return {
+		summary,
+		truncated: true
+	};
+}
+async function collectGraphNodes(input, graphName, dependencies) {
+	const nodes = [];
+	let cursor;
+	let graphKind = "unknown";
+	let truncated = false;
+	for (let page = 0; page < 40; page += 1) {
+		const response = await getBlueprintGraph({
+			blueprintPath: input.blueprintPath,
+			graphName,
+			...input.loadIfNeeded === void 0 ? {} : { loadIfNeeded: input.loadIfNeeded },
+			maxNodes: input.maxNodesPerGraph,
+			...cursor === void 0 ? {} : { nodeCursor: cursor },
+			projectId: input.projectId
+		}, dependencies);
+		nodes.push(...response.nodes);
+		graphKind = response.graphKind;
+		truncated = truncated || response.truncated;
+		if (response.nextNodeCursor === void 0) return {
+			graphKind,
+			nodes,
+			truncated
+		};
+		cursor = response.nextNodeCursor;
+	}
+	return {
+		graphKind,
+		nodes,
+		truncated: true
+	};
+}
+async function exportBlueprintCpp(input, dependencies) {
+	const { summary, truncated: summaryTruncated } = await collectBlueprintSummary(input, dependencies);
+	const selected = input.graphName === void 0 ? summary.graphs.slice(0, input.maxGraphs) : summary.graphs.filter((graph) => graph.name === input.graphName);
+	if (input.graphName !== void 0 && selected.length === 0) throw new Error(`Blueprint '${summary.blueprintPath}' has no graph named '${input.graphName}'.`);
+	const rendered = [];
+	let truncated = summaryTruncated || input.graphName === void 0 && selected.length < summary.graphs.length;
+	for (const graph of selected) {
+		const { graphKind, nodes, truncated: graphTruncated } = await collectGraphNodes(input, graph.name, dependencies);
+		const pseudoCode = renderGraphPseudoCode({
+			graphKind,
+			graphName: graph.name,
+			nodes,
+			truncated: graphTruncated
+		});
+		truncated = truncated || pseudoCode.truncated;
+		rendered.push(pseudoCode);
+	}
+	const skeleton = renderCppSkeleton({
+		blueprintName: summary.blueprintName,
+		functions: summary.functions,
+		interfaces: summary.interfaces,
+		...summary.parentClass === void 0 ? {} : { parentClass: summary.parentClass },
+		variables: summary.variables
+	});
+	dependencies.logger.info({
+		blueprintPath: summary.blueprintPath,
+		graphCount: rendered.length,
+		projectId: summary.projectId
+	}, "Exported Blueprint graphs as pseudo-code");
+	return {
+		blueprintName: summary.blueprintName,
+		blueprintPath: summary.blueprintPath,
+		graphs: rendered,
+		projectId: summary.projectId,
+		pseudoCode: rendered.map((graph) => [`// ${graph.graphName} (${graph.graphKind})`, ...graph.lines].join("\n")).join("\n\n"),
+		skeleton,
+		truncated
+	};
 }
 const blueprintToolDomain = {
 	domain: "blueprint",
@@ -13576,10 +14146,498 @@ const blueprintToolDomain = {
 		"add_bp_component",
 		"add_bp_interface",
 		"set_bp_default",
-		"batch_edit"
+		"batch_edit",
+		"export_blueprint_cpp"
 	]
 };
 //#endregion
+//#region src/classScaffold.ts
+const REFLECTED_MEMBER_KINDS = ["property", "function"];
+const CLASS_TEMPLATES = [
+	"interface",
+	"game_instance_subsystem",
+	"world_subsystem",
+	"editor_subsystem"
+];
+const IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/u;
+const INTERFACE_NAME_PATTERN = /^I[A-Za-z0-9_]+$/u;
+const UCLASS_NAME_PATTERN = /^U[A-Za-z0-9_]+$/u;
+function specifierSet(names) {
+	return new Set(names.map((name) => name.toLowerCase()));
+}
+const PROPERTY_SPECIFIERS = specifierSet([
+	"AdvancedDisplay",
+	"AssetRegistrySearchable",
+	"BlueprintAssignable",
+	"BlueprintAuthorityOnly",
+	"BlueprintCallable",
+	"BlueprintGetter",
+	"BlueprintReadOnly",
+	"BlueprintReadWrite",
+	"BlueprintSetter",
+	"Config",
+	"DuplicateTransient",
+	"EditAnywhere",
+	"EditDefaultsOnly",
+	"EditFixedSize",
+	"EditInline",
+	"EditInstanceOnly",
+	"ExportObject",
+	"GlobalConfig",
+	"Instanced",
+	"Interp",
+	"Meta",
+	"NoClear",
+	"NonPIEDuplicateTransient",
+	"NonTransactional",
+	"NotReplicated",
+	"Replicated",
+	"ReplicatedUsing",
+	"SaveGame",
+	"SimpleDisplay",
+	"SkipSerialization",
+	"TextExportTransient",
+	"Transient",
+	"VisibleAnywhere",
+	"VisibleDefaultsOnly",
+	"VisibleInstanceOnly"
+]);
+const FUNCTION_SPECIFIERS = specifierSet([
+	"BlueprintAuthorityOnly",
+	"BlueprintCallable",
+	"BlueprintCosmetic",
+	"BlueprintImplementableEvent",
+	"BlueprintInternalUseOnly",
+	"BlueprintNativeEvent",
+	"BlueprintPure",
+	"CallInEditor",
+	"Client",
+	"Const",
+	"Custom",
+	"CustomThunk",
+	"Exec",
+	"Meta",
+	"NetMulticast",
+	"Reliable",
+	"SealedEvent",
+	"Server",
+	"ServiceRequest",
+	"ServiceResponse",
+	"Unreliable",
+	"WithValidation"
+]);
+const EDIT_SPECIFIER_NAMES = [
+	"EditAnywhere",
+	"EditDefaultsOnly",
+	"EditInstanceOnly"
+];
+const VISIBLE_SPECIFIER_NAMES = [
+	"VisibleAnywhere",
+	"VisibleDefaultsOnly",
+	"VisibleInstanceOnly"
+];
+const RPC_SPECIFIER_NAMES = [
+	"Server",
+	"Client",
+	"NetMulticast"
+];
+const CATEGORY_REQUIRING_SPECIFIER_NAMES = [
+	...EDIT_SPECIFIER_NAMES,
+	...VISIBLE_SPECIFIER_NAMES,
+	"BlueprintReadOnly",
+	"BlueprintReadWrite"
+];
+function normalizeSpecifierName(specifier) {
+	const [name] = specifier.split("=");
+	return (name ?? specifier).trim().toLowerCase();
+}
+function hasSpecifier(specifiers, name) {
+	const wanted = name.toLowerCase();
+	return specifiers.some((specifier) => normalizeSpecifierName(specifier) === wanted);
+}
+function assertKnownSpecifiers(specifiers, kind) {
+	const known = kind === "property" ? PROPERTY_SPECIFIERS : FUNCTION_SPECIFIERS;
+	const macro = kind === "property" ? "UPROPERTY" : "UFUNCTION";
+	for (const specifier of specifiers) {
+		const trimmed = specifier.trim();
+		if (trimmed.length === 0) throw new ModuleScaffoldError(`${macro} specifiers cannot contain an empty entry.`);
+		if (!known.has(normalizeSpecifierName(trimmed))) throw new ModuleScaffoldError(`'${trimmed}' is not a recognised ${macro} specifier.`);
+	}
+}
+function validatePropertySpecifiers(specifiers) {
+	assertKnownSpecifiers(specifiers, "property");
+	const editSpecifiers = EDIT_SPECIFIER_NAMES.filter((name) => hasSpecifier(specifiers, name));
+	const visibleSpecifiers = VISIBLE_SPECIFIER_NAMES.filter((name) => hasSpecifier(specifiers, name));
+	if (editSpecifiers.length + visibleSpecifiers.length > 1) throw new ModuleScaffoldError(`UPROPERTY takes at most one of ${[...EDIT_SPECIFIER_NAMES, ...VISIBLE_SPECIFIER_NAMES].join(", ")}; got ${[...editSpecifiers, ...visibleSpecifiers].join(", ")}.`);
+	if (hasSpecifier(specifiers, "BlueprintReadOnly") && hasSpecifier(specifiers, "BlueprintReadWrite")) throw new ModuleScaffoldError("UPROPERTY cannot be both BlueprintReadOnly and BlueprintReadWrite.");
+	if (hasSpecifier(specifiers, "Replicated") && hasSpecifier(specifiers, "ReplicatedUsing")) throw new ModuleScaffoldError("UPROPERTY cannot be both Replicated and ReplicatedUsing.");
+	const replicatedUsing = specifiers.find((specifier) => normalizeSpecifierName(specifier) === "ReplicatedUsing".toLowerCase());
+	if (replicatedUsing !== void 0 && !replicatedUsing.includes("=")) throw new ModuleScaffoldError("ReplicatedUsing needs a handler function, e.g. ReplicatedUsing = OnRep_Health.");
+	if (hasSpecifier(specifiers, "Config") && hasSpecifier(specifiers, "GlobalConfig")) throw new ModuleScaffoldError("UPROPERTY cannot be both Config and GlobalConfig.");
+	if (hasSpecifier(specifiers, "Transient") && hasSpecifier(specifiers, "Config")) throw new ModuleScaffoldError("A Transient UPROPERTY cannot also be Config.");
+	if ((hasSpecifier(specifiers, "Replicated") || hasSpecifier(specifiers, "ReplicatedUsing")) && hasSpecifier(specifiers, "NotReplicated")) throw new ModuleScaffoldError("UPROPERTY cannot be both replicated and NotReplicated.");
+}
+function validateFunctionSpecifiers(specifiers, returnType) {
+	assertKnownSpecifiers(specifiers, "function");
+	if (hasSpecifier(specifiers, "BlueprintPure") && hasSpecifier(specifiers, "BlueprintCallable")) throw new ModuleScaffoldError("UFUNCTION cannot be both BlueprintPure and BlueprintCallable.");
+	if (hasSpecifier(specifiers, "BlueprintImplementableEvent") && hasSpecifier(specifiers, "BlueprintNativeEvent")) throw new ModuleScaffoldError("UFUNCTION cannot be both BlueprintImplementableEvent and BlueprintNativeEvent.");
+	const rpcs = RPC_SPECIFIER_NAMES.filter((name) => hasSpecifier(specifiers, name));
+	if (rpcs.length > 1) throw new ModuleScaffoldError(`UFUNCTION takes at most one of Server, Client, NetMulticast; got ${rpcs.join(", ")}.`);
+	if (rpcs.length === 1) {
+		if (!hasSpecifier(specifiers, "Reliable") && !hasSpecifier(specifiers, "Unreliable")) throw new ModuleScaffoldError("A replicated UFUNCTION must also be Reliable or Unreliable.");
+		if (returnType.trim() !== "void") throw new ModuleScaffoldError(`A replicated UFUNCTION must return void, got '${returnType.trim()}'.`);
+	}
+	if (hasSpecifier(specifiers, "Reliable") && hasSpecifier(specifiers, "Unreliable")) throw new ModuleScaffoldError("UFUNCTION cannot be both Reliable and Unreliable.");
+	if (rpcs.length === 0 && (hasSpecifier(specifiers, "Reliable") || hasSpecifier(specifiers, "Unreliable"))) throw new ModuleScaffoldError("Reliable and Unreliable only apply to a Server, Client or NetMulticast UFUNCTION.");
+}
+function renderSpecifierList(specifiers, category) {
+	const rendered = specifiers.map((specifier) => specifier.trim());
+	if (category !== void 0 && category.trim().length > 0 && !rendered.some((specifier) => normalizeSpecifierName(specifier) === "Category".toLowerCase())) rendered.push(`Category = "${category.trim()}"`);
+	return rendered.join(", ");
+}
+function requiresCategory(specifiers) {
+	return CATEGORY_REQUIRING_SPECIFIER_NAMES.some((name) => hasSpecifier(specifiers, name));
+}
+function maskCommentsAndLiterals(text) {
+	const masked = text.split("");
+	const charLiteralPattern = /'(?:\\.|[^'\\\n])'/y;
+	const blank = (start, end) => {
+		for (let index = start; index < end && index < masked.length; index += 1) if (masked[index] !== "\n") masked[index] = " ";
+	};
+	let index = 0;
+	while (index < text.length) {
+		const character = text[index];
+		if (character === "/" && text[index + 1] === "/") {
+			const end = text.indexOf("\n", index);
+			const stop = end === -1 ? text.length : end;
+			blank(index, stop);
+			index = stop;
+			continue;
+		}
+		if (character === "/" && text[index + 1] === "*") {
+			const end = text.indexOf("*/", index + 2);
+			const stop = end === -1 ? text.length : end + 2;
+			blank(index, stop);
+			index = stop;
+			continue;
+		}
+		if (character === "R" && text[index + 1] === "\"") {
+			const open = text.indexOf("(", index + 2);
+			const delimiter = open === -1 ? void 0 : text.slice(index + 2, open);
+			if (delimiter !== void 0 && !/[\s()\\]/u.test(delimiter)) {
+				const end = text.indexOf(`)${delimiter}"`, open + 1);
+				const stop = end === -1 ? text.length : end + delimiter.length + 2;
+				blank(index, stop);
+				index = stop;
+				continue;
+			}
+		}
+		if (character === "\"") {
+			let scan = index + 1;
+			while (scan < text.length && text[scan] !== "\"") scan += text[scan] === "\\" ? 2 : 1;
+			const stop = Math.min(scan + 1, text.length);
+			blank(index, stop);
+			index = stop;
+			continue;
+		}
+		if (character === "'") {
+			charLiteralPattern.lastIndex = index;
+			const match = charLiteralPattern.exec(text);
+			if (match !== null) {
+				blank(index, index + match[0].length);
+				index += match[0].length;
+				continue;
+			}
+		}
+		index += 1;
+	}
+	return masked.join("");
+}
+function findDeclarationHeadEnd(masked, start) {
+	let depth = 0;
+	for (let index = start; index < masked.length; index += 1) {
+		const character = masked[index];
+		if (character === "(") {
+			depth += 1;
+			continue;
+		}
+		if (character === ")") {
+			depth -= 1;
+			continue;
+		}
+		if (depth === 0 && (character === ";" || character === "{" || character === ":")) return index;
+	}
+	return -1;
+}
+function findClassBody(masked, className) {
+	const declarationPattern = /^[ \t]*(?:class|struct)\b/gmu;
+	for (let match = declarationPattern.exec(masked); match !== null; match = declarationPattern.exec(masked)) {
+		const headEnd = findDeclarationHeadEnd(masked, match.index);
+		if (headEnd === -1) continue;
+		if (masked.slice(match.index, headEnd).trim().split(/\s+/u).filter((token) => token !== "final").at(-1) !== className || masked[headEnd] === ";") continue;
+		const bodyStart = masked.indexOf("{", headEnd);
+		if (bodyStart === -1) continue;
+		let depth = 0;
+		for (let index = bodyStart; index < masked.length; index += 1) {
+			if (masked[index] === "{") {
+				depth += 1;
+				continue;
+			}
+			if (masked[index] !== "}") continue;
+			depth -= 1;
+			if (depth === 0) return {
+				end: index,
+				start: bodyStart
+			};
+		}
+		return {
+			end: masked.length,
+			start: bodyStart
+		};
+	}
+}
+function insertMemberIntoHeader(headerText, className, memberLines) {
+	const masked = maskCommentsAndLiterals(headerText);
+	const body = findClassBody(masked, className);
+	if (body === void 0) throw new ModuleScaffoldError(`Header does not declare a class or struct named '${className}'.`);
+	const bodyMatch = /^[ \t]*GENERATED_(?:BODY|UCLASS_BODY|USTRUCT_BODY|IINTERFACE_BODY)\(\)[ \t]*$/mu.exec(masked.slice(body.start, body.end));
+	if (bodyMatch === null) throw new ModuleScaffoldError(`Class '${className}' has no GENERATED_BODY() to insert after.`);
+	const insertionOffset = body.start + bodyMatch.index + bodyMatch[0].length;
+	const block = [
+		"",
+		"",
+		"public:",
+		...memberLines
+	].join("\n");
+	return `${headerText.slice(0, insertionOffset)}${block}${headerText.slice(insertionOffset)}`;
+}
+const UE_CLASS_REFERENCE_PATTERN = /\b([AUI][A-Z][A-Za-z0-9_]*)\s*[*&>]/gu;
+function ensureForwardDeclarations(headerText, signature, className) {
+	const candidates = /* @__PURE__ */ new Set();
+	for (const match of signature.matchAll(UE_CLASS_REFERENCE_PATTERN)) {
+		const typeName = match[1];
+		if (typeName === void 0 || typeName === className) continue;
+		if (new RegExp(String.raw`\b${typeName}\b`, "u").test(headerText)) continue;
+		candidates.add(typeName);
+	}
+	if (candidates.size === 0) return {
+		addedTypes: [],
+		headerText
+	};
+	const macroMatch = /^[ \t]*(?:UCLASS|USTRUCT|UINTERFACE|UENUM)\s*\(/mu.exec(headerText);
+	if (macroMatch === null) return {
+		addedTypes: [],
+		headerText
+	};
+	const addedTypes = [...candidates].sort();
+	const block = `${addedTypes.map((typeName) => `class ${typeName};`).join("\n")}\n\n`;
+	return {
+		addedTypes,
+		headerText: `${headerText.slice(0, macroMatch.index)}${block}${headerText.slice(macroMatch.index)}`
+	};
+}
+function memberAlreadyDeclared(headerText, name) {
+	return new RegExp(String.raw`\b${name}\b\s*(?:[;=(\[])`, "u").test(headerText);
+}
+function deriveSourcePath(headerPath) {
+	const parsed = path.parse(headerPath);
+	const segments = parsed.dir.split(path.sep);
+	const publicIndex = segments.lastIndexOf("Public");
+	const directory = publicIndex === -1 ? parsed.dir : [
+		...segments.slice(0, publicIndex),
+		"Private",
+		...segments.slice(publicIndex + 1)
+	].join(path.sep);
+	return path.join(directory, `${parsed.name}.cpp`);
+}
+async function fileExists(filePath) {
+	try {
+		await stat(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function addReflectedMember(input) {
+	const name = input.name.trim();
+	if (!IDENTIFIER_PATTERN.test(name)) throw new ModuleScaffoldError(`Member name '${name}' is not a valid C++ identifier.`);
+	const className = input.className.trim();
+	if (!IDENTIFIER_PATTERN.test(className)) throw new ModuleScaffoldError(`Class name '${className}' is not a valid C++ identifier.`);
+	const headerPath = path.resolve(input.headerPath.trim());
+	let headerText;
+	try {
+		headerText = await readFile(headerPath, "utf8");
+	} catch (error) {
+		throw new ModuleScaffoldError(`Header not found at ${headerPath}.`, { cause: error });
+	}
+	if (memberAlreadyDeclared(headerText, name)) throw new ModuleScaffoldError(`'${name}' is already declared in ${headerPath}.`);
+	if (input.kind === "property") return await addProperty(input, {
+		className,
+		headerPath,
+		headerText,
+		name
+	});
+	return await addFunction(input, {
+		className,
+		headerPath,
+		headerText,
+		name
+	});
+}
+async function addProperty(input, context) {
+	const type = input.type?.trim();
+	if (type === void 0 || type.length === 0) throw new ModuleScaffoldError("A UPROPERTY needs a type.");
+	validatePropertySpecifiers(input.specifiers);
+	if (requiresCategory(input.specifiers) && (input.category === void 0 || input.category.trim().length === 0)) throw new ModuleScaffoldError("A UPROPERTY exposed to the editor or Blueprint needs a category.");
+	const initializer = input.defaultValue?.trim();
+	const declaration = `\t${type} ${context.name}${initializer === void 0 || initializer.length === 0 ? "" : ` = ${initializer}`};`;
+	const memberLines = [`\tUPROPERTY(${renderSpecifierList(input.specifiers, input.category)})`, declaration];
+	const forwardDeclared = ensureForwardDeclarations(context.headerText, type, context.className);
+	await writeFile(context.headerPath, insertMemberIntoHeader(forwardDeclared.headerText, context.className, memberLines), "utf8");
+	return {
+		className: context.className,
+		declaration: memberLines.join("\n"),
+		forwardDeclaredTypes: forwardDeclared.addedTypes,
+		headerPath: context.headerPath,
+		name: context.name
+	};
+}
+async function addFunction(input, context) {
+	const returnType = input.returnType?.trim() ?? "void";
+	const parameters = input.parameters?.trim() ?? "";
+	validateFunctionSpecifiers(input.specifiers, returnType);
+	if (requiresCategory(input.specifiers) && (input.category === void 0 || input.category.trim().length === 0)) throw new ModuleScaffoldError("A UFUNCTION exposed to Blueprint needs a category.");
+	const declaration = `\t${returnType} ${context.name}(${parameters});`;
+	const memberLines = [`\tUFUNCTION(${renderSpecifierList(input.specifiers, input.category)})`, declaration];
+	const forwardDeclared = ensureForwardDeclarations(context.headerText, `${returnType} ${parameters}`, context.className);
+	await writeFile(context.headerPath, insertMemberIntoHeader(forwardDeclared.headerText, context.className, memberLines), "utf8");
+	const result = {
+		className: context.className,
+		declaration: memberLines.join("\n"),
+		forwardDeclaredTypes: forwardDeclared.addedTypes,
+		headerPath: context.headerPath,
+		name: context.name
+	};
+	if (hasSpecifier(input.specifiers, "BlueprintImplementableEvent")) return result;
+	const sourcePath = path.resolve((input.sourcePath ?? deriveSourcePath(context.headerPath)).trim());
+	if (!await fileExists(sourcePath)) return result;
+	const body = returnType === "void" ? "" : "	return {};\n";
+	const definedName = hasSpecifier(input.specifiers, "BlueprintNativeEvent") ? `${context.name}_Implementation` : context.name;
+	const definition = `\n${returnType} ${context.className}::${definedName}(${parameters})\n{\n${body}}\n`;
+	const sourceText = await readFile(sourcePath, "utf8");
+	await writeFile(sourcePath, `${sourceText.replace(/\s*$/u, "\n")}${definition}`, "utf8");
+	result.definition = definition.trim();
+	result.sourcePath = sourcePath;
+	return result;
+}
+const SUBSYSTEM_LIFECYCLE = [{
+	declaration: "virtual void Initialize(FSubsystemCollectionBase& Collection) override;",
+	definition: "void %CLASS%::Initialize(FSubsystemCollectionBase& Collection)\n{\n	Super::Initialize(Collection);\n}"
+}, {
+	declaration: "virtual void Deinitialize() override;",
+	definition: "void %CLASS%::Deinitialize()\n{\n	Super::Deinitialize();\n}"
+}];
+const CLASS_TEMPLATE_SPECS = {
+	editor_subsystem: {
+		headerIncludes: ["EditorSubsystem.h"],
+		overrides: SUBSYSTEM_LIFECYCLE,
+		parentClass: "UEditorSubsystem",
+		requiredModuleDependencies: ["EditorSubsystem"]
+	},
+	game_instance_subsystem: {
+		headerIncludes: ["Subsystems/GameInstanceSubsystem.h"],
+		overrides: SUBSYSTEM_LIFECYCLE,
+		parentClass: "UGameInstanceSubsystem",
+		requiredModuleDependencies: ["Engine"]
+	},
+	world_subsystem: {
+		headerIncludes: ["Subsystems/WorldSubsystem.h"],
+		overrides: SUBSYSTEM_LIFECYCLE,
+		parentClass: "UWorldSubsystem",
+		requiredModuleDependencies: ["Engine"]
+	}
+};
+function renderInterfaceHeader(interfaceName, apiMacro, includePath) {
+	const shimClassName = `U${interfaceName.slice(1)}`;
+	return `#pragma once
+
+#include "CoreMinimal.h"
+#include "UObject/Interface.h"
+
+#include "${path.basename(includePath, ".h")}.generated.h"
+
+UINTERFACE(MinimalAPI, BlueprintType)
+class ${shimClassName} : public UInterface
+{
+\tGENERATED_BODY()
+};
+
+class ${apiMacro} ${interfaceName}
+{
+\tGENERATED_BODY()
+
+public:
+};
+`;
+}
+function renderSubsystemHeader(className, apiMacro, includePath, spec) {
+	const includes = spec.headerIncludes.map((include) => `#include "${include}"`).join("\n");
+	const overrides = spec.overrides.map((entry) => `\t${entry.declaration}`).join("\n");
+	return `#pragma once
+
+#include "CoreMinimal.h"
+${includes}
+
+#include "${path.basename(includePath, ".h")}.generated.h"
+
+UCLASS()
+class ${apiMacro} ${className} : public ${spec.parentClass}
+{
+\tGENERATED_BODY()
+
+public:
+${overrides}
+};
+`;
+}
+function renderTemplateSource(className, includePath, spec) {
+	const header = `#include "${includePath}"\n`;
+	if (spec === void 0 || spec.overrides.length === 0) return header;
+	return `${header}\n${spec.overrides.map((entry) => entry.definition.replaceAll("%CLASS%", className)).join("\n\n")}\n`;
+}
+async function scaffoldClassTemplate(input) {
+	const className = input.className.trim();
+	const moduleName = input.moduleName.trim();
+	if (!IDENTIFIER_PATTERN.test(moduleName)) throw new ModuleScaffoldError(`Module name '${moduleName}' is not a valid C++ identifier.`);
+	if (input.template === "interface") {
+		if (!INTERFACE_NAME_PATTERN.test(className)) throw new ModuleScaffoldError(`Interface name '${className}' must start with I, e.g. IDamageable.`);
+	} else if (!UCLASS_NAME_PATTERN.test(className)) throw new ModuleScaffoldError(`Class name '${className}' must start with U, e.g. UCombatSubsystem.`);
+	const subdirectory = input.subdirectory?.trim().replace(/^[\\/]+|[\\/]+$/gu, "") ?? "";
+	if (subdirectory.includes("..")) throw new ModuleScaffoldError(`Subdirectory '${subdirectory}' must stay inside the module.`);
+	const fileStem = className.slice(1);
+	const moduleRoot = path.resolve(input.moduleRoot.trim());
+	const headerPath = path.join(moduleRoot, "Public", subdirectory, `${fileStem}.h`);
+	const sourcePath = path.join(moduleRoot, "Private", subdirectory, `${fileStem}.cpp`);
+	if (await fileExists(headerPath)) throw new ModuleScaffoldError(`Header already exists at ${headerPath}; refusing to overwrite it.`);
+	if (await fileExists(sourcePath)) throw new ModuleScaffoldError(`Source already exists at ${sourcePath}; refusing to overwrite it.`);
+	const apiMacro = `${moduleName.toUpperCase()}_API`;
+	const includePath = subdirectory.length === 0 ? `${fileStem}.h` : `${subdirectory.replaceAll("\\", "/")}/${fileStem}.h`;
+	const spec = input.template === "interface" ? void 0 : CLASS_TEMPLATE_SPECS[input.template];
+	const headerText = spec === void 0 ? renderInterfaceHeader(className, apiMacro, includePath) : renderSubsystemHeader(className, apiMacro, includePath, spec);
+	await mkdir(path.dirname(headerPath), { recursive: true });
+	await mkdir(path.dirname(sourcePath), { recursive: true });
+	await writeFile(headerPath, headerText, "utf8");
+	await writeFile(sourcePath, renderTemplateSource(className, includePath, spec), "utf8");
+	return {
+		className,
+		createdFiles: [headerPath, sourcePath],
+		headerPath,
+		requiredModuleDependencies: spec?.requiredModuleDependencies ?? ["CoreUObject"],
+		sourcePath,
+		template: input.template
+	};
+}
+//#endregion
 //#region src/moduleScaffold.ts
 const MODULE_DESCRIPTOR_TYPES = [
 	"Runtime",
@@ -13793,8 +14851,412 @@ function isPlainObject(value) {
 function getErrorCode(error) {
 	if (error instanceof Error && "code" in error && typeof error.code === "string") return error.code;
 }
+const SKIPPED_DIRECTORY_NAMES = /* @__PURE__ */ new Set([
+	".git",
+	".svn",
+	"Binaries",
+	"DerivedDataCache",
+	"Intermediate",
+	"Saved",
+	"ThirdParty",
+	"node_modules"
+]);
+const UCLASS_MACRO_PATTERN = /^\s*UCLASS\s*\(/u;
+const UINTERFACE_MACRO_PATTERN = /^\s*UINTERFACE\s*\(/u;
+const USTRUCT_MACRO_PATTERN = /^\s*USTRUCT\s*\(/u;
+const UENUM_MACRO_PATTERN = /^\s*UENUM\s*\(/u;
+const UFUNCTION_MACRO_PATTERN = /^\s*UFUNCTION\s*\(/u;
+const UPROPERTY_MACRO_PATTERN = /^\s*UPROPERTY\s*\(/u;
+const CLASS_DECLARATION_PATTERN = /^\s*class\s+(?:[A-Za-z_][A-Za-z0-9_]*_API\s+)?(?<symbol>[A-Za-z_][A-Za-z0-9_]*)\b(?<rest>.*)$/u;
+const STRUCT_DECLARATION_PATTERN = /^\s*struct\s+(?:[A-Za-z_][A-Za-z0-9_]*_API\s+)?(?<symbol>[A-Za-z_][A-Za-z0-9_]*)\b(?<rest>.*)$/u;
+const ENUM_DECLARATION_PATTERN = /^\s*enum(?:\s+(?:class|struct))?\s+(?<symbol>[A-Za-z_][A-Za-z0-9_]*)\b/u;
+const BASE_CLASS_PATTERN = /:\s*public\s+(?<parent>[A-Za-z_][A-Za-z0-9_:]*)/u;
+const FUNCTION_DECLARATION_PATTERN = /(?<symbol>[A-Za-z_][A-Za-z0-9_]*)\s*\(/u;
+const PROPERTY_DECLARATION_PATTERN = /(?<symbol>[A-Za-z_][A-Za-z0-9_]*)\s*(?:\[[^\]]*\])?\s*(?:=[^;]*)?;\s*$/u;
+const symbolKindSchema = z.enum([
+	"class",
+	"enum",
+	"function",
+	"interface",
+	"property",
+	"struct"
+]);
+const symbolRecordSchema = z.object({
+	file: z.string(),
+	includePath: z.string().optional(),
+	kind: symbolKindSchema,
+	line: z.number().int().min(1),
+	module: z.string().optional(),
+	owner: z.string().optional(),
+	parent: z.string().optional(),
+	symbol: z.string()
+});
+const symbolIndexCacheSchema = z.object({
+	files: z.record(z.string(), z.object({
+		mtimeMs: z.number(),
+		records: z.array(symbolRecordSchema),
+		size: z.number()
+	})),
+	version: z.literal(1)
+});
+const nodeFileSystem = {
+	listDirectory: async (dirPath) => {
+		return (await readdir(dirPath, { withFileTypes: true })).map((entry) => ({
+			isDirectory: entry.isDirectory(),
+			name: entry.name
+		}));
+	},
+	readCache: async (filePath) => readFile(filePath, "utf8"),
+	readFile: async (filePath) => readFile(filePath, "utf8"),
+	stat: async (filePath) => {
+		const stats = await stat(filePath);
+		return {
+			mtimeMs: stats.mtimeMs,
+			size: stats.size
+		};
+	},
+	writeCache: async (filePath, contents) => {
+		await mkdir(path.dirname(filePath), { recursive: true });
+		await writeFile(filePath, contents, "utf8");
+	}
+};
+function symbolIndexCacheFileName(roots) {
+	return `symbols-${createHash("sha256").update([...roots].sort().join("\0")).digest("hex").slice(0, 16)}.json`;
+}
+function deriveIncludePath(filePath) {
+	const segments = filePath.split(/[\\/]/u);
+	for (let index = segments.length - 2; index >= 0; index -= 1) {
+		const segment = segments[index];
+		if (segment === "Public" || segment === "Classes" || segment === "Private") return segments.slice(index + 1).join("/");
+	}
+}
+function stripLineComment(line) {
+	const commentIndex = line.indexOf("//");
+	return commentIndex === -1 ? line : line.slice(0, commentIndex);
+}
+function isDeclarationCandidate(line) {
+	const trimmed = stripLineComment(line).trim();
+	return trimmed.length > 0 && !trimmed.startsWith("#") && !trimmed.startsWith("*") && !trimmed.startsWith("/*");
+}
+function parseReflectedSymbols(contents, filePath, module) {
+	const includePath = deriveIncludePath(filePath);
+	const lines = contents.split(/\r?\n/u);
+	const records = [];
+	let owner;
+	function base(kind, symbol, line) {
+		const record = {
+			file: filePath,
+			kind,
+			line,
+			symbol
+		};
+		if (includePath !== void 0) record.includePath = includePath;
+		if (module !== void 0) record.module = module;
+		return record;
+	}
+	function nextDeclaration(startIndex) {
+		for (let index = startIndex; index < Math.min(lines.length, startIndex + 8); index += 1) {
+			const raw = lines[index];
+			if (raw === void 0) return;
+			if (isDeclarationCandidate(raw)) return {
+				index,
+				text: stripLineComment(raw)
+			};
+		}
+	}
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (line === void 0) continue;
+		const isEnum = UENUM_MACRO_PATTERN.test(line);
+		const isStruct = USTRUCT_MACRO_PATTERN.test(line);
+		const isInterface = UINTERFACE_MACRO_PATTERN.test(line);
+		if (UCLASS_MACRO_PATTERN.test(line) || isStruct || isEnum || isInterface) {
+			const declaration = nextDeclaration(index + 1);
+			if (!declaration) continue;
+			if (isEnum) {
+				const match = ENUM_DECLARATION_PATTERN.exec(declaration.text);
+				if (match?.groups?.symbol !== void 0) {
+					owner = void 0;
+					records.push(base("enum", match.groups.symbol, declaration.index + 1));
+				}
+				continue;
+			}
+			const match = (isStruct ? STRUCT_DECLARATION_PATTERN : CLASS_DECLARATION_PATTERN).exec(declaration.text);
+			const symbol = match?.groups?.symbol;
+			if (symbol === void 0) continue;
+			const record = base(isStruct ? "struct" : isInterface ? "interface" : "class", symbol, declaration.index + 1);
+			const parent = BASE_CLASS_PATTERN.exec(match?.groups?.rest ?? "")?.groups?.parent;
+			if (parent !== void 0) record.parent = parent;
+			owner = symbol;
+			records.push(record);
+			continue;
+		}
+		if (UFUNCTION_MACRO_PATTERN.test(line) || UPROPERTY_MACRO_PATTERN.test(line)) {
+			const isFunction = UFUNCTION_MACRO_PATTERN.test(line);
+			const declaration = nextDeclaration(index + 1);
+			if (!declaration) continue;
+			const symbol = (isFunction ? FUNCTION_DECLARATION_PATTERN : PROPERTY_DECLARATION_PATTERN).exec(declaration.text)?.groups?.symbol;
+			if (symbol === void 0) continue;
+			const record = base(isFunction ? "function" : "property", symbol, declaration.index + 1);
+			if (owner !== void 0) record.owner = owner;
+			records.push(record);
+		}
+	}
+	return records;
+}
+async function collectHeaderFiles(root, fileSystem, limit, accumulator) {
+	const queue = [root];
+	while (queue.length > 0) {
+		const current = queue.pop();
+		if (current === void 0) break;
+		let entries;
+		try {
+			entries = await fileSystem.listDirectory(current);
+		} catch {
+			continue;
+		}
+		for (const entry of entries) {
+			if (entry.isDirectory) {
+				if (!SKIPPED_DIRECTORY_NAMES.has(entry.name)) queue.push(path.join(current, entry.name));
+				continue;
+			}
+			if (!entry.name.endsWith(".h") || entry.name.endsWith(".generated.h")) continue;
+			if (accumulator.length >= limit) return true;
+			accumulator.push(path.join(current, entry.name));
+		}
+	}
+	return false;
+}
+async function resolveModuleName(filePath, fileSystem, cache) {
+	const directories = [];
+	let current = path.dirname(filePath);
+	for (let depth = 0; depth < 12; depth += 1) {
+		const cached = cache.get(current);
+		if (cached !== void 0 || cache.has(current)) {
+			for (const directory of directories) cache.set(directory, cached);
+			return cached;
+		}
+		directories.push(current);
+		let moduleName;
+		try {
+			moduleName = (await fileSystem.listDirectory(current)).find((entry) => !entry.isDirectory && entry.name.endsWith(".Build.cs"))?.name.slice(0, -9);
+		} catch {
+			moduleName = void 0;
+		}
+		if (moduleName !== void 0) {
+			for (const directory of directories) cache.set(directory, moduleName);
+			return moduleName;
+		}
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	for (const directory of directories) cache.set(directory, void 0);
+}
+async function loadCache(cacheFilePath, fileSystem) {
+	if (cacheFilePath === void 0) return {
+		files: {},
+		version: 1
+	};
+	try {
+		const contents = await fileSystem.readCache(cacheFilePath);
+		const parsed = symbolIndexCacheSchema.safeParse(JSON.parse(contents));
+		if (parsed.success) return parsed.data;
+	} catch {}
+	return {
+		files: {},
+		version: 1
+	};
+}
+async function buildSymbolIndex(options) {
+	const fileSystem = options.fileSystem ?? nodeFileSystem;
+	const limit = options.maxFiles ?? 8e4;
+	const files = [];
+	let truncated = false;
+	for (const root of options.roots) if (await collectHeaderFiles(root, fileSystem, limit, files)) {
+		truncated = true;
+		break;
+	}
+	const previous = options.refresh === true ? {
+		files: {},
+		version: 1
+	} : await loadCache(options.cacheFilePath, fileSystem);
+	const next = {
+		files: {},
+		version: 1
+	};
+	const moduleCache = /* @__PURE__ */ new Map();
+	const records = [];
+	let parsedFileCount = 0;
+	for (const file of files) {
+		let stats;
+		try {
+			stats = await fileSystem.stat(file);
+		} catch {
+			continue;
+		}
+		const cached = previous.files[file];
+		if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
+			next.files[file] = cached;
+			records.push(...cached.records);
+			continue;
+		}
+		let contents;
+		try {
+			contents = await fileSystem.readFile(file);
+		} catch {
+			continue;
+		}
+		const module = await resolveModuleName(file, fileSystem, moduleCache);
+		const parsed = parseReflectedSymbols(contents, file, module);
+		parsedFileCount += 1;
+		next.files[file] = {
+			mtimeMs: stats.mtimeMs,
+			records: parsed,
+			size: stats.size
+		};
+		records.push(...parsed);
+	}
+	if (options.cacheFilePath !== void 0) try {
+		await fileSystem.writeCache(options.cacheFilePath, JSON.stringify(next));
+	} catch {}
+	const result = {
+		fileCount: files.length,
+		parsedFileCount,
+		records,
+		truncated
+	};
+	if (options.cacheFilePath !== void 0) result.cacheFilePath = options.cacheFilePath;
+	return result;
+}
+function searchSymbolIndex(records, options) {
+	const needle = options.symbol.toLowerCase();
+	const allowedKinds = options.kinds === void 0 ? void 0 : new Set(options.kinds);
+	const exact = [];
+	const prefix = [];
+	const substring = [];
+	for (const record of records) {
+		if (allowedKinds && !allowedKinds.has(record.kind)) continue;
+		const candidate = record.symbol.toLowerCase();
+		if (candidate === needle) {
+			exact.push({
+				...record,
+				match: "exact"
+			});
+			continue;
+		}
+		if (candidate.startsWith(needle)) {
+			prefix.push({
+				...record,
+				match: "prefix"
+			});
+			continue;
+		}
+		if (candidate.includes(needle)) substring.push({
+			...record,
+			match: "substring"
+		});
+	}
+	const ordered = [
+		...exact,
+		...prefix,
+		...substring
+	];
+	return {
+		matches: ordered.slice(0, options.maxResults),
+		totalCount: ordered.length
+	};
+}
 //#endregion
 //#region src/tools/codeGen.ts
+const findSymbolInputSchema = {
+	engineVersion: engineVersionSchema,
+	kinds: z.array(z.enum([
+		"class",
+		"enum",
+		"function",
+		"interface",
+		"property",
+		"struct"
+	])).min(1).optional().describe("Restrict results to these reflected symbol kinds; defaults to every kind."),
+	maxResults: z.number().int().min(1).max(200).default(25).describe("Maximum matches to return, ordered exact then prefix then substring (1-200, default 25)."),
+	projectPath: z.string().trim().min(1).optional().describe("Path to the .uproject file or its directory; required unless scope is \"engine\"."),
+	refresh: z.boolean().default(false).describe("Discard the cached index and rescan every header."),
+	scope: z.enum([
+		"all",
+		"engine",
+		"project"
+	]).default("all").describe("Which source trees to index: the engine install, the project, or both."),
+	symbol: z.string().trim().min(1).describe("Reflected symbol name to look up, e.g. \"UCharacterMovementComponent\".")
+};
+const addReflectedMemberInputSchema = {
+	category: z.string().trim().min(1).optional().describe("Editor category for the member; required when a Blueprint or editor specifier is used."),
+	className: z.string().trim().min(1).describe("Class or struct in the header to add the member to."),
+	defaultValue: z.string().trim().min(1).optional().describe("In-class initializer for a property, e.g. \"100.f\"; properties only."),
+	headerPath: z.string().trim().min(1).describe("Absolute path to the header declaring the class."),
+	kind: z.enum(REFLECTED_MEMBER_KINDS).describe("Whether to add a UPROPERTY or a UFUNCTION."),
+	name: z.string().trim().min(1).describe("Member name, a valid C++ identifier."),
+	parameters: z.string().trim().optional().describe("Parameter list for a function, verbatim C++ (e.g. \"float Amount, AActor* Instigator\")."),
+	returnType: z.string().trim().min(1).optional().describe("Return type for a function; defaults to void."),
+	sourcePath: z.string().trim().min(1).optional().describe("Where to append the function stub; defaults to the Private/*.cpp matching the header."),
+	specifiers: z.array(z.string().trim().min(1)).max(32).default([]).describe("UPROPERTY/UFUNCTION specifiers, e.g. [\"EditAnywhere\", \"BlueprintReadWrite\"]. Validated against the UHT rules before anything is written."),
+	type: z.string().trim().min(1).optional().describe("C++ type for a property, e.g. \"float\" or \"TObjectPtr<AActor>\".")
+};
+const scaffoldClassTemplateInputSchema = {
+	className: z.string().trim().min(1).describe("Class name with its UE prefix: I-prefixed for an interface, U-prefixed for a subsystem."),
+	moduleName: z.string().trim().min(1).describe("Owning module, used for the MODULENAME_API export macro."),
+	moduleRoot: z.string().trim().min(1).describe("Absolute path to the module directory holding Public/ and Private/."),
+	subdirectory: z.string().trim().optional().describe("Optional path under Public/ and Private/ to place the pair in, e.g. \"Combat\"."),
+	template: z.enum(CLASS_TEMPLATES).describe("Which class template to generate.")
+};
+async function findSymbol(input, dependencies, context = createEngineToolchainContext(), overrides = {}) {
+	if (input.scope !== "engine" && input.projectPath === void 0) throw new EngineToolchainError(`find_symbol scope "${input.scope}" needs a projectPath.`);
+	const roots = [];
+	let engineVersion;
+	if (input.scope !== "project") {
+		const uprojectPath = input.projectPath === void 0 ? void 0 : (await resolveProjectPaths(input.projectPath, context)).uprojectPath;
+		const engine = await resolveEngine({
+			context,
+			engineVersion: input.engineVersion,
+			uprojectPath
+		});
+		engineVersion = engine.engineVersion;
+		roots.push(path.join(engine.engineRoot, "Engine", "Source"), path.join(engine.engineRoot, "Engine", "Plugins"));
+	}
+	if (input.scope !== "engine" && input.projectPath !== void 0) {
+		const { projectDirectory } = await resolveProjectPaths(input.projectPath, context);
+		roots.push(path.join(projectDirectory, "Source"), path.join(projectDirectory, "Plugins"));
+	}
+	const cacheDirectory = overrides.cacheDirectory ?? resolveSymbolIndexCacheDirectory({ env: context.env });
+	const index = await buildSymbolIndex({
+		cacheFilePath: path.join(cacheDirectory, symbolIndexCacheFileName(roots)),
+		...overrides.fileSystem === void 0 ? {} : { fileSystem: overrides.fileSystem },
+		refresh: input.refresh,
+		roots
+	});
+	const { matches, totalCount } = searchSymbolIndex(index.records, {
+		...input.kinds === void 0 ? {} : { kinds: input.kinds },
+		maxResults: input.maxResults,
+		symbol: input.symbol
+	});
+	dependencies.logger.info({
+		fileCount: index.fileCount,
+		parsedFileCount: index.parsedFileCount,
+		symbol: input.symbol,
+		totalCount
+	}, "Searched the Unreal reflected symbol index");
+	return {
+		...engineVersion === void 0 ? {} : { engineVersion },
+		fileCount: index.fileCount,
+		matches,
+		parsedFileCount: index.parsedFileCount,
+		roots,
+		scope: input.scope,
+		symbol: input.symbol,
+		totalCount,
+		truncated: index.truncated || matches.length < totalCount
+	};
+}
 const createCppClassInputSchema = {
 	className: bridgeCreateCppClassRequestSchema.shape.className.describe("Unprefixed C++ class name to generate (e.g. MyCharacter); the engine adds the A/U/F prefix that matches the parent class."),
 	classPath: bridgeCreateCppClassRequestSchema.shape.classPath.describe("Optional path relative to the target module's source directory (e.g. Public/Characters). Defaults to the module source root."),
@@ -13911,6 +15373,27 @@ function registerCodeGenTools(server, dependencies) {
 			projectId
 		}, dependencies));
 	});
+	server.registerTool("find_symbol", {
+		description: "Look up a reflected Unreal symbol (UCLASS/USTRUCT/UENUM/UINTERFACE type, or a UFUNCTION/UPROPERTY member) across the engine install and the project, returning the declaring header, the owning module and the #include path to use. Results are ordered exact, then prefix, then substring. The header index is cached per source-root set and refreshed incrementally by file mtime, so the first call after an engine install pays a full scan. Server-side; does not require a running editor.",
+		inputSchema: findSymbolInputSchema,
+		title: "Find Symbol"
+	}, async (input) => {
+		return toToolSuccess(await findSymbol(input, dependencies));
+	});
+	server.registerTool("add_reflected_member", {
+		description: "Insert a UPROPERTY or UFUNCTION into an existing class or struct header, and append a matching .cpp stub for a function. Specifiers are validated against the UHT rules (conflicting edit/visibility specifiers, BlueprintReadOnly with BlueprintReadWrite, an RPC without Reliable/Unreliable or with a non-void return, a bare ReplicatedUsing) and nothing is written when they fail. The member goes in its own public: section right after GENERATED_BODY(), and any UE type it names by pointer or reference is forward-declared above the class. Server-side; does not require a running editor.",
+		inputSchema: addReflectedMemberInputSchema,
+		title: "Add Reflected Member"
+	}, async (input) => {
+		return toToolSuccess(await addReflectedMember(input));
+	});
+	server.registerTool("scaffold_class_template", {
+		description: "Write a header/source pair for a class shape the New C++ Class wizard does not template well: a UINTERFACE/IInterface pair, or a Game Instance, World or Editor subsystem with its Initialize/Deinitialize overrides. Returns the module dependencies the template needs in Build.cs. Refuses to overwrite an existing file. Server-side; does not require a running editor.",
+		inputSchema: scaffoldClassTemplateInputSchema,
+		title: "Scaffold Class Template"
+	}, async (input) => {
+		return toToolSuccess(await scaffoldClassTemplate(input));
+	});
 }
 const codeGenToolDomain = {
 	domain: "codeGen",
@@ -13918,7 +15401,10 @@ const codeGenToolDomain = {
 	toolNames: [
 		"add_module",
 		"create_cpp_class",
-		"get_create_class_status"
+		"get_create_class_status",
+		"find_symbol",
+		"add_reflected_member",
+		"scaffold_class_template"
 	]
 };
 //#endregion
@@ -13929,6 +15415,10 @@ const getCompileStatusInputSchema = {
 	compileJobId: z.string().trim().min(1).max(512).describe("compileJobId returned by trigger_live_compile or trigger_hot_reload identifying the compile job to poll."),
 	projectId: projectIdSchema
 };
+const getLiveCompileDetailsInputSchema = {
+	compileJobId: z.string().trim().min(1).max(512).describe("compileJobId returned by trigger_live_compile identifying the compile job to report on."),
+	projectId: projectIdSchema
+};
 async function triggerLiveCompile(projectId, dependencies) {
 	const normalizedProjectId = projectIdSchema.parse(projectId);
 	const entry = dependencies.registry.getProject(normalizedProjectId);
@@ -13996,6 +15486,29 @@ function buildGetCompileStatusResult(response, projectId) {
 	if (response.restartReason !== void 0) result.restartReason = response.restartReason;
 	return result;
 }
+async function getLiveCompileDetails(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeGetLiveCompileDetailsRequest(createBridgeGetLiveCompileDetailsRequest(input.compileJobId), {
+		connectTimeoutMs: dependencies.pingTimeoutMs,
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: dependencies.pingTimeoutMs
+	});
+	if (!response.ok) throw new Error(`Bridge get_live_compile_details failed (${response.error.code}): ${response.error.message}`);
+	return {
+		compileJobId: response.compileJobId,
+		patchedFunctions: response.patchedFunctions,
+		patchedModules: response.patchedModules,
+		projectId: normalizedProjectId,
+		rejections: response.rejections,
+		...response.restartReason === void 0 ? {} : { restartReason: response.restartReason },
+		...response.restartRequired === void 0 ? {} : { restartRequired: response.restartRequired },
+		state: response.state,
+		truncated: response.truncated
+	};
+}
 function registerCompileTools(server, dependencies) {
 	server.registerTool("trigger_live_compile", {
 		description: "Trigger an Unreal Live Coding recompile of patched modules for a projectId; tail stream_output_log (LogLiveCoding) for build output.",
@@ -14021,6 +15534,16 @@ function registerCompileTools(server, dependencies) {
 			projectId
 		}, dependencies));
 	});
+	server.registerTool("get_live_compile_details", {
+		description: "Report what a Live Coding compile actually did for a projectId: the modules it patched, the reasons it refused a change, and whether the editor needs restarting because a reflected type's layout changed. get_compile_status answers pass/fail; this answers what was applied. Windows only in practice — Live Coding ships only where the engine supports it.",
+		inputSchema: getLiveCompileDetailsInputSchema,
+		title: "Get Live Compile Details"
+	}, async ({ compileJobId, projectId }) => {
+		return toToolSuccess(await getLiveCompileDetails({
+			compileJobId,
+			projectId
+		}, dependencies));
+	});
 }
 const compileToolDomain = {
 	domain: "compile",
@@ -14028,7 +15551,8 @@ const compileToolDomain = {
 	toolNames: [
 		"trigger_live_compile",
 		"trigger_hot_reload",
-		"get_compile_status"
+		"get_compile_status",
+		"get_live_compile_details"
 	]
 };
 //#endregion
@@ -16229,6 +17753,8 @@ async function sendProgressNotification(extra, logger, params) {
 //#region src/buildDiagnostics.ts
 const CLANG_DIAGNOSTIC_PATTERN = /^(?<file>.+?):(?<line>\d+):(?:(?<column>\d+):)?\s+(?<severity>fatal error|error|warning):\s+(?<message>.*)$/u;
 const MSVC_DIAGNOSTIC_PATTERN = /^(?<file>.+?)\((?<line>\d+)(?:,\d+)?\):\s+(?<severity>fatal error|error|warning)\s+(?<code>[A-Z]+\d+):\s+(?<message>.*)$/u;
+const UHT_LINE_PREFIX_PATTERN = /^(?:\[\d+\/\d+\]\s+)?(?:(?:LogCompile|LogInit|UnrealHeaderTool)\s*:\s*)?/u;
+const UHT_DIAGNOSTIC_PATTERN = /^(?<file>.+?)\((?<line>\d+)(?:,\d+)?\):\s+(?<severity>Error|Warning)(?:\s+(?<code>UHT\d+))?:\s+(?<message>.+)$/u;
 const CLANG_TIDY_PATTERN = /^(?<file>.+?):(?<line>\d+):(?<column>\d+):\s+(?<severity>error|warning):\s+(?<message>.*?)(?:\s+\[(?<check>[^\]]+)\])?$/u;
 const COOK_LINE_PREFIX_PATTERN = /^(?:\[[^\]]*\]\s*)*(?:[A-Za-z]+Helper:\s*[^:]*:\s*)?/u;
 const COOK_DIAGNOSTIC_PATTERN = /^(?<category>[A-Za-z_][A-Za-z0-9_]*):\s+(?<severity>Error|Warning)(?::)?\s+(?<message>.+)$/u;
@@ -16312,7 +17838,7 @@ function parseBuildDiagnostics(output) {
 	for (const rawLine of output.split(/\r?\n/u)) {
 		const line = rawLine.trim();
 		if (line.length === 0) continue;
-		const match = CLANG_DIAGNOSTIC_PATTERN.exec(line) ?? MSVC_DIAGNOSTIC_PATTERN.exec(line);
+		const match = CLANG_DIAGNOSTIC_PATTERN.exec(line) ?? MSVC_DIAGNOSTIC_PATTERN.exec(line) ?? UHT_DIAGNOSTIC_PATTERN.exec(line.replace(UHT_LINE_PREFIX_PATTERN, ""));
 		if (!match?.groups) continue;
 		const groups = match.groups;
 		const { file, line: lineText, message, severity } = groups;
@@ -16323,7 +17849,7 @@ function parseBuildDiagnostics(output) {
 			line: Number.parseInt(lineText, 10),
 			message: `${code}${message}`.trim()
 		};
-		const isError = severity === "error" || severity === "fatal error";
+		const isError = severity === "error" || severity === "fatal error" || severity === "Error";
 		const target = isError ? errors : warnings;
 		const seen = isError ? seenErrors : seenWarnings;
 		const key = diagnosticKey(diagnostic);
@@ -16363,6 +17889,79 @@ function parseClangTidyFindings(output) {
 	}
 	return findings;
 }
+function clampInteger(value, minimum, maximum) {
+	return Math.min(Math.max(Math.trunc(value), minimum), maximum);
+}
+async function readSourceLines(filePath, cache, maxFileBytes, readFile) {
+	const cached = cache.get(filePath);
+	if (cached !== void 0) return cached;
+	let lines = null;
+	try {
+		const contents = await readFile(filePath);
+		lines = Buffer.byteLength(contents, "utf8") > maxFileBytes ? null : contents.split(/\r?\n/u);
+	} catch {
+		lines = null;
+	}
+	cache.set(filePath, lines);
+	return lines;
+}
+async function attachSourceContext(diagnostics, options) {
+	const contextLines = clampInteger(options.contextLines ?? 3, 0, 10);
+	const maxFileBytes = Math.max(0, Math.trunc(options.maxFileBytes ?? 524288));
+	const cache = /* @__PURE__ */ new Map();
+	let budget = clampInteger(options.maxDiagnostics ?? 20, 0, 50);
+	const readAllowance = budget;
+	let reads = 0;
+	let truncated = false;
+	async function decorate(entries) {
+		const decorated = [];
+		for (const entry of entries) {
+			if (entry.file === void 0 || entry.line === void 0) {
+				decorated.push({ ...entry });
+				continue;
+			}
+			if (budget <= 0) {
+				truncated = true;
+				decorated.push({ ...entry });
+				continue;
+			}
+			if (!cache.has(entry.file)) {
+				if (reads >= readAllowance) {
+					truncated = true;
+					decorated.push({ ...entry });
+					continue;
+				}
+				reads += 1;
+			}
+			const lines = await readSourceLines(entry.file, cache, maxFileBytes, options.readFile);
+			if (!lines || entry.line > lines.length) {
+				decorated.push({ ...entry });
+				continue;
+			}
+			const startLine = Math.max(1, entry.line - contextLines);
+			const endLine = Math.min(lines.length, entry.line + contextLines);
+			budget -= 1;
+			decorated.push({
+				...entry,
+				sourceContext: {
+					endLine,
+					lines: lines.slice(startLine - 1, endLine),
+					startLine
+				}
+			});
+		}
+		return decorated;
+	}
+	const errors = await decorate(diagnostics.errors);
+	const warnings = await decorate(diagnostics.warnings);
+	return {
+		errorCount: diagnostics.errorCount,
+		errors,
+		sourceContextTruncated: truncated,
+		warningCount: diagnostics.warningCount,
+		warnings
+	};
+}
 const PACKAGE_JOB_MAX_OUTPUT_BYTES = 2097152;
 var PackageJobCapacityError = class extends Error {
 	constructor(message) {
@@ -18971,6 +20570,62 @@ const projectSettingsToolDomain = {
 	toolNames: ["set_project_settings", "set_default_gamemode"]
 };
 //#endregion
+//#region src/tools/python.ts
+const runEditorPythonInputSchema = {
+	command: bridgeRunEditorPythonRequestSchema.shape.command.describe("Python to run in the editor: a multi-statement block, a single statement, an expression to evaluate, or a .py file path with optional arguments."),
+	executionMode: bridgeRunEditorPythonRequestSchema.shape.executionMode.default("script").describe("\"script\" (default) runs a whole block of Python, or a .py file path with arguments; \"statement\" runs exactly one statement; \"evaluate\" evaluates one expression and returns its value."),
+	projectId: projectIdSchema,
+	unattended: bridgeRunEditorPythonRequestSchema.shape.unattended.default(true).describe("Suppress modal dialogs the script would otherwise block the editor on (default true).")
+};
+async function runEditorPython(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const entry = dependencies.registry.getProject(normalizedProjectId);
+	if (!entry) throw new Error(`No registered Unreal engine was found for projectId '${normalizedProjectId}'.`);
+	const response = await sendBridgeRunEditorPythonRequest(createBridgeRunEditorPythonRequest(input.command, {
+		executionMode: input.executionMode,
+		unattended: input.unattended
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge run_editor_python failed (${response.error.code}): ${response.error.message}`);
+	dependencies.logger.info({
+		executionMode: input.executionMode,
+		projectId: normalizedProjectId,
+		state: response.state
+	}, "Ran editor Python through the bridge");
+	return {
+		errors: response.errors,
+		...response.message === void 0 ? {} : { message: response.message },
+		output: response.output,
+		projectId: normalizedProjectId,
+		...response.result === void 0 ? {} : { result: response.result },
+		state: response.state,
+		truncated: response.truncated
+	};
+}
+function registerPythonTools(server, dependencies) {
+	server.registerTool("run_editor_python", {
+		description: "Execute Python inside the running editor for a projectId and return its log output, error lines and evaluated result. Runs inside one transaction, so whatever the script changes through Unreal's transaction system undoes as a single step; work the engine does not record in a transaction, such as an asset import or a file write, is not undoable. A failed run is rolled back. Disabled by default: the tool answers state 'disabled' until a human enables Allow run_editor_python in the project's MCP Bridge settings, and 'unsupported' when the Python Script Plugin is not available.",
+		inputSchema: runEditorPythonInputSchema,
+		title: "Run Editor Python"
+	}, async ({ command, executionMode, projectId, unattended }) => {
+		return toToolSuccess(await runEditorPython({
+			command,
+			executionMode,
+			projectId,
+			unattended
+		}, dependencies));
+	});
+}
+const pythonToolDomain = {
+	domain: "python",
+	register: registerPythonTools,
+	toolNames: ["run_editor_python"]
+};
+//#endregion
 //#region src/tools/reflection.ts
 const getClassReflectionInputSchema = {
 	className: bridgeGetClassReflectionRequestSchema.shape.className.describe("Reflected UCLASS or USTRUCT name. Both the UHT name and the C++ spelling work (Actor or AActor); a full path such as /Script/Engine.Actor also resolves."),
@@ -19218,8 +20873,10 @@ const buildTargetInputSchema = {
 	configuration: configurationSchema,
 	engineVersion: engineVersionSchema,
 	force: forceSchema,
+	includeSourceContext: z.boolean().default(false).describe("Attach the source lines around each located diagnostic. Off by default; snippets are capped at 20 diagnostics per build."),
 	platform: platformSchema,
 	projectPath: projectPathSchema,
+	sourceContextLines: z.number().int().min(0).max(10).default(3).describe("Source lines to include on each side of a diagnostic when includeSourceContext is true (0-10)."),
 	target: targetSchema,
 	timeoutMs: buildTimeoutSchema
 };
@@ -19271,7 +20928,14 @@ async function buildTarget(input, dependencies, context = createEngineToolchainC
 		cwd: engine.engineRoot,
 		timeoutMs: input.timeoutMs
 	});
-	const diagnostics = parseBuildDiagnostics(result.combinedOutput);
+	const parsed = parseBuildDiagnostics(result.combinedOutput);
+	const diagnostics = input.includeSourceContext ? await attachSourceContext(parsed, {
+		contextLines: input.sourceContextLines,
+		readFile: context.readFile
+	}) : {
+		...parsed,
+		sourceContextTruncated: void 0
+	};
 	const success = result.exitCode === 0 && !result.timedOut;
 	if (!success) dependencies.logger.warn({
 		errorCount: diagnostics.errorCount,
@@ -19288,6 +20952,7 @@ async function buildTarget(input, dependencies, context = createEngineToolchainC
 		exitCode: result.exitCode,
 		outputTruncated: result.truncated,
 		platform,
+		sourceContextTruncated: diagnostics.sourceContextTruncated,
 		success,
 		target: input.target,
 		timedOut: result.timedOut,
@@ -19930,6 +21595,7 @@ function registerWorldPartitionTools(server, dependencies) {
 const TOOL_CATALOG = [
 	projectToolDomain,
 	doctorToolDomain,
+	pythonToolDomain,
 	codeGenToolDomain,
 	compileToolDomain,
 	diagnosticsToolDomain,