@uemcp/server 1.8.0 → 1.9.1

package/dist/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import os, { tmpdir } from "node:os";
-import path from "node:path";
+import os, { homedir, tmpdir } from "node:os";
+import path, { join } from "node:path";
 import { z } from "zod";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -10,9 +10,10 @@ import Fastify from "fastify";
 import { Buffer as Buffer$1 } from "node:buffer";
 import pino from "pino";
 import { spawn } from "node:child_process";
-import { createReadStream } from "node:fs";
-import { access, mkdir, mkdtemp, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { createReadStream, existsSync } from "node:fs";
+import { access, copyFile, mkdir, mkdtemp, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { createInterface } from "node:readline";
+import { PNG } from "pngjs";
 //#region src/errors.ts
 var McpServerError = class extends Error {
 	constructor(message, options) {
@@ -397,14 +398,30 @@ const TOOL_METADATA = {
 	]),
 	build_texture_streaming: mutates("level", "start_editor_build"),
 	build_virtual_textures: mutates("level", "start_editor_build"),
+	call_actor_function: mutates("test", "call_actor_function", [
+		"call function",
+		"invoke",
+		"runtime"
+	]),
 	call_tool: mutates("core", void 0, ["dispatch", "invoke"]),
 	cancel_package_job: idempotentMutates("build"),
 	cancel_test_run: idempotentMutates("test", "cancel_automation_run"),
 	capture_viewport: readOnly("core", "capture_viewport", ["screenshot", "image"]),
 	checkout_assets: mutates("asset", "checkout_assets"),
 	clean_build: destroys("build", void 0, ["intermediate", "binaries"]),
+	compare_viewport_baseline: reachesOutside("core", false, "capture_viewport", [
+		"baseline",
+		"visual regression",
+		"diff",
+		"screenshot"
+	]),
 	compile_blueprint: idempotentMutates("blueprint", "compile_blueprint"),
 	connect_pins: mutates("blueprint", "connect_pins"),
+	control_blueprint_debugger: mutates("blueprint", "control_blueprint_debugger", [
+		"step",
+		"resume",
+		"debugger"
+	]),
 	convert_to_nanite: idempotentMutates("asset", "convert_to_nanite"),
 	cook_content: mutates("build", void 0, ["cook", "platform"]),
 	create_anim_blueprint: mutates("anim", "create_anim_blueprint"),
@@ -507,6 +524,11 @@ const TOOL_METADATA = {
 		"fix"
 	]),
 	get_blueprint_compile_status: readOnly("blueprint", "get_blueprint_compile_status"),
+	get_blueprint_debugger_state: readOnly("blueprint", "get_blueprint_debugger_state", [
+		"paused",
+		"call stack",
+		"watch"
+	]),
 	get_blueprint_graph: readOnly("blueprint", "get_blueprint_graph"),
 	get_blueprint_summary: readOnly("blueprint", "get_blueprint_summary"),
 	get_build_job_status: readOnly("level", "get_build_job_status"),
@@ -533,6 +555,12 @@ const TOOL_METADATA = {
 	get_current_level: readOnly("core", "get_current_level"),
 	get_editor_state: readOnly("core", "get_editor_state"),
 	get_import_job_status: readOnly("asset", "get_import_job_status"),
+	get_net_stats: readOnly("test", "get_net_stats", [
+		"network",
+		"multiplayer",
+		"replication",
+		"ping"
+	]),
 	get_open_level_status: readOnly("level", "get_open_level_status"),
 	get_package_status: readOnly("build"),
 	get_pie_status: readOnly("test", "get_pie_status"),
@@ -554,17 +582,28 @@ const TOOL_METADATA = {
 		"mesh"
 	]),
 	import_data_table: reachesOutside("asset", false, "import_data_table", ["csv", "json"]),
+	inject_input_action: mutates("input", "inject_input_action", [
+		"press",
+		"simulate input",
+		"enhanced input"
+	]),
 	launch_on_device: reachesOutside("test", false, "launch_on_device"),
 	list_actors: readOnly("core", "list_actors"),
 	list_asset_factories: readOnly("asset", "list_asset_factories"),
 	list_automation_tests: readOnly("test", "list_automation_tests"),
 	list_available_nodes: readOnly("blueprint", "list_available_nodes"),
+	list_blueprint_breakpoints: readOnly("blueprint", "list_blueprint_breakpoints", ["breakpoint"]),
 	list_config_section: readOnly("core", "list_config_section"),
 	list_data_layers: readOnly("level", "list_data_layers"),
 	list_gameplay_tags: readOnly("gas", "list_gameplay_tags"),
 	list_graph_nodes: readOnly("blueprint", "list_graph_nodes"),
 	list_launch_devices: reachesOutside("test", true, "list_launch_devices"),
 	list_material_params: readOnly("fx", "list_material_params"),
+	list_pie_worlds: readOnly("test", "list_pie_worlds", [
+		"client",
+		"server",
+		"instance"
+	]),
 	list_registered_projects: readOnly("core", void 0, [
 		"registry",
 		"editors",
@@ -625,6 +664,7 @@ const TOOL_METADATA = {
 	set_asset_property: idempotentMutates("asset", "set_asset_property"),
 	set_blackboard_keys: idempotentMutates("ai", "set_blackboard_keys"),
 	set_blend_space_samples: idempotentMutates("anim", "set_blend_space_samples"),
+	set_blueprint_breakpoint: idempotentMutates("blueprint", "set_blueprint_breakpoint", ["breakpoint", "debug"]),
 	set_bp_default: idempotentMutates("blueprint", "set_bp_default"),
 	set_config_value: idempotentMutates("core", "set_config_value"),
 	set_data_layer_state: idempotentMutates("level", "set_data_layer_state"),
@@ -671,6 +711,11 @@ const TOOL_METADATA = {
 		"block",
 		"await"
 	]),
+	watch_blueprint_pin: idempotentMutates("blueprint", "watch_blueprint_pin", [
+		"watch",
+		"pin",
+		"value"
+	]),
 	write_data_table_row: idempotentMutates("asset", "write_data_table_row")
 };
 function isToolsetName(value) {
@@ -1711,6 +1756,136 @@ function createBridgeLaunchOnDeviceRequest(deviceId, map, requestId = randomUUID
 		version: 2
 	});
 }
+const BRIDGE_CALL_ACTOR_FUNCTION_REQUEST_TYPE = "call_actor_function";
+const BRIDGE_LIST_PIE_WORLDS_REQUEST_TYPE = "list_pie_worlds";
+const BRIDGE_GET_NET_STATS_REQUEST_TYPE = "get_net_stats";
+const BRIDGE_WORLD_SELECTORS = ["editor", "pie"];
+const BRIDGE_NET_ROLES = [
+	"standalone",
+	"server",
+	"client"
+];
+const worldSelectorSchema = z.enum(BRIDGE_WORLD_SELECTORS);
+const pieInstanceIndexSchema = z.number().int().min(0).max(16);
+const netRoleSchema = z.enum(BRIDGE_NET_ROLES);
+const bridgeCallActorFunctionArgumentSchema = z.object({
+	name: z.string().trim().min(1).max(512),
+	value: z.string().max(BRIDGE_PROPERTY_VALUE_MAX_CHARS)
+});
+const bridgeCallActorFunctionRequestSchema = z.object({
+	actorPath: actorPathSchema,
+	args: z.array(bridgeCallActorFunctionArgumentSchema).max(16).default([]),
+	functionName: z.string().trim().min(1).max(512),
+	pieInstanceIndex: pieInstanceIndexSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_CALL_ACTOR_FUNCTION_REQUEST_TYPE),
+	version: z.literal(2),
+	world: worldSelectorSchema.optional()
+});
+const bridgeCallActorFunctionOutputSchema = z.object({
+	name: z.string(),
+	value: z.string()
+});
+const bridgeCallActorFunctionSuccessResponseSchema = z.object({
+	actorPath: z.string(),
+	functionName: z.string(),
+	ok: z.literal(true),
+	outputs: z.array(bridgeCallActorFunctionOutputSchema),
+	requestId: requestIdSchema,
+	returnValue: z.string().optional(),
+	type: z.literal(BRIDGE_CALL_ACTOR_FUNCTION_REQUEST_TYPE),
+	version: z.literal(2),
+	worldName: z.string()
+});
+const bridgeListPieWorldsRequestSchema = z.object({
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_LIST_PIE_WORLDS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgePieWorldSchema = z.object({
+	actorCount: z.number().int().min(0),
+	index: z.number().int().min(0),
+	isServer: z.boolean(),
+	mapName: z.string(),
+	netMode: pieNetModeSchema,
+	playerCount: z.number().int().min(0),
+	worldName: z.string()
+});
+const bridgeListPieWorldsSuccessResponseSchema = z.object({
+	active: z.boolean(),
+	message: z.string().trim().min(1).optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_LIST_PIE_WORLDS_REQUEST_TYPE),
+	version: z.literal(2),
+	worlds: z.array(bridgePieWorldSchema)
+});
+const bridgeGetNetStatsRequestSchema = z.object({
+	pieInstanceIndex: pieInstanceIndexSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_NET_STATS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeNetConnectionStatsSchema = z.object({
+	address: z.string(),
+	index: z.number().int().min(0),
+	packetLossIn: z.number().min(0),
+	packetLossOut: z.number().min(0),
+	pingMs: z.number().min(0),
+	playerName: z.string(),
+	state: z.string()
+});
+const bridgeNetWorldStatsSchema = z.object({
+	connectionCount: z.number().int().min(0),
+	connections: z.array(bridgeNetConnectionStatsSchema),
+	hasNetDriver: z.boolean(),
+	inBytesPerSecond: z.number().min(0),
+	index: z.number().int().min(0),
+	netMode: pieNetModeSchema,
+	outBytesPerSecond: z.number().min(0),
+	replicatedActorCount: z.number().int().min(0),
+	role: netRoleSchema,
+	worldName: z.string()
+});
+const bridgeGetNetStatsSuccessResponseSchema = z.object({
+	active: z.boolean(),
+	message: z.string().trim().min(1).optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_NET_STATS_REQUEST_TYPE),
+	version: z.literal(2),
+	worlds: z.array(bridgeNetWorldStatsSchema)
+});
+const bridgeCallActorFunctionResponseSchema = z.union([bridgeCallActorFunctionSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeListPieWorldsResponseSchema = z.union([bridgeListPieWorldsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetNetStatsResponseSchema = z.union([bridgeGetNetStatsSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeCallActorFunctionRequest(actorPath, functionName, options = {}, requestId = randomUUID()) {
+	return bridgeCallActorFunctionRequestSchema.parse({
+		actorPath,
+		args: options.args,
+		functionName,
+		pieInstanceIndex: options.pieInstanceIndex,
+		requestId,
+		type: BRIDGE_CALL_ACTOR_FUNCTION_REQUEST_TYPE,
+		version: 2,
+		world: options.world
+	});
+}
+function createBridgeListPieWorldsRequest(requestId = randomUUID()) {
+	return bridgeListPieWorldsRequestSchema.parse({
+		requestId,
+		type: BRIDGE_LIST_PIE_WORLDS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeGetNetStatsRequest(options = {}, requestId = randomUUID()) {
+	return bridgeGetNetStatsRequestSchema.parse({
+		pieInstanceIndex: options.pieInstanceIndex,
+		requestId,
+		type: BRIDGE_GET_NET_STATS_REQUEST_TYPE,
+		version: 2
+	});
+}
 //#endregion
 //#region src/protocol/compile.ts
 const BRIDGE_START_LIVE_COMPILE_REQUEST_TYPE = "start_live_compile";
@@ -2329,135 +2504,659 @@ function createBridgeGetCdoDefaultsRequest(className, options = {}, requestId =
 	});
 }
 //#endregion
-//#region src/protocol/diagnostics.ts
-const BRIDGE_GET_CRASH_CALLSTACK_REQUEST_TYPE = "get_crash_callstack";
-const BRIDGE_CRASH_RECORD_KINDS = ["ensure", "fatal"];
-const BRIDGE_EXEC_CONSOLE_COMMAND_REQUEST_TYPE = "exec_console_command";
-const BRIDGE_STAT_SNAPSHOT_REQUEST_TYPE = "stat_snapshot";
-const BRIDGE_START_TRACE_REQUEST_TYPE = "start_trace";
-const BRIDGE_STOP_TRACE_REQUEST_TYPE = "stop_trace";
-const BRIDGE_EXEC_CONSOLE_TARGETS = [
-	"editor",
-	"pie",
-	"none"
-];
-const BRIDGE_EXEC_CONSOLE_MAX_COMMAND_CHARS = 2048;
-const BRIDGE_START_TRACE_STATES = [
-	"started",
-	"already_tracing",
-	"unsupported"
-];
-const BRIDGE_STOP_TRACE_STATES = [
-	"stopped",
-	"not_tracing",
-	"unsupported"
+//#region src/protocol/graph.ts
+const BRIDGE_LIST_GRAPH_NODES_REQUEST_TYPE = "list_graph_nodes";
+const BRIDGE_ADD_GRAPH_NODE_REQUEST_TYPE = "add_graph_node";
+const BRIDGE_REMOVE_GRAPH_NODE_REQUEST_TYPE = "remove_graph_node";
+const BRIDGE_CONNECT_PINS_REQUEST_TYPE = "connect_pins";
+const BRIDGE_DISCONNECT_PINS_REQUEST_TYPE = "disconnect_pins";
+const BRIDGE_SET_PIN_DEFAULT_REQUEST_TYPE = "set_pin_default";
+const BRIDGE_LIST_AVAILABLE_NODES_REQUEST_TYPE = "list_available_nodes";
+const BRIDGE_GRAPH_PIN_VALUE_MAX_CHARS = 4096;
+const BRIDGE_GRAPH_NODE_POSITION_LIMIT = 1e6;
+const BRIDGE_GRAPH_NODE_KINDS = [
+	"class",
+	"function",
+	"variable_get",
+	"variable_set"
 ];
-const crashRecordKindSchema = z.enum(BRIDGE_CRASH_RECORD_KINDS);
-const crashMaxRecordsSchema = z.number().int().min(1).max(5);
-const crashMaxFramesSchema = z.number().int().min(1).max(64);
-const execConsoleTargetSchema = z.enum(BRIDGE_EXEC_CONSOLE_TARGETS);
-const consoleCommandSchema = z.string().trim().min(1).max(BRIDGE_EXEC_CONSOLE_MAX_COMMAND_CHARS);
-const consoleOutputLineSchema = z.string().max(512);
-const consoleOutputSchema = z.array(consoleOutputLineSchema).max(100);
-const startTraceStateSchema = z.enum(BRIDGE_START_TRACE_STATES);
-const stopTraceStateSchema = z.enum(BRIDGE_STOP_TRACE_STATES);
-const traceChannelSchema = z.string().trim().min(1).max(64).regex(/^[A-Za-z0-9_]+$/);
-const traceChannelArraySchema = z.array(traceChannelSchema).max(32);
-const traceFileNameSchema = z.string().trim().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/);
-const memoryMegabytesSchema = z.number().min(0);
-const frameTimingMillisecondsSchema = z.number().min(0);
-const bridgeGetCrashCallstackRequestSchema = z.object({
-	maxFrames: crashMaxFramesSchema,
-	maxRecords: crashMaxRecordsSchema,
-	requestId: requestIdSchema,
-	type: z.literal(BRIDGE_GET_CRASH_CALLSTACK_REQUEST_TYPE),
-	version: z.literal(2)
+const graphPinNameSchema = z.string().trim().min(1).max(256);
+const graphPinValueSchema = z.string().max(BRIDGE_GRAPH_PIN_VALUE_MAX_CHARS);
+const graphNodeKindSchema = z.enum(BRIDGE_GRAPH_NODE_KINDS);
+const graphNodeMaxResultsSchema = z.number().int().min(1).max(100);
+const availableNodeMaxResultsSchema = z.number().int().min(1).max(100);
+const graphNodePositionSchema = z.object({
+	x: z.number().int().min(-1e6).max(BRIDGE_GRAPH_NODE_POSITION_LIMIT).default(0),
+	y: z.number().int().min(-1e6).max(BRIDGE_GRAPH_NODE_POSITION_LIMIT).default(0)
 });
-const bridgeExecConsoleCommandRequestSchema = z.object({
-	command: consoleCommandSchema,
+const bridgeListGraphNodesRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	cursor: assetCursorSchema.optional(),
+	graphName: graphNameSchema,
+	loadIfNeeded: z.boolean().optional(),
+	maxResults: graphNodeMaxResultsSchema.optional(),
 	requestId: requestIdSchema,
-	type: z.literal(BRIDGE_EXEC_CONSOLE_COMMAND_REQUEST_TYPE),
+	type: z.literal(BRIDGE_LIST_GRAPH_NODES_REQUEST_TYPE),
 	version: z.literal(2)
 });
-const bridgeStatSnapshotRequestSchema = z.object({
+const bridgeAddGraphNodeRequestFieldsSchema = z.object({
+	assetPath: assetPathSchema,
+	graphName: graphNameSchema,
+	nodeClass: assetPathSchema.optional(),
+	kind: graphNodeKindSchema,
+	memberName: boundedStringSchema.optional(),
+	memberParentClass: assetPathSchema.optional(),
+	pinDefaults: z.record(graphPinNameSchema, graphPinValueSchema).refine((value) => Object.keys(value).length <= 64, { message: `An add_graph_node request carries at most ${String(64)} pin defaults.` }).optional(),
+	position: graphNodePositionSchema.optional(),
 	requestId: requestIdSchema,
-	type: z.literal(BRIDGE_STAT_SNAPSHOT_REQUEST_TYPE),
+	type: z.literal(BRIDGE_ADD_GRAPH_NODE_REQUEST_TYPE),
 	version: z.literal(2)
 });
-const bridgeStartTraceRequestSchema = z.object({
-	channels: traceChannelArraySchema.default([]),
-	fileName: traceFileNameSchema.optional(),
+const bridgeAddGraphNodeRequestSchema = bridgeAddGraphNodeRequestFieldsSchema.refine((value) => value.kind === "class" ? value.nodeClass !== void 0 : value.memberName !== void 0, {
+	message: "kind 'class' requires nodeClass; every other kind requires memberName.",
+	path: ["nodeClass"]
+});
+const bridgeRemoveGraphNodeRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	graphName: graphNameSchema,
+	nodeGuid: graphNodeGuidSchema,
 	requestId: requestIdSchema,
-	type: z.literal(BRIDGE_START_TRACE_REQUEST_TYPE),
+	type: z.literal(BRIDGE_REMOVE_GRAPH_NODE_REQUEST_TYPE),
 	version: z.literal(2)
 });
-const bridgeStopTraceRequestSchema = z.object({
+const graphPinPairFields = {
+	assetPath: assetPathSchema,
+	graphName: graphNameSchema,
 	requestId: requestIdSchema,
-	type: z.literal(BRIDGE_STOP_TRACE_REQUEST_TYPE),
+	sourceNodeGuid: graphNodeGuidSchema,
+	sourcePinName: graphPinNameSchema,
+	targetNodeGuid: graphNodeGuidSchema,
+	targetPinName: graphPinNameSchema,
 	version: z.literal(2)
+};
+const bridgeConnectPinsRequestSchema = z.object({
+	...graphPinPairFields,
+	type: z.literal(BRIDGE_CONNECT_PINS_REQUEST_TYPE)
 });
-const bridgeCrashFrameSchema = z.object({
-	address: nonEmptyStringSchema,
-	file: z.string().trim().min(1).optional(),
-	index: z.number().int().min(0),
-	line: z.number().int().min(1).optional(),
-	module: z.string().trim().min(1).optional(),
-	symbol: z.string().trim().min(1).optional()
+const bridgeDisconnectPinsRequestSchema = z.object({
+	...graphPinPairFields,
+	type: z.literal(BRIDGE_DISCONNECT_PINS_REQUEST_TYPE)
 });
-const bridgeCrashRecordSchema = z.object({
-	frames: z.array(bridgeCrashFrameSchema),
-	framesTruncated: z.boolean(),
-	kind: crashRecordKindSchema,
-	message: z.string(),
-	occurredAt: nonEmptyStringSchema,
-	recordId: nonEmptyStringSchema,
-	threadId: z.number().int().min(0),
-	totalFrameCount: z.number().int().min(0)
+const bridgeSetPinDefaultRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	graphName: graphNameSchema,
+	nodeGuid: graphNodeGuidSchema,
+	pinName: graphPinNameSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_SET_PIN_DEFAULT_REQUEST_TYPE),
+	value: graphPinValueSchema,
+	version: z.literal(2)
 });
-const bridgeGetCrashCallstackSuccessResponseSchema = z.object({
-	ok: z.literal(true),
-	records: z.array(bridgeCrashRecordSchema),
+const bridgeListAvailableNodesRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	cursor: assetCursorSchema.optional(),
+	graphName: graphNameSchema,
+	maxResults: availableNodeMaxResultsSchema.optional(),
+	nameFilter: boundedStringSchema.optional(),
 	requestId: requestIdSchema,
-	totalCount: z.number().int().min(0),
-	truncated: z.boolean(),
-	type: z.literal(BRIDGE_GET_CRASH_CALLSTACK_REQUEST_TYPE),
+	type: z.literal(BRIDGE_LIST_AVAILABLE_NODES_REQUEST_TYPE),
 	version: z.literal(2)
 });
-const bridgeExecConsoleCommandSuccessResponseSchema = z.object({
-	handled: z.boolean(),
+const bridgeListGraphNodesSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	graphName: z.string(),
+	nextCursor: assetCursorSchema.optional(),
+	nodeCount: z.number().int().min(0),
+	nodes: z.array(bridgeBlueprintNodeSchema).max(100),
 	ok: z.literal(true),
-	output: consoleOutputSchema,
 	requestId: requestIdSchema,
-	target: execConsoleTargetSchema,
 	truncated: z.boolean(),
-	type: z.literal(BRIDGE_EXEC_CONSOLE_COMMAND_REQUEST_TYPE),
+	type: z.literal(BRIDGE_LIST_GRAPH_NODES_REQUEST_TYPE),
 	version: z.literal(2)
 });
-const bridgeMemorySnapshotSchema = z.object({
-	availablePhysicalMb: memoryMegabytesSchema,
-	peakUsedPhysicalMb: memoryMegabytesSchema,
-	peakUsedVirtualMb: memoryMegabytesSchema,
-	usedPhysicalMb: memoryMegabytesSchema,
-	usedVirtualMb: memoryMegabytesSchema
-});
-const bridgeStatSnapshotSuccessResponseSchema = z.object({
-	capturedAt: nonEmptyStringSchema,
-	fps: z.number().min(0),
-	frameTimeMs: frameTimingMillisecondsSchema,
-	gameThreadTimeMs: frameTimingMillisecondsSchema.optional(),
-	memory: bridgeMemorySnapshotSchema,
+const bridgeAddGraphNodeSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	graphName: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	node: bridgeBlueprintNodeSchema,
 	ok: z.literal(true),
-	renderThreadTimeMs: frameTimingMillisecondsSchema.optional(),
 	requestId: requestIdSchema,
-	type: z.literal(BRIDGE_STAT_SNAPSHOT_REQUEST_TYPE),
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_ADD_GRAPH_NODE_REQUEST_TYPE),
 	version: z.literal(2)
 });
-const bridgeStartTraceSuccessResponseSchema = z.object({
+const bridgeRemoveGraphNodeSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	graphName: z.string(),
 	message: nonEmptyStringSchema.optional(),
+	nodeGuid: z.string(),
 	ok: z.literal(true),
+	removed: z.boolean(),
 	requestId: requestIdSchema,
-	state: startTraceStateSchema,
-	tracePath: nonEmptyStringSchema.optional(),
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_REMOVE_GRAPH_NODE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const graphPinPairResponseFields = {
+	assetPath: z.string(),
+	graphName: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	sourceNodeGuid: z.string(),
+	sourcePinName: z.string(),
+	state: creativeEditStateSchema,
+	targetNodeGuid: z.string(),
+	targetPinName: z.string(),
+	version: z.literal(2)
+};
+const bridgeConnectPinsSuccessResponseSchema = z.object({
+	...graphPinPairResponseFields,
+	connected: z.boolean(),
+	type: z.literal(BRIDGE_CONNECT_PINS_REQUEST_TYPE)
+});
+const bridgeDisconnectPinsSuccessResponseSchema = z.object({
+	...graphPinPairResponseFields,
+	disconnected: z.boolean(),
+	type: z.literal(BRIDGE_DISCONNECT_PINS_REQUEST_TYPE)
+});
+const bridgeSetPinDefaultSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	graphName: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	nodeGuid: z.string(),
+	ok: z.literal(true),
+	pinName: z.string(),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_SET_PIN_DEFAULT_REQUEST_TYPE),
+	value: z.string(),
+	version: z.literal(2)
+});
+const bridgeGraphActionSchema = z.object({
+	category: z.string(),
+	keywords: z.string().optional(),
+	memberName: z.string().optional(),
+	memberParentClass: z.string().optional(),
+	nodeClass: z.string(),
+	nodeKind: graphNodeKindSchema,
+	title: z.string(),
+	tooltip: z.string().optional()
+});
+const bridgeListAvailableNodesSuccessResponseSchema = z.object({
+	actions: z.array(bridgeGraphActionSchema).max(100),
+	assetPath: z.string(),
+	graphName: z.string(),
+	nextCursor: assetCursorSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	totalCount: z.number().int().min(0),
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_LIST_AVAILABLE_NODES_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeListGraphNodesResponseSchema = z.union([bridgeListGraphNodesSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddGraphNodeResponseSchema = z.union([bridgeAddGraphNodeSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeRemoveGraphNodeResponseSchema = z.union([bridgeRemoveGraphNodeSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeConnectPinsResponseSchema = z.union([bridgeConnectPinsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeDisconnectPinsResponseSchema = z.union([bridgeDisconnectPinsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetPinDefaultResponseSchema = z.union([bridgeSetPinDefaultSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeListAvailableNodesResponseSchema = z.union([bridgeListAvailableNodesSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeListGraphNodesRequest(assetPath, graphName, options = {}, requestId = randomUUID()) {
+	return bridgeListGraphNodesRequestSchema.parse({
+		assetPath,
+		cursor: options.cursor,
+		graphName,
+		loadIfNeeded: options.loadIfNeeded,
+		maxResults: options.maxResults,
+		requestId,
+		type: BRIDGE_LIST_GRAPH_NODES_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddGraphNodeRequest(assetPath, graphName, kind, options = {}, requestId = randomUUID()) {
+	return bridgeAddGraphNodeRequestSchema.parse({
+		assetPath,
+		graphName,
+		kind,
+		memberName: options.memberName,
+		memberParentClass: options.memberParentClass,
+		nodeClass: options.nodeClass,
+		pinDefaults: options.pinDefaults,
+		position: options.position,
+		requestId,
+		type: BRIDGE_ADD_GRAPH_NODE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeRemoveGraphNodeRequest(assetPath, graphName, nodeGuid, requestId = randomUUID()) {
+	return bridgeRemoveGraphNodeRequestSchema.parse({
+		assetPath,
+		graphName,
+		nodeGuid,
+		requestId,
+		type: BRIDGE_REMOVE_GRAPH_NODE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeConnectPinsRequest(assetPath, graphName, source, target, requestId = randomUUID()) {
+	return bridgeConnectPinsRequestSchema.parse({
+		assetPath,
+		graphName,
+		requestId,
+		sourceNodeGuid: source.nodeGuid,
+		sourcePinName: source.pinName,
+		targetNodeGuid: target.nodeGuid,
+		targetPinName: target.pinName,
+		type: BRIDGE_CONNECT_PINS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeDisconnectPinsRequest(assetPath, graphName, source, target, requestId = randomUUID()) {
+	return bridgeDisconnectPinsRequestSchema.parse({
+		assetPath,
+		graphName,
+		requestId,
+		sourceNodeGuid: source.nodeGuid,
+		sourcePinName: source.pinName,
+		targetNodeGuid: target.nodeGuid,
+		targetPinName: target.pinName,
+		type: BRIDGE_DISCONNECT_PINS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSetPinDefaultRequest(assetPath, graphName, nodeGuid, pinName, value, requestId = randomUUID()) {
+	return bridgeSetPinDefaultRequestSchema.parse({
+		assetPath,
+		graphName,
+		nodeGuid,
+		pinName,
+		requestId,
+		type: BRIDGE_SET_PIN_DEFAULT_REQUEST_TYPE,
+		value,
+		version: 2
+	});
+}
+function createBridgeListAvailableNodesRequest(assetPath, graphName, options = {}, requestId = randomUUID()) {
+	return bridgeListAvailableNodesRequestSchema.parse({
+		assetPath,
+		cursor: options.cursor,
+		graphName,
+		maxResults: options.maxResults,
+		nameFilter: options.nameFilter,
+		requestId,
+		type: BRIDGE_LIST_AVAILABLE_NODES_REQUEST_TYPE,
+		version: 2
+	});
+}
+//#endregion
+//#region src/protocol/debugger.ts
+const BRIDGE_SET_BLUEPRINT_BREAKPOINT_REQUEST_TYPE = "set_blueprint_breakpoint";
+const BRIDGE_LIST_BLUEPRINT_BREAKPOINTS_REQUEST_TYPE = "list_blueprint_breakpoints";
+const BRIDGE_GET_BLUEPRINT_DEBUGGER_STATE_REQUEST_TYPE = "get_blueprint_debugger_state";
+const BRIDGE_CONTROL_BLUEPRINT_DEBUGGER_REQUEST_TYPE = "control_blueprint_debugger";
+const BRIDGE_WATCH_BLUEPRINT_PIN_REQUEST_TYPE = "watch_blueprint_pin";
+const BRIDGE_BREAKPOINT_ACTIONS = [
+	"set",
+	"clear",
+	"enable",
+	"disable"
+];
+const BRIDGE_PIN_WATCH_ACTIONS = [
+	"set",
+	"clear",
+	"clear_all"
+];
+const BRIDGE_PIN_WATCH_STATES = [
+	"set",
+	"already_set",
+	"cleared",
+	"cleared_all",
+	"not_found",
+	"unsupported"
+];
+const BRIDGE_BREAKPOINT_STATES = [
+	"set",
+	"cleared",
+	"enabled",
+	"disabled",
+	"already_set",
+	"not_found",
+	"unsupported"
+];
+const BRIDGE_DEBUGGER_ACTIONS = [
+	"resume",
+	"step_over",
+	"step_into",
+	"step_out",
+	"stop"
+];
+const BRIDGE_DEBUGGER_CONTROL_STATES = [
+	"resumed",
+	"stepping",
+	"stopped",
+	"not_paused",
+	"unsupported"
+];
+const breakpointActionSchema = z.enum(BRIDGE_BREAKPOINT_ACTIONS);
+const breakpointStateSchema = z.enum(BRIDGE_BREAKPOINT_STATES);
+const pinWatchActionSchema = z.enum(BRIDGE_PIN_WATCH_ACTIONS);
+const pinWatchStateSchema = z.enum(BRIDGE_PIN_WATCH_STATES);
+const debuggerActionSchema = z.enum(BRIDGE_DEBUGGER_ACTIONS);
+const debuggerControlStateSchema = z.enum(BRIDGE_DEBUGGER_CONTROL_STATES);
+const nodeGuidSchema = z.string().trim().min(1).max(64);
+const nodeTitleSchema = z.string().trim().min(1).max(512);
+const debuggerGraphNameSchema = z.string().trim().min(1).max(512);
+const pinNameSchema = z.string().trim().min(1).max(256);
+const bridgeSetBlueprintBreakpointRequestSchema = z.object({
+	action: breakpointActionSchema,
+	blueprintPath: assetPathSchema,
+	graphName: debuggerGraphNameSchema.optional(),
+	nodeGuid: nodeGuidSchema.optional(),
+	nodeTitle: nodeTitleSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_SET_BLUEPRINT_BREAKPOINT_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine((value) => value.nodeGuid !== void 0 || value.nodeTitle !== void 0, {
+	message: "A set_blueprint_breakpoint request requires a nodeGuid or a nodeTitle.",
+	path: ["nodeGuid"]
+});
+const bridgeSetBlueprintBreakpointSuccessResponseSchema = z.object({
+	blueprintPath: z.string(),
+	breakpointCount: z.number().int().min(0),
+	graphName: z.string(),
+	message: z.string().trim().min(1).optional(),
+	nodeGuid: z.string(),
+	nodeTitle: z.string(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	state: breakpointStateSchema,
+	type: z.literal(BRIDGE_SET_BLUEPRINT_BREAKPOINT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeListBlueprintBreakpointsRequestSchema = z.object({
+	blueprintPath: assetPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_LIST_BLUEPRINT_BREAKPOINTS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeBlueprintBreakpointSchema = z.object({
+	enabled: z.boolean(),
+	graphName: z.string(),
+	nodeGuid: z.string(),
+	nodeTitle: z.string()
+});
+const bridgeListBlueprintBreakpointsSuccessResponseSchema = z.object({
+	blueprintPath: z.string(),
+	breakpoints: z.array(bridgeBlueprintBreakpointSchema),
+	message: z.string().trim().min(1).optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_LIST_BLUEPRINT_BREAKPOINTS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeGetBlueprintDebuggerStateRequestSchema = z.object({
+	maxFrames: z.number().int().min(1).max(64).default(32),
+	maxWatches: z.number().int().min(1).max(64).default(32),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_BLUEPRINT_DEBUGGER_STATE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeDebuggerStackFrameSchema = z.object({
+	blueprintPath: z.string(),
+	functionName: z.string(),
+	graphName: z.string(),
+	index: z.number().int().min(0),
+	nodeTitle: z.string()
+});
+const bridgeDebuggerWatchSchema = z.object({
+	nodeTitle: z.string(),
+	pinName: z.string(),
+	status: z.string(),
+	value: z.string()
+});
+const bridgeGetBlueprintDebuggerStateSuccessResponseSchema = z.object({
+	blueprintPath: z.string(),
+	callStack: z.array(bridgeDebuggerStackFrameSchema),
+	graphName: z.string(),
+	message: z.string().trim().min(1).optional(),
+	nodeGuid: z.string(),
+	nodeTitle: z.string(),
+	ok: z.literal(true),
+	paused: z.boolean(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_BLUEPRINT_DEBUGGER_STATE_REQUEST_TYPE),
+	version: z.literal(2),
+	watches: z.array(bridgeDebuggerWatchSchema)
+});
+const bridgeWatchBlueprintPinRequestSchema = z.object({
+	action: pinWatchActionSchema,
+	blueprintPath: assetPathSchema,
+	graphName: debuggerGraphNameSchema.optional(),
+	nodeGuid: nodeGuidSchema.optional(),
+	nodeTitle: nodeTitleSchema.optional(),
+	pinName: pinNameSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_WATCH_BLUEPRINT_PIN_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine((value) => value.action === "clear_all" || (value.nodeGuid !== void 0 || value.nodeTitle !== void 0) && value.pinName !== void 0, {
+	message: "A watch_blueprint_pin request other than 'clear_all' requires a pinName and a nodeGuid or nodeTitle.",
+	path: ["pinName"]
+});
+const bridgeWatchBlueprintPinSuccessResponseSchema = z.object({
+	blueprintPath: z.string(),
+	graphName: z.string(),
+	message: z.string().trim().min(1).optional(),
+	nodeGuid: z.string(),
+	nodeTitle: z.string(),
+	ok: z.literal(true),
+	pinName: z.string(),
+	requestId: requestIdSchema,
+	state: pinWatchStateSchema,
+	type: z.literal(BRIDGE_WATCH_BLUEPRINT_PIN_REQUEST_TYPE),
+	version: z.literal(2),
+	watchCount: z.number().int().min(0)
+});
+const bridgeControlBlueprintDebuggerRequestSchema = z.object({
+	action: debuggerActionSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_CONTROL_BLUEPRINT_DEBUGGER_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeControlBlueprintDebuggerSuccessResponseSchema = z.object({
+	action: debuggerActionSchema,
+	message: z.string().trim().min(1).optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	state: debuggerControlStateSchema,
+	type: z.literal(BRIDGE_CONTROL_BLUEPRINT_DEBUGGER_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSetBlueprintBreakpointResponseSchema = z.union([bridgeSetBlueprintBreakpointSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeListBlueprintBreakpointsResponseSchema = z.union([bridgeListBlueprintBreakpointsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetBlueprintDebuggerStateResponseSchema = z.union([bridgeGetBlueprintDebuggerStateSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeWatchBlueprintPinResponseSchema = z.union([bridgeWatchBlueprintPinSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeControlBlueprintDebuggerResponseSchema = z.union([bridgeControlBlueprintDebuggerSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeSetBlueprintBreakpointRequest(blueprintPath, action, options = {}, requestId = randomUUID()) {
+	return bridgeSetBlueprintBreakpointRequestSchema.parse({
+		action,
+		blueprintPath,
+		graphName: options.graphName,
+		nodeGuid: options.nodeGuid,
+		nodeTitle: options.nodeTitle,
+		requestId,
+		type: BRIDGE_SET_BLUEPRINT_BREAKPOINT_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeListBlueprintBreakpointsRequest(blueprintPath, requestId = randomUUID()) {
+	return bridgeListBlueprintBreakpointsRequestSchema.parse({
+		blueprintPath,
+		requestId,
+		type: BRIDGE_LIST_BLUEPRINT_BREAKPOINTS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeGetBlueprintDebuggerStateRequest(options = {}, requestId = randomUUID()) {
+	return bridgeGetBlueprintDebuggerStateRequestSchema.parse({
+		maxFrames: options.maxFrames ?? 32,
+		maxWatches: options.maxWatches ?? 32,
+		requestId,
+		type: BRIDGE_GET_BLUEPRINT_DEBUGGER_STATE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeControlBlueprintDebuggerRequest(action, requestId = randomUUID()) {
+	return bridgeControlBlueprintDebuggerRequestSchema.parse({
+		action,
+		requestId,
+		type: BRIDGE_CONTROL_BLUEPRINT_DEBUGGER_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeWatchBlueprintPinRequest(blueprintPath, action, options = {}, requestId = randomUUID()) {
+	return bridgeWatchBlueprintPinRequestSchema.parse({
+		action,
+		blueprintPath,
+		graphName: options.graphName,
+		nodeGuid: options.nodeGuid,
+		nodeTitle: options.nodeTitle,
+		pinName: options.pinName,
+		requestId,
+		type: BRIDGE_WATCH_BLUEPRINT_PIN_REQUEST_TYPE,
+		version: 2
+	});
+}
+//#endregion
+//#region src/protocol/diagnostics.ts
+const BRIDGE_GET_CRASH_CALLSTACK_REQUEST_TYPE = "get_crash_callstack";
+const BRIDGE_CRASH_RECORD_KINDS = ["ensure", "fatal"];
+const BRIDGE_EXEC_CONSOLE_COMMAND_REQUEST_TYPE = "exec_console_command";
+const BRIDGE_STAT_SNAPSHOT_REQUEST_TYPE = "stat_snapshot";
+const BRIDGE_START_TRACE_REQUEST_TYPE = "start_trace";
+const BRIDGE_STOP_TRACE_REQUEST_TYPE = "stop_trace";
+const BRIDGE_EXEC_CONSOLE_TARGETS = [
+	"editor",
+	"pie",
+	"none"
+];
+const BRIDGE_EXEC_CONSOLE_MAX_COMMAND_CHARS = 2048;
+const BRIDGE_START_TRACE_STATES = [
+	"started",
+	"already_tracing",
+	"unsupported"
+];
+const BRIDGE_STOP_TRACE_STATES = [
+	"stopped",
+	"not_tracing",
+	"unsupported"
+];
+const crashRecordKindSchema = z.enum(BRIDGE_CRASH_RECORD_KINDS);
+const crashMaxRecordsSchema = z.number().int().min(1).max(5);
+const crashMaxFramesSchema = z.number().int().min(1).max(64);
+const execConsoleTargetSchema = z.enum(BRIDGE_EXEC_CONSOLE_TARGETS);
+const consoleCommandSchema = z.string().trim().min(1).max(BRIDGE_EXEC_CONSOLE_MAX_COMMAND_CHARS);
+const consoleOutputLineSchema = z.string().max(512);
+const consoleOutputSchema = z.array(consoleOutputLineSchema).max(100);
+const startTraceStateSchema = z.enum(BRIDGE_START_TRACE_STATES);
+const stopTraceStateSchema = z.enum(BRIDGE_STOP_TRACE_STATES);
+const traceChannelSchema = z.string().trim().min(1).max(64).regex(/^[A-Za-z0-9_]+$/);
+const traceChannelArraySchema = z.array(traceChannelSchema).max(32);
+const traceFileNameSchema = z.string().trim().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/);
+const memoryMegabytesSchema = z.number().min(0);
+const frameTimingMillisecondsSchema = z.number().min(0);
+const bridgeGetCrashCallstackRequestSchema = z.object({
+	maxFrames: crashMaxFramesSchema,
+	maxRecords: crashMaxRecordsSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_CRASH_CALLSTACK_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeExecConsoleCommandRequestSchema = z.object({
+	command: consoleCommandSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_EXEC_CONSOLE_COMMAND_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeStatSnapshotRequestSchema = z.object({
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_STAT_SNAPSHOT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeStartTraceRequestSchema = z.object({
+	channels: traceChannelArraySchema.default([]),
+	fileName: traceFileNameSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_START_TRACE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeStopTraceRequestSchema = z.object({
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_STOP_TRACE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCrashFrameSchema = z.object({
+	address: nonEmptyStringSchema,
+	file: z.string().trim().min(1).optional(),
+	index: z.number().int().min(0),
+	line: z.number().int().min(1).optional(),
+	module: z.string().trim().min(1).optional(),
+	symbol: z.string().trim().min(1).optional()
+});
+const bridgeCrashRecordSchema = z.object({
+	frames: z.array(bridgeCrashFrameSchema),
+	framesTruncated: z.boolean(),
+	kind: crashRecordKindSchema,
+	message: z.string(),
+	occurredAt: nonEmptyStringSchema,
+	recordId: nonEmptyStringSchema,
+	threadId: z.number().int().min(0),
+	totalFrameCount: z.number().int().min(0)
+});
+const bridgeGetCrashCallstackSuccessResponseSchema = z.object({
+	ok: z.literal(true),
+	records: z.array(bridgeCrashRecordSchema),
+	requestId: requestIdSchema,
+	totalCount: z.number().int().min(0),
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_GET_CRASH_CALLSTACK_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeExecConsoleCommandSuccessResponseSchema = z.object({
+	handled: z.boolean(),
+	ok: z.literal(true),
+	output: consoleOutputSchema,
+	requestId: requestIdSchema,
+	target: execConsoleTargetSchema,
+	truncated: z.boolean(),
+	type: z.literal(BRIDGE_EXEC_CONSOLE_COMMAND_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeMemorySnapshotSchema = z.object({
+	availablePhysicalMb: memoryMegabytesSchema,
+	peakUsedPhysicalMb: memoryMegabytesSchema,
+	peakUsedVirtualMb: memoryMegabytesSchema,
+	usedPhysicalMb: memoryMegabytesSchema,
+	usedVirtualMb: memoryMegabytesSchema
+});
+const bridgeStatSnapshotSuccessResponseSchema = z.object({
+	capturedAt: nonEmptyStringSchema,
+	fps: z.number().min(0),
+	frameTimeMs: frameTimingMillisecondsSchema,
+	gameThreadTimeMs: frameTimingMillisecondsSchema.optional(),
+	memory: bridgeMemorySnapshotSchema,
+	ok: z.literal(true),
+	renderThreadTimeMs: frameTimingMillisecondsSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_STAT_SNAPSHOT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeStartTraceSuccessResponseSchema = z.object({
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	state: startTraceStateSchema,
+	tracePath: nonEmptyStringSchema.optional(),
 	type: z.literal(BRIDGE_START_TRACE_REQUEST_TYPE),
 	version: z.literal(2)
 }).refine((value) => value.state !== "unsupported" || value.tracePath === void 0, {
@@ -3912,10 +4611,12 @@ const bridgeListActorsRequestSchema = z.object({
 	levelName: boundedStringSchema.optional(),
 	maxResults: levelMaxResultsSchema,
 	nameFilter: boundedStringSchema.optional(),
+	pieInstanceIndex: pieInstanceIndexSchema.optional(),
 	requestId: requestIdSchema,
 	tag: boundedStringSchema.optional(),
 	type: z.literal(BRIDGE_LIST_ACTORS_REQUEST_TYPE),
-	version: z.literal(2)
+	version: z.literal(2),
+	world: worldSelectorSchema.optional()
 });
 const bridgeGetActorDetailsRequestSchema = z.object({
 	actorPath: actorPathSchema,
@@ -3923,9 +4624,11 @@ const bridgeGetActorDetailsRequestSchema = z.object({
 	includeInherited: z.boolean().default(false),
 	maxResults: actorDetailMemberLimitSchema,
 	propertyCursor: levelCursorSchema.default(0),
+	pieInstanceIndex: pieInstanceIndexSchema.optional(),
 	requestId: requestIdSchema,
 	type: z.literal(BRIDGE_GET_ACTOR_DETAILS_REQUEST_TYPE),
-	version: z.literal(2)
+	version: z.literal(2),
+	world: worldSelectorSchema.optional()
 });
 const bridgeGetCurrentLevelRequestSchema = z.object({
 	requestId: requestIdSchema,
@@ -3993,9 +4696,11 @@ const bridgeSetActorPropertyEntrySchema = z.object({
 const bridgeSetActorPropertyRequestSchema = z.object({
 	dryRun: z.boolean().default(false),
 	properties: z.array(bridgeSetActorPropertyEntrySchema).min(1).max(64),
+	pieInstanceIndex: pieInstanceIndexSchema.optional(),
 	requestId: requestIdSchema,
 	type: z.literal(BRIDGE_SET_ACTOR_PROPERTY_REQUEST_TYPE),
-	version: z.literal(2)
+	version: z.literal(2),
+	world: worldSelectorSchema.optional()
 });
 const bridgeSelectActorsRequestSchema = z.object({
 	actorPaths: z.array(actorPathSchema).max(64).default([]),
@@ -4216,10 +4921,12 @@ function createBridgeListActorsRequest(options = {}, requestId = randomUUID()) {
 		levelName: options.levelName,
 		maxResults: options.maxResults ?? 50,
 		nameFilter: options.nameFilter,
+		pieInstanceIndex: options.pieInstanceIndex,
 		requestId,
 		tag: options.tag,
 		type: BRIDGE_LIST_ACTORS_REQUEST_TYPE,
-		version: 2
+		version: 2,
+		world: options.world
 	});
 }
 function createBridgeGetActorDetailsRequest(actorPath, options = {}, requestId = randomUUID()) {
@@ -4228,10 +4935,12 @@ function createBridgeGetActorDetailsRequest(actorPath, options = {}, requestId =
 		componentCursor: options.componentCursor,
 		includeInherited: options.includeInherited,
 		maxResults: options.maxResults ?? 25,
+		pieInstanceIndex: options.pieInstanceIndex,
 		propertyCursor: options.propertyCursor,
 		requestId,
 		type: BRIDGE_GET_ACTOR_DETAILS_REQUEST_TYPE,
-		version: 2
+		version: 2,
+		world: options.world
 	});
 }
 function createBridgeGetCurrentLevelRequest(requestId = randomUUID()) {
@@ -4271,10 +4980,12 @@ function createBridgeSetActorTransformRequest(transforms, options = {}, requestI
 function createBridgeSetActorPropertyRequest(properties, options = {}, requestId = randomUUID()) {
 	return bridgeSetActorPropertyRequestSchema.parse({
 		dryRun: options.dryRun,
+		pieInstanceIndex: options.pieInstanceIndex,
 		properties,
 		requestId,
 		type: BRIDGE_SET_ACTOR_PROPERTY_REQUEST_TYPE,
-		version: 2
+		version: 2,
+		world: options.world
 	});
 }
 function createBridgeSelectActorsRequest(actorPaths, options = {}, requestId = randomUUID()) {
@@ -5123,339 +5834,53 @@ const bridgeAddPostProcessMaterialSuccessResponseSchema = z.object({
 	materialPath: z.string(),
 	message: nonEmptyStringSchema.optional(),
 	ok: z.literal(true),
-	packageDirty: z.boolean(),
-	requestId: requestIdSchema,
-	state: creativeEditStateSchema,
-	type: z.literal(BRIDGE_ADD_POST_PROCESS_MATERIAL_REQUEST_TYPE),
-	version: z.literal(2)
-});
-const bridgeCreatePostProcessVolumeResponseSchema = z.union([bridgeCreatePostProcessVolumeSuccessResponseSchema, bridgeErrorResponseSchema]);
-const bridgeSetPostProcessSettingsResponseSchema = z.union([bridgeSetPostProcessSettingsSuccessResponseSchema, bridgeErrorResponseSchema]);
-const bridgeAddPostProcessMaterialResponseSchema = z.union([bridgeAddPostProcessMaterialSuccessResponseSchema, bridgeErrorResponseSchema]);
-function createBridgeCreatePostProcessVolumeRequest(options = {}, requestId = randomUUID()) {
-	return bridgeCreatePostProcessVolumeRequestSchema.parse({
-		actorLabel: options.actorLabel,
-		blendRadius: options.blendRadius,
-		blendWeight: options.blendWeight,
-		extent: options.extent,
-		folderPath: options.folderPath,
-		location: options.location,
-		priority: options.priority,
-		requestId,
-		settings: options.settings,
-		type: BRIDGE_CREATE_POST_PROCESS_VOLUME_REQUEST_TYPE,
-		unbound: options.unbound,
-		version: 2
-	});
-}
-function createBridgeSetPostProcessSettingsRequest(actorPath, targetKind, settings, options = {}, requestId = randomUUID()) {
-	return bridgeSetPostProcessSettingsRequestSchema.parse({
-		actorPath,
-		componentName: options.componentName,
-		requestId,
-		settings,
-		targetKind,
-		type: BRIDGE_SET_POST_PROCESS_SETTINGS_REQUEST_TYPE,
-		version: 2
-	});
-}
-function createBridgeAddPostProcessMaterialRequest(actorPath, materialPath, options = {}, requestId = randomUUID()) {
-	return bridgeAddPostProcessMaterialRequestSchema.parse({
-		actorPath,
-		blendableLocation: options.blendableLocation,
-		componentName: options.componentName,
-		materialPath,
-		requestId,
-		targetKind: options.targetKind,
-		type: BRIDGE_ADD_POST_PROCESS_MATERIAL_REQUEST_TYPE,
-		version: 2,
-		weight: options.weight
-	});
-}
-//#endregion
-//#region src/protocol/graph.ts
-const BRIDGE_LIST_GRAPH_NODES_REQUEST_TYPE = "list_graph_nodes";
-const BRIDGE_ADD_GRAPH_NODE_REQUEST_TYPE = "add_graph_node";
-const BRIDGE_REMOVE_GRAPH_NODE_REQUEST_TYPE = "remove_graph_node";
-const BRIDGE_CONNECT_PINS_REQUEST_TYPE = "connect_pins";
-const BRIDGE_DISCONNECT_PINS_REQUEST_TYPE = "disconnect_pins";
-const BRIDGE_SET_PIN_DEFAULT_REQUEST_TYPE = "set_pin_default";
-const BRIDGE_LIST_AVAILABLE_NODES_REQUEST_TYPE = "list_available_nodes";
-const BRIDGE_GRAPH_PIN_VALUE_MAX_CHARS = 4096;
-const BRIDGE_GRAPH_NODE_POSITION_LIMIT = 1e6;
-const BRIDGE_GRAPH_NODE_KINDS = [
-	"class",
-	"function",
-	"variable_get",
-	"variable_set"
-];
-const graphPinNameSchema = z.string().trim().min(1).max(256);
-const graphPinValueSchema = z.string().max(BRIDGE_GRAPH_PIN_VALUE_MAX_CHARS);
-const graphNodeKindSchema = z.enum(BRIDGE_GRAPH_NODE_KINDS);
-const graphNodeMaxResultsSchema = z.number().int().min(1).max(100);
-const availableNodeMaxResultsSchema = z.number().int().min(1).max(100);
-const graphNodePositionSchema = z.object({
-	x: z.number().int().min(-1e6).max(BRIDGE_GRAPH_NODE_POSITION_LIMIT).default(0),
-	y: z.number().int().min(-1e6).max(BRIDGE_GRAPH_NODE_POSITION_LIMIT).default(0)
-});
-const bridgeListGraphNodesRequestSchema = z.object({
-	assetPath: assetPathSchema,
-	cursor: assetCursorSchema.optional(),
-	graphName: graphNameSchema,
-	loadIfNeeded: z.boolean().optional(),
-	maxResults: graphNodeMaxResultsSchema.optional(),
-	requestId: requestIdSchema,
-	type: z.literal(BRIDGE_LIST_GRAPH_NODES_REQUEST_TYPE),
-	version: z.literal(2)
-});
-const bridgeAddGraphNodeRequestFieldsSchema = z.object({
-	assetPath: assetPathSchema,
-	graphName: graphNameSchema,
-	nodeClass: assetPathSchema.optional(),
-	kind: graphNodeKindSchema,
-	memberName: boundedStringSchema.optional(),
-	memberParentClass: assetPathSchema.optional(),
-	pinDefaults: z.record(graphPinNameSchema, graphPinValueSchema).refine((value) => Object.keys(value).length <= 64, { message: `An add_graph_node request carries at most ${String(64)} pin defaults.` }).optional(),
-	position: graphNodePositionSchema.optional(),
-	requestId: requestIdSchema,
-	type: z.literal(BRIDGE_ADD_GRAPH_NODE_REQUEST_TYPE),
-	version: z.literal(2)
-});
-const bridgeAddGraphNodeRequestSchema = bridgeAddGraphNodeRequestFieldsSchema.refine((value) => value.kind === "class" ? value.nodeClass !== void 0 : value.memberName !== void 0, {
-	message: "kind 'class' requires nodeClass; every other kind requires memberName.",
-	path: ["nodeClass"]
-});
-const bridgeRemoveGraphNodeRequestSchema = z.object({
-	assetPath: assetPathSchema,
-	graphName: graphNameSchema,
-	nodeGuid: graphNodeGuidSchema,
-	requestId: requestIdSchema,
-	type: z.literal(BRIDGE_REMOVE_GRAPH_NODE_REQUEST_TYPE),
-	version: z.literal(2)
-});
-const graphPinPairFields = {
-	assetPath: assetPathSchema,
-	graphName: graphNameSchema,
-	requestId: requestIdSchema,
-	sourceNodeGuid: graphNodeGuidSchema,
-	sourcePinName: graphPinNameSchema,
-	targetNodeGuid: graphNodeGuidSchema,
-	targetPinName: graphPinNameSchema,
-	version: z.literal(2)
-};
-const bridgeConnectPinsRequestSchema = z.object({
-	...graphPinPairFields,
-	type: z.literal(BRIDGE_CONNECT_PINS_REQUEST_TYPE)
-});
-const bridgeDisconnectPinsRequestSchema = z.object({
-	...graphPinPairFields,
-	type: z.literal(BRIDGE_DISCONNECT_PINS_REQUEST_TYPE)
-});
-const bridgeSetPinDefaultRequestSchema = z.object({
-	assetPath: assetPathSchema,
-	graphName: graphNameSchema,
-	nodeGuid: graphNodeGuidSchema,
-	pinName: graphPinNameSchema,
-	requestId: requestIdSchema,
-	type: z.literal(BRIDGE_SET_PIN_DEFAULT_REQUEST_TYPE),
-	value: graphPinValueSchema,
-	version: z.literal(2)
-});
-const bridgeListAvailableNodesRequestSchema = z.object({
-	assetPath: assetPathSchema,
-	cursor: assetCursorSchema.optional(),
-	graphName: graphNameSchema,
-	maxResults: availableNodeMaxResultsSchema.optional(),
-	nameFilter: boundedStringSchema.optional(),
-	requestId: requestIdSchema,
-	type: z.literal(BRIDGE_LIST_AVAILABLE_NODES_REQUEST_TYPE),
-	version: z.literal(2)
-});
-const bridgeListGraphNodesSuccessResponseSchema = z.object({
-	assetPath: z.string(),
-	graphName: z.string(),
-	nextCursor: assetCursorSchema.optional(),
-	nodeCount: z.number().int().min(0),
-	nodes: z.array(bridgeBlueprintNodeSchema).max(100),
-	ok: z.literal(true),
-	requestId: requestIdSchema,
-	truncated: z.boolean(),
-	type: z.literal(BRIDGE_LIST_GRAPH_NODES_REQUEST_TYPE),
-	version: z.literal(2)
-});
-const bridgeAddGraphNodeSuccessResponseSchema = z.object({
-	assetPath: z.string(),
-	graphName: z.string(),
-	message: nonEmptyStringSchema.optional(),
-	node: bridgeBlueprintNodeSchema,
-	ok: z.literal(true),
-	requestId: requestIdSchema,
-	state: creativeEditStateSchema,
-	type: z.literal(BRIDGE_ADD_GRAPH_NODE_REQUEST_TYPE),
-	version: z.literal(2)
-});
-const bridgeRemoveGraphNodeSuccessResponseSchema = z.object({
-	assetPath: z.string(),
-	graphName: z.string(),
-	message: nonEmptyStringSchema.optional(),
-	nodeGuid: z.string(),
-	ok: z.literal(true),
-	removed: z.boolean(),
-	requestId: requestIdSchema,
-	state: creativeEditStateSchema,
-	type: z.literal(BRIDGE_REMOVE_GRAPH_NODE_REQUEST_TYPE),
-	version: z.literal(2)
-});
-const graphPinPairResponseFields = {
-	assetPath: z.string(),
-	graphName: z.string(),
-	message: nonEmptyStringSchema.optional(),
-	ok: z.literal(true),
-	requestId: requestIdSchema,
-	sourceNodeGuid: z.string(),
-	sourcePinName: z.string(),
-	state: creativeEditStateSchema,
-	targetNodeGuid: z.string(),
-	targetPinName: z.string(),
-	version: z.literal(2)
-};
-const bridgeConnectPinsSuccessResponseSchema = z.object({
-	...graphPinPairResponseFields,
-	connected: z.boolean(),
-	type: z.literal(BRIDGE_CONNECT_PINS_REQUEST_TYPE)
-});
-const bridgeDisconnectPinsSuccessResponseSchema = z.object({
-	...graphPinPairResponseFields,
-	disconnected: z.boolean(),
-	type: z.literal(BRIDGE_DISCONNECT_PINS_REQUEST_TYPE)
-});
-const bridgeSetPinDefaultSuccessResponseSchema = z.object({
-	assetPath: z.string(),
-	graphName: z.string(),
-	message: nonEmptyStringSchema.optional(),
-	nodeGuid: z.string(),
-	ok: z.literal(true),
-	pinName: z.string(),
-	requestId: requestIdSchema,
-	state: creativeEditStateSchema,
-	type: z.literal(BRIDGE_SET_PIN_DEFAULT_REQUEST_TYPE),
-	value: z.string(),
-	version: z.literal(2)
-});
-const bridgeGraphActionSchema = z.object({
-	category: z.string(),
-	keywords: z.string().optional(),
-	memberName: z.string().optional(),
-	memberParentClass: z.string().optional(),
-	nodeClass: z.string(),
-	nodeKind: graphNodeKindSchema,
-	title: z.string(),
-	tooltip: z.string().optional()
-});
-const bridgeListAvailableNodesSuccessResponseSchema = z.object({
-	actions: z.array(bridgeGraphActionSchema).max(100),
-	assetPath: z.string(),
-	graphName: z.string(),
-	nextCursor: assetCursorSchema.optional(),
-	ok: z.literal(true),
+	packageDirty: z.boolean(),
 	requestId: requestIdSchema,
-	totalCount: z.number().int().min(0),
-	truncated: z.boolean(),
-	type: z.literal(BRIDGE_LIST_AVAILABLE_NODES_REQUEST_TYPE),
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_ADD_POST_PROCESS_MATERIAL_REQUEST_TYPE),
 	version: z.literal(2)
 });
-const bridgeListGraphNodesResponseSchema = z.union([bridgeListGraphNodesSuccessResponseSchema, bridgeErrorResponseSchema]);
-const bridgeAddGraphNodeResponseSchema = z.union([bridgeAddGraphNodeSuccessResponseSchema, bridgeErrorResponseSchema]);
-const bridgeRemoveGraphNodeResponseSchema = z.union([bridgeRemoveGraphNodeSuccessResponseSchema, bridgeErrorResponseSchema]);
-const bridgeConnectPinsResponseSchema = z.union([bridgeConnectPinsSuccessResponseSchema, bridgeErrorResponseSchema]);
-const bridgeDisconnectPinsResponseSchema = z.union([bridgeDisconnectPinsSuccessResponseSchema, bridgeErrorResponseSchema]);
-const bridgeSetPinDefaultResponseSchema = z.union([bridgeSetPinDefaultSuccessResponseSchema, bridgeErrorResponseSchema]);
-const bridgeListAvailableNodesResponseSchema = z.union([bridgeListAvailableNodesSuccessResponseSchema, bridgeErrorResponseSchema]);
-function createBridgeListGraphNodesRequest(assetPath, graphName, options = {}, requestId = randomUUID()) {
-	return bridgeListGraphNodesRequestSchema.parse({
-		assetPath,
-		cursor: options.cursor,
-		graphName,
-		loadIfNeeded: options.loadIfNeeded,
-		maxResults: options.maxResults,
-		requestId,
-		type: BRIDGE_LIST_GRAPH_NODES_REQUEST_TYPE,
-		version: 2
-	});
-}
-function createBridgeAddGraphNodeRequest(assetPath, graphName, kind, options = {}, requestId = randomUUID()) {
-	return bridgeAddGraphNodeRequestSchema.parse({
-		assetPath,
-		graphName,
-		kind,
-		memberName: options.memberName,
-		memberParentClass: options.memberParentClass,
-		nodeClass: options.nodeClass,
-		pinDefaults: options.pinDefaults,
-		position: options.position,
-		requestId,
-		type: BRIDGE_ADD_GRAPH_NODE_REQUEST_TYPE,
-		version: 2
-	});
-}
-function createBridgeRemoveGraphNodeRequest(assetPath, graphName, nodeGuid, requestId = randomUUID()) {
-	return bridgeRemoveGraphNodeRequestSchema.parse({
-		assetPath,
-		graphName,
-		nodeGuid,
-		requestId,
-		type: BRIDGE_REMOVE_GRAPH_NODE_REQUEST_TYPE,
-		version: 2
-	});
-}
-function createBridgeConnectPinsRequest(assetPath, graphName, source, target, requestId = randomUUID()) {
-	return bridgeConnectPinsRequestSchema.parse({
-		assetPath,
-		graphName,
-		requestId,
-		sourceNodeGuid: source.nodeGuid,
-		sourcePinName: source.pinName,
-		targetNodeGuid: target.nodeGuid,
-		targetPinName: target.pinName,
-		type: BRIDGE_CONNECT_PINS_REQUEST_TYPE,
-		version: 2
-	});
-}
-function createBridgeDisconnectPinsRequest(assetPath, graphName, source, target, requestId = randomUUID()) {
-	return bridgeDisconnectPinsRequestSchema.parse({
-		assetPath,
-		graphName,
+const bridgeCreatePostProcessVolumeResponseSchema = z.union([bridgeCreatePostProcessVolumeSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetPostProcessSettingsResponseSchema = z.union([bridgeSetPostProcessSettingsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddPostProcessMaterialResponseSchema = z.union([bridgeAddPostProcessMaterialSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeCreatePostProcessVolumeRequest(options = {}, requestId = randomUUID()) {
+	return bridgeCreatePostProcessVolumeRequestSchema.parse({
+		actorLabel: options.actorLabel,
+		blendRadius: options.blendRadius,
+		blendWeight: options.blendWeight,
+		extent: options.extent,
+		folderPath: options.folderPath,
+		location: options.location,
+		priority: options.priority,
 		requestId,
-		sourceNodeGuid: source.nodeGuid,
-		sourcePinName: source.pinName,
-		targetNodeGuid: target.nodeGuid,
-		targetPinName: target.pinName,
-		type: BRIDGE_DISCONNECT_PINS_REQUEST_TYPE,
+		settings: options.settings,
+		type: BRIDGE_CREATE_POST_PROCESS_VOLUME_REQUEST_TYPE,
+		unbound: options.unbound,
 		version: 2
 	});
 }
-function createBridgeSetPinDefaultRequest(assetPath, graphName, nodeGuid, pinName, value, requestId = randomUUID()) {
-	return bridgeSetPinDefaultRequestSchema.parse({
-		assetPath,
-		graphName,
-		nodeGuid,
-		pinName,
+function createBridgeSetPostProcessSettingsRequest(actorPath, targetKind, settings, options = {}, requestId = randomUUID()) {
+	return bridgeSetPostProcessSettingsRequestSchema.parse({
+		actorPath,
+		componentName: options.componentName,
 		requestId,
-		type: BRIDGE_SET_PIN_DEFAULT_REQUEST_TYPE,
-		value,
+		settings,
+		targetKind,
+		type: BRIDGE_SET_POST_PROCESS_SETTINGS_REQUEST_TYPE,
 		version: 2
 	});
 }
-function createBridgeListAvailableNodesRequest(assetPath, graphName, options = {}, requestId = randomUUID()) {
-	return bridgeListAvailableNodesRequestSchema.parse({
-		assetPath,
-		cursor: options.cursor,
-		graphName,
-		maxResults: options.maxResults,
-		nameFilter: options.nameFilter,
+function createBridgeAddPostProcessMaterialRequest(actorPath, materialPath, options = {}, requestId = randomUUID()) {
+	return bridgeAddPostProcessMaterialRequestSchema.parse({
+		actorPath,
+		blendableLocation: options.blendableLocation,
+		componentName: options.componentName,
+		materialPath,
 		requestId,
-		type: BRIDGE_LIST_AVAILABLE_NODES_REQUEST_TYPE,
-		version: 2
+		targetKind: options.targetKind,
+		type: BRIDGE_ADD_POST_PROCESS_MATERIAL_REQUEST_TYPE,
+		version: 2,
+		weight: options.weight
 	});
 }
 //#endregion
@@ -8073,6 +8498,46 @@ function createBridgeAddInputMappingRequest(contextPath, mappings, requestId = r
 		version: 2
 	});
 }
+const BRIDGE_INJECT_INPUT_ACTION_REQUEST_TYPE = "inject_input_action";
+const bridgeInjectInputActionRequestSchema = z.object({
+	actionPath: assetPathSchema,
+	durationSeconds: z.number().min(0).max(60).optional(),
+	pieInstanceIndex: pieInstanceIndexSchema.optional(),
+	playerIndex: z.number().int().min(0).max(16).default(0),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_INJECT_INPUT_ACTION_REQUEST_TYPE),
+	value: vectorInputSchema.default({
+		x: 0,
+		y: 0,
+		z: 0
+	}),
+	version: z.literal(2)
+});
+const bridgeInjectInputActionSuccessResponseSchema = z.object({
+	actionPath: z.string(),
+	durationSeconds: z.number().min(0),
+	ok: z.literal(true),
+	pieInstanceIndex: z.number().int().min(0),
+	playerIndex: z.number().int().min(0),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_INJECT_INPUT_ACTION_REQUEST_TYPE),
+	valueType: z.string(),
+	version: z.literal(2),
+	worldName: z.string()
+});
+const bridgeInjectInputActionResponseSchema = z.union([bridgeInjectInputActionSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeInjectInputActionRequest(actionPath, options = {}, requestId = randomUUID()) {
+	return bridgeInjectInputActionRequestSchema.parse({
+		actionPath,
+		durationSeconds: options.durationSeconds,
+		pieInstanceIndex: options.pieInstanceIndex,
+		playerIndex: options.playerIndex,
+		requestId,
+		type: BRIDGE_INJECT_INPUT_ACTION_REQUEST_TYPE,
+		value: options.value,
+		version: 2
+	});
+}
 //#endregion
 //#region src/protocol/behaviorTree.ts
 const BRIDGE_CREATE_BEHAVIOR_TREE_REQUEST_TYPE = "create_behavior_tree";
@@ -9250,7 +9715,7 @@ function createBridgeSetDefaultGamemodeRequest(scope, gameModePath, options = {}
 }
 //#endregion
 //#region src/version.ts
-const SERVER_VERSION = "1.8.0";
+const SERVER_VERSION = "1.9.1";
 //#endregion
 //#region src/bridgeSocketClient.ts
 var BridgeSocketError = class extends Error {
@@ -10113,6 +10578,33 @@ async function sendBridgeSetProjectSettingsRequest(request, options) {
 async function sendBridgeSetDefaultGamemodeRequest(request, options) {
 	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetDefaultGamemodeResponseSchema, request.requestId);
 }
+async function sendBridgeCallActorFunctionRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCallActorFunctionResponseSchema, request.requestId);
+}
+async function sendBridgeListPieWorldsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeListPieWorldsResponseSchema, request.requestId);
+}
+async function sendBridgeGetNetStatsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetNetStatsResponseSchema, request.requestId);
+}
+async function sendBridgeInjectInputActionRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeInjectInputActionResponseSchema, request.requestId);
+}
+async function sendBridgeSetBlueprintBreakpointRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetBlueprintBreakpointResponseSchema, request.requestId);
+}
+async function sendBridgeListBlueprintBreakpointsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeListBlueprintBreakpointsResponseSchema, request.requestId);
+}
+async function sendBridgeGetBlueprintDebuggerStateRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetBlueprintDebuggerStateResponseSchema, request.requestId);
+}
+async function sendBridgeControlBlueprintDebuggerRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeControlBlueprintDebuggerResponseSchema, request.requestId);
+}
+async function sendBridgeWatchBlueprintPinRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeWatchBlueprintPinResponseSchema, request.requestId);
+}
 //#endregion
 //#region src/enginePing.ts
 async function pingRegistryEntry$1(entry, options) {
@@ -16103,6 +16595,227 @@ const dataTableToolDomain = {
 	]
 };
 //#endregion
+//#region src/tools/debugger.ts
+const setBlueprintBreakpointInputSchema = {
+	action: bridgeSetBlueprintBreakpointRequestSchema.shape.action.describe("What to do: 'set' adds a breakpoint, 'clear' removes it, 'enable' and 'disable' toggle an existing one."),
+	blueprintPath: bridgeSetBlueprintBreakpointRequestSchema.shape.blueprintPath.describe("Path of the Blueprint asset holding the node (e.g. /Game/BP/BP_Character)."),
+	graphName: bridgeSetBlueprintBreakpointRequestSchema.shape.graphName.describe("Restrict a nodeTitle match to one graph (e.g. EventGraph). Ignored when nodeGuid is supplied."),
+	nodeGuid: bridgeSetBlueprintBreakpointRequestSchema.shape.nodeGuid.describe("Guid of the graph node, as list_blueprint_breakpoints and get_blueprint_debugger_state report it. Takes precedence over nodeTitle."),
+	nodeTitle: bridgeSetBlueprintBreakpointRequestSchema.shape.nodeTitle.describe("The node's displayed title (e.g. 'Print String'). Supply this when you have no guid; narrow it with graphName when the title repeats."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor holds the Blueprint.")
+};
+const listBlueprintBreakpointsInputSchema = {
+	blueprintPath: bridgeListBlueprintBreakpointsRequestSchema.shape.blueprintPath.describe("Path of the Blueprint asset whose breakpoints should be listed."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor holds the Blueprint.")
+};
+const getBlueprintDebuggerStateInputSchema = {
+	maxFrames: bridgeGetBlueprintDebuggerStateRequestSchema.shape.maxFrames.describe(`Maximum call stack frames to return (1-${String(64)}, default ${String(32)}), innermost first.`),
+	maxWatches: bridgeGetBlueprintDebuggerStateRequestSchema.shape.maxWatches.describe(`Maximum watched pin values to return (1-${String(64)}, default ${String(32)}).`),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should report its Blueprint debugger state.")
+};
+const controlBlueprintDebuggerInputSchema = {
+	action: bridgeControlBlueprintDebuggerRequestSchema.shape.action.describe("What to do: 'resume' continues play, 'step_over' / 'step_into' / 'step_out' advance one node, 'stop' ends the play session outright."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor is paused at a Blueprint breakpoint.")
+};
+const watchBlueprintPinInputSchema = {
+	action: bridgeWatchBlueprintPinRequestSchema.shape.action.describe("What to do: 'set' starts watching a pin, 'clear' stops watching one, 'clear_all' drops every watch on the Blueprint."),
+	blueprintPath: bridgeWatchBlueprintPinRequestSchema.shape.blueprintPath.describe("Path of the Blueprint asset holding the pin (e.g. /Game/BP/BP_Character)."),
+	graphName: bridgeWatchBlueprintPinRequestSchema.shape.graphName.describe("Restrict a nodeTitle match to one graph (e.g. EventGraph). Ignored when nodeGuid is supplied."),
+	nodeGuid: bridgeWatchBlueprintPinRequestSchema.shape.nodeGuid.describe("Guid of the node owning the pin, as list_graph_nodes reports it. Takes precedence over nodeTitle."),
+	nodeTitle: bridgeWatchBlueprintPinRequestSchema.shape.nodeTitle.describe("The owning node's displayed title (e.g. 'Print String'). Supply this when you have no guid."),
+	pinName: bridgeWatchBlueprintPinRequestSchema.shape.pinName.describe("The pin's name, as list_graph_nodes reports it (e.g. 'InString'). Required unless action is 'clear_all'."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor holds the Blueprint.")
+};
+async function setBlueprintBreakpoint(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 sendBridgeSetBlueprintBreakpointRequest(createBridgeSetBlueprintBreakpointRequest(input.blueprintPath, input.action, {
+		graphName: input.graphName,
+		nodeGuid: input.nodeGuid,
+		nodeTitle: input.nodeTitle
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge set_blueprint_breakpoint failed (${response.error.code}): ${response.error.message}`);
+	return {
+		blueprintPath: response.blueprintPath,
+		breakpointCount: response.breakpointCount,
+		graphName: response.graphName,
+		message: response.message,
+		nodeGuid: response.nodeGuid,
+		nodeTitle: response.nodeTitle,
+		projectId: entry.projectId,
+		state: response.state
+	};
+}
+async function listBlueprintBreakpoints(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 sendBridgeListBlueprintBreakpointsRequest(createBridgeListBlueprintBreakpointsRequest(input.blueprintPath), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge list_blueprint_breakpoints failed (${response.error.code}): ${response.error.message}`);
+	return {
+		blueprintPath: response.blueprintPath,
+		breakpoints: response.breakpoints,
+		message: response.message,
+		projectId: entry.projectId
+	};
+}
+async function getBlueprintDebuggerState(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 sendBridgeGetBlueprintDebuggerStateRequest(createBridgeGetBlueprintDebuggerStateRequest({
+		maxFrames: input.maxFrames,
+		maxWatches: input.maxWatches
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge get_blueprint_debugger_state failed (${response.error.code}): ${response.error.message}`);
+	return {
+		blueprintPath: response.blueprintPath,
+		callStack: response.callStack,
+		graphName: response.graphName,
+		message: response.message,
+		nodeGuid: response.nodeGuid,
+		nodeTitle: response.nodeTitle,
+		paused: response.paused,
+		projectId: entry.projectId,
+		watches: response.watches
+	};
+}
+async function controlBlueprintDebugger(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 sendBridgeControlBlueprintDebuggerRequest(createBridgeControlBlueprintDebuggerRequest(input.action), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge control_blueprint_debugger failed (${response.error.code}): ${response.error.message}`);
+	return {
+		action: response.action,
+		message: response.message,
+		projectId: entry.projectId,
+		state: response.state
+	};
+}
+async function watchBlueprintPin(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 sendBridgeWatchBlueprintPinRequest(createBridgeWatchBlueprintPinRequest(input.blueprintPath, input.action, {
+		graphName: input.graphName,
+		nodeGuid: input.nodeGuid,
+		nodeTitle: input.nodeTitle,
+		pinName: input.pinName
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge watch_blueprint_pin failed (${response.error.code}): ${response.error.message}`);
+	return {
+		blueprintPath: response.blueprintPath,
+		graphName: response.graphName,
+		message: response.message,
+		nodeGuid: response.nodeGuid,
+		nodeTitle: response.nodeTitle,
+		pinName: response.pinName,
+		projectId: normalizedProjectId,
+		state: response.state,
+		watchCount: response.watchCount
+	};
+}
+function registerDebuggerTools(server, dependencies) {
+	server.registerTool("set_blueprint_breakpoint", {
+		description: "Set, clear, enable or disable a breakpoint on one Blueprint graph node, addressed by nodeGuid or by nodeTitle. Breakpoints survive until the editor closes, so set them before start_pie and the play session will halt on the node. Returns the resulting state and the Blueprint's total breakpoint count.",
+		inputSchema: setBlueprintBreakpointInputSchema,
+		title: "Set Blueprint Breakpoint"
+	}, async ({ action, blueprintPath, graphName, nodeGuid, nodeTitle, projectId }) => {
+		return toToolSuccess(await setBlueprintBreakpoint({
+			action,
+			blueprintPath,
+			graphName,
+			nodeGuid,
+			nodeTitle,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("list_blueprint_breakpoints", {
+		description: "List every breakpoint on one Blueprint, each with its node guid, node title, owning graph and enabled flag. The guids are what set_blueprint_breakpoint takes to clear or toggle a breakpoint precisely.",
+		inputSchema: listBlueprintBreakpointsInputSchema,
+		title: "List Blueprint Breakpoints"
+	}, async ({ blueprintPath, projectId }) => {
+		return toToolSuccess(await listBlueprintBreakpoints({
+			blueprintPath,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("get_blueprint_debugger_state", {
+		description: "Report whether Blueprint execution is paused at a breakpoint and, when it is, the node it stopped on, the call stack innermost first, and the value of every watched pin. Returns paused=false with a message when nothing is halted, so it is safe to poll while waiting for a breakpoint to hit.",
+		inputSchema: getBlueprintDebuggerStateInputSchema,
+		title: "Get Blueprint Debugger State"
+	}, async ({ maxFrames, maxWatches, projectId }) => {
+		return toToolSuccess(await getBlueprintDebuggerState({
+			maxFrames,
+			maxWatches,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("control_blueprint_debugger", {
+		description: "Resume, step or stop a play session halted at a Blueprint breakpoint. 'stop' works whether or not execution is paused; every other action reports not_paused rather than silently doing nothing when nothing is halted.",
+		inputSchema: controlBlueprintDebuggerInputSchema,
+		title: "Control Blueprint Debugger"
+	}, async ({ action, projectId }) => {
+		return toToolSuccess(await controlBlueprintDebugger({
+			action,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("watch_blueprint_pin", {
+		description: "Start or stop watching a Blueprint pin, so get_blueprint_debugger_state reports its value whenever execution halts. Watches survive between play sessions and are what turns a breakpoint into a readable snapshot of local state; without one the debugger reports the paused node and call stack but no values.",
+		inputSchema: watchBlueprintPinInputSchema,
+		title: "Watch Blueprint Pin"
+	}, async ({ action, blueprintPath, graphName, nodeGuid, nodeTitle, pinName, projectId }) => {
+		return toToolSuccess(await watchBlueprintPin({
+			action,
+			blueprintPath,
+			graphName,
+			nodeGuid,
+			nodeTitle,
+			pinName,
+			projectId
+		}, dependencies));
+	});
+}
+const debuggerToolDomain = {
+	domain: "debugger",
+	register: registerDebuggerTools,
+	toolNames: [
+		"set_blueprint_breakpoint",
+		"list_blueprint_breakpoints",
+		"get_blueprint_debugger_state",
+		"control_blueprint_debugger",
+		"watch_blueprint_pin"
+	]
+};
+//#endregion
 //#region src/traceAnalysis.ts
 const SECONDS_TO_MS = 1e3;
 const FRAME_ROOT_TIMER_NAMES = /* @__PURE__ */ new Set(["FEngineLoop::Tick"]);
@@ -17613,27 +18326,329 @@ function registerImportTools(server, dependencies) {
 			settings
 		}, dependencies));
 	});
-	server.registerTool("get_import_job_status", {
-		description: "Poll an import job started by import_asset or reimport_asset; returns state (running, succeeded, failed, unknown_job), which operation it was, and once finished the per-file results with the assets each one created plus successCount / failureCount and timing. Poll until the state leaves 'running' before referencing any imported asset.",
-		inputSchema: getImportJobStatusInputSchema,
-		title: "Get Import Job Status"
-	}, async ({ importJobId, projectId }) => {
-		return toToolSuccess(await getImportJobStatus({
-			importJobId,
+	server.registerTool("get_import_job_status", {
+		description: "Poll an import job started by import_asset or reimport_asset; returns state (running, succeeded, failed, unknown_job), which operation it was, and once finished the per-file results with the assets each one created plus successCount / failureCount and timing. Poll until the state leaves 'running' before referencing any imported asset.",
+		inputSchema: getImportJobStatusInputSchema,
+		title: "Get Import Job Status"
+	}, async ({ importJobId, projectId }) => {
+		return toToolSuccess(await getImportJobStatus({
+			importJobId,
+			projectId
+		}, dependencies));
+	});
+}
+const importToolDomain = {
+	domain: "import",
+	register: registerImportTools,
+	toolNames: [
+		"import_asset",
+		"reimport_asset",
+		"set_import_settings",
+		"get_import_job_status"
+	]
+};
+const startPieInputSchema = {
+	map: z.string().trim().min(1).max(512).optional().describe("Optional level/map path to load before play (e.g. /Game/Maps/MyLevel)."),
+	mode: z.enum(BRIDGE_PIE_MODES).optional().describe("Play-in-Editor mode: 'selected_viewport', 'new_window' (default), or 'standalone'."),
+	netMode: z.enum(BRIDGE_PIE_NET_MODES).optional().describe("Multiplayer net mode: 'standalone', 'listen_server', 'client', or 'dedicated_server'. Omit for single-player editor defaults."),
+	numClients: z.number().int().min(1).max(16).optional().describe(`Number of client windows to launch (1-${String(16)}). With a server net mode, launches 1 server + N-1 clients.`),
+	projectId: projectIdSchema,
+	runUnderOneProcess: z.boolean().optional().describe("Run all multiplayer instances under a single process instead of separate processes.")
+};
+const getPieStatusInputSchema = {
+	pieSessionId: z.string().trim().min(1).max(512).optional().describe("Optional pieSessionId returned by start_pie; omit to query the editor current PIE session."),
+	projectId: projectIdSchema
+};
+const stopPieInputSchema = {
+	pieSessionId: z.string().trim().min(1).max(512).optional().describe("Optional pieSessionId returned by start_pie; omit to stop the editor current PIE session."),
+	projectId: projectIdSchema
+};
+const listLaunchDevicesInputSchema = { projectId: projectIdSchema };
+const launchOnDeviceInputSchema = {
+	deviceId: z.string().trim().min(1).max(512).describe("Target device id from list_launch_devices (e.g. IOS@MyiPhone, Android@serial)."),
+	map: z.string().trim().min(1).max(512).optional().describe("Optional level/map path to load on the device before play (e.g. /Game/Maps/MyLevel)."),
+	projectId: projectIdSchema
+};
+async function startPie(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 sendBridgeStartPieRequest(createBridgeStartPieRequest(input.mode ?? "new_window", input.map, {
+		netMode: input.netMode,
+		numClients: input.numClients,
+		runUnderOneProcess: input.runUnderOneProcess
+	}), {
+		connectTimeoutMs: dependencies.pingTimeoutMs,
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: dependencies.pingTimeoutMs
+	});
+	if (!response.ok) throw new Error(`Bridge protocol error (${response.error.code}): ${response.error.message}`);
+	const result = {
+		pieSessionId: response.pieSessionId,
+		projectId: normalizedProjectId,
+		state: response.state
+	};
+	if (response.message !== void 0) result.message = response.message;
+	return result;
+}
+async function getPieStatus(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 sendBridgeGetPieStatusRequest(createBridgeGetPieStatusRequest(input.pieSessionId), {
+		connectTimeoutMs: dependencies.pingTimeoutMs,
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: dependencies.pingTimeoutMs
+	});
+	if (!response.ok) throw new Error(`Bridge get_pie_status failed (${response.error.code}): ${response.error.message}`);
+	return buildGetPieStatusResult(response, normalizedProjectId);
+}
+function buildGetPieStatusResult(response, projectId) {
+	const result = {
+		projectId,
+		state: response.state
+	};
+	if (response.pieSessionId !== void 0) result.pieSessionId = response.pieSessionId;
+	if (response.startedAt !== void 0) result.startedAt = response.startedAt;
+	if (response.errorCount !== void 0) result.errorCount = response.errorCount;
+	if (response.message !== void 0) result.message = response.message;
+	return result;
+}
+async function stopPie(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 sendBridgeStopPieRequest(createBridgeStopPieRequest(input.pieSessionId), {
+		connectTimeoutMs: dependencies.pingTimeoutMs,
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: dependencies.pingTimeoutMs
+	});
+	if (!response.ok) throw new Error(`Bridge stop_pie failed (${response.error.code}): ${response.error.message}`);
+	const result = {
+		projectId: normalizedProjectId,
+		state: response.state,
+		stopped: response.stopped
+	};
+	if (response.message !== void 0) result.message = response.message;
+	return result;
+}
+async function listLaunchDevices(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 sendBridgeListLaunchDevicesRequest(createBridgeListLaunchDevicesRequest(), {
+		connectTimeoutMs: dependencies.pingTimeoutMs,
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: dependencies.pingTimeoutMs
+	});
+	if (!response.ok) throw new Error(`Bridge list_launch_devices failed (${response.error.code}): ${response.error.message}`);
+	return {
+		devices: response.devices,
+		projectId: normalizedProjectId
+	};
+}
+async function launchOnDevice(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 sendBridgeLaunchOnDeviceRequest(createBridgeLaunchOnDeviceRequest(input.deviceId, input.map), {
+		connectTimeoutMs: dependencies.pingTimeoutMs,
+		host: "127.0.0.1",
+		port: entry.port,
+		readTimeoutMs: dependencies.pingTimeoutMs
+	});
+	if (!response.ok) throw new Error(`Bridge launch_on_device failed (${response.error.code}): ${response.error.message}`);
+	const result = {
+		launchSessionId: response.launchSessionId,
+		projectId: normalizedProjectId,
+		state: response.state
+	};
+	if (response.message !== void 0) result.message = response.message;
+	return result;
+}
+function registerPieTools(server, dependencies) {
+	server.registerTool("start_pie", {
+		description: "Start a Play-in-Editor session in the registered Unreal editor for a project; play begins on the next editor tick (async). Returns starting/running/unsupported.",
+		inputSchema: startPieInputSchema,
+		title: "Start Play-in-Editor"
+	}, async ({ map, mode, netMode, numClients, projectId, runUnderOneProcess }) => {
+		return toToolSuccess(await startPie({
+			map,
+			mode,
+			netMode,
+			numClients,
+			projectId,
+			runUnderOneProcess
+		}, dependencies));
+	});
+	server.registerTool("get_pie_status", {
+		description: "Report the state of the Play-in-Editor session started by start_pie for a project: starting, running, stopped, or none. Reports running only after PIE has actually begun.",
+		inputSchema: getPieStatusInputSchema,
+		title: "Get Play-in-Editor Status"
+	}, async ({ pieSessionId, projectId }) => {
+		return toToolSuccess(await getPieStatus({
+			pieSessionId,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("stop_pie", {
+		description: "End the active Play-in-Editor session for a project. Returns stopped=true when a session was ended, or stopped=false (state none) when nothing was playing.",
+		inputSchema: stopPieInputSchema,
+		title: "Stop Play-in-Editor"
+	}, async ({ pieSessionId, projectId }) => {
+		return toToolSuccess(await stopPie({
+			pieSessionId,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("list_launch_devices", {
+		description: "List the target devices the registered Unreal editor can launch onto (iOS, Android, etc.), with each device id, name, platform, and connected/authorized state. Pick a deviceId for launch_on_device.",
+		inputSchema: listLaunchDevicesInputSchema,
+		title: "List Launch Devices"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await listLaunchDevices({ projectId }, dependencies));
+	});
+	server.registerTool("launch_on_device", {
+		description: "Launch (cook-on-the-fly + deploy, not package) the current project onto a connected target device by deviceId from list_launch_devices. Returns a launchSessionId and starting/unsupported state; deploy proceeds asynchronously.",
+		inputSchema: launchOnDeviceInputSchema,
+		title: "Launch On Device"
+	}, async ({ deviceId, map, projectId }) => {
+		return toToolSuccess(await launchOnDevice({
+			deviceId,
+			map,
+			projectId
+		}, dependencies));
+	});
+}
+const pieToolDomain = {
+	domain: "pie",
+	register: (server, dependencies) => {
+		registerPieTools(server, dependencies);
+		registerPieRuntimeTools(server, dependencies);
+	},
+	toolNames: [
+		"start_pie",
+		"get_pie_status",
+		"stop_pie",
+		"list_launch_devices",
+		"launch_on_device",
+		"call_actor_function",
+		"list_pie_worlds",
+		"get_net_stats"
+	]
+};
+const WORLD_SELECTOR_DESCRIPTION = "Which world to address: 'editor' (default) is the level open in the editor; 'pie' is a running Play-in-Editor session, whose actors are separate objects reflecting live gameplay state. A 'pie' request with no session running fails rather than falling back to the editor world.";
+const PIE_INSTANCE_INDEX_DESCRIPTION = "Which Play-in-Editor world to address, as list_pie_worlds reports its index. Omitted means the lowest running instance, which is the server in a listen-server session. Ignored unless world is \"pie\".";
+const callActorFunctionInputSchema = {
+	actorPath: bridgeCallActorFunctionRequestSchema.shape.actorPath.describe("Full path name of the actor, as list_actors returns it. A path read from the editor world also addresses the same actor in a PIE world."),
+	args: bridgeCallActorFunctionRequestSchema.shape.args.describe("Arguments to pass, each a { name, value } pair. Names are the UFunction parameter names get_class_reflection reports; values use the same ExportText format get_actor_details emits. Omitted parameters keep their zero value."),
+	functionName: bridgeCallActorFunctionRequestSchema.shape.functionName.describe("Name of the BlueprintCallable function to invoke, as get_class_reflection reports it."),
+	pieInstanceIndex: bridgeCallActorFunctionRequestSchema.shape.pieInstanceIndex.describe(PIE_INSTANCE_INDEX_DESCRIPTION),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor holds the actor."),
+	world: bridgeCallActorFunctionRequestSchema.shape.world.describe(WORLD_SELECTOR_DESCRIPTION)
+};
+const listPieWorldsInputSchema = { projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should report its Play-in-Editor worlds.") };
+const getNetStatsInputSchema = {
+	pieInstanceIndex: bridgeGetNetStatsRequestSchema.shape.pieInstanceIndex.describe("Restrict the report to one PIE world, as list_pie_worlds reports its index. Omitted reports every running world."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should report its network statistics.")
+};
+async function callActorFunction(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 sendBridgeCallActorFunctionRequest(createBridgeCallActorFunctionRequest(input.actorPath, input.functionName, {
+		args: input.args,
+		pieInstanceIndex: input.pieInstanceIndex,
+		world: input.world
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge call_actor_function failed (${response.error.code}): ${response.error.message}`);
+	return {
+		actorPath: response.actorPath,
+		functionName: response.functionName,
+		outputs: response.outputs,
+		projectId: entry.projectId,
+		returnValue: response.returnValue,
+		worldName: response.worldName
+	};
+}
+async function listPieWorlds(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 sendBridgeListPieWorldsRequest(createBridgeListPieWorldsRequest(), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge list_pie_worlds failed (${response.error.code}): ${response.error.message}`);
+	return {
+		active: response.active,
+		message: response.message,
+		projectId: entry.projectId,
+		worlds: response.worlds
+	};
+}
+async function getNetStats(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 sendBridgeGetNetStatsRequest(createBridgeGetNetStatsRequest({ pieInstanceIndex: input.pieInstanceIndex }), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge get_net_stats failed (${response.error.code}): ${response.error.message}`);
+	return {
+		active: response.active,
+		message: response.message,
+		projectId: entry.projectId,
+		worlds: response.worlds
+	};
+}
+function registerPieRuntimeTools(server, dependencies) {
+	server.registerTool("call_actor_function", {
+		description: "Invoke a BlueprintCallable function on one actor and return its return value and any out parameters. Set world to 'pie' to call into a running Play-in-Editor session, where the actor holds live gameplay state rather than its editor defaults. Functions that are not BlueprintCallable, and latent functions that need a calling graph, are rejected with an explicit error.",
+		inputSchema: callActorFunctionInputSchema,
+		title: "Call Actor Function"
+	}, async ({ actorPath, args, functionName, pieInstanceIndex, projectId, world }) => {
+		return toToolSuccess(await callActorFunction({
+			actorPath,
+			args,
+			functionName,
+			pieInstanceIndex,
+			projectId,
+			world
+		}, dependencies));
+	});
+	server.registerTool("list_pie_worlds", {
+		description: "List the worlds a running Play-in-Editor session owns, each with the engine's own instance index, net mode, server flag, map name, player count and actor count. The index is what every world-addressed tool takes as pieInstanceIndex, so this is how a multiplayer session becomes addressable. Reports active=false with a message rather than failing when nothing is playing.",
+		inputSchema: listPieWorldsInputSchema,
+		title: "List PIE Worlds"
+	}, async ({ projectId }) => {
+		return toToolSuccess(await listPieWorlds({ projectId }, dependencies));
+	});
+	server.registerTool("get_net_stats", {
+		description: "Report per-world network statistics for a running Play-in-Editor session: each world's role and replicated actor count, and for every connection its address, ping, packet loss and throughput. Pass pieInstanceIndex to narrow it to one client. A standalone world reports hasNetDriver=false rather than failing.",
+		inputSchema: getNetStatsInputSchema,
+		title: "Get Net Stats"
+	}, async ({ pieInstanceIndex, projectId }) => {
+		return toToolSuccess(await getNetStats({
+			pieInstanceIndex,
 			projectId
 		}, dependencies));
 	});
 }
-const importToolDomain = {
-	domain: "import",
-	register: registerImportTools,
-	toolNames: [
-		"import_asset",
-		"reimport_asset",
-		"set_import_settings",
-		"get_import_job_status"
-	]
-};
 //#endregion
 //#region src/tools/input.ts
 const createInputActionInputSchema = {
@@ -17708,13 +18723,67 @@ function registerInputTools(server, dependencies) {
 }
 const inputToolDomain = {
 	domain: "input",
-	register: registerInputTools,
+	register: (server, dependencies) => {
+		registerInputTools(server, dependencies);
+		registerInputInjectionTools(server, dependencies);
+	},
 	toolNames: [
 		"create_input_action",
 		"create_input_mapping_context",
-		"add_input_mapping"
+		"add_input_mapping",
+		"inject_input_action"
 	]
 };
+const injectInputActionInputSchema = {
+	actionPath: bridgeInjectInputActionRequestSchema.shape.actionPath.describe("Path of the Enhanced Input Action asset to inject (e.g. /Game/Input/IA_Jump)."),
+	durationSeconds: bridgeInjectInputActionRequestSchema.shape.durationSeconds.describe(`Hold the action for this many seconds by re-injecting it every frame (0-${String(60)}). Omitted injects for a single frame, which is enough for a pressed trigger but not for a held one.`),
+	pieInstanceIndex: bridgeInjectInputActionRequestSchema.shape.pieInstanceIndex.describe(PIE_INSTANCE_INDEX_DESCRIPTION),
+	playerIndex: bridgeInjectInputActionRequestSchema.shape.playerIndex.describe("Which local player in that world receives the input (default 0). Enhanced Input binds mapping contexts per player, so a split-screen or multi-window session has one target per window."),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor is running the Play-in-Editor session."),
+	value: bridgeInjectInputActionRequestSchema.shape.value.describe("The value to inject, always as a vector: a digital action reads x != 0 as pressed, an Axis1D reads x, an Axis2D reads x and y. The response's valueType reports how the action actually read it.")
+};
+async function injectInputAction(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 sendBridgeInjectInputActionRequest(createBridgeInjectInputActionRequest(input.actionPath, {
+		durationSeconds: input.durationSeconds,
+		pieInstanceIndex: input.pieInstanceIndex,
+		playerIndex: input.playerIndex,
+		value: input.value
+	}), {
+		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
+		host: BRIDGE_LOOPBACK_HOST,
+		port: entry.port,
+		readTimeoutMs: deriveEditorWorkTimeoutMs(dependencies.pingTimeoutMs)
+	});
+	if (!response.ok) throw new Error(`Bridge inject_input_action failed (${response.error.code}): ${response.error.message}`);
+	return {
+		actionPath: response.actionPath,
+		durationSeconds: response.durationSeconds,
+		pieInstanceIndex: response.pieInstanceIndex,
+		playerIndex: response.playerIndex,
+		projectId: entry.projectId,
+		valueType: response.valueType,
+		worldName: response.worldName
+	};
+}
+function registerInputInjectionTools(server, dependencies) {
+	server.registerTool("inject_input_action", {
+		description: "Inject a value for one Enhanced Input Action into a running Play-in-Editor session, as if the player had triggered it. Pass durationSeconds to hold the action, which re-injects it every frame until it elapses. Requires a running PIE session and a local player at playerIndex; both are reported as explicit errors rather than silently doing nothing.",
+		inputSchema: injectInputActionInputSchema,
+		title: "Inject Input Action"
+	}, async ({ actionPath, durationSeconds, pieInstanceIndex, playerIndex, projectId, value }) => {
+		return toToolSuccess(await injectInputAction({
+			actionPath,
+			durationSeconds,
+			pieInstanceIndex,
+			playerIndex,
+			projectId,
+			value
+		}, dependencies));
+	});
+}
 //#endregion
 //#region src/mcpProgress.ts
 function createProgressReporter(extra, logger) {
@@ -18367,194 +19436,6 @@ const packagingToolDomain = {
 		"cancel_package_job"
 	]
 };
-const startPieInputSchema = {
-	map: z.string().trim().min(1).max(512).optional().describe("Optional level/map path to load before play (e.g. /Game/Maps/MyLevel)."),
-	mode: z.enum(BRIDGE_PIE_MODES).optional().describe("Play-in-Editor mode: 'selected_viewport', 'new_window' (default), or 'standalone'."),
-	netMode: z.enum(BRIDGE_PIE_NET_MODES).optional().describe("Multiplayer net mode: 'standalone', 'listen_server', 'client', or 'dedicated_server'. Omit for single-player editor defaults."),
-	numClients: z.number().int().min(1).max(16).optional().describe(`Number of client windows to launch (1-${String(16)}). With a server net mode, launches 1 server + N-1 clients.`),
-	projectId: projectIdSchema,
-	runUnderOneProcess: z.boolean().optional().describe("Run all multiplayer instances under a single process instead of separate processes.")
-};
-const getPieStatusInputSchema = {
-	pieSessionId: z.string().trim().min(1).max(512).optional().describe("Optional pieSessionId returned by start_pie; omit to query the editor current PIE session."),
-	projectId: projectIdSchema
-};
-const stopPieInputSchema = {
-	pieSessionId: z.string().trim().min(1).max(512).optional().describe("Optional pieSessionId returned by start_pie; omit to stop the editor current PIE session."),
-	projectId: projectIdSchema
-};
-const listLaunchDevicesInputSchema = { projectId: projectIdSchema };
-const launchOnDeviceInputSchema = {
-	deviceId: z.string().trim().min(1).max(512).describe("Target device id from list_launch_devices (e.g. IOS@MyiPhone, Android@serial)."),
-	map: z.string().trim().min(1).max(512).optional().describe("Optional level/map path to load on the device before play (e.g. /Game/Maps/MyLevel)."),
-	projectId: projectIdSchema
-};
-async function startPie(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 sendBridgeStartPieRequest(createBridgeStartPieRequest(input.mode ?? "new_window", input.map, {
-		netMode: input.netMode,
-		numClients: input.numClients,
-		runUnderOneProcess: input.runUnderOneProcess
-	}), {
-		connectTimeoutMs: dependencies.pingTimeoutMs,
-		host: "127.0.0.1",
-		port: entry.port,
-		readTimeoutMs: dependencies.pingTimeoutMs
-	});
-	if (!response.ok) throw new Error(`Bridge protocol error (${response.error.code}): ${response.error.message}`);
-	const result = {
-		pieSessionId: response.pieSessionId,
-		projectId: normalizedProjectId,
-		state: response.state
-	};
-	if (response.message !== void 0) result.message = response.message;
-	return result;
-}
-async function getPieStatus(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 sendBridgeGetPieStatusRequest(createBridgeGetPieStatusRequest(input.pieSessionId), {
-		connectTimeoutMs: dependencies.pingTimeoutMs,
-		host: "127.0.0.1",
-		port: entry.port,
-		readTimeoutMs: dependencies.pingTimeoutMs
-	});
-	if (!response.ok) throw new Error(`Bridge get_pie_status failed (${response.error.code}): ${response.error.message}`);
-	return buildGetPieStatusResult(response, normalizedProjectId);
-}
-function buildGetPieStatusResult(response, projectId) {
-	const result = {
-		projectId,
-		state: response.state
-	};
-	if (response.pieSessionId !== void 0) result.pieSessionId = response.pieSessionId;
-	if (response.startedAt !== void 0) result.startedAt = response.startedAt;
-	if (response.errorCount !== void 0) result.errorCount = response.errorCount;
-	if (response.message !== void 0) result.message = response.message;
-	return result;
-}
-async function stopPie(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 sendBridgeStopPieRequest(createBridgeStopPieRequest(input.pieSessionId), {
-		connectTimeoutMs: dependencies.pingTimeoutMs,
-		host: "127.0.0.1",
-		port: entry.port,
-		readTimeoutMs: dependencies.pingTimeoutMs
-	});
-	if (!response.ok) throw new Error(`Bridge stop_pie failed (${response.error.code}): ${response.error.message}`);
-	const result = {
-		projectId: normalizedProjectId,
-		state: response.state,
-		stopped: response.stopped
-	};
-	if (response.message !== void 0) result.message = response.message;
-	return result;
-}
-async function listLaunchDevices(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 sendBridgeListLaunchDevicesRequest(createBridgeListLaunchDevicesRequest(), {
-		connectTimeoutMs: dependencies.pingTimeoutMs,
-		host: "127.0.0.1",
-		port: entry.port,
-		readTimeoutMs: dependencies.pingTimeoutMs
-	});
-	if (!response.ok) throw new Error(`Bridge list_launch_devices failed (${response.error.code}): ${response.error.message}`);
-	return {
-		devices: response.devices,
-		projectId: normalizedProjectId
-	};
-}
-async function launchOnDevice(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 sendBridgeLaunchOnDeviceRequest(createBridgeLaunchOnDeviceRequest(input.deviceId, input.map), {
-		connectTimeoutMs: dependencies.pingTimeoutMs,
-		host: "127.0.0.1",
-		port: entry.port,
-		readTimeoutMs: dependencies.pingTimeoutMs
-	});
-	if (!response.ok) throw new Error(`Bridge launch_on_device failed (${response.error.code}): ${response.error.message}`);
-	const result = {
-		launchSessionId: response.launchSessionId,
-		projectId: normalizedProjectId,
-		state: response.state
-	};
-	if (response.message !== void 0) result.message = response.message;
-	return result;
-}
-function registerPieTools(server, dependencies) {
-	server.registerTool("start_pie", {
-		description: "Start a Play-in-Editor session in the registered Unreal editor for a project; play begins on the next editor tick (async). Returns starting/running/unsupported.",
-		inputSchema: startPieInputSchema,
-		title: "Start Play-in-Editor"
-	}, async ({ map, mode, netMode, numClients, projectId, runUnderOneProcess }) => {
-		return toToolSuccess(await startPie({
-			map,
-			mode,
-			netMode,
-			numClients,
-			projectId,
-			runUnderOneProcess
-		}, dependencies));
-	});
-	server.registerTool("get_pie_status", {
-		description: "Report the state of the Play-in-Editor session started by start_pie for a project: starting, running, stopped, or none. Reports running only after PIE has actually begun.",
-		inputSchema: getPieStatusInputSchema,
-		title: "Get Play-in-Editor Status"
-	}, async ({ pieSessionId, projectId }) => {
-		return toToolSuccess(await getPieStatus({
-			pieSessionId,
-			projectId
-		}, dependencies));
-	});
-	server.registerTool("stop_pie", {
-		description: "End the active Play-in-Editor session for a project. Returns stopped=true when a session was ended, or stopped=false (state none) when nothing was playing.",
-		inputSchema: stopPieInputSchema,
-		title: "Stop Play-in-Editor"
-	}, async ({ pieSessionId, projectId }) => {
-		return toToolSuccess(await stopPie({
-			pieSessionId,
-			projectId
-		}, dependencies));
-	});
-	server.registerTool("list_launch_devices", {
-		description: "List the target devices the registered Unreal editor can launch onto (iOS, Android, etc.), with each device id, name, platform, and connected/authorized state. Pick a deviceId for launch_on_device.",
-		inputSchema: listLaunchDevicesInputSchema,
-		title: "List Launch Devices"
-	}, async ({ projectId }) => {
-		return toToolSuccess(await listLaunchDevices({ projectId }, dependencies));
-	});
-	server.registerTool("launch_on_device", {
-		description: "Launch (cook-on-the-fly + deploy, not package) the current project onto a connected target device by deviceId from list_launch_devices. Returns a launchSessionId and starting/unsupported state; deploy proceeds asynchronously.",
-		inputSchema: launchOnDeviceInputSchema,
-		title: "Launch On Device"
-	}, async ({ deviceId, map, projectId }) => {
-		return toToolSuccess(await launchOnDevice({
-			deviceId,
-			map,
-			projectId
-		}, dependencies));
-	});
-}
-const pieToolDomain = {
-	domain: "pie",
-	register: registerPieTools,
-	toolNames: [
-		"start_pie",
-		"get_pie_status",
-		"stop_pie",
-		"list_launch_devices",
-		"launch_on_device"
-	]
-};
 //#endregion
 //#region src/tools/render.ts
 const renderSequenceInputSchema = {
@@ -19130,16 +20011,20 @@ const listActorsInputSchema = {
 	levelName: bridgeListActorsRequestSchema.shape.levelName.describe("Restrict the walk to a single level, by package name (/Game/Maps/MyLevel) or short name (MyLevel). Omitted means every level loaded in the editor world."),
 	maxResults: bridgeListActorsRequestSchema.shape.maxResults.default(50).describe("Maximum number of actors to return per page (1-100, default 50). totalCount still reports the unbounded match count."),
 	nameFilter: bridgeListActorsRequestSchema.shape.nameFilter.describe("Optional case-insensitive substring matched against each actor label and path."),
+	pieInstanceIndex: bridgeListActorsRequestSchema.shape.pieInstanceIndex.describe(PIE_INSTANCE_INDEX_DESCRIPTION),
 	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should list its actors."),
-	tag: bridgeListActorsRequestSchema.shape.tag.describe("Optional exact-match actor tag (AActor::Tags) to filter by.")
+	tag: bridgeListActorsRequestSchema.shape.tag.describe("Optional exact-match actor tag (AActor::Tags) to filter by."),
+	world: bridgeListActorsRequestSchema.shape.world.describe(WORLD_SELECTOR_DESCRIPTION)
 };
 const getActorDetailsInputSchema = {
 	actorPath: bridgeGetActorDetailsRequestSchema.shape.actorPath.describe("Full path name of the actor, as returned by list_actors or get_editor_state (e.g. /Game/Maps/Test.Test:PersistentLevel.StaticMeshActor_3)."),
 	componentCursor: bridgeGetActorDetailsRequestSchema.shape.componentCursor.describe("Offset into the component list (default 0). Pass the previous response nextComponentCursor to fetch the next page."),
 	includeInherited: bridgeGetActorDetailsRequestSchema.shape.includeInherited.describe("Whether to include properties inherited from parent classes (default false). Inherited properties are the bulk of any AActor subclass."),
 	maxResults: bridgeGetActorDetailsRequestSchema.shape.maxResults.default(25).describe("Maximum entries returned per page for each list (1-200, default 25)."),
+	pieInstanceIndex: bridgeGetActorDetailsRequestSchema.shape.pieInstanceIndex.describe(PIE_INSTANCE_INDEX_DESCRIPTION),
 	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor holds the actor."),
-	propertyCursor: bridgeGetActorDetailsRequestSchema.shape.propertyCursor.describe("Offset into the property list (default 0). Pass the previous response nextPropertyCursor to fetch the next page.")
+	propertyCursor: bridgeGetActorDetailsRequestSchema.shape.propertyCursor.describe("Offset into the property list (default 0). Pass the previous response nextPropertyCursor to fetch the next page."),
+	world: bridgeGetActorDetailsRequestSchema.shape.world.describe(WORLD_SELECTOR_DESCRIPTION)
 };
 const getCurrentLevelInputSchema = { projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should report its loaded level.") };
 const spawnActorInputSchema = {
@@ -19159,8 +20044,10 @@ const setActorTransformInputSchema = {
 };
 const setActorPropertyInputSchema = {
 	dryRun: bridgeSetActorPropertyRequestSchema.shape.dryRun.describe("When true, resolve every property path and check the value coerces, without opening a transaction or writing anything (default false)."),
+	pieInstanceIndex: bridgeSetActorPropertyRequestSchema.shape.pieInstanceIndex.describe(PIE_INSTANCE_INDEX_DESCRIPTION),
 	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor holds the actors."),
-	properties: bridgeSetActorPropertyRequestSchema.shape.properties.describe("Property writes to apply (1-64). Each entry needs an actorPath, a propertyPath — 'bHidden' for an actor property or 'StaticMeshComponent.RelativeScale3D' for a component's — and a value in the same ExportText format get_actor_details and get_cdo_defaults emit. Non-editable (EditConst) properties are rejected with an error rather than silently ignored.")
+	properties: bridgeSetActorPropertyRequestSchema.shape.properties.describe("Property writes to apply (1-64). Each entry needs an actorPath, a propertyPath — 'bHidden' for an actor property or 'StaticMeshComponent.RelativeScale3D' for a component's — and a value in the same ExportText format get_actor_details and get_cdo_defaults emit. Non-editable (EditConst) properties are rejected with an error rather than silently ignored."),
+	world: bridgeSetActorPropertyRequestSchema.shape.world.describe(WORLD_SELECTOR_DESCRIPTION)
 };
 const selectActorsInputSchema = {
 	actorPaths: bridgeSelectActorsRequestSchema.shape.actorPaths.describe("Actor paths to select (up to 64). An empty list clears the selection. These are the same actorPath values list_actors and get_editor_state report."),
@@ -19190,7 +20077,9 @@ async function listActors(input, dependencies) {
 		levelName: input.levelName,
 		maxResults: input.maxResults,
 		nameFilter: input.nameFilter,
-		tag: input.tag
+		pieInstanceIndex: input.pieInstanceIndex,
+		tag: input.tag,
+		world: input.world
 	}), {
 		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
 		host: "127.0.0.1",
@@ -19215,7 +20104,9 @@ async function getActorDetails(input, dependencies) {
 		componentCursor: input.componentCursor,
 		includeInherited: input.includeInherited,
 		maxResults: input.maxResults,
-		propertyCursor: input.propertyCursor
+		pieInstanceIndex: input.pieInstanceIndex,
+		propertyCursor: input.propertyCursor,
+		world: input.world
 	}), {
 		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
 		host: "127.0.0.1",
@@ -19333,7 +20224,11 @@ async function setActorProperty(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 sendBridgeSetActorPropertyRequest(createBridgeSetActorPropertyRequest(input.properties, { dryRun: input.dryRun }), {
+	const response = await sendBridgeSetActorPropertyRequest(createBridgeSetActorPropertyRequest(input.properties, {
+		dryRun: input.dryRun,
+		pieInstanceIndex: input.pieInstanceIndex,
+		world: input.world
+	}), {
 		connectTimeoutMs: deriveBridgeConnectTimeoutMs$1(dependencies.pingTimeoutMs),
 		host: "127.0.0.1",
 		port: entry.port,
@@ -19525,29 +20420,33 @@ function registerLevelTools(server, dependencies) {
 		description: "Enumerate actors in the editor's currently loaded level(s), optionally filtered by class, name substring, tag, or level. Returns each actor's canonical actorPath (the identifier every other level tool takes), display label, class, level, and World Outliner folder. Results are paged: pass the previous response nextCursor to fetch the next page, and totalCount reports the full match count even when a page truncates. Use this to find an actor before calling get_actor_details.",
 		inputSchema: listActorsInputSchema,
 		title: "List Actors"
-	}, async ({ classNames, cursor, levelName, maxResults, nameFilter, projectId, tag }) => {
+	}, async ({ classNames, cursor, levelName, maxResults, nameFilter, pieInstanceIndex, projectId, tag, world }) => {
 		return toToolSuccess(await listActors({
 			classNames,
 			cursor,
 			levelName,
 			maxResults,
 			nameFilter,
+			pieInstanceIndex,
 			projectId,
-			tag
+			tag,
+			world
 		}, dependencies));
 	});
 	server.registerTool("get_actor_details", {
 		description: "Inspect one actor in the loaded level by its actorPath: world transform, attached component hierarchy (each component's name, class, attachment parent, and relative transform), and reflected UPROPERTY values. Property values use the same ExportText format get_cdo_defaults emits, so a value read here can be written back verbatim. Components and properties page independently — pass nextComponentCursor / nextPropertyCursor to continue each list. Inherited properties are excluded unless includeInherited is true.",
 		inputSchema: getActorDetailsInputSchema,
 		title: "Get Actor Details"
-	}, async ({ actorPath, componentCursor, includeInherited, maxResults, projectId, propertyCursor }) => {
+	}, async ({ actorPath, componentCursor, includeInherited, maxResults, pieInstanceIndex, projectId, propertyCursor, world }) => {
 		return toToolSuccess(await getActorDetails({
 			actorPath,
 			componentCursor,
 			includeInherited,
 			maxResults,
+			pieInstanceIndex,
 			projectId,
-			propertyCursor
+			propertyCursor,
+			world
 		}, dependencies));
 	});
 	server.registerTool("get_current_level", {
@@ -19594,11 +20493,13 @@ function registerLevelTools(server, dependencies) {
 		description: "Write reflected UPROPERTY values on actors or their components in the loaded level. Each entry takes an actorPath, a propertyPath ('bHidden' on the actor, 'StaticMeshComponent.RelativeScale3D' on a component), and a value in the same ExportText format get_actor_details and get_cdo_defaults emit — so you can read a value, edit it, and write it back without translating. Properties marked EditConst or not exposed for editing are rejected with an explicit error rather than silently ignored. The whole batch runs in one transaction; pass dryRun: true to resolve paths and check coercion without writing.",
 		inputSchema: setActorPropertyInputSchema,
 		title: "Set Actor Property"
-	}, async ({ dryRun, projectId, properties }) => {
+	}, async ({ dryRun, pieInstanceIndex, projectId, properties, world }) => {
 		return toToolSuccess(await setActorProperty({
 			dryRun,
+			pieInstanceIndex,
 			projectId,
-			properties
+			properties,
+			world
 		}, dependencies));
 	});
 	server.registerTool("select_actors", {
@@ -21514,15 +22415,150 @@ function registerViewportTools(server, dependencies) {
 }
 const viewportToolDomain = {
 	domain: "viewport",
-	register: registerViewportTools,
+	register: (server, dependencies) => {
+		registerViewportTools(server, dependencies);
+		registerViewportBaselineTools(server, dependencies);
+	},
 	toolNames: [
 		"set_viewport_camera",
 		"focus_actors",
 		"set_view_mode",
 		"toggle_show_flags",
-		"high_res_screenshot"
+		"high_res_screenshot",
+		"compare_viewport_baseline"
 	]
 };
+const VIEWPORT_BASELINE_DEFAULT_MAX_MISMATCH_RATIO = .02;
+const compareViewportBaselineInputSchema = {
+	baselineDir: z.string().trim().min(1).max(1024).optional().describe("Directory holding the baseline images. Defaults to <home>/.uemcp/baselines/<projectId>, so a project accumulates its own set without any setup."),
+	baselineName: z.string().trim().min(1).max(128).regex(/^[A-Za-z0-9_-]+$/).describe("Name of the baseline to compare against, without an extension. Letters, digits, underscore and hyphen only, since it becomes a file name."),
+	maxMismatchRatio: z.number().min(0).max(1).default(VIEWPORT_BASELINE_DEFAULT_MAX_MISMATCH_RATIO).describe(`Fraction of differing pixels tolerated before the comparison fails (0-1, default ${String(VIEWPORT_BASELINE_DEFAULT_MAX_MISMATCH_RATIO)}). The default absorbs the renderer's own frame-to-frame jitter; pass 0 to demand an exact match.`),
+	pixelTolerance: z.number().int().min(0).max(255).default(16).describe(`Per-channel difference a pixel may have before it counts as differing (0-255, default ${String(16)}). Raise this rather than maxMismatchRatio to absorb anti-aliasing and dithering; pass 0 to compare exactly.`),
+	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should capture a frame."),
+	updateBaseline: z.boolean().default(false).describe("Overwrite the baseline with this capture instead of comparing against it. Use after an intended visual change."),
+	writeDiffImage: z.boolean().default(true).describe("Write a diff image next to the baseline when pixels differ, marking every differing pixel in red over a dimmed copy of the capture.")
+};
+function comparePngs(capture, baseline, pixelTolerance) {
+	const diff = new PNG({
+		height: capture.height,
+		width: capture.width
+	});
+	const captureData = capture.data;
+	const baselineData = baseline.data;
+	const diffData = diff.data;
+	let differingPixels = 0;
+	for (let index = 0; index < captureData.length; index += 4) {
+		let differs = false;
+		for (let channel = 0; channel < 4; channel += 1) {
+			const captureChannel = captureData[index + channel] ?? 0;
+			const baselineChannel = baselineData[index + channel] ?? 0;
+			if (Math.abs(captureChannel - baselineChannel) > pixelTolerance) {
+				differs = true;
+				break;
+			}
+		}
+		if (differs) {
+			differingPixels += 1;
+			diffData[index] = 255;
+			diffData[index + 1] = 0;
+			diffData[index + 2] = 0;
+			diffData[index + 3] = 255;
+			continue;
+		}
+		const red = captureData[index] ?? 0;
+		const green = captureData[index + 1] ?? 0;
+		const blue = captureData[index + 2] ?? 0;
+		const grey = Math.round((red + green + blue) / 3 * .25);
+		diffData[index] = grey;
+		diffData[index + 1] = grey;
+		diffData[index + 2] = grey;
+		diffData[index + 3] = 255;
+	}
+	return {
+		diff,
+		differingPixels
+	};
+}
+async function readPng(filePath) {
+	return PNG.sync.read(await readFile(filePath));
+}
+async function compareViewportBaseline(input, dependencies) {
+	const normalizedProjectId = projectIdSchema.parse(input.projectId);
+	const capture = await captureViewport({ projectId: normalizedProjectId }, dependencies);
+	const pixelTolerance = input.pixelTolerance ?? 16;
+	const maxMismatchRatio = input.maxMismatchRatio ?? .02;
+	const baselineDir = input.baselineDir ?? join(homedir(), ".uemcp", "baselines", normalizedProjectId);
+	const baselinePath = join(baselineDir, `${input.baselineName}.png`);
+	const totalPixels = capture.width * capture.height;
+	const common = {
+		baselinePath,
+		capturePath: capture.path,
+		height: capture.height,
+		maxMismatchRatio,
+		pixelTolerance,
+		projectId: normalizedProjectId,
+		totalPixels,
+		width: capture.width
+	};
+	const baselineExists = existsSync(baselinePath);
+	if (!baselineExists || input.updateBaseline === true) {
+		await mkdir(baselineDir, { recursive: true });
+		await copyFile(capture.path, baselinePath);
+		return {
+			...common,
+			differingPixels: 0,
+			matched: true,
+			mismatchRatio: 0,
+			state: baselineExists ? "baseline_updated" : "baseline_created"
+		};
+	}
+	const [captureImage, baselineImage] = await Promise.all([readPng(capture.path), readPng(baselinePath)]);
+	if (captureImage.width !== baselineImage.width || captureImage.height !== baselineImage.height) return {
+		...common,
+		baselineHeight: baselineImage.height,
+		baselineWidth: baselineImage.width,
+		differingPixels: totalPixels,
+		matched: false,
+		mismatchRatio: 1,
+		state: "size_mismatch"
+	};
+	const { diff, differingPixels } = comparePngs(captureImage, baselineImage, pixelTolerance);
+	const mismatchRatio = totalPixels === 0 ? 0 : differingPixels / totalPixels;
+	const matched = mismatchRatio <= maxMismatchRatio;
+	let diffPath;
+	if (!matched && input.writeDiffImage !== false) {
+		diffPath = join(baselineDir, `${input.baselineName}.diff.png`);
+		await mkdir(baselineDir, { recursive: true });
+		await writeFile(diffPath, PNG.sync.write(diff));
+	}
+	return {
+		...common,
+		baselineHeight: baselineImage.height,
+		baselineWidth: baselineImage.width,
+		diffPath,
+		differingPixels,
+		matched,
+		mismatchRatio,
+		state: matched ? "matched" : "mismatched"
+	};
+}
+function registerViewportBaselineTools(server, dependencies) {
+	server.registerTool("compare_viewport_baseline", {
+		description: "Capture the editor viewport and compare it against a stored baseline image, returning the fraction of differing pixels and writing a diff image that marks them in red. The first call for a baselineName stores the capture as the baseline; pass updateBaseline: true to replace it after an intended visual change. A capture whose size no longer matches the baseline is reported as size_mismatch rather than failing. The default tolerances absorb the frame-to-frame jitter a live viewport renders anyway, so a mismatch means the scene changed rather than that it was rendered again.",
+		inputSchema: compareViewportBaselineInputSchema,
+		title: "Compare Viewport Baseline"
+	}, async ({ baselineDir, baselineName, maxMismatchRatio, pixelTolerance, projectId, updateBaseline, writeDiffImage }) => {
+		return toToolSuccess(await compareViewportBaseline({
+			baselineDir,
+			baselineName,
+			maxMismatchRatio,
+			pixelTolerance,
+			projectId,
+			updateBaseline,
+			writeDiffImage
+		}, dependencies));
+	});
+}
 //#endregion
 //#region src/tools/worldPartition.ts
 const listDataLayersInputSchema = {
@@ -21603,6 +22639,7 @@ const TOOL_CATALOG = [
 	packagingToolDomain,
 	logsToolDomain,
 	pieToolDomain,
+	debuggerToolDomain,
 	automationToolDomain,
 	jobsToolDomain,
 	editorToolDomain,