@uemcp/server 1.3.0 → 1.4.0

package/dist/index.mjs

@@ -4569,6 +4569,1526 @@ function createBridgeLoadWpRegionRequest(action, options = {}, requestId = rando
 		version: 2
 	});
 }
+const BRIDGE_GET_ASSET_PROPERTY_REQUEST_TYPE = "get_asset_property";
+const BRIDGE_SET_ASSET_PROPERTY_REQUEST_TYPE = "set_asset_property";
+const BRIDGE_ARRAY_PROPERTY_OP_REQUEST_TYPE = "array_property_op";
+const BRIDGE_CREATE_STRUCT_REQUEST_TYPE = "create_struct";
+const BRIDGE_CREATE_ENUM_REQUEST_TYPE = "create_enum";
+const BRIDGE_CREATE_BLUEPRINT_REQUEST_TYPE = "create_blueprint";
+const BRIDGE_ADD_BP_VARIABLE_REQUEST_TYPE = "add_bp_variable";
+const BRIDGE_ADD_BP_FUNCTION_REQUEST_TYPE = "add_bp_function";
+const BRIDGE_ADD_BP_EVENT_REQUEST_TYPE = "add_bp_event";
+const BRIDGE_ADD_BP_COMPONENT_REQUEST_TYPE = "add_bp_component";
+const BRIDGE_ADD_BP_INTERFACE_REQUEST_TYPE = "add_bp_interface";
+const BRIDGE_SET_BP_DEFAULT_REQUEST_TYPE = "set_bp_default";
+const BRIDGE_BATCH_EDIT_REQUEST_TYPE = "batch_edit";
+const BRIDGE_IMPORT_ASSET_REQUEST_TYPE = "import_asset";
+const BRIDGE_REIMPORT_ASSET_REQUEST_TYPE = "reimport_asset";
+const BRIDGE_SET_IMPORT_SETTINGS_REQUEST_TYPE = "set_import_settings";
+const BRIDGE_GET_IMPORT_JOB_STATUS_REQUEST_TYPE = "get_import_job_status";
+const BRIDGE_CREATE_BLACKBOARD_REQUEST_TYPE = "create_blackboard";
+const BRIDGE_SET_BLACKBOARD_KEYS_REQUEST_TYPE = "set_blackboard_keys";
+const BRIDGE_CREATE_EQS_QUERY_REQUEST_TYPE = "create_eqs_query";
+const BRIDGE_CREATE_STATE_TREE_REQUEST_TYPE = "create_state_tree";
+const BRIDGE_ADD_STATE_TREE_STATE_REQUEST_TYPE = "add_state_tree_state";
+const BRIDGE_CREATE_LEVEL_SEQUENCE_REQUEST_TYPE = "create_level_sequence";
+const BRIDGE_ADD_SEQUENCE_BINDING_REQUEST_TYPE = "add_sequence_binding";
+const BRIDGE_ADD_SEQUENCE_TRACK_REQUEST_TYPE = "add_sequence_track";
+const BRIDGE_ADD_SEQUENCE_KEYS_REQUEST_TYPE = "add_sequence_keys";
+const BRIDGE_ADD_FOLIAGE_TYPE_REQUEST_TYPE = "add_foliage_type";
+const BRIDGE_PAINT_FOLIAGE_REQUEST_TYPE = "paint_foliage";
+const BRIDGE_CREATE_SOUND_CUE_REQUEST_TYPE = "create_sound_cue";
+const BRIDGE_CREATE_METASOUND_REQUEST_TYPE = "create_metasound";
+const BRIDGE_SET_METASOUND_GRAPH_REQUEST_TYPE = "set_metasound_graph";
+const BRIDGE_ASSET_PROPERTY_STATES = ["reported", "unsupported"];
+const BRIDGE_ARRAY_PROPERTY_OPERATIONS = [
+	"add",
+	"insert",
+	"remove",
+	"clear"
+];
+const BRIDGE_ARRAY_PROPERTY_MAX_INDEX = 65535;
+const BRIDGE_TYPE_SPEC_KINDS = [
+	"bool",
+	"byte",
+	"int",
+	"int64",
+	"float",
+	"double",
+	"name",
+	"string",
+	"text",
+	"struct",
+	"object",
+	"class",
+	"soft_object",
+	"soft_class",
+	"interface",
+	"enum"
+];
+const BRIDGE_TYPE_SPEC_CONTAINERS = [
+	"none",
+	"array",
+	"set",
+	"map"
+];
+const TYPE_SPEC_KINDS_REQUIRING_SUBTYPE = /* @__PURE__ */ new Set([
+	"struct",
+	"object",
+	"class",
+	"soft_object",
+	"soft_class",
+	"interface",
+	"enum"
+]);
+const BRIDGE_CREATE_BLUEPRINT_KINDS = [
+	"normal",
+	"const",
+	"macro_library",
+	"interface",
+	"function_library"
+];
+const BRIDGE_BLUEPRINT_EVENT_KINDS = ["override", "custom"];
+const assetPropertyStateSchema = z.enum(BRIDGE_ASSET_PROPERTY_STATES);
+const arrayPropertyOperationSchema = z.enum(BRIDGE_ARRAY_PROPERTY_OPERATIONS);
+const propertyPathSchema = z.string().trim().min(1).max(512);
+const propertyValueSchema = z.string().max(BRIDGE_PROPERTY_VALUE_MAX_CHARS);
+const typeSpecKindSchema = z.enum(BRIDGE_TYPE_SPEC_KINDS);
+const typeSpecContainerSchema = z.enum(BRIDGE_TYPE_SPEC_CONTAINERS);
+const userTypeIdentifierSchema = z.string().trim().min(1).max(128).regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
+const userTypeDescriptionSchema = z.string().trim().max(512);
+const createBlueprintKindSchema = z.enum(BRIDGE_CREATE_BLUEPRINT_KINDS);
+const blueprintEventKindSchema = z.enum(BRIDGE_BLUEPRINT_EVENT_KINDS);
+const blueprintVariableNameSchema = z.string().trim().min(1).max(128);
+const blueprintCategorySchema = z.string().trim().max(128);
+const blueprintTooltipSchema = z.string().trim().max(512);
+const bridgeTypeSpecSchema = z.object({
+	container: typeSpecContainerSchema.default("none"),
+	kind: typeSpecKindSchema,
+	keyKind: typeSpecKindSchema.optional(),
+	keySubtype: assetPathSchema.optional(),
+	subtype: assetPathSchema.optional()
+}).superRefine((value, ctx) => {
+	if (TYPE_SPEC_KINDS_REQUIRING_SUBTYPE.has(value.kind) && value.subtype === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: `A '${value.kind}' type spec must name what it points at through subtype.`,
+		path: ["subtype"]
+	});
+	if (value.container === "map") {
+		if (value.keyKind === void 0) {
+			ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: "A map type spec must declare keyKind.",
+				path: ["keyKind"]
+			});
+			return;
+		}
+		if (TYPE_SPEC_KINDS_REQUIRING_SUBTYPE.has(value.keyKind) && value.keySubtype === void 0) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: `A '${value.keyKind}' map key must name what it points at through keySubtype.`,
+			path: ["keySubtype"]
+		});
+		return;
+	}
+	if (value.keyKind !== void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "keyKind is only meaningful on a map type spec.",
+		path: ["keyKind"]
+	});
+});
+const bridgeGetAssetPropertyRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	propertyPath: propertyPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_ASSET_PROPERTY_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAssetPropertyEntrySchema = z.object({
+	propertyPath: propertyPathSchema,
+	value: propertyValueSchema
+});
+const bridgeSetAssetPropertyRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	properties: z.array(bridgeAssetPropertyEntrySchema).min(1).max(32),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_SET_ASSET_PROPERTY_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeArrayPropertyOpRequestFieldsSchema = z.object({
+	assetPath: assetPathSchema,
+	index: z.number().int().min(0).max(BRIDGE_ARRAY_PROPERTY_MAX_INDEX).optional(),
+	operation: arrayPropertyOperationSchema,
+	propertyPath: propertyPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_ARRAY_PROPERTY_OP_REQUEST_TYPE),
+	value: propertyValueSchema.optional(),
+	version: z.literal(2)
+});
+const bridgeArrayPropertyOpRequestSchema = bridgeArrayPropertyOpRequestFieldsSchema.superRefine((request, ctx) => {
+	if ((request.operation === "insert" || request.operation === "remove") && request.index === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: `An array_property_op '${request.operation}' requires an index.`,
+		path: ["index"]
+	});
+	if ((request.operation === "add" || request.operation === "insert") && request.value === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: `An array_property_op '${request.operation}' requires a value.`,
+		path: ["value"]
+	});
+	if (request.operation === "clear" && (request.index !== void 0 || request.value !== void 0)) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "An array_property_op 'clear' takes neither an index nor a value.",
+		path: ["operation"]
+	});
+});
+const bridgeStructFieldSchema = z.object({
+	defaultValue: propertyValueSchema.optional(),
+	name: userTypeIdentifierSchema,
+	type: bridgeTypeSpecSchema
+});
+const bridgeCreateStructRequestSchema = z.object({
+	assetName: assetNameSchema,
+	description: userTypeDescriptionSchema.optional(),
+	fields: z.array(bridgeStructFieldSchema).max(64).default([]),
+	packagePath: contentPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_CREATE_STRUCT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeEnumEntrySchema = z.object({
+	description: userTypeDescriptionSchema.optional(),
+	displayName: userTypeDescriptionSchema.optional(),
+	name: userTypeIdentifierSchema
+});
+const bridgeCreateEnumRequestSchema = z.object({
+	assetName: assetNameSchema,
+	description: userTypeDescriptionSchema.optional(),
+	entries: z.array(bridgeEnumEntrySchema).min(1).max(128),
+	packagePath: contentPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_CREATE_ENUM_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateBlueprintRequestSchema = z.object({
+	assetName: assetNameSchema,
+	blueprintKind: createBlueprintKindSchema.default("normal"),
+	packagePath: contentPathSchema,
+	parentClass: assetPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_CREATE_BLUEPRINT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeBlueprintVariableEntrySchema = z.object({
+	category: blueprintCategorySchema.optional(),
+	defaultValue: propertyValueSchema.optional(),
+	exposeOnSpawn: z.boolean().default(false),
+	instanceEditable: z.boolean().default(false),
+	name: blueprintVariableNameSchema,
+	replication: blueprintReplicationSchema.default("none"),
+	tooltip: blueprintTooltipSchema.optional(),
+	type: bridgeTypeSpecSchema
+});
+const bridgeAddBpVariableRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_ADD_BP_VARIABLE_REQUEST_TYPE),
+	variables: z.array(bridgeBlueprintVariableEntrySchema).min(1).max(32),
+	version: z.literal(2)
+});
+const bridgeBlueprintParameterSchema = z.object({
+	name: userTypeIdentifierSchema,
+	type: bridgeTypeSpecSchema
+});
+const bridgeBlueprintFunctionEntrySchema = z.object({
+	category: blueprintCategorySchema.optional(),
+	inputs: z.array(bridgeBlueprintParameterSchema).max(16).default([]),
+	name: userTypeIdentifierSchema,
+	outputs: z.array(bridgeBlueprintParameterSchema).max(16).default([]),
+	pure: z.boolean().default(false)
+});
+const bridgeAddBpFunctionRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	functions: z.array(bridgeBlueprintFunctionEntrySchema).min(1).max(32),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_ADD_BP_FUNCTION_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeBlueprintEventEntrySchema = z.object({
+	eventKind: blueprintEventKindSchema.default("override"),
+	eventName: userTypeIdentifierSchema,
+	inputs: z.array(bridgeBlueprintParameterSchema).max(16).default([])
+}).refine((entry) => entry.eventKind === "custom" || entry.inputs.length === 0, {
+	message: "An override event takes its parameters from the parent function, so inputs must be empty.",
+	path: ["inputs"]
+});
+const bridgeAddBpEventRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	events: z.array(bridgeBlueprintEventEntrySchema).min(1).max(32),
+	graphName: graphNameSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_ADD_BP_EVENT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeBlueprintComponentEntrySchema = z.object({
+	componentClass: assetPathSchema,
+	name: blueprintVariableNameSchema,
+	parentComponent: blueprintVariableNameSchema.optional(),
+	transform: transformInputSchema.optional()
+});
+const bridgeAddBpComponentRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	components: z.array(bridgeBlueprintComponentEntrySchema).min(1).max(32),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_ADD_BP_COMPONENT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddBpInterfaceRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	interfacePaths: z.array(assetPathSchema).min(1).max(32),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_ADD_BP_INTERFACE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSetBpDefaultRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	properties: z.array(bridgeAssetPropertyEntrySchema).min(1).max(32),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_SET_BP_DEFAULT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const BRIDGE_BATCH_EDIT_STATES = [
+	"applied",
+	"validated",
+	"rolled_back",
+	"unsupported"
+];
+const BRIDGE_BATCH_EDIT_OPS = [
+	"spawn",
+	"destroy",
+	"transform",
+	"property",
+	"attach",
+	"place",
+	"tag"
+];
+const BRIDGE_IMPORT_JOB_ACCEPT_STATES = ["accepted", "unsupported"];
+const BRIDGE_IMPORT_JOB_STATES = [
+	"running",
+	"succeeded",
+	"failed",
+	"unknown_job"
+];
+const BRIDGE_IMPORT_OPERATIONS = ["import", "reimport"];
+const BRIDGE_IMPORT_PIPELINES = [
+	"auto",
+	"interchange",
+	"legacy_factory"
+];
+const BRIDGE_IMPORT_SETTING_VALUE_MAX_CHARS = 1024;
+const BRIDGE_BLACKBOARD_KEY_TYPES = [
+	"bool",
+	"int",
+	"float",
+	"string",
+	"name",
+	"vector",
+	"rotator",
+	"enum",
+	"class",
+	"object"
+];
+const BRIDGE_BLACKBOARD_KEY_MODES = ["merge", "replace"];
+const BRIDGE_EQS_TEST_PURPOSES = [
+	"filter",
+	"score",
+	"filter_and_score"
+];
+const BRIDGE_STATE_TREE_SCHEMAS = [
+	"actor_component",
+	"ai_component",
+	"custom"
+];
+const BRIDGE_STATE_TREE_STATE_TYPES = [
+	"state",
+	"group",
+	"linked",
+	"subtree"
+];
+const BRIDGE_STATE_TREE_TRANSITION_TRIGGERS = [
+	"on_state_completed",
+	"on_state_succeeded",
+	"on_state_failed",
+	"on_tick",
+	"on_event"
+];
+const BRIDGE_SEQUENCE_BINDING_KINDS = ["possessable", "spawnable"];
+const BRIDGE_SEQUENCE_TRACK_KINDS = [
+	"transform",
+	"skeletal_animation",
+	"camera_cut",
+	"audio",
+	"visibility",
+	"property"
+];
+const BRIDGE_SEQUENCE_TIME_UNITS = ["frames", "seconds"];
+const BRIDGE_SEQUENCE_INTERPOLATIONS = [
+	"auto",
+	"user",
+	"break",
+	"linear",
+	"constant"
+];
+const BRIDGE_SEQUENCE_MAX_FRAME_RATE = 24e4;
+const BRIDGE_SEQUENCE_MAX_FRAME = 1e7;
+const BRIDGE_FOLIAGE_PLACEMENT_MODES = ["explicit", "region"];
+const BRIDGE_FOLIAGE_MAX_DENSITY = 1e3;
+const BRIDGE_FOLIAGE_COORDINATE_LIMIT = 21e6;
+const BRIDGE_FOLIAGE_MAX_SCALE = 1e3;
+const BRIDGE_SOUND_CUE_NODE_KINDS = [
+	"wave_player",
+	"random",
+	"mixer",
+	"looping",
+	"modulator",
+	"attenuation",
+	"concatenator",
+	"delay"
+];
+const BRIDGE_METASOUND_OUTPUT_FORMATS = ["mono", "stereo"];
+const batchEditStateSchema = z.enum(BRIDGE_BATCH_EDIT_STATES);
+const batchEditOpSchema = z.enum(BRIDGE_BATCH_EDIT_OPS);
+const batchActorRefSchema = z.string().trim().min(1).max(512);
+const batchHandleSchema = z.string().trim().min(1).max(64).regex(/^[A-Za-z0-9_-]+$/);
+const batchTransactionTitleSchema = z.string().trim().min(1).max(128);
+const importJobAcceptStateSchema = z.enum(BRIDGE_IMPORT_JOB_ACCEPT_STATES);
+const importJobStateSchema = z.enum(BRIDGE_IMPORT_JOB_STATES);
+const importOperationSchema = z.enum(BRIDGE_IMPORT_OPERATIONS);
+const importPipelineSchema = z.enum(BRIDGE_IMPORT_PIPELINES);
+const importJobIdSchema = z.string().trim().min(1);
+const importPresetNameSchema = z.string().trim().min(1).max(128);
+const importSettingsSchema = z.record(z.string().trim().min(1).max(128), z.string().max(BRIDGE_IMPORT_SETTING_VALUE_MAX_CHARS)).refine((value) => Object.keys(value).length <= 32, { message: `An import preset carries at most ${String(32)} settings.` });
+const blackboardKeyTypeSchema = z.enum(BRIDGE_BLACKBOARD_KEY_TYPES);
+const blackboardKeyModeSchema = z.enum(BRIDGE_BLACKBOARD_KEY_MODES);
+const eqsTestPurposeSchema = z.enum(BRIDGE_EQS_TEST_PURPOSES);
+const eqsParamsSchema = z.record(z.string().trim().min(1).max(128), z.string().max(BRIDGE_FACTORY_OPTION_VALUE_MAX_CHARS)).refine((value) => Object.keys(value).length <= 32, { message: `An EQS node carries at most ${String(32)} params.` });
+const stateTreeSchemaSchema = z.enum(BRIDGE_STATE_TREE_SCHEMAS);
+const stateTreeStateTypeSchema = z.enum(BRIDGE_STATE_TREE_STATE_TYPES);
+const stateTreeTransitionTriggerSchema = z.enum(BRIDGE_STATE_TREE_TRANSITION_TRIGGERS);
+const sequenceBindingKindSchema = z.enum(BRIDGE_SEQUENCE_BINDING_KINDS);
+const sequenceTrackKindSchema = z.enum(BRIDGE_SEQUENCE_TRACK_KINDS);
+const sequenceTimeUnitSchema = z.enum(BRIDGE_SEQUENCE_TIME_UNITS);
+const sequenceInterpolationSchema = z.enum(BRIDGE_SEQUENCE_INTERPOLATIONS);
+const sequenceBindingIdSchema = z.string().trim().min(1).max(64);
+const sequenceFrameSchema = z.number().int().min(-1e7).max(BRIDGE_SEQUENCE_MAX_FRAME);
+const foliagePlacementModeSchema = z.enum(BRIDGE_FOLIAGE_PLACEMENT_MODES);
+const foliageCoordinateSchema = z.number().min(-21e6).max(BRIDGE_FOLIAGE_COORDINATE_LIMIT);
+const foliageSlopeSchema = z.number().min(0).max(90);
+const soundCueNodeKindSchema = z.enum(BRIDGE_SOUND_CUE_NODE_KINDS);
+const metasoundOutputFormatSchema = z.enum(BRIDGE_METASOUND_OUTPUT_FORMATS);
+const metasoundIdentifierSchema = z.string().trim().min(1).max(128);
+const audioNodeIdSchema = z.string().trim().min(1).max(64);
+const bridgeSequenceFrameRateSchema = z.object({
+	denominator: z.number().int().min(1).max(BRIDGE_SEQUENCE_MAX_FRAME_RATE),
+	numerator: z.number().int().min(1).max(BRIDGE_SEQUENCE_MAX_FRAME_RATE)
+});
+const bridgeBatchEditOpSchema = z.discriminatedUnion("op", [
+	z.object({
+		classPath: assetPathSchema,
+		folderPath: boundedStringSchema.optional(),
+		handle: batchHandleSchema.optional(),
+		label: boundedStringSchema.optional(),
+		op: z.literal("spawn"),
+		tags: actorTagArraySchema.default([]),
+		transform: transformInputSchema.default({
+			location: {
+				x: 0,
+				y: 0,
+				z: 0
+			},
+			rotation: {
+				pitch: 0,
+				roll: 0,
+				yaw: 0
+			},
+			scale: {
+				x: 1,
+				y: 1,
+				z: 1
+			}
+		})
+	}),
+	z.object({
+		actorRef: batchActorRefSchema,
+		op: z.literal("destroy")
+	}),
+	z.object({
+		actorRef: batchActorRefSchema,
+		location: vectorInputSchema.optional(),
+		op: z.literal("transform"),
+		rotation: rotatorInputSchema.optional(),
+		scale: vectorInputSchema.optional()
+	}),
+	z.object({
+		actorRef: batchActorRefSchema,
+		op: z.literal("property"),
+		propertyPath: propertyPathSchema,
+		value: propertyValueSchema
+	}),
+	z.object({
+		childRef: batchActorRefSchema,
+		locationRule: attachmentRuleSchema.optional(),
+		op: z.literal("attach"),
+		parentRef: z.string().trim().max(512),
+		rotationRule: attachmentRuleSchema.optional(),
+		scaleRule: attachmentRuleSchema.optional(),
+		socketName: boundedStringSchema.optional(),
+		weldSimulatedBodies: z.boolean().optional()
+	}),
+	z.object({
+		assetPath: assetPathSchema,
+		folderPath: actorFolderSchema.optional(),
+		handle: batchHandleSchema.optional(),
+		label: boundedStringSchema.optional(),
+		op: z.literal("place"),
+		transform: transformInputSchema.optional()
+	}),
+	z.object({
+		actorRef: batchActorRefSchema,
+		mode: actorTagModeSchema,
+		op: z.literal("tag"),
+		tags: actorTagArraySchema
+	})
+]);
+const bridgeBatchEditRequestSchema = z.object({
+	dryRun: z.boolean().default(false),
+	ops: z.array(bridgeBatchEditOpSchema).min(1).max(64),
+	requestId: requestIdSchema,
+	transactionTitle: batchTransactionTitleSchema.optional(),
+	type: z.literal(BRIDGE_BATCH_EDIT_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeImportAssetRequestSchema = z.object({
+	destinationPath: contentPathSchema,
+	pipeline: importPipelineSchema.default("auto"),
+	presetName: importPresetNameSchema.optional(),
+	replaceExisting: z.boolean().default(false),
+	requestId: requestIdSchema,
+	sourceFiles: z.array(filePathSchema).min(1).max(16),
+	type: z.literal(BRIDGE_IMPORT_ASSET_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeReimportAssetRequestSchema = z.object({
+	assetPaths: z.array(assetPathSchema).min(1).max(16),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_REIMPORT_ASSET_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSetImportSettingsRequestSchema = z.object({
+	presetName: importPresetNameSchema,
+	requestId: requestIdSchema,
+	settings: importSettingsSchema,
+	type: z.literal(BRIDGE_SET_IMPORT_SETTINGS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeGetImportJobStatusRequestSchema = z.object({
+	importJobId: importJobIdSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_GET_IMPORT_JOB_STATUS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeBlackboardKeySchema = z.object({
+	baseClass: assetPathSchema.optional(),
+	description: userTypeDescriptionSchema.optional(),
+	enumPath: assetPathSchema.optional(),
+	instanceSynced: z.boolean().default(false),
+	keyName: userTypeIdentifierSchema,
+	keyType: blackboardKeyTypeSchema
+}).superRefine((key, ctx) => {
+	if ((key.keyType === "object" || key.keyType === "class") && key.baseClass === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: `A '${key.keyType}' blackboard key must name its baseClass.`,
+		path: ["baseClass"]
+	});
+	if (key.keyType === "enum" && key.enumPath === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "An 'enum' blackboard key must name its enumPath.",
+		path: ["enumPath"]
+	});
+});
+const bridgeCreateBlackboardRequestSchema = z.object({
+	assetName: assetNameSchema,
+	keys: z.array(bridgeBlackboardKeySchema).max(64).default([]),
+	packagePath: contentPathSchema,
+	parentBlackboardPath: assetPathSchema.optional(),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_CREATE_BLACKBOARD_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSetBlackboardKeysRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	keys: z.array(bridgeBlackboardKeySchema).min(1).max(64),
+	mode: blackboardKeyModeSchema.default("merge"),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_SET_BLACKBOARD_KEYS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeEqsGeneratorSchema = z.object({
+	generatorClass: assetPathSchema,
+	params: eqsParamsSchema.default({})
+});
+const bridgeEqsTestSchema = z.object({
+	params: eqsParamsSchema.default({}),
+	purpose: eqsTestPurposeSchema.default("filter_and_score"),
+	testClass: assetPathSchema
+});
+const bridgeCreateEqsQueryRequestSchema = z.object({
+	assetName: assetNameSchema,
+	generator: bridgeEqsGeneratorSchema,
+	packagePath: contentPathSchema,
+	requestId: requestIdSchema,
+	tests: z.array(bridgeEqsTestSchema).max(16).default([]),
+	type: z.literal(BRIDGE_CREATE_EQS_QUERY_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateStateTreeRequestFieldsSchema = z.object({
+	assetName: assetNameSchema,
+	packagePath: contentPathSchema,
+	requestId: requestIdSchema,
+	schema: stateTreeSchemaSchema.default("actor_component"),
+	schemaClass: assetPathSchema.optional(),
+	type: z.literal(BRIDGE_CREATE_STATE_TREE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateStateTreeRequestSchema = bridgeCreateStateTreeRequestFieldsSchema.refine((request) => request.schema !== "custom" || request.schemaClass !== void 0, {
+	message: "A 'custom' StateTree schema must name its schemaClass.",
+	path: ["schemaClass"]
+});
+const bridgeStateTreeNodeSchema = z.object({
+	nodeClass: assetPathSchema,
+	params: eqsParamsSchema.default({})
+});
+const bridgeStateTreeTransitionSchema = z.object({
+	eventTag: boundedStringSchema.optional(),
+	targetStateName: userTypeIdentifierSchema.optional(),
+	trigger: stateTreeTransitionTriggerSchema
+}).refine((transition) => transition.trigger !== "on_event" || transition.eventTag !== void 0, {
+	message: "An 'on_event' transition must name the eventTag it listens for.",
+	path: ["eventTag"]
+});
+const bridgeStateTreeStateSchema = z.object({
+	enterConditions: z.array(bridgeStateTreeNodeSchema).max(8).default([]),
+	name: userTypeIdentifierSchema,
+	parentStateName: userTypeIdentifierSchema.optional(),
+	stateType: stateTreeStateTypeSchema.default("state"),
+	tasks: z.array(bridgeStateTreeNodeSchema).max(8).default([]),
+	transitions: z.array(bridgeStateTreeTransitionSchema).max(8).default([])
+});
+const bridgeAddStateTreeStateRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	compile: z.boolean().default(true),
+	requestId: requestIdSchema,
+	states: z.array(bridgeStateTreeStateSchema).min(1).max(32),
+	type: z.literal(BRIDGE_ADD_STATE_TREE_STATE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateLevelSequenceRequestSchema = z.object({
+	assetName: assetNameSchema,
+	displayRate: bridgeSequenceFrameRateSchema.optional(),
+	durationInFrames: z.number().int().min(1).max(BRIDGE_SEQUENCE_MAX_FRAME).optional(),
+	packagePath: contentPathSchema,
+	requestId: requestIdSchema,
+	tickResolution: bridgeSequenceFrameRateSchema.optional(),
+	type: z.literal(BRIDGE_CREATE_LEVEL_SEQUENCE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeSequenceBindingSchema = z.object({
+	actorPath: actorPathSchema.optional(),
+	bindingKind: sequenceBindingKindSchema,
+	name: boundedStringSchema.optional(),
+	objectClassPath: assetPathSchema.optional()
+}).superRefine((binding, ctx) => {
+	if (binding.bindingKind === "possessable" && binding.actorPath === void 0) {
+		ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "A possessable binding must name the actorPath it possesses.",
+			path: ["actorPath"]
+		});
+		return;
+	}
+	if (binding.bindingKind === "spawnable" && binding.actorPath === void 0 && binding.objectClassPath === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "A spawnable binding needs a template, so it must carry actorPath or objectClassPath.",
+		path: ["objectClassPath"]
+	});
+});
+const bridgeAddSequenceBindingRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	bindings: z.array(bridgeSequenceBindingSchema).min(1).max(32),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_ADD_SEQUENCE_BINDING_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddSequenceTrackRequestFieldsSchema = z.object({
+	assetPath: assetPathSchema,
+	bindingId: sequenceBindingIdSchema.optional(),
+	propertyPath: propertyPathSchema.optional(),
+	requestId: requestIdSchema,
+	sectionEndFrame: sequenceFrameSchema.optional(),
+	sectionStartFrame: sequenceFrameSchema.optional(),
+	trackKind: sequenceTrackKindSchema,
+	type: z.literal(BRIDGE_ADD_SEQUENCE_TRACK_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddSequenceTrackRequestSchema = bridgeAddSequenceTrackRequestFieldsSchema.superRefine((request, ctx) => {
+	if (request.trackKind === "property" && request.propertyPath === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "A 'property' track must name the propertyPath it animates.",
+		path: ["propertyPath"]
+	});
+	if (request.trackKind !== "camera_cut" && request.bindingId === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: `A '${request.trackKind}' track belongs to a binding, so bindingId is required.`,
+		path: ["bindingId"]
+	});
+	if (request.sectionStartFrame !== void 0 && request.sectionEndFrame !== void 0 && request.sectionEndFrame < request.sectionStartFrame) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "A section cannot end before it starts.",
+		path: ["sectionEndFrame"]
+	});
+});
+const bridgeSequenceKeySchema = z.object({
+	arriveTangent: z.number().optional(),
+	interpolation: sequenceInterpolationSchema.default("auto"),
+	leaveTangent: z.number().optional(),
+	time: z.number(),
+	value: z.number()
+});
+const bridgeAddSequenceKeysRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	bindingId: sequenceBindingIdSchema.optional(),
+	channelName: boundedStringSchema,
+	keys: z.array(bridgeSequenceKeySchema).min(1).max(128),
+	requestId: requestIdSchema,
+	timeUnit: sequenceTimeUnitSchema,
+	trackName: boundedStringSchema,
+	type: z.literal(BRIDGE_ADD_SEQUENCE_KEYS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeFoliageSettingsSchema = z.object({
+	alignToNormal: z.boolean().optional(),
+	collisionEnabled: z.boolean().optional(),
+	density: z.number().min(0).max(BRIDGE_FOLIAGE_MAX_DENSITY).optional(),
+	groundSlopeMax: foliageSlopeSchema.optional(),
+	groundSlopeMin: foliageSlopeSchema.optional(),
+	randomYaw: z.boolean().optional(),
+	scaleMax: z.number().min(0).max(BRIDGE_FOLIAGE_MAX_SCALE).optional(),
+	scaleMin: z.number().min(0).max(BRIDGE_FOLIAGE_MAX_SCALE).optional()
+});
+const bridgeAddFoliageTypeRequestSchema = z.object({
+	assetName: assetNameSchema,
+	packagePath: contentPathSchema,
+	requestId: requestIdSchema,
+	settings: bridgeFoliageSettingsSchema.default({}),
+	staticMeshPath: assetPathSchema,
+	type: z.literal(BRIDGE_ADD_FOLIAGE_TYPE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeFoliageRegionSchema = z.object({
+	maxX: foliageCoordinateSchema,
+	maxY: foliageCoordinateSchema,
+	minX: foliageCoordinateSchema,
+	minY: foliageCoordinateSchema,
+	traceEndZ: foliageCoordinateSchema,
+	traceStartZ: foliageCoordinateSchema
+}).refine((region) => region.maxX >= region.minX && region.maxY >= region.minY, { message: "A foliage region must have every max component >= its min component." }).refine((region) => region.traceStartZ > region.traceEndZ, {
+	message: "A foliage region traces downward, so traceStartZ must be above traceEndZ.",
+	path: ["traceStartZ"]
+});
+const bridgePaintFoliageRequestFieldsSchema = z.object({
+	alignToNormal: z.boolean().optional(),
+	density: z.number().min(0).max(BRIDGE_FOLIAGE_MAX_DENSITY).optional(),
+	foliageTypePath: assetPathSchema,
+	mode: foliagePlacementModeSchema,
+	randomSeed: z.number().int().min(0).max(2147483647).optional(),
+	region: bridgeFoliageRegionSchema.optional(),
+	requestId: requestIdSchema,
+	slopeMax: foliageSlopeSchema.optional(),
+	slopeMin: foliageSlopeSchema.optional(),
+	transforms: z.array(transformInputSchema).max(128).optional(),
+	type: z.literal(BRIDGE_PAINT_FOLIAGE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgePaintFoliageRequestSchema = bridgePaintFoliageRequestFieldsSchema.superRefine((request, ctx) => {
+	if (request.mode === "explicit") {
+		if (request.transforms === void 0 || request.transforms.length === 0) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: "An 'explicit' paint_foliage request must carry the transforms to place.",
+			path: ["transforms"]
+		});
+		return;
+	}
+	if (request.region === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "A 'region' paint_foliage request must carry the region to scatter across.",
+		path: ["region"]
+	});
+	if (request.density === void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "A 'region' paint_foliage request must carry a density.",
+		path: ["density"]
+	});
+});
+const bridgeSoundCueNodeSchema = z.object({
+	nodeId: audioNodeIdSchema,
+	nodeKind: soundCueNodeKindSchema,
+	params: eqsParamsSchema.default({}),
+	wavePath: assetPathSchema.optional()
+}).refine((node) => node.nodeKind !== "wave_player" || node.wavePath !== void 0, {
+	message: "A wave_player node must name the wavePath it plays.",
+	path: ["wavePath"]
+});
+const bridgeSoundCueConnectionSchema = z.object({
+	childNodeId: audioNodeIdSchema,
+	inputIndex: z.number().int().min(0).max(64).default(0),
+	parentNodeId: audioNodeIdSchema
+});
+const bridgeCreateSoundCueRequestFieldsSchema = z.object({
+	assetName: assetNameSchema,
+	connections: z.array(bridgeSoundCueConnectionSchema).max(64).default([]),
+	nodes: z.array(bridgeSoundCueNodeSchema).min(1).max(32),
+	packagePath: contentPathSchema,
+	requestId: requestIdSchema,
+	rootNodeId: audioNodeIdSchema,
+	type: z.literal(BRIDGE_CREATE_SOUND_CUE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateSoundCueRequestSchema = bridgeCreateSoundCueRequestFieldsSchema.superRefine((request, ctx) => {
+	const nodeIds = new Set(request.nodes.map((node) => node.nodeId));
+	if (nodeIds.size !== request.nodes.length) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "Every sound cue nodeId must be unique within the request.",
+		path: ["nodes"]
+	});
+	if (!nodeIds.has(request.rootNodeId)) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "rootNodeId must name one of the nodes in this request.",
+		path: ["rootNodeId"]
+	});
+	for (const [index, connection] of request.connections.entries()) if (!nodeIds.has(connection.parentNodeId) || !nodeIds.has(connection.childNodeId)) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "A sound cue connection must join two nodes declared in this request.",
+		path: ["connections", index]
+	});
+});
+const bridgeCreateMetasoundRequestSchema = z.object({
+	assetName: assetNameSchema,
+	outputFormat: metasoundOutputFormatSchema.default("mono"),
+	packagePath: contentPathSchema,
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_CREATE_METASOUND_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeMetasoundMemberSchema = z.object({
+	dataType: metasoundIdentifierSchema,
+	defaultValue: propertyValueSchema.optional(),
+	name: metasoundIdentifierSchema
+});
+const bridgeMetasoundNodeSchema = z.object({
+	nodeClassName: metasoundIdentifierSchema,
+	nodeId: audioNodeIdSchema,
+	nodeNamespace: metasoundIdentifierSchema.optional()
+});
+const bridgeMetasoundConnectionSchema = z.object({
+	fromNodeId: audioNodeIdSchema,
+	fromOutput: metasoundIdentifierSchema,
+	toInput: metasoundIdentifierSchema,
+	toNodeId: audioNodeIdSchema
+});
+const bridgeSetMetasoundGraphRequestSchema = z.object({
+	assetPath: assetPathSchema,
+	connections: z.array(bridgeMetasoundConnectionSchema).max(64).default([]),
+	inputs: z.array(bridgeMetasoundMemberSchema).max(32).default([]),
+	nodes: z.array(bridgeMetasoundNodeSchema).max(32).default([]),
+	outputs: z.array(bridgeMetasoundMemberSchema).max(32).default([]),
+	requestId: requestIdSchema,
+	type: z.literal(BRIDGE_SET_METASOUND_GRAPH_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAuthoringItemResultSchema = z.object({
+	error: z.string().optional(),
+	index: z.number().int().min(0),
+	ok: z.boolean(),
+	target: z.string().optional()
+});
+const authoringBatchResponseFields = {
+	appliedCount: z.number().int().min(0),
+	assetPath: z.string(),
+	failureCount: z.number().int().min(0),
+	items: z.array(bridgeAuthoringItemResultSchema).max(64),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	version: z.literal(2)
+};
+const createdUserAssetResponseFields = {
+	message: nonEmptyStringSchema.optional(),
+	objectPath: z.string(),
+	ok: z.literal(true),
+	packageName: z.string(),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	version: z.literal(2)
+};
+const bridgeGetAssetPropertySuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	propertyPath: z.string(),
+	propertyType: z.string(),
+	requestId: requestIdSchema,
+	state: assetPropertyStateSchema,
+	type: z.literal(BRIDGE_GET_ASSET_PROPERTY_REQUEST_TYPE),
+	value: z.string(),
+	version: z.literal(2)
+});
+const bridgeSetAssetPropertySuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	type: z.literal(BRIDGE_SET_ASSET_PROPERTY_REQUEST_TYPE)
+});
+const bridgeArrayPropertyOpSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	elementCount: z.number().int().min(0),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	operation: arrayPropertyOperationSchema,
+	packageDirty: z.boolean(),
+	propertyPath: z.string(),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_ARRAY_PROPERTY_OP_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateStructSuccessResponseSchema = z.object({
+	...createdUserAssetResponseFields,
+	fieldCount: z.number().int().min(0),
+	rebuiltAssets: z.array(z.string()).max(25),
+	rebuiltCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_CREATE_STRUCT_REQUEST_TYPE)
+});
+const bridgeCreateEnumSuccessResponseSchema = z.object({
+	...createdUserAssetResponseFields,
+	entryCount: z.number().int().min(0),
+	rebuiltAssets: z.array(z.string()).max(25),
+	rebuiltCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_CREATE_ENUM_REQUEST_TYPE)
+});
+const bridgeCreateBlueprintSuccessResponseSchema = z.object({
+	...createdUserAssetResponseFields,
+	blueprintKind: createBlueprintKindSchema,
+	generatedClassPath: z.string(),
+	parentClass: z.string(),
+	type: z.literal(BRIDGE_CREATE_BLUEPRINT_REQUEST_TYPE)
+});
+const bridgeAddBpVariableSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	type: z.literal(BRIDGE_ADD_BP_VARIABLE_REQUEST_TYPE)
+});
+const bridgeAddBpFunctionSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	type: z.literal(BRIDGE_ADD_BP_FUNCTION_REQUEST_TYPE)
+});
+const bridgeAddBpEventSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	graphName: z.string(),
+	type: z.literal(BRIDGE_ADD_BP_EVENT_REQUEST_TYPE)
+});
+const bridgeAddBpComponentSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	type: z.literal(BRIDGE_ADD_BP_COMPONENT_REQUEST_TYPE)
+});
+const bridgeAddBpInterfaceSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	addedGraphs: z.array(z.string()).max(200),
+	type: z.literal(BRIDGE_ADD_BP_INTERFACE_REQUEST_TYPE)
+});
+const bridgeSetBpDefaultSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	type: z.literal(BRIDGE_SET_BP_DEFAULT_REQUEST_TYPE)
+});
+const bridgeBatchHandleSchema = z.object({
+	actorPath: z.string(),
+	handle: z.string()
+});
+const bridgeBatchEditItemResultSchema = z.object({
+	actorPath: z.string().optional(),
+	error: z.string().optional(),
+	index: z.number().int().min(0),
+	ok: z.boolean(),
+	op: batchEditOpSchema
+});
+const bridgeBatchEditSuccessResponseSchema = z.object({
+	appliedCount: z.number().int().min(0),
+	dryRun: z.boolean(),
+	failedError: z.string().optional(),
+	failedIndex: z.number().int().min(0).optional(),
+	handles: z.array(bridgeBatchHandleSchema).max(64),
+	items: z.array(bridgeBatchEditItemResultSchema).max(64),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	state: batchEditStateSchema,
+	transactionTitle: z.string().optional(),
+	type: z.literal(BRIDGE_BATCH_EDIT_REQUEST_TYPE),
+	version: z.literal(2)
+}).refine((value) => value.state === "rolled_back" === (value.failedIndex !== void 0), {
+	message: "A batch_edit response must carry failedIndex exactly when state is 'rolled_back'.",
+	path: ["failedIndex"]
+});
+const importJobAcceptFields = {
+	importJobId: importJobIdSchema.optional(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	requestId: requestIdSchema,
+	state: importJobAcceptStateSchema,
+	version: z.literal(2)
+};
+const importJobAcceptRefinement = {
+	message: "An import response must carry importJobId exactly when state is 'accepted'.",
+	path: ["importJobId"]
+};
+function isImportJobAcceptConsistent(value) {
+	return value.state === "accepted" === (value.importJobId !== void 0);
+}
+const bridgeImportAssetSuccessResponseSchema = z.object({
+	...importJobAcceptFields,
+	sourceFileCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_IMPORT_ASSET_REQUEST_TYPE)
+}).refine(isImportJobAcceptConsistent, importJobAcceptRefinement);
+const bridgeReimportAssetSuccessResponseSchema = z.object({
+	...importJobAcceptFields,
+	assetCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_REIMPORT_ASSET_REQUEST_TYPE)
+}).refine(isImportJobAcceptConsistent, importJobAcceptRefinement);
+const bridgeSetImportSettingsSuccessResponseSchema = z.object({
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	presetName: z.string(),
+	requestId: requestIdSchema,
+	settingCount: z.number().int().min(0),
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_SET_IMPORT_SETTINGS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeImportJobItemResultSchema = z.object({
+	createdAssets: z.array(z.string()).max(25),
+	error: z.string().optional(),
+	index: z.number().int().min(0),
+	ok: z.boolean(),
+	source: z.string()
+});
+const bridgeGetImportJobStatusSuccessResponseSchema = z.object({
+	durationMs: z.number().int().min(0).optional(),
+	failureCount: z.number().int().min(0),
+	finishedAt: nonEmptyStringSchema.optional(),
+	importJobId: importJobIdSchema,
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	operation: importOperationSchema.optional(),
+	requestId: requestIdSchema,
+	results: z.array(bridgeImportJobItemResultSchema).max(16),
+	state: importJobStateSchema,
+	successCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_GET_IMPORT_JOB_STATUS_REQUEST_TYPE),
+	version: z.literal(2)
+}).superRefine((value, ctx) => {
+	if (value.state === "succeeded" || value.state === "failed") return;
+	if (value.durationMs !== void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "durationMs must be absent until the job finishes",
+		path: ["durationMs"]
+	});
+	if (value.finishedAt !== void 0) ctx.addIssue({
+		code: z.ZodIssueCode.custom,
+		message: "finishedAt must be absent until the job finishes",
+		path: ["finishedAt"]
+	});
+});
+const bridgeBlackboardKeyReportSchema = z.object({
+	baseType: z.string().optional(),
+	keyName: z.string(),
+	keyType: blackboardKeyTypeSchema
+});
+const bridgeCreateBlackboardSuccessResponseSchema = z.object({
+	...createdUserAssetResponseFields,
+	inheritedKeyCount: z.number().int().min(0),
+	keyCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_CREATE_BLACKBOARD_REQUEST_TYPE)
+});
+const bridgeSetBlackboardKeysSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	inheritedKeys: z.array(bridgeBlackboardKeyReportSchema).max(64),
+	keys: z.array(bridgeBlackboardKeyReportSchema).max(64),
+	type: z.literal(BRIDGE_SET_BLACKBOARD_KEYS_REQUEST_TYPE)
+});
+const bridgeCreateEqsQuerySuccessResponseSchema = z.object({
+	...createdUserAssetResponseFields,
+	eqsEnabled: z.boolean(),
+	generatorClass: z.string(),
+	testCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_CREATE_EQS_QUERY_REQUEST_TYPE)
+});
+const bridgeCreateStateTreeSuccessResponseSchema = z.object({
+	...createdUserAssetResponseFields,
+	schemaClass: z.string(),
+	supportedVersions: z.array(z.string()).max(16),
+	type: z.literal(BRIDGE_CREATE_STATE_TREE_REQUEST_TYPE)
+});
+const bridgeAddStateTreeStateSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	compiled: z.boolean(),
+	compileMessages: z.array(z.string()).max(25),
+	type: z.literal(BRIDGE_ADD_STATE_TREE_STATE_REQUEST_TYPE)
+});
+const bridgeCreateLevelSequenceSuccessResponseSchema = z.object({
+	...createdUserAssetResponseFields,
+	displayRate: bridgeSequenceFrameRateSchema,
+	durationInFrames: z.number().int().min(0),
+	tickResolution: bridgeSequenceFrameRateSchema,
+	type: z.literal(BRIDGE_CREATE_LEVEL_SEQUENCE_REQUEST_TYPE)
+});
+const bridgeAddSequenceBindingSuccessResponseSchema = z.object({
+	...authoringBatchResponseFields,
+	type: z.literal(BRIDGE_ADD_SEQUENCE_BINDING_REQUEST_TYPE)
+});
+const bridgeAddSequenceTrackSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	requestId: requestIdSchema,
+	sectionIndex: z.number().int().min(0),
+	state: creativeEditStateSchema,
+	trackKind: sequenceTrackKindSchema,
+	trackName: z.string(),
+	type: z.literal(BRIDGE_ADD_SEQUENCE_TRACK_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddSequenceKeysSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	channelName: z.string(),
+	keyCount: z.number().int().min(0),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	requestId: requestIdSchema,
+	resolvedFrames: z.array(z.number().int()).max(128),
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_ADD_SEQUENCE_KEYS_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeAddFoliageTypeSuccessResponseSchema = z.object({
+	...createdUserAssetResponseFields,
+	staticMeshPath: z.string(),
+	type: z.literal(BRIDGE_ADD_FOLIAGE_TYPE_REQUEST_TYPE)
+});
+const bridgePaintFoliageSuccessResponseSchema = z.object({
+	attemptedCount: z.number().int().min(0),
+	foliageTypePath: z.string(),
+	instanceCount: z.number().int().min(0),
+	message: nonEmptyStringSchema.optional(),
+	ok: z.literal(true),
+	packageDirty: z.boolean(),
+	placedCount: z.number().int().min(0),
+	requestId: requestIdSchema,
+	skippedCount: z.number().int().min(0),
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_PAINT_FOLIAGE_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeCreateSoundCueSuccessResponseSchema = z.object({
+	...createdUserAssetResponseFields,
+	connectionCount: z.number().int().min(0),
+	nodeCount: z.number().int().min(0),
+	type: z.literal(BRIDGE_CREATE_SOUND_CUE_REQUEST_TYPE)
+});
+const bridgeCreateMetasoundSuccessResponseSchema = z.object({
+	...createdUserAssetResponseFields,
+	outputFormat: metasoundOutputFormatSchema,
+	type: z.literal(BRIDGE_CREATE_METASOUND_REQUEST_TYPE)
+});
+const bridgeSetMetasoundGraphSuccessResponseSchema = z.object({
+	assetPath: z.string(),
+	connectionCount: z.number().int().min(0),
+	inputCount: z.number().int().min(0),
+	message: nonEmptyStringSchema.optional(),
+	nodeCount: z.number().int().min(0),
+	ok: z.literal(true),
+	outputCount: z.number().int().min(0),
+	packageDirty: z.boolean(),
+	requestId: requestIdSchema,
+	state: creativeEditStateSchema,
+	type: z.literal(BRIDGE_SET_METASOUND_GRAPH_REQUEST_TYPE),
+	version: z.literal(2)
+});
+const bridgeGetAssetPropertyResponseSchema = z.union([bridgeGetAssetPropertySuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetAssetPropertyResponseSchema = z.union([bridgeSetAssetPropertySuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeArrayPropertyOpResponseSchema = z.union([bridgeArrayPropertyOpSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCreateStructResponseSchema = z.union([bridgeCreateStructSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCreateEnumResponseSchema = z.union([bridgeCreateEnumSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCreateBlueprintResponseSchema = z.union([bridgeCreateBlueprintSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddBpVariableResponseSchema = z.union([bridgeAddBpVariableSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddBpFunctionResponseSchema = z.union([bridgeAddBpFunctionSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddBpEventResponseSchema = z.union([bridgeAddBpEventSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddBpComponentResponseSchema = z.union([bridgeAddBpComponentSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddBpInterfaceResponseSchema = z.union([bridgeAddBpInterfaceSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetBpDefaultResponseSchema = z.union([bridgeSetBpDefaultSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeBatchEditResponseSchema = z.union([bridgeBatchEditSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeImportAssetResponseSchema = z.union([bridgeImportAssetSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeReimportAssetResponseSchema = z.union([bridgeReimportAssetSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetImportSettingsResponseSchema = z.union([bridgeSetImportSettingsSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeGetImportJobStatusResponseSchema = z.union([bridgeGetImportJobStatusSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCreateBlackboardResponseSchema = z.union([bridgeCreateBlackboardSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetBlackboardKeysResponseSchema = z.union([bridgeSetBlackboardKeysSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCreateEqsQueryResponseSchema = z.union([bridgeCreateEqsQuerySuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCreateStateTreeResponseSchema = z.union([bridgeCreateStateTreeSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddStateTreeStateResponseSchema = z.union([bridgeAddStateTreeStateSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCreateLevelSequenceResponseSchema = z.union([bridgeCreateLevelSequenceSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddSequenceBindingResponseSchema = z.union([bridgeAddSequenceBindingSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddSequenceTrackResponseSchema = z.union([bridgeAddSequenceTrackSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddSequenceKeysResponseSchema = z.union([bridgeAddSequenceKeysSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeAddFoliageTypeResponseSchema = z.union([bridgeAddFoliageTypeSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgePaintFoliageResponseSchema = z.union([bridgePaintFoliageSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCreateSoundCueResponseSchema = z.union([bridgeCreateSoundCueSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeCreateMetasoundResponseSchema = z.union([bridgeCreateMetasoundSuccessResponseSchema, bridgeErrorResponseSchema]);
+const bridgeSetMetasoundGraphResponseSchema = z.union([bridgeSetMetasoundGraphSuccessResponseSchema, bridgeErrorResponseSchema]);
+function createBridgeGetAssetPropertyRequest(assetPath, propertyPath, requestId = randomUUID()) {
+	return bridgeGetAssetPropertyRequestSchema.parse({
+		assetPath,
+		propertyPath,
+		requestId,
+		type: BRIDGE_GET_ASSET_PROPERTY_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSetAssetPropertyRequest(assetPath, properties, requestId = randomUUID()) {
+	return bridgeSetAssetPropertyRequestSchema.parse({
+		assetPath,
+		properties,
+		requestId,
+		type: BRIDGE_SET_ASSET_PROPERTY_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeArrayPropertyOpRequest(assetPath, propertyPath, operation, options = {}, requestId = randomUUID()) {
+	return bridgeArrayPropertyOpRequestSchema.parse({
+		assetPath,
+		index: options.index,
+		operation,
+		propertyPath,
+		requestId,
+		type: BRIDGE_ARRAY_PROPERTY_OP_REQUEST_TYPE,
+		value: options.value,
+		version: 2
+	});
+}
+function createBridgeCreateStructRequest(assetName, packagePath, options = {}, requestId = randomUUID()) {
+	return bridgeCreateStructRequestSchema.parse({
+		assetName,
+		description: options.description,
+		fields: options.fields,
+		packagePath,
+		requestId,
+		type: BRIDGE_CREATE_STRUCT_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCreateEnumRequest(assetName, packagePath, entries, options = {}, requestId = randomUUID()) {
+	return bridgeCreateEnumRequestSchema.parse({
+		assetName,
+		description: options.description,
+		entries,
+		packagePath,
+		requestId,
+		type: BRIDGE_CREATE_ENUM_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCreateBlueprintRequest(assetName, packagePath, parentClass, options = {}, requestId = randomUUID()) {
+	return bridgeCreateBlueprintRequestSchema.parse({
+		assetName,
+		blueprintKind: options.blueprintKind,
+		packagePath,
+		parentClass,
+		requestId,
+		type: BRIDGE_CREATE_BLUEPRINT_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddBpVariableRequest(assetPath, variables, requestId = randomUUID()) {
+	return bridgeAddBpVariableRequestSchema.parse({
+		assetPath,
+		requestId,
+		type: BRIDGE_ADD_BP_VARIABLE_REQUEST_TYPE,
+		variables,
+		version: 2
+	});
+}
+function createBridgeAddBpFunctionRequest(assetPath, functions, requestId = randomUUID()) {
+	return bridgeAddBpFunctionRequestSchema.parse({
+		assetPath,
+		functions,
+		requestId,
+		type: BRIDGE_ADD_BP_FUNCTION_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddBpEventRequest(assetPath, events, options = {}, requestId = randomUUID()) {
+	return bridgeAddBpEventRequestSchema.parse({
+		assetPath,
+		events,
+		graphName: options.graphName,
+		requestId,
+		type: BRIDGE_ADD_BP_EVENT_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddBpComponentRequest(assetPath, components, requestId = randomUUID()) {
+	return bridgeAddBpComponentRequestSchema.parse({
+		assetPath,
+		components,
+		requestId,
+		type: BRIDGE_ADD_BP_COMPONENT_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddBpInterfaceRequest(assetPath, interfacePaths, requestId = randomUUID()) {
+	return bridgeAddBpInterfaceRequestSchema.parse({
+		assetPath,
+		interfacePaths,
+		requestId,
+		type: BRIDGE_ADD_BP_INTERFACE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSetBpDefaultRequest(assetPath, properties, requestId = randomUUID()) {
+	return bridgeSetBpDefaultRequestSchema.parse({
+		assetPath,
+		properties,
+		requestId,
+		type: BRIDGE_SET_BP_DEFAULT_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeBatchEditRequest(ops, options = {}, requestId = randomUUID()) {
+	return bridgeBatchEditRequestSchema.parse({
+		dryRun: options.dryRun,
+		ops,
+		requestId,
+		transactionTitle: options.transactionTitle,
+		type: BRIDGE_BATCH_EDIT_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeImportAssetRequest(sourceFiles, destinationPath, options = {}, requestId = randomUUID()) {
+	return bridgeImportAssetRequestSchema.parse({
+		destinationPath,
+		pipeline: options.pipeline,
+		presetName: options.presetName,
+		replaceExisting: options.replaceExisting,
+		requestId,
+		sourceFiles,
+		type: BRIDGE_IMPORT_ASSET_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeReimportAssetRequest(assetPaths, requestId = randomUUID()) {
+	return bridgeReimportAssetRequestSchema.parse({
+		assetPaths,
+		requestId,
+		type: BRIDGE_REIMPORT_ASSET_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSetImportSettingsRequest(presetName, settings, requestId = randomUUID()) {
+	return bridgeSetImportSettingsRequestSchema.parse({
+		presetName,
+		requestId,
+		settings,
+		type: BRIDGE_SET_IMPORT_SETTINGS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeGetImportJobStatusRequest(importJobId, requestId = randomUUID()) {
+	return bridgeGetImportJobStatusRequestSchema.parse({
+		importJobId,
+		requestId,
+		type: BRIDGE_GET_IMPORT_JOB_STATUS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCreateBlackboardRequest(assetName, packagePath, options = {}, requestId = randomUUID()) {
+	return bridgeCreateBlackboardRequestSchema.parse({
+		assetName,
+		keys: options.keys,
+		packagePath,
+		parentBlackboardPath: options.parentBlackboardPath,
+		requestId,
+		type: BRIDGE_CREATE_BLACKBOARD_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSetBlackboardKeysRequest(assetPath, keys, options = {}, requestId = randomUUID()) {
+	return bridgeSetBlackboardKeysRequestSchema.parse({
+		assetPath,
+		keys,
+		mode: options.mode,
+		requestId,
+		type: BRIDGE_SET_BLACKBOARD_KEYS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCreateEqsQueryRequest(assetName, packagePath, generator, options = {}, requestId = randomUUID()) {
+	return bridgeCreateEqsQueryRequestSchema.parse({
+		assetName,
+		generator,
+		packagePath,
+		requestId,
+		tests: options.tests,
+		type: BRIDGE_CREATE_EQS_QUERY_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCreateStateTreeRequest(assetName, packagePath, options = {}, requestId = randomUUID()) {
+	return bridgeCreateStateTreeRequestSchema.parse({
+		assetName,
+		packagePath,
+		requestId,
+		schema: options.schema,
+		schemaClass: options.schemaClass,
+		type: BRIDGE_CREATE_STATE_TREE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddStateTreeStateRequest(assetPath, states, options = {}, requestId = randomUUID()) {
+	return bridgeAddStateTreeStateRequestSchema.parse({
+		assetPath,
+		compile: options.compile,
+		requestId,
+		states,
+		type: BRIDGE_ADD_STATE_TREE_STATE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCreateLevelSequenceRequest(assetName, packagePath, options = {}, requestId = randomUUID()) {
+	return bridgeCreateLevelSequenceRequestSchema.parse({
+		assetName,
+		displayRate: options.displayRate,
+		durationInFrames: options.durationInFrames,
+		packagePath,
+		requestId,
+		tickResolution: options.tickResolution,
+		type: BRIDGE_CREATE_LEVEL_SEQUENCE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddSequenceBindingRequest(assetPath, bindings, requestId = randomUUID()) {
+	return bridgeAddSequenceBindingRequestSchema.parse({
+		assetPath,
+		bindings,
+		requestId,
+		type: BRIDGE_ADD_SEQUENCE_BINDING_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddSequenceTrackRequest(assetPath, trackKind, options = {}, requestId = randomUUID()) {
+	return bridgeAddSequenceTrackRequestSchema.parse({
+		assetPath,
+		bindingId: options.bindingId,
+		propertyPath: options.propertyPath,
+		requestId,
+		sectionEndFrame: options.sectionEndFrame,
+		sectionStartFrame: options.sectionStartFrame,
+		trackKind,
+		type: BRIDGE_ADD_SEQUENCE_TRACK_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddSequenceKeysRequest(assetPath, trackName, channelName, timeUnit, keys, options = {}, requestId = randomUUID()) {
+	return bridgeAddSequenceKeysRequestSchema.parse({
+		assetPath,
+		bindingId: options.bindingId,
+		channelName,
+		keys,
+		requestId,
+		timeUnit,
+		trackName,
+		type: BRIDGE_ADD_SEQUENCE_KEYS_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeAddFoliageTypeRequest(assetName, packagePath, staticMeshPath, options = {}, requestId = randomUUID()) {
+	return bridgeAddFoliageTypeRequestSchema.parse({
+		assetName,
+		packagePath,
+		requestId,
+		settings: options.settings,
+		staticMeshPath,
+		type: BRIDGE_ADD_FOLIAGE_TYPE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgePaintFoliageRequest(foliageTypePath, mode, options = {}, requestId = randomUUID()) {
+	return bridgePaintFoliageRequestSchema.parse({
+		alignToNormal: options.alignToNormal,
+		density: options.density,
+		foliageTypePath,
+		mode,
+		randomSeed: options.randomSeed,
+		region: options.region,
+		requestId,
+		slopeMax: options.slopeMax,
+		slopeMin: options.slopeMin,
+		transforms: options.transforms,
+		type: BRIDGE_PAINT_FOLIAGE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCreateSoundCueRequest(assetName, packagePath, nodes, rootNodeId, options = {}, requestId = randomUUID()) {
+	return bridgeCreateSoundCueRequestSchema.parse({
+		assetName,
+		connections: options.connections,
+		nodes,
+		packagePath,
+		requestId,
+		rootNodeId,
+		type: BRIDGE_CREATE_SOUND_CUE_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeCreateMetasoundRequest(assetName, packagePath, options = {}, requestId = randomUUID()) {
+	return bridgeCreateMetasoundRequestSchema.parse({
+		assetName,
+		outputFormat: options.outputFormat,
+		packagePath,
+		requestId,
+		type: BRIDGE_CREATE_METASOUND_REQUEST_TYPE,
+		version: 2
+	});
+}
+function createBridgeSetMetasoundGraphRequest(assetPath, options = {}, requestId = randomUUID()) {
+	return bridgeSetMetasoundGraphRequestSchema.parse({
+		assetPath,
+		connections: options.connections,
+		inputs: options.inputs,
+		nodes: options.nodes,
+		outputs: options.outputs,
+		requestId,
+		type: BRIDGE_SET_METASOUND_GRAPH_REQUEST_TYPE,
+		version: 2
+	});
+}
 //#endregion
 //#region src/bridgeSocketClient.ts
 var BridgeSocketError = class extends Error {
@@ -5177,6 +6697,99 @@ function exchangeBridgeMessage(frame, options) {
 		});
 	});
 }
+async function sendBridgeGetAssetPropertyRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetAssetPropertyResponseSchema, request.requestId);
+}
+async function sendBridgeSetAssetPropertyRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetAssetPropertyResponseSchema, request.requestId);
+}
+async function sendBridgeArrayPropertyOpRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeArrayPropertyOpResponseSchema, request.requestId);
+}
+async function sendBridgeCreateStructRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateStructResponseSchema, request.requestId);
+}
+async function sendBridgeCreateEnumRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateEnumResponseSchema, request.requestId);
+}
+async function sendBridgeCreateBlueprintRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateBlueprintResponseSchema, request.requestId);
+}
+async function sendBridgeAddBpVariableRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddBpVariableResponseSchema, request.requestId);
+}
+async function sendBridgeAddBpFunctionRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddBpFunctionResponseSchema, request.requestId);
+}
+async function sendBridgeAddBpEventRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddBpEventResponseSchema, request.requestId);
+}
+async function sendBridgeAddBpComponentRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddBpComponentResponseSchema, request.requestId);
+}
+async function sendBridgeAddBpInterfaceRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddBpInterfaceResponseSchema, request.requestId);
+}
+async function sendBridgeSetBpDefaultRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetBpDefaultResponseSchema, request.requestId);
+}
+async function sendBridgeBatchEditRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeBatchEditResponseSchema, request.requestId);
+}
+async function sendBridgeImportAssetRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeImportAssetResponseSchema, request.requestId);
+}
+async function sendBridgeReimportAssetRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeReimportAssetResponseSchema, request.requestId);
+}
+async function sendBridgeSetImportSettingsRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetImportSettingsResponseSchema, request.requestId);
+}
+async function sendBridgeGetImportJobStatusRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeGetImportJobStatusResponseSchema, request.requestId);
+}
+async function sendBridgeCreateBlackboardRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateBlackboardResponseSchema, request.requestId);
+}
+async function sendBridgeSetBlackboardKeysRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetBlackboardKeysResponseSchema, request.requestId);
+}
+async function sendBridgeCreateEqsQueryRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateEqsQueryResponseSchema, request.requestId);
+}
+async function sendBridgeCreateStateTreeRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateStateTreeResponseSchema, request.requestId);
+}
+async function sendBridgeAddStateTreeStateRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddStateTreeStateResponseSchema, request.requestId);
+}
+async function sendBridgeCreateLevelSequenceRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateLevelSequenceResponseSchema, request.requestId);
+}
+async function sendBridgeAddSequenceBindingRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddSequenceBindingResponseSchema, request.requestId);
+}
+async function sendBridgeAddSequenceTrackRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddSequenceTrackResponseSchema, request.requestId);
+}
+async function sendBridgeAddSequenceKeysRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddSequenceKeysResponseSchema, request.requestId);
+}
+async function sendBridgeAddFoliageTypeRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeAddFoliageTypeResponseSchema, request.requestId);
+}
+async function sendBridgePaintFoliageRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgePaintFoliageResponseSchema, request.requestId);
+}
+async function sendBridgeCreateSoundCueRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateSoundCueResponseSchema, request.requestId);
+}
+async function sendBridgeCreateMetasoundRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeCreateMetasoundResponseSchema, request.requestId);
+}
+async function sendBridgeSetMetasoundGraphRequest(request, options) {
+	return parseBridgeResponse(await exchangeBridgeMessage(encodeBridgeFrame(request), options), bridgeSetMetasoundGraphResponseSchema, request.requestId);
+}
 //#endregion
 //#region src/enginePing.ts
 async function pingRegistryEntry$1(entry, options) {
@@ -7162,6 +8775,7 @@ const WAIT_FOR_JOB_KINDS = [
 	"build",
 	"compile",
 	"create_class",
+	"import",
 	"pie",
 	"source_control",
 	"test_run"
@@ -7171,6 +8785,7 @@ const WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS = {
 	build: WAIT_FOR_JOB_MAX_TIMEOUT_MS,
 	compile: 12e4,
 	create_class: 6e4,
+	import: 3e5,
 	pie: 3e4,
 	source_control: 6e4,
 	test_run: 3e5
@@ -7188,6 +8803,10 @@ const WAIT_FOR_JOB_POLL_CADENCE_MS = {
 		capMs: 2e3,
 		initialMs: 250
 	},
+	import: {
+		capMs: 5e3,
+		initialMs: 1e3
+	},
 	pie: {
 		capMs: 2e3,
 		initialMs: 250
@@ -7300,10 +8919,10 @@ const getTestRunStatusInputSchema = {
 	testRunId: z.string().trim().min(1).describe("The testRunId returned by run_automation_tests for the run to poll.")
 };
 const waitForJobInputSchema = {
-	jobId: z.string().trim().min(1).max(512).describe("Job identifier to wait on: compileJobId (compile), createClassJobId (create_class), testRunId (test_run), or pieSessionId (pie)."),
+	jobId: z.string().trim().min(1).max(512).describe("Job identifier to wait on: compileJobId (compile), createClassJobId (create_class), importJobId (import), testRunId (test_run), or pieSessionId (pie)."),
 	kind: z.enum(WAIT_FOR_JOB_KINDS).describe("Which async job the id belongs to. Required — job ids are bare GUIDs and carry no type tag, so the kind cannot be inferred."),
 	projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor owns the job."),
-	timeoutMs: z.number().int().min(1).optional().describe(`Wall-clock budget for the wait, clamped to ${String(WAIT_FOR_JOB_MAX_TIMEOUT_MS)}ms. Defaults per kind: compile ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.compile)}ms, create_class ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.create_class)}ms, pie ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.pie)}ms, source_control ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.source_control)}ms, test_run ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.test_run)}ms.`)
+	timeoutMs: z.number().int().min(1).optional().describe(`Wall-clock budget for the wait, clamped to ${String(WAIT_FOR_JOB_MAX_TIMEOUT_MS)}ms. Defaults per kind: compile ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.compile)}ms, create_class ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.create_class)}ms, import ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.import)}ms, pie ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.pie)}ms, source_control ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.source_control)}ms, test_run ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.test_run)}ms.`)
 };
 const getEditorStateInputSchema = { projectId: projectIdSchema.describe("Canonical Unreal ProjectID whose registered editor should report its state.") };
 const saveDirtyPackagesInputSchema = {
@@ -8502,7 +10121,7 @@ function registerMcpTools(server, dependencies) {
 		}, dependencies));
 	});
 	server.registerTool("wait_for_job", {
-		description: `Block server-side until an async job reaches a terminal state, then return the payload its get_*_status tool would have returned under 'status'. Use instead of a poll loop after trigger_live_compile, trigger_hot_reload (kind 'compile'), create_cpp_class ('create_class'), run_automation_tests ('test_run'), or start_pie ('pie'). kind is required — job ids carry no type tag. outcome is 'completed', 'timed_out' (the last observed status is still returned; call again or poll), or 'unknown_job' (unknown/expired/cancelled id, returned immediately). timeoutMs defaults per kind (compile ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.compile)}ms, create_class ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.create_class)}ms, pie ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.pie)}ms, test_run ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.test_run)}ms) and is clamped to ${String(WAIT_FOR_JOB_MAX_TIMEOUT_MS)}ms, so a long automation run may need more than one call. For kind 'test_run' the returned status.results is the first page only — page the rest with get_test_run_status and nextCursor. For kind 'pie' only 'starting' keeps waiting; 'running', 'stopped' and 'none' are all terminal.`,
+		description: `Block server-side until an async job reaches a terminal state, then return the payload its get_*_status tool would have returned under 'status'. Use instead of a poll loop after trigger_live_compile, trigger_hot_reload (kind 'compile'), create_cpp_class ('create_class'), import_asset or reimport_asset ('import'), run_automation_tests ('test_run'), or start_pie ('pie'). kind is required — job ids carry no type tag. outcome is 'completed', 'timed_out' (the last observed status is still returned; call again or poll), or 'unknown_job' (unknown/expired/cancelled id, returned immediately). timeoutMs defaults per kind (compile ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.compile)}ms, create_class ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.create_class)}ms, pie ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.pie)}ms, test_run ${String(WAIT_FOR_JOB_DEFAULT_TIMEOUT_MS.test_run)}ms) and is clamped to ${String(WAIT_FOR_JOB_MAX_TIMEOUT_MS)}ms, so a long automation run may need more than one call. For kind 'test_run' the returned status.results is the first page only — page the rest with get_test_run_status and nextCursor. For kind 'pie' only 'starting' keeps waiting; 'running', 'stopped' and 'none' are all terminal.`,
 		inputSchema: waitForJobInputSchema,
 		title: "Wait For Job"
 	}, async ({ jobId, kind, projectId, timeoutMs }) => {
@@ -9585,6 +11204,394 @@ function registerMcpTools(server, dependencies) {
 			regionId
 		}, dependencies));
 	});
+	server.registerTool("get_asset_property", {
+		description: "Read any reflected property on a content asset — material settings, mesh build settings, data asset fields, a Blueprint's class defaults — without loading it in an editor window. Returns the value as ExportText plus the resolved UE type, so an enum can be told apart from the integer it exports as. propertyPath walks structs with dots and arrays with subscripts ('BuildSettings.bRecomputeNormals', 'Modifiers[0].Weight'). Address a Blueprint CDO through its generated class path.",
+		inputSchema: getAssetPropertyInputSchema,
+		title: "Get Asset Property"
+	}, async ({ assetPath, projectId, propertyPath }) => {
+		return toToolSuccess(await getAssetProperty({
+			assetPath,
+			projectId,
+			propertyPath
+		}, dependencies));
+	});
+	server.registerTool("set_asset_property", {
+		description: "Write reflected properties on a content asset, in one transaction and one undo step. Values are ExportText, exactly as get_asset_property returns them. The asset is marked dirty but not saved, so a run of edits is followed by a single save_dirty_packages. A transient, deprecated or EditConst property is refused by name rather than written and silently discarded. For a Blueprint's class defaults use set_bp_default, which routes through the same walker but also tells the Blueprint it changed.",
+		inputSchema: setAssetPropertyInputSchema,
+		title: "Set Asset Property"
+	}, async ({ assetPath, projectId, properties }) => {
+		return toToolSuccess(await setAssetProperty({
+			assetPath,
+			projectId,
+			properties
+		}, dependencies));
+	});
+	server.registerTool("array_property_op", {
+		description: "Add, insert, remove or clear elements of an array property on an asset. Separate from set_asset_property because an array mutation needs an index and an operation rather than a whole-array value — writing a full array literal through ExportText loses element identity and is what makes generated content drift. Returns the array's length after the change; the elements themselves are read back with get_asset_property.",
+		inputSchema: arrayPropertyOpInputSchema,
+		title: "Array Property Op"
+	}, async ({ assetPath, index, operation, projectId, propertyPath, value }) => {
+		return toToolSuccess(await arrayPropertyOp({
+			assetPath,
+			index,
+			operation,
+			projectId,
+			propertyPath,
+			value
+		}, dependencies));
+	});
+	server.registerTool("create_struct", {
+		description: "Create a user-defined struct asset with typed fields. This is the first step of any data-driven workflow: create_data_table needs a row struct, and without this one it has to already exist. Field types use the shared type spec — { kind: 'float' }, { kind: 'object', subtype: '/Script/Engine.StaticMesh' }, { container: 'array', kind: 'struct', subtype: '/Game/Types/S_Item.S_Item' } — the same grammar add_bp_variable takes. Adding fields to a struct already in use recompiles its dependents, which are reported back.",
+		inputSchema: createStructInputSchema,
+		title: "Create Struct"
+	}, async ({ assetName, description, fields, packagePath, projectId }) => {
+		return toToolSuccess(await createStruct({
+			assetName,
+			description,
+			fields,
+			packagePath,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("create_enum", {
+		description: "Create a user-defined enum asset. Each entry carries both the authored name the compiler sees and the display name the editor shows in a dropdown, so a generated enum reads like a hand-authored one. Use the resulting asset path as the subtype of an enum type spec in create_struct or add_bp_variable.",
+		inputSchema: createEnumInputSchema,
+		title: "Create Enum"
+	}, async ({ assetName, description, entries, packagePath, projectId }) => {
+		return toToolSuccess(await createEnum({
+			assetName,
+			description,
+			entries,
+			packagePath,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("create_blueprint", {
+		description: "Create a Blueprint class from a parent class. Returns both the asset path and the generated class path ('/Game/BP/BP_Foo.BP_Foo_C') — the generated class is what spawn_actor and every other class reference takes, and passing the asset path there is the usual mistake. The Blueprint arrives empty: add members with add_bp_variable / add_bp_function / add_bp_event / add_bp_component, then compile it with compile_blueprint.",
+		inputSchema: createBlueprintInputSchema,
+		title: "Create Blueprint"
+	}, async ({ assetName, blueprintKind, packagePath, parentClass, projectId }) => {
+		return toToolSuccess(await createBlueprint({
+			assetName,
+			blueprintKind,
+			packagePath,
+			parentClass,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("add_bp_variable", {
+		description: "Add member variables to a Blueprint. Types use the shared type spec, covering primitives, structs, object and class references, and array / set / map containers. instanceEditable exposes the variable in the details panel and exposeOnSpawn adds it to the spawn node; both default off. Each entry succeeds or fails on its own, so one bad type does not lose the rest. Recompile with compile_blueprint when the batch is done.",
+		inputSchema: addBpVariableInputSchema,
+		title: "Add Blueprint Variable"
+	}, async ({ assetPath, projectId, variables }) => {
+		return toToolSuccess(await addBpVariable({
+			assetPath,
+			projectId,
+			variables
+		}, dependencies));
+	});
+	server.registerTool("add_bp_function", {
+		description: "Add function graphs to a Blueprint with typed inputs and outputs. This creates the graph and its entry and result nodes only — the body is authored with add_graph_node and connect_pins against the returned graph name. A pure function has no exec pins, which is decided here because changing it later rebuilds the entry node.",
+		inputSchema: addBpFunctionInputSchema,
+		title: "Add Blueprint Function"
+	}, async ({ assetPath, functions, projectId }) => {
+		return toToolSuccess(await addBpFunction({
+			assetPath,
+			functions,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("add_bp_event", {
+		description: "Place event nodes in a Blueprint graph. eventKind 'override' places a node for a function the parent class already declares — BeginPlay, Tick, or any BlueprintImplementableEvent — and takes its signature from the parent, so inputs must be empty. 'custom' adds a custom event with the inputs given. Returns each node's id for wiring with connect_pins.",
+		inputSchema: addBpEventInputSchema,
+		title: "Add Blueprint Event"
+	}, async ({ assetPath, events, graphName, projectId }) => {
+		return toToolSuccess(await addBpEvent({
+			assetPath,
+			events,
+			graphName,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("add_bp_component", {
+		description: "Add components to a Blueprint's construction script, optionally attached under an existing component by name so a real hierarchy can be built in one call. This is the Blueprint-asset equivalent of add_actor_component, which edits a placed actor instead. Components added here exist on every instance of the class.",
+		inputSchema: addBpComponentInputSchema,
+		title: "Add Blueprint Component"
+	}, async ({ assetPath, components, projectId }) => {
+		return toToolSuccess(await addBpComponent({
+			assetPath,
+			components,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("add_bp_interface", {
+		description: "Implement Blueprint or native interfaces on a Blueprint. The interface brings its function graphs with it; their names are returned so the bodies can be filled in with the graph tools. Compile afterwards — an interface added but not implemented is a compile error, not a silent no-op.",
+		inputSchema: addBpInterfaceInputSchema,
+		title: "Add Blueprint Interface"
+	}, async ({ assetPath, interfacePaths, projectId }) => {
+		return toToolSuccess(await addBpInterface({
+			assetPath,
+			interfacePaths,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("set_bp_default", {
+		description: "Write class defaults on a Blueprint — the values every new instance starts with. Takes the same property paths and ExportText values set_asset_property does, but addresses the Blueprint's class default object and marks the Blueprint structurally modified so the change survives a recompile.",
+		inputSchema: setBpDefaultInputSchema,
+		title: "Set Blueprint Default"
+	}, async ({ assetPath, projectId, properties }) => {
+		return toToolSuccess(await setBpDefault({
+			assetPath,
+			projectId,
+			properties
+		}, dependencies));
+	});
+	server.registerTool("batch_edit", {
+		description: "Apply an ordered list of level edits — spawn, destroy, transform, property, attach, place, tag — inside a single transaction, so the whole arrangement is one entry in the editor's Undo History and one Ctrl+Z. If any op fails the transaction is cancelled and the level is left exactly as it was, with the failing op's index and error reported; nothing is half-applied. A spawn or place op can carry a handle, and later ops address that actor as 'handle:<name>' before the editor has assigned it a path. Prefer this over a run of individual level-edit calls whenever the edits are only meaningful together.",
+		inputSchema: batchEditInputSchema,
+		title: "Batch Edit"
+	}, async ({ dryRun, ops, projectId, transactionTitle }) => {
+		return toToolSuccess(await batchEdit({
+			dryRun,
+			ops,
+			projectId,
+			transactionTitle
+		}, dependencies));
+	});
+	server.registerTool("import_asset", {
+		description: "Import files from disk into the project — FBX meshes and animations, textures, audio — through Interchange where the engine version owns the format, or a configured UFactory where it does not. An import runs for minutes on a large file, so this only accepts the job: it returns state 'accepted' with an importJobId to poll with get_import_job_status (or wait_for_job with kind import). The final status lists every asset each file produced, which for a skeletal mesh is the mesh, its skeleton and its physics asset. Configure the import beforehand with set_import_settings rather than relying on the defaults.",
+		inputSchema: importAssetInputSchema,
+		title: "Import Asset"
+	}, async ({ destinationPath, pipeline, presetName, projectId, replaceExisting, sourceFiles }) => {
+		return toToolSuccess(await importAsset({
+			destinationPath,
+			pipeline,
+			presetName,
+			projectId,
+			replaceExisting,
+			sourceFiles
+		}, dependencies));
+	});
+	server.registerTool("reimport_asset", {
+		description: "Re-read assets from the source files they were imported from, keeping their existing references intact. Like import_asset this only accepts the job and returns an importJobId to poll. An asset with no import data recorded fails its own entry rather than the batch.",
+		inputSchema: reimportAssetInputSchema,
+		title: "Reimport Asset"
+	}, async ({ assetPaths, projectId }) => {
+		return toToolSuccess(await reimportAsset({
+			assetPaths,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("set_import_settings", {
+		description: "Store a named set of import options — mesh combining, skeleton reuse, texture compression and sRGB, LOD import — that import_asset then applies before running. This is what makes an import deterministic and dialog-free; without it the engine's defaults for the file type are used. Settings are reflected property names on the pipeline or factory, valued as ExportText.",
+		inputSchema: setImportSettingsInputSchema,
+		title: "Set Import Settings"
+	}, async ({ presetName, projectId, settings }) => {
+		return toToolSuccess(await setImportSettings({
+			presetName,
+			projectId,
+			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,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("create_blackboard", {
+		description: "Create a Blackboard asset, optionally with its keys and a parent blackboard to inherit from. A Behavior Tree is useless without one, so this is the first step of any AI work. Inherited keys are reported separately from local ones — redeclaring an inherited key locally is the mistake this split exists to prevent.",
+		inputSchema: createBlackboardInputSchema,
+		title: "Create Blackboard"
+	}, async ({ assetName, keys, packagePath, parentBlackboardPath, projectId }) => {
+		return toToolSuccess(await createBlackboard({
+			assetName,
+			keys,
+			packagePath,
+			parentBlackboardPath,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("set_blackboard_keys", {
+		description: "Add, update or replace the keys on a Blackboard asset. Object and class keys must name their base class and enum keys their enum asset: without it the key still appears in the editor and simply never matches anything at runtime, which is the failure mode this tool is built to avoid. mode 'merge' leaves unlisted keys alone; 'replace' makes the local key list exactly what was sent.",
+		inputSchema: setBlackboardKeysInputSchema,
+		title: "Set Blackboard Keys"
+	}, async ({ assetPath, keys, mode, projectId }) => {
+		return toToolSuccess(await setBlackboardKeys({
+			assetPath,
+			keys,
+			mode,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("create_eqs_query", {
+		description: "Create an Environment Query asset with a generator and its tests, then rebuild it from its graph so the saved query matches what was authored. Use it for AI spatial reasoning — cover selection, flanking, item search. Generator and test settings are reflected property names valued as ExportText. If the project has the Environment Query System switched off the query is still created and eqsEnabled comes back false, naming the setting to turn on rather than failing opaquely.",
+		inputSchema: createEqsQueryInputSchema,
+		title: "Create EQS Query"
+	}, async ({ assetName, generator, packagePath, projectId, tests }) => {
+		return toToolSuccess(await createEqsQuery({
+			assetName,
+			generator,
+			packagePath,
+			projectId,
+			tests
+		}, dependencies));
+	});
+	server.registerTool("create_state_tree", {
+		description: "Create a StateTree asset bound to a schema — Epic's newer alternative to Behavior Trees, used for AI and for general state logic. The schema decides what the tree may reference and cannot be changed afterwards without invalidating every node, so it is set here. The response reports which engine versions this plugin build can author StateTrees for; an unsupported editor says so instead of failing inside the compiler.",
+		inputSchema: createStateTreeInputSchema,
+		title: "Create StateTree"
+	}, async ({ assetName, packagePath, projectId, schema, schemaClass }) => {
+		return toToolSuccess(await createStateTree({
+			assetName,
+			packagePath,
+			projectId,
+			schema,
+			schemaClass
+		}, dependencies));
+	});
+	server.registerTool("add_state_tree_state", {
+		description: "Add states to a StateTree, each with its enter conditions, tasks and transitions, then compile the tree. Compilation is on by default because an uncompiled StateTree fails at runtime rather than in the editor; compiler messages come back verbatim. States are added in list order, so a state may name a parent that appeared earlier in the same call.",
+		inputSchema: addStateTreeStateInputSchema,
+		title: "Add StateTree State"
+	}, async ({ assetPath, compile, projectId, states }) => {
+		return toToolSuccess(await addStateTreeState({
+			assetPath,
+			compile,
+			projectId,
+			states
+		}, dependencies));
+	});
+	server.registerTool("create_level_sequence", {
+		description: "Create a Level Sequence for cinematics, scripted scenes and camera moves. Frame rates are exact rationals rather than decimals, because 30000/1001 is not 29.97 and the difference shows up as keys landing a frame off. The response reports both the display rate and the tick resolution the sequence stores time in — add_sequence_keys converts through them.",
+		inputSchema: createLevelSequenceInputSchema,
+		title: "Create Level Sequence"
+	}, async ({ assetName, displayRate, durationInFrames, packagePath, projectId, tickResolution }) => {
+		return toToolSuccess(await createLevelSequence({
+			assetName,
+			displayRate,
+			durationInFrames,
+			packagePath,
+			projectId,
+			tickResolution
+		}, dependencies));
+	});
+	server.registerTool("add_sequence_binding", {
+		description: "Bind objects into a Level Sequence. A 'possessable' animates an actor that already exists in the level and dies with it; a 'spawnable' carries its own template and creates its object while the sequence plays. The two behave differently enough that the kind is explicit rather than inferred. Returns each binding's id, which add_sequence_track and add_sequence_keys take.",
+		inputSchema: addSequenceBindingInputSchema,
+		title: "Add Sequence Binding"
+	}, async ({ assetPath, bindings, projectId }) => {
+		return toToolSuccess(await addSequenceBinding({
+			assetPath,
+			bindings,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("add_sequence_track", {
+		description: "Add a track and its first section to a Level Sequence binding — transform, skeletal animation, audio, visibility, or a generic property track. A camera cut track belongs to the sequence itself and takes no bindingId; every other kind requires one. Returns the trackName add_sequence_keys uses to find it again.",
+		inputSchema: addSequenceTrackInputSchema,
+		title: "Add Sequence Track"
+	}, async ({ assetPath, bindingId, projectId, propertyPath, sectionEndFrame, sectionStartFrame, trackKind }) => {
+		return toToolSuccess(await addSequenceTrack({
+			assetPath,
+			bindingId,
+			projectId,
+			propertyPath,
+			sectionEndFrame,
+			sectionStartFrame,
+			trackKind
+		}, dependencies));
+	});
+	server.registerTool("add_sequence_keys", {
+		description: "Add keyframes to a channel of a sequence track. timeUnit is required and says how to read each key's time — 'frames' at the sequence's display rate, or 'seconds' — because a Level Sequence stores time in tick resolution and a bare number lands at the wrong moment on any non-default frame rate. The response reports where each key actually landed in tick resolution, which is what proves the conversion. Interpolation and tangents are per key.",
+		inputSchema: addSequenceKeysInputSchema,
+		title: "Add Sequence Keys"
+	}, async ({ assetPath, bindingId, channelName, keys, projectId, timeUnit, trackName }) => {
+		return toToolSuccess(await addSequenceKeys({
+			assetPath,
+			bindingId,
+			channelName,
+			keys,
+			projectId,
+			timeUnit,
+			trackName
+		}, dependencies));
+	});
+	server.registerTool("add_foliage_type", {
+		description: "Create a foliage type asset wrapping a static mesh, with its density, scale range, alignment to normal, ground slope limits and collision. This is the reusable settings asset; paint_foliage places instances of it. Settings left out keep the engine defaults rather than being zeroed.",
+		inputSchema: addFoliageTypeInputSchema,
+		title: "Add Foliage Type"
+	}, async ({ assetName, packagePath, projectId, settings, staticMeshPath }) => {
+		return toToolSuccess(await addFoliageType({
+			assetName,
+			packagePath,
+			projectId,
+			settings,
+			staticMeshPath
+		}, dependencies));
+	});
+	server.registerTool("paint_foliage", {
+		description: "Add instanced foliage to the loaded level. 'explicit' mode places exactly the transforms given, which is what makes a layout reproducible. 'region' mode scatters at a density across a box and traces downward onto the landscape or meshes below, honouring the slope limits — that is what the editor's paint brush actually does, and it is what makes this usable without computing every transform. Reports how many placements were attempted, placed and skipped, plus the type's total instance count in the level.",
+		inputSchema: paintFoliageInputSchema,
+		title: "Paint Foliage"
+	}, async ({ alignToNormal, density, foliageTypePath, mode, projectId, randomSeed, region, slopeMax, slopeMin, transforms }) => {
+		return toToolSuccess(await paintFoliage({
+			alignToNormal,
+			density,
+			foliageTypePath,
+			mode,
+			projectId,
+			randomSeed,
+			region,
+			slopeMax,
+			slopeMin,
+			transforms
+		}, dependencies));
+	});
+	server.registerTool("create_sound_cue", {
+		description: "Create a Sound Cue and build its node graph in one call — wave players, random and mixer nodes, looping, modulation, attenuation and delay. Nodes carry caller-supplied ids so connections can be expressed before the editor has created anything. The editor graph is rebuilt from the node tree afterwards, so the cue opens with its nodes laid out rather than blank. A randomised footstep cue is three wave players under a random node.",
+		inputSchema: createSoundCueInputSchema,
+		title: "Create Sound Cue"
+	}, async ({ assetName, connections, nodes, packagePath, projectId, rootNodeId }) => {
+		return toToolSuccess(await createSoundCue({
+			assetName,
+			connections,
+			nodes,
+			packagePath,
+			projectId,
+			rootNodeId
+		}, dependencies));
+	});
+	server.registerTool("create_metasound", {
+		description: "Create a MetaSound Source asset through the engine builder subsystem, which is the supported programmatic surface and produces an asset that opens cleanly in the MetaSound editor. Populate it with set_metasound_graph.",
+		inputSchema: createMetasoundInputSchema,
+		title: "Create MetaSound"
+	}, async ({ assetName, outputFormat, packagePath, projectId }) => {
+		return toToolSuccess(await createMetasound({
+			assetName,
+			outputFormat,
+			packagePath,
+			projectId
+		}, dependencies));
+	});
+	server.registerTool("set_metasound_graph", {
+		description: "Declare a MetaSound Source's inputs and outputs, add nodes and wire them, through the builder subsystem rather than by editing the frontend document — the document layer changes between engine versions and produces assets that fail to open. A declared float input is what a component can drive at runtime with SetFloatParameter.",
+		inputSchema: setMetasoundGraphInputSchema,
+		title: "Set MetaSound Graph"
+	}, async ({ assetPath, connections, inputs, nodes, outputs, projectId }) => {
+		return toToolSuccess(await setMetasoundGraph({
+			assetPath,
+			connections,
+			inputs,
+			nodes,
+			outputs,
+			projectId
+		}, dependencies));
+	});
 }
 async function listActors(input, dependencies) {
 	const normalizedProjectId = projectIdSchema.parse(input.projectId);
@@ -11283,6 +13290,10 @@ async function pollJobStatus(kind, jobId, projectId, dependencies) {
 			createClassJobId: jobId,
 			projectId
 		}, dependencies);
+		case "import": return await getImportJobStatus({
+			importJobId: jobId,
+			projectId
+		}, dependencies);
 		case "pie": return await getPieStatus({
 			pieSessionId: jobId,
 			projectId
@@ -11302,6 +13313,7 @@ function classifyJobStatus(kind, status) {
 		case "build": return status.state === "running" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
 		case "compile": return status.state === "compiling" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
 		case "create_class": return status.state === "creating" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
+		case "import": return status.state === "running" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
 		case "pie": return status.state === "starting" ? "pending" : "completed";
 		case "source_control": return status.state === "running" ? "pending" : toTerminalOutcome(status.state === "unknown_job");
 		case "test_run": return status.state === "running" ? "pending" : toTerminalOutcome(status.state === "unknown_run");
@@ -11832,6 +13844,342 @@ const buildHlodInputSchema = {
 	projectId: creativeProjectIdSchema
 };
 const buildOnlyInputSchema = { projectId: creativeProjectIdSchema };
+const getAssetPropertyInputSchema = {
+	assetPath: bridgeGetAssetPropertyRequestSchema.shape.assetPath.describe("Package name or object path of the asset to read (e.g. /Game/Materials/M_Rock or /Game/BP/BP_Player.BP_Player_C for a Blueprint CDO)."),
+	projectId: creativeProjectIdSchema,
+	propertyPath: bridgeGetAssetPropertyRequestSchema.shape.propertyPath.describe("Reflected property path on the asset, dotted for nested structs and subscripted for arrays: 'TwoSided', 'BuildSettings.bRecomputeNormals', 'Modifiers[0].Weight'.")
+};
+const setAssetPropertyInputSchema = {
+	assetPath: bridgeSetAssetPropertyRequestSchema.shape.assetPath.describe("Package name or object path of the asset to write."),
+	projectId: creativeProjectIdSchema,
+	properties: bridgeSetAssetPropertyRequestSchema.shape.properties.describe(`Up to ${String(32)} { propertyPath, value } writes applied in one transaction. value is ExportText — exactly the spelling get_asset_property returns.`)
+};
+const arrayPropertyOpInputSchema = {
+	assetPath: bridgeArrayPropertyOpRequestFieldsSchema.shape.assetPath.describe("Package name or object path of the asset holding the array."),
+	index: bridgeArrayPropertyOpRequestFieldsSchema.shape.index.describe("Element index. Required for 'insert' and 'remove'; ignored by 'add' and rejected on 'clear'."),
+	operation: bridgeArrayPropertyOpRequestFieldsSchema.shape.operation.describe("What to do to the array: 'add' appends, 'insert' places at index, 'remove' drops the element at index, 'clear' empties it."),
+	projectId: creativeProjectIdSchema,
+	propertyPath: bridgeArrayPropertyOpRequestFieldsSchema.shape.propertyPath.describe("Reflected path of the array property itself, not of an element."),
+	value: bridgeArrayPropertyOpRequestFieldsSchema.shape.value.describe("ExportText for the new element. Required for 'add' and 'insert'.")
+};
+const createStructInputSchema = {
+	assetName: bridgeCreateStructRequestSchema.shape.assetName.describe("Name of the new struct asset, e.g. 'S_WeaponRow'."),
+	description: bridgeCreateStructRequestSchema.shape.description.describe("Tooltip shown for the struct in the editor."),
+	fields: bridgeCreateStructRequestSchema.shape.fields.describe(`Up to ${String(64)} { name, type, defaultValue? } fields. type uses the shared type spec: { kind, container?, subtype?, keyKind?, keySubtype? }.`),
+	packagePath: bridgeCreateStructRequestSchema.shape.packagePath.describe("Content folder to create the struct in, e.g. /Game/Data."),
+	projectId: creativeProjectIdSchema
+};
+const createEnumInputSchema = {
+	assetName: bridgeCreateEnumRequestSchema.shape.assetName.describe("Name of the new enum asset, e.g. 'E_DamageType'."),
+	description: bridgeCreateEnumRequestSchema.shape.description.describe("Tooltip shown for the enum in the editor."),
+	entries: bridgeCreateEnumRequestSchema.shape.entries.describe(`Up to ${String(128)} { name, displayName?, description? } entries, in declaration order.`),
+	packagePath: bridgeCreateEnumRequestSchema.shape.packagePath.describe("Content folder to create the enum in."),
+	projectId: creativeProjectIdSchema
+};
+const createBlueprintInputSchema = {
+	assetName: bridgeCreateBlueprintRequestSchema.shape.assetName.describe("Name of the new Blueprint, e.g. 'BP_Player'."),
+	blueprintKind: bridgeCreateBlueprintRequestSchema.shape.blueprintKind.describe("What kind of Blueprint to create. Defaults to 'normal', which is what the Content Browser's Blueprint Class entry produces."),
+	packagePath: bridgeCreateBlueprintRequestSchema.shape.packagePath.describe("Content folder to create the Blueprint in."),
+	parentClass: bridgeCreateBlueprintRequestSchema.shape.parentClass.describe("Class to derive from: a native class path ('/Script/Engine.Actor') or another Blueprint's generated class ('/Game/BP/BP_Base.BP_Base_C')."),
+	projectId: creativeProjectIdSchema
+};
+const addBpVariableInputSchema = {
+	assetPath: bridgeAddBpVariableRequestSchema.shape.assetPath.describe("Object path of the Blueprint asset to add variables to."),
+	projectId: creativeProjectIdSchema,
+	variables: bridgeAddBpVariableRequestSchema.shape.variables.describe(`Up to ${String(32)} variables. Each carries { name, type, defaultValue?, category?, instanceEditable?, exposeOnSpawn?, replication?, tooltip? }.`)
+};
+const addBpFunctionInputSchema = {
+	assetPath: bridgeAddBpFunctionRequestSchema.shape.assetPath.describe("Object path of the Blueprint asset to add functions to."),
+	functions: bridgeAddBpFunctionRequestSchema.shape.functions.describe("Functions to create, each with { name, inputs, outputs, pure?, category? }. Creates the graph and its entry/result nodes only — fill the body with the graph tools."),
+	projectId: creativeProjectIdSchema
+};
+const addBpEventInputSchema = {
+	assetPath: bridgeAddBpEventRequestSchema.shape.assetPath.describe("Object path of the Blueprint asset to add event nodes to."),
+	events: bridgeAddBpEventRequestSchema.shape.events.describe("Events to place. eventKind 'override' places a node for a function the parent already declares (BeginPlay, Tick); 'custom' adds a custom event with the inputs given."),
+	graphName: bridgeAddBpEventRequestSchema.shape.graphName.describe("Graph to place the nodes in. Defaults to the Blueprint's EventGraph."),
+	projectId: creativeProjectIdSchema
+};
+const addBpComponentInputSchema = {
+	assetPath: bridgeAddBpComponentRequestSchema.shape.assetPath.describe("Object path of the Blueprint asset to add components to."),
+	components: bridgeAddBpComponentRequestSchema.shape.components.describe("Components to add to the construction script, each with { componentClass, name, parentComponent?, transform? }. parentComponent names an existing component to attach under."),
+	projectId: creativeProjectIdSchema
+};
+const addBpInterfaceInputSchema = {
+	assetPath: bridgeAddBpInterfaceRequestSchema.shape.assetPath.describe("Object path of the Blueprint asset to implement the interfaces on."),
+	interfacePaths: bridgeAddBpInterfaceRequestSchema.shape.interfacePaths.describe("Interfaces to implement: a Blueprint interface's generated class path ('/Game/I/BPI_Use.BPI_Use_C') or a native one ('/Script/Module.UMyInterface')."),
+	projectId: creativeProjectIdSchema
+};
+const setBpDefaultInputSchema = {
+	assetPath: bridgeSetBpDefaultRequestSchema.shape.assetPath.describe("Object path of the Blueprint asset whose class defaults to write."),
+	projectId: creativeProjectIdSchema,
+	properties: bridgeSetBpDefaultRequestSchema.shape.properties.describe("{ propertyPath, value } writes applied to the Blueprint class default object, using the same paths and ExportText values set_asset_property takes.")
+};
+const batchEditInputSchema = {
+	dryRun: bridgeBatchEditRequestSchema.shape.dryRun.describe("Resolve every op and report what would change without opening a transaction or touching the level."),
+	ops: bridgeBatchEditRequestSchema.shape.ops.describe(`Ordered ops (max ${String(64)}), each discriminated by op: spawn, destroy, transform, property, attach, place, tag. A spawn or place op may carry a handle; later ops reference it as 'handle:<name>' in actorRef, childRef or parentRef.`),
+	projectId: creativeProjectIdSchema,
+	transactionTitle: bridgeBatchEditRequestSchema.shape.transactionTitle.describe("What the editor's Undo History shows for the whole batch.")
+};
+const importAssetInputSchema = {
+	destinationPath: bridgeImportAssetRequestSchema.shape.destinationPath.describe("Content folder the imported assets land in, e.g. /Game/Meshes."),
+	pipeline: bridgeImportAssetRequestSchema.shape.pipeline.describe("Which import path to use. 'auto' picks per engine version and file type; 'interchange' and 'legacy_factory' force one."),
+	presetName: bridgeImportAssetRequestSchema.shape.presetName.describe("Name of a preset previously stored with set_import_settings. Omitted uses the engine defaults for the file type."),
+	projectId: creativeProjectIdSchema,
+	replaceExisting: bridgeImportAssetRequestSchema.shape.replaceExisting.describe("Overwrite an asset already at the destination. Defaults false so an import cannot silently replace edited content."),
+	sourceFiles: bridgeImportAssetRequestSchema.shape.sourceFiles.describe(`Absolute paths of the files to import (max ${String(16)}), readable by the editor process.`)
+};
+const reimportAssetInputSchema = {
+	assetPaths: bridgeReimportAssetRequestSchema.shape.assetPaths.describe("Object paths of assets to re-read from the source files they were imported from."),
+	projectId: creativeProjectIdSchema
+};
+const setImportSettingsInputSchema = {
+	presetName: bridgeSetImportSettingsRequestSchema.shape.presetName.describe("Name to store the preset under, then passed to import_asset."),
+	projectId: creativeProjectIdSchema,
+	settings: bridgeSetImportSettingsRequestSchema.shape.settings.describe("Reflected property names on the import pipeline or factory, valued as ExportText: { 'bCombineMeshes': 'true', 'bImportTextures': 'false' }.")
+};
+const getImportJobStatusInputSchema = {
+	importJobId: bridgeGetImportJobStatusRequestSchema.shape.importJobId.describe("importJobId returned by import_asset or reimport_asset."),
+	projectId: creativeProjectIdSchema
+};
+const createBlackboardInputSchema = {
+	assetName: bridgeCreateBlackboardRequestSchema.shape.assetName.describe("Name of the new blackboard, e.g. 'BB_Guard'."),
+	keys: bridgeCreateBlackboardRequestSchema.shape.keys.describe("Keys to create with the asset. Each is { keyName, keyType, baseClass?, enumPath?, instanceSynced?, description? }."),
+	packagePath: bridgeCreateBlackboardRequestSchema.shape.packagePath.describe("Content folder to create the blackboard in."),
+	parentBlackboardPath: bridgeCreateBlackboardRequestSchema.shape.parentBlackboardPath.describe("Blackboard to inherit keys from. Inherited keys are reported separately and must not be redeclared locally."),
+	projectId: creativeProjectIdSchema
+};
+const setBlackboardKeysInputSchema = {
+	assetPath: bridgeSetBlackboardKeysRequestSchema.shape.assetPath.describe("Object path of the blackboard asset to edit."),
+	keys: bridgeSetBlackboardKeysRequestSchema.shape.keys.describe("Keys to write. An 'object' or 'class' key must carry baseClass; an 'enum' key must carry enumPath, or it will never match anything at runtime."),
+	mode: bridgeSetBlackboardKeysRequestSchema.shape.mode.describe("'merge' adds or updates the named keys and leaves the rest; 'replace' makes the local key list exactly what was sent, which is the only way to remove one."),
+	projectId: creativeProjectIdSchema
+};
+const createEqsQueryInputSchema = {
+	assetName: bridgeCreateEqsQueryRequestSchema.shape.assetName.describe("Name of the new query, e.g. 'EQS_FindCover'."),
+	generator: bridgeCreateEqsQueryRequestSchema.shape.generator.describe("The query's generator: { generatorClass, params }. generatorClass is a path such as '/Script/AIModule.EnvQueryGenerator_SimpleGrid'."),
+	packagePath: bridgeCreateEqsQueryRequestSchema.shape.packagePath.describe("Content folder to create the query in."),
+	projectId: creativeProjectIdSchema,
+	tests: bridgeCreateEqsQueryRequestSchema.shape.tests.describe("Tests applied to the generated items, each { testClass, purpose?, params? }. purpose is 'filter', 'score' or 'filter_and_score'.")
+};
+const createStateTreeInputSchema = {
+	assetName: bridgeCreateStateTreeRequestFieldsSchema.shape.assetName.describe("Name of the new StateTree, e.g. 'ST_Guard'."),
+	packagePath: bridgeCreateStateTreeRequestFieldsSchema.shape.packagePath.describe("Content folder to create the StateTree in."),
+	projectId: creativeProjectIdSchema,
+	schema: bridgeCreateStateTreeRequestFieldsSchema.shape.schema.describe("Which schema the tree is bound to. This cannot be changed later without invalidating every node, so pick the one matching where the tree will run."),
+	schemaClass: bridgeCreateStateTreeRequestFieldsSchema.shape.schemaClass.describe("Class path of a custom schema. Required when schema is 'custom'.")
+};
+const addStateTreeStateInputSchema = {
+	assetPath: bridgeAddStateTreeStateRequestSchema.shape.assetPath.describe("Object path of the StateTree asset to add states to."),
+	compile: bridgeAddStateTreeStateRequestSchema.shape.compile.describe("Run the StateTree compiler after the edit. Defaults true — an uncompiled tree fails at runtime rather than in the editor."),
+	projectId: creativeProjectIdSchema,
+	states: bridgeAddStateTreeStateRequestSchema.shape.states.describe("States to add, each { name, parentStateName?, stateType?, enterConditions?, tasks?, transitions? }. Parents must already exist or appear earlier in this same list.")
+};
+const createLevelSequenceInputSchema = {
+	assetName: bridgeCreateLevelSequenceRequestSchema.shape.assetName.describe("Name of the new sequence, e.g. 'LS_Intro'."),
+	displayRate: bridgeCreateLevelSequenceRequestSchema.shape.displayRate.describe("Editor frame rate as an exact rational { numerator, denominator } — 30000/1001 for 29.97. Omitted uses the project default."),
+	durationInFrames: bridgeCreateLevelSequenceRequestSchema.shape.durationInFrames.describe("Playback range length in display-rate frames."),
+	packagePath: bridgeCreateLevelSequenceRequestSchema.shape.packagePath.describe("Content folder to create the sequence in."),
+	projectId: creativeProjectIdSchema,
+	tickResolution: bridgeCreateLevelSequenceRequestSchema.shape.tickResolution.describe("Internal storage resolution as an exact rational. Every key time is stored in this rate, not in display rate.")
+};
+const addSequenceBindingInputSchema = {
+	assetPath: bridgeAddSequenceBindingRequestSchema.shape.assetPath.describe("Object path of the Level Sequence asset."),
+	bindings: bridgeAddSequenceBindingRequestSchema.shape.bindings.describe("Bindings to add. A 'possessable' binds an actor already in the level and needs actorPath; a 'spawnable' carries its own template and needs actorPath or objectClassPath."),
+	projectId: creativeProjectIdSchema
+};
+const addSequenceTrackInputSchema = {
+	assetPath: bridgeAddSequenceTrackRequestFieldsSchema.shape.assetPath.describe("Object path of the Level Sequence asset."),
+	bindingId: bridgeAddSequenceTrackRequestFieldsSchema.shape.bindingId.describe("bindingId from add_sequence_binding. Required for every track kind except 'camera_cut', which belongs to the sequence itself."),
+	projectId: creativeProjectIdSchema,
+	propertyPath: bridgeAddSequenceTrackRequestFieldsSchema.shape.propertyPath.describe("Property a 'property' track animates, e.g. 'Intensity' on a light component."),
+	sectionEndFrame: bridgeAddSequenceTrackRequestFieldsSchema.shape.sectionEndFrame.describe("Section end in the sequence's tick resolution. Omitted fills the playback range."),
+	sectionStartFrame: bridgeAddSequenceTrackRequestFieldsSchema.shape.sectionStartFrame.describe("Section start in the sequence's tick resolution."),
+	trackKind: bridgeAddSequenceTrackRequestFieldsSchema.shape.trackKind.describe("What the track animates.")
+};
+const addSequenceKeysInputSchema = {
+	assetPath: bridgeAddSequenceKeysRequestSchema.shape.assetPath.describe("Object path of the Level Sequence asset."),
+	bindingId: bridgeAddSequenceKeysRequestSchema.shape.bindingId.describe("bindingId the track belongs to. Omitted looks the track up on the sequence itself."),
+	channelName: bridgeAddSequenceKeysRequestSchema.shape.channelName.describe("Channel inside the track, e.g. 'Location.X' on a transform track."),
+	keys: bridgeAddSequenceKeysRequestSchema.shape.keys.describe("Keys to add, each { time, value, interpolation?, arriveTangent?, leaveTangent? }. Tangents are only read for user and break interpolation."),
+	projectId: creativeProjectIdSchema,
+	timeUnit: bridgeAddSequenceKeysRequestSchema.shape.timeUnit.describe("How to read each key's time: 'frames' at the sequence display rate, or 'seconds'. Required — a bare number is ambiguous and lands at the wrong time on a non-default rate."),
+	trackName: bridgeAddSequenceKeysRequestSchema.shape.trackName.describe("trackName returned by add_sequence_track.")
+};
+const addFoliageTypeInputSchema = {
+	assetName: bridgeAddFoliageTypeRequestSchema.shape.assetName.describe("Name of the new foliage type, e.g. 'FT_Grass'."),
+	packagePath: bridgeAddFoliageTypeRequestSchema.shape.packagePath.describe("Content folder to create the foliage type in."),
+	projectId: creativeProjectIdSchema,
+	settings: bridgeAddFoliageTypeRequestSchema.shape.settings.describe("Placement settings. Anything omitted keeps the engine default rather than being zeroed."),
+	staticMeshPath: bridgeAddFoliageTypeRequestSchema.shape.staticMeshPath.describe("Object path of the static mesh this foliage type instances.")
+};
+const paintFoliageInputSchema = {
+	alignToNormal: bridgePaintFoliageRequestFieldsSchema.shape.alignToNormal.describe("Rotate each instance to the surface it landed on. Omitted uses the foliage type setting."),
+	density: bridgePaintFoliageRequestFieldsSchema.shape.density.describe("Instances per 1000x1000 unit square. Required in 'region' mode."),
+	foliageTypePath: bridgePaintFoliageRequestFieldsSchema.shape.foliageTypePath.describe("Object path of the foliage type to place instances of."),
+	mode: bridgePaintFoliageRequestFieldsSchema.shape.mode.describe("'explicit' places exactly the transforms given; 'region' scatters across a box and traces down onto whatever is under it."),
+	projectId: creativeProjectIdSchema,
+	randomSeed: bridgePaintFoliageRequestFieldsSchema.shape.randomSeed.describe("Seed for region scattering, so the same request reproduces the same layout."),
+	region: bridgePaintFoliageRequestFieldsSchema.shape.region.describe("Box to scatter across, plus the vertical span each placement traces through. Required in 'region' mode."),
+	slopeMax: bridgePaintFoliageRequestFieldsSchema.shape.slopeMax.describe("Steepest ground, in degrees from horizontal, an instance may land on."),
+	slopeMin: bridgePaintFoliageRequestFieldsSchema.shape.slopeMin.describe("Shallowest ground an instance may land on."),
+	transforms: bridgePaintFoliageRequestFieldsSchema.shape.transforms.describe(`Exact instance transforms (max ${String(128)}). Required in 'explicit' mode.`)
+};
+const createSoundCueInputSchema = {
+	assetName: bridgeCreateSoundCueRequestFieldsSchema.shape.assetName.describe("Name of the new cue, e.g. 'SC_Footstep'."),
+	connections: bridgeCreateSoundCueRequestFieldsSchema.shape.connections.describe("{ parentNodeId, childNodeId, inputIndex? } wires. Both ends must be nodes declared in this same request."),
+	nodes: bridgeCreateSoundCueRequestFieldsSchema.shape.nodes.describe("Nodes to build the cue from, each { nodeId, nodeKind, wavePath?, params? }. nodeId is caller-supplied so connections can name nodes before the editor creates them."),
+	packagePath: bridgeCreateSoundCueRequestFieldsSchema.shape.packagePath.describe("Content folder to create the cue in."),
+	projectId: creativeProjectIdSchema,
+	rootNodeId: bridgeCreateSoundCueRequestFieldsSchema.shape.rootNodeId.describe("The node wired into the cue's output. Must be one of the nodes in this request.")
+};
+const createMetasoundInputSchema = {
+	assetName: bridgeCreateMetasoundRequestSchema.shape.assetName.describe("Name of the new MetaSound Source, e.g. 'MS_Engine'."),
+	outputFormat: bridgeCreateMetasoundRequestSchema.shape.outputFormat.describe("Channel layout of the source output."),
+	packagePath: bridgeCreateMetasoundRequestSchema.shape.packagePath.describe("Content folder to create the MetaSound in."),
+	projectId: creativeProjectIdSchema
+};
+const setMetasoundGraphInputSchema = {
+	assetPath: bridgeSetMetasoundGraphRequestSchema.shape.assetPath.describe("Object path of the MetaSound Source to edit."),
+	connections: bridgeSetMetasoundGraphRequestSchema.shape.connections.describe("{ fromNodeId, fromOutput, toNodeId, toInput } wires between declared nodes."),
+	inputs: bridgeSetMetasoundGraphRequestSchema.shape.inputs.describe("Graph inputs to declare, each { name, dataType, defaultValue? }. A declared 'Float' input is what a component can drive at runtime."),
+	nodes: bridgeSetMetasoundGraphRequestSchema.shape.nodes.describe("Nodes to add, each { nodeId, nodeClassName, nodeNamespace? }. nodeId is caller-supplied and only used to express connections."),
+	outputs: bridgeSetMetasoundGraphRequestSchema.shape.outputs.describe("Graph outputs to declare, each { name, dataType }."),
+	projectId: creativeProjectIdSchema
+};
+async function getAssetProperty(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeGetAssetPropertyRequest(input.assetPath, input.propertyPath), sendBridgeGetAssetPropertyRequest, BRIDGE_GET_ASSET_PROPERTY_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function setAssetProperty(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSetAssetPropertyRequest(input.assetPath, input.properties), sendBridgeSetAssetPropertyRequest, BRIDGE_SET_ASSET_PROPERTY_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function arrayPropertyOp(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeArrayPropertyOpRequest(input.assetPath, input.propertyPath, input.operation, {
+		index: input.index,
+		value: input.value
+	}), sendBridgeArrayPropertyOpRequest, BRIDGE_ARRAY_PROPERTY_OP_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function createStruct(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateStructRequest(input.assetName, input.packagePath, {
+		description: input.description,
+		fields: input.fields
+	}), sendBridgeCreateStructRequest, BRIDGE_CREATE_STRUCT_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function createEnum(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateEnumRequest(input.assetName, input.packagePath, input.entries, { description: input.description }), sendBridgeCreateEnumRequest, BRIDGE_CREATE_ENUM_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function createBlueprint(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateBlueprintRequest(input.assetName, input.packagePath, input.parentClass, { blueprintKind: input.blueprintKind }), sendBridgeCreateBlueprintRequest, BRIDGE_CREATE_BLUEPRINT_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addBpVariable(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddBpVariableRequest(input.assetPath, input.variables), sendBridgeAddBpVariableRequest, BRIDGE_ADD_BP_VARIABLE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addBpFunction(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddBpFunctionRequest(input.assetPath, input.functions), sendBridgeAddBpFunctionRequest, BRIDGE_ADD_BP_FUNCTION_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addBpEvent(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddBpEventRequest(input.assetPath, input.events, { graphName: input.graphName }), sendBridgeAddBpEventRequest, BRIDGE_ADD_BP_EVENT_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addBpComponent(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddBpComponentRequest(input.assetPath, input.components), sendBridgeAddBpComponentRequest, BRIDGE_ADD_BP_COMPONENT_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addBpInterface(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddBpInterfaceRequest(input.assetPath, input.interfacePaths), sendBridgeAddBpInterfaceRequest, BRIDGE_ADD_BP_INTERFACE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function setBpDefault(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSetBpDefaultRequest(input.assetPath, input.properties), sendBridgeSetBpDefaultRequest, BRIDGE_SET_BP_DEFAULT_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function batchEdit(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeBatchEditRequest(input.ops, {
+		dryRun: input.dryRun,
+		transactionTitle: input.transactionTitle
+	}), sendBridgeBatchEditRequest, BRIDGE_BATCH_EDIT_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function importAsset(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeImportAssetRequest(input.sourceFiles, input.destinationPath, {
+		pipeline: input.pipeline,
+		presetName: input.presetName,
+		replaceExisting: input.replaceExisting
+	}), sendBridgeImportAssetRequest, BRIDGE_IMPORT_ASSET_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function reimportAsset(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeReimportAssetRequest(input.assetPaths), sendBridgeReimportAssetRequest, BRIDGE_REIMPORT_ASSET_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function setImportSettings(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSetImportSettingsRequest(input.presetName, input.settings), sendBridgeSetImportSettingsRequest, BRIDGE_SET_IMPORT_SETTINGS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function getImportJobStatus(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeGetImportJobStatusRequest(input.importJobId), sendBridgeGetImportJobStatusRequest, BRIDGE_GET_IMPORT_JOB_STATUS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function createBlackboard(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateBlackboardRequest(input.assetName, input.packagePath, {
+		keys: input.keys,
+		parentBlackboardPath: input.parentBlackboardPath
+	}), sendBridgeCreateBlackboardRequest, BRIDGE_CREATE_BLACKBOARD_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function setBlackboardKeys(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSetBlackboardKeysRequest(input.assetPath, input.keys, { mode: input.mode }), sendBridgeSetBlackboardKeysRequest, BRIDGE_SET_BLACKBOARD_KEYS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function createEqsQuery(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateEqsQueryRequest(input.assetName, input.packagePath, input.generator, { tests: input.tests }), sendBridgeCreateEqsQueryRequest, BRIDGE_CREATE_EQS_QUERY_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function createStateTree(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateStateTreeRequest(input.assetName, input.packagePath, {
+		schema: input.schema,
+		schemaClass: input.schemaClass
+	}), sendBridgeCreateStateTreeRequest, BRIDGE_CREATE_STATE_TREE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addStateTreeState(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddStateTreeStateRequest(input.assetPath, input.states, { compile: input.compile }), sendBridgeAddStateTreeStateRequest, BRIDGE_ADD_STATE_TREE_STATE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function createLevelSequence(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateLevelSequenceRequest(input.assetName, input.packagePath, {
+		displayRate: input.displayRate,
+		durationInFrames: input.durationInFrames,
+		tickResolution: input.tickResolution
+	}), sendBridgeCreateLevelSequenceRequest, BRIDGE_CREATE_LEVEL_SEQUENCE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addSequenceBinding(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddSequenceBindingRequest(input.assetPath, input.bindings), sendBridgeAddSequenceBindingRequest, BRIDGE_ADD_SEQUENCE_BINDING_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addSequenceTrack(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddSequenceTrackRequest(input.assetPath, input.trackKind, {
+		bindingId: input.bindingId,
+		propertyPath: input.propertyPath,
+		sectionEndFrame: input.sectionEndFrame,
+		sectionStartFrame: input.sectionStartFrame
+	}), sendBridgeAddSequenceTrackRequest, BRIDGE_ADD_SEQUENCE_TRACK_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addSequenceKeys(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddSequenceKeysRequest(input.assetPath, input.trackName, input.channelName, input.timeUnit, input.keys, { bindingId: input.bindingId }), sendBridgeAddSequenceKeysRequest, BRIDGE_ADD_SEQUENCE_KEYS_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function addFoliageType(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeAddFoliageTypeRequest(input.assetName, input.packagePath, input.staticMeshPath, { settings: input.settings }), sendBridgeAddFoliageTypeRequest, BRIDGE_ADD_FOLIAGE_TYPE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function paintFoliage(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgePaintFoliageRequest(input.foliageTypePath, input.mode, {
+		alignToNormal: input.alignToNormal,
+		density: input.density,
+		randomSeed: input.randomSeed,
+		region: input.region,
+		slopeMax: input.slopeMax,
+		slopeMin: input.slopeMin,
+		transforms: input.transforms
+	}), sendBridgePaintFoliageRequest, BRIDGE_PAINT_FOLIAGE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function createSoundCue(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateSoundCueRequest(input.assetName, input.packagePath, input.nodes, input.rootNodeId, { connections: input.connections }), sendBridgeCreateSoundCueRequest, BRIDGE_CREATE_SOUND_CUE_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function createMetasound(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeCreateMetasoundRequest(input.assetName, input.packagePath, { outputFormat: input.outputFormat }), sendBridgeCreateMetasoundRequest, BRIDGE_CREATE_METASOUND_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
+async function setMetasoundGraph(input, dependencies) {
+	return await exchangeCreativeRequest(createBridgeSetMetasoundGraphRequest(input.assetPath, {
+		connections: input.connections,
+		inputs: input.inputs,
+		nodes: input.nodes,
+		outputs: input.outputs
+	}), sendBridgeSetMetasoundGraphRequest, BRIDGE_SET_METASOUND_GRAPH_REQUEST_TYPE, projectIdSchema.parse(input.projectId), dependencies);
+}
 //#endregion
 //#region src/projectId.ts
 const GENERAL_PROJECT_SETTINGS_SECTION = "[/Script/EngineSettings.GeneralProjectSettings]";
@@ -12049,7 +14397,7 @@ function isMissingFileError(error) {
 //#endregion
 //#region src/server.ts
 const SERVER_NAME = "ue-mcp-server";
-const SERVER_VERSION = "1.3.0";
+const SERVER_VERSION = "1.4.0";
 const logger = createModuleLogger("bootstrap");
 const enginePingLogger = createModuleLogger("engine-ping");
 const httpApiLogger = createModuleLogger("http-api");