@skillcap/gdh 3.2.3 → 4.1.0

package/node_modules/@gdh/core/dist/editor-operation-runner.js

@@ -58,6 +58,34 @@ func _dispatch_operation(operation: Dictionary) -> Dictionary:
 			return _resource_properties(operation)
 		"resource.set_property":
 			return _resource_set_property(operation)
+		"animation.player.inspect":
+			return _animation_player_inspect(operation)
+		"animation.clip.create":
+			return _animation_clip_create(operation)
+		"animation.clip.read":
+			return _animation_clip_read(operation)
+		"animation.clip.delete":
+			return _animation_clip_delete(operation)
+		"animation.track.add":
+			return _animation_track_add(operation)
+		"animation.track.remove":
+			return _animation_track_remove(operation)
+		"animation.keyframe.upsert":
+			return _animation_keyframe_upsert(operation)
+		"animation.keyframe.delete":
+			return _animation_keyframe_delete(operation)
+		"animation.state_machine.create":
+			return _animation_state_machine_create(operation)
+		"animation.state_machine.read":
+			return _animation_state_machine_read(operation)
+		"animation.state_machine.node.upsert":
+			return _animation_state_machine_node_upsert(operation)
+		"animation.state_machine.node.delete":
+			return _animation_state_machine_node_delete(operation)
+		"animation.state_machine.transition.upsert":
+			return _animation_state_machine_transition_upsert(operation)
+		"animation.state_machine.transition.delete":
+			return _animation_state_machine_transition_delete(operation)
 		"script.attach":
 			return _script_attach(operation)
 		"class.search":
@@ -314,6 +342,287 @@ func _resource_set_property(operation: Dictionary) -> Dictionary:
 		return _failure("Failed to save resource: " + resource_path, ["resource_save_failed"])
 	return _success("Resource property set.", {"resourcePath": resource_path, "propertyName": property_name})
 
+func _animation_player_inspect(operation: Dictionary) -> Dictionary:
+	var loaded := _load_animation_player_context(operation)
+	if not loaded.get("ok", false):
+		return loaded
+	var player = loaded["player"]
+	var libraries := []
+	if player.has_method("get_animation_library_list"):
+		for library_name in player.get_animation_library_list():
+			var library = player.get_animation_library(library_name)
+			if library == null:
+				continue
+			var animations := []
+			for animation_name in library.get_animation_list():
+				var animation = library.get_animation(animation_name)
+				animations.append(_animation_clip_summary(str(library_name), str(animation_name), animation))
+			libraries.append({"name": str(library_name), "animations": animations})
+	var output := {
+		"scenePath": loaded["scenePath"],
+		"animationPlayerPath": loaded["animationPlayerPath"],
+		"class": player.get_class(),
+		"autoplay": str(player.get("autoplay")),
+		"defaultBlendTime": player.get("playback_default_blend_time"),
+		"libraries": libraries,
+	}
+	loaded["root"].queue_free()
+	return _success("Animation player inspected.", output)
+
+func _animation_clip_create(operation: Dictionary) -> Dictionary:
+	var loaded := _load_animation_player_context(operation)
+	if not loaded.get("ok", false):
+		return loaded
+	var player = loaded["player"]
+	var library_name := str(operation.get("libraryName", ""))
+	var animation_name := str(operation.get("animationName", ""))
+	var library = _get_or_create_animation_library(player, library_name)
+	if library == null:
+		return _failure("Animation library could not be created: " + library_name, ["animation_library_unavailable"])
+	if library.has_animation(animation_name) and not bool(operation.get("overwrite", false)):
+		return _failure("Animation already exists: " + animation_name, ["animation_clip_exists"])
+	var animation := Animation.new()
+	animation.length = max(0.001, float(operation.get("length", 1.0)))
+	animation.step = max(0.001, float(operation.get("step", animation.step)))
+	animation.loop_mode = _animation_loop_mode(operation.get("loopMode", animation.loop_mode))
+	if library.has_animation(animation_name):
+		library.remove_animation(animation_name)
+	var add_err = library.add_animation(animation_name, animation)
+	if int(add_err) != OK:
+		return _failure("Animation could not be added: " + animation_name, ["animation_clip_add_failed"])
+	var result := _save_instantiated_scene(loaded["root"], loaded["scenePath"])
+	if not result.get("ok", false):
+		return result
+	return _success("Animation clip created.", {"scenePath": loaded["scenePath"], "animationPlayerPath": loaded["animationPlayerPath"], "libraryName": library_name, "animationName": animation_name, "length": animation.length, "loopMode": animation.loop_mode, "step": animation.step})
+
+func _animation_clip_read(operation: Dictionary) -> Dictionary:
+	var loaded := _load_animation_player_context(operation)
+	if not loaded.get("ok", false):
+		return loaded
+	var resolved := _resolve_animation_clip(loaded["player"], operation)
+	if not resolved.get("ok", false):
+		loaded["root"].queue_free()
+		return resolved
+	var animation: Animation = resolved["animation"]
+	var include_keys := bool(operation.get("includeKeys", false))
+	var key_limit := int(operation.get("keyLimit", 200))
+	var tracks := []
+	for track_index in range(animation.get_track_count()):
+		tracks.append(_animation_track_summary(animation, track_index, include_keys, key_limit))
+	var output := _animation_clip_summary(str(resolved["libraryName"]), str(resolved["animationName"]), animation)
+	output["tracks"] = tracks
+	loaded["root"].queue_free()
+	return _success("Animation clip read.", output)
+
+func _animation_clip_delete(operation: Dictionary) -> Dictionary:
+	var loaded := _load_animation_player_context(operation)
+	if not loaded.get("ok", false):
+		return loaded
+	var library_name := str(operation.get("libraryName", ""))
+	var animation_name := str(operation.get("animationName", ""))
+	var library = _get_animation_library(loaded["player"], library_name)
+	if library == null or not library.has_animation(animation_name):
+		return _failure("Animation clip not found: " + animation_name, ["animation_clip_not_found"])
+	library.remove_animation(animation_name)
+	var result := _save_instantiated_scene(loaded["root"], loaded["scenePath"])
+	if not result.get("ok", false):
+		return result
+	return _success("Animation clip deleted.", {"scenePath": loaded["scenePath"], "animationPlayerPath": loaded["animationPlayerPath"], "libraryName": library_name, "animationName": animation_name})
+
+func _animation_track_add(operation: Dictionary) -> Dictionary:
+	var loaded := _load_animation_player_context(operation)
+	if not loaded.get("ok", false):
+		return loaded
+	var resolved := _resolve_animation_clip(loaded["player"], operation)
+	if not resolved.get("ok", false):
+		return resolved
+	var animation: Animation = resolved["animation"]
+	var track_type := _animation_track_type(operation.get("trackType", "value"))
+	if track_type < 0:
+		return _failure("Unsupported Animation track type: " + str(operation.get("trackType", "")), ["animation_track_type_unsupported"], _operation_help("animation.track.add"))
+	var at_position := int(operation.get("atPosition", -1))
+	var track_index := animation.add_track(track_type, at_position)
+	if track_index < 0:
+		return _failure("Animation track could not be added.", ["animation_track_add_failed"])
+	animation.track_set_path(track_index, NodePath(str(operation.get("trackPath", ""))))
+	if operation.has("interpolation"):
+		animation.track_set_interpolation_type(track_index, _animation_interpolation_type(operation.get("interpolation")))
+	if track_type == Animation.TYPE_VALUE and operation.has("updateMode"):
+		animation.value_track_set_update_mode(track_index, _animation_update_mode(operation.get("updateMode")))
+	var result := _save_instantiated_scene(loaded["root"], loaded["scenePath"])
+	if not result.get("ok", false):
+		return result
+	return _success("Animation track added.", {"scenePath": loaded["scenePath"], "animationPlayerPath": loaded["animationPlayerPath"], "animationName": str(resolved["animationName"]), "trackIndex": track_index, "trackType": track_type, "trackPath": str(animation.track_get_path(track_index))})
+
+func _animation_track_remove(operation: Dictionary) -> Dictionary:
+	var loaded := _load_animation_player_context(operation)
+	if not loaded.get("ok", false):
+		return loaded
+	var resolved := _resolve_animation_clip(loaded["player"], operation)
+	if not resolved.get("ok", false):
+		return resolved
+	var animation: Animation = resolved["animation"]
+	var track_index := int(operation.get("trackIndex", -1))
+	if track_index < 0 or track_index >= animation.get_track_count():
+		return _failure("Animation track index is out of range.", ["animation_track_not_found"])
+	animation.remove_track(track_index)
+	var result := _save_instantiated_scene(loaded["root"], loaded["scenePath"])
+	if not result.get("ok", false):
+		return result
+	return _success("Animation track removed.", {"scenePath": loaded["scenePath"], "animationPlayerPath": loaded["animationPlayerPath"], "animationName": str(resolved["animationName"]), "trackIndex": track_index})
+
+func _animation_keyframe_upsert(operation: Dictionary) -> Dictionary:
+	var loaded := _load_animation_player_context(operation)
+	if not loaded.get("ok", false):
+		return loaded
+	var resolved := _resolve_animation_clip(loaded["player"], operation)
+	if not resolved.get("ok", false):
+		return resolved
+	var animation: Animation = resolved["animation"]
+	var track_index := int(operation.get("trackIndex", -1))
+	if track_index < 0 or track_index >= animation.get_track_count():
+		return _failure("Animation track index is out of range.", ["animation_track_not_found"])
+	var time := float(operation.get("time", 0.0))
+	animation.track_remove_key_at_time(track_index, time)
+	var key_index := _animation_insert_key(animation, track_index, time, operation.get("value"), float(operation.get("transition", 1.0)))
+	if key_index < 0:
+		return _failure("Animation keyframe could not be inserted.", ["animation_keyframe_insert_failed"])
+	var result := _save_instantiated_scene(loaded["root"], loaded["scenePath"])
+	if not result.get("ok", false):
+		return result
+	return _success("Animation keyframe upserted.", {"scenePath": loaded["scenePath"], "animationPlayerPath": loaded["animationPlayerPath"], "animationName": str(resolved["animationName"]), "trackIndex": track_index, "keyIndex": key_index, "time": time})
+
+func _animation_keyframe_delete(operation: Dictionary) -> Dictionary:
+	var loaded := _load_animation_player_context(operation)
+	if not loaded.get("ok", false):
+		return loaded
+	var resolved := _resolve_animation_clip(loaded["player"], operation)
+	if not resolved.get("ok", false):
+		return resolved
+	var animation: Animation = resolved["animation"]
+	var track_index := int(operation.get("trackIndex", -1))
+	if track_index < 0 or track_index >= animation.get_track_count():
+		return _failure("Animation track index is out of range.", ["animation_track_not_found"])
+	var key_index := int(operation.get("keyIndex", -1))
+	if key_index >= 0:
+		if key_index >= animation.track_get_key_count(track_index):
+			return _failure("Animation key index is out of range.", ["animation_keyframe_not_found"])
+		animation.track_remove_key(track_index, key_index)
+	elif operation.has("time"):
+		animation.track_remove_key_at_time(track_index, float(operation.get("time", 0.0)))
+	else:
+		return _failure("animation.keyframe.delete requires keyIndex or time.", ["animation_keyframe_selector_missing"])
+	var result := _save_instantiated_scene(loaded["root"], loaded["scenePath"])
+	if not result.get("ok", false):
+		return result
+	return _success("Animation keyframe deleted.", {"scenePath": loaded["scenePath"], "animationPlayerPath": loaded["animationPlayerPath"], "animationName": str(resolved["animationName"]), "trackIndex": track_index})
+
+func _animation_state_machine_create(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	var root = _load_scene_root(scene_path)
+	if root == null:
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	var tree_path := str(operation.get("animationTreePath", ""))
+	var tree = _find_node(root, tree_path)
+	if tree == null:
+		root.queue_free()
+		return _failure("AnimationTree not found: " + tree_path, ["animation_tree_not_found"])
+	if not (tree is AnimationTree):
+		root.queue_free()
+		return _failure("Node is not an AnimationTree: " + tree_path, ["animation_tree_invalid"])
+	var existing = tree.get("tree_root")
+	if existing != null and existing is AnimationNodeStateMachine and not bool(operation.get("overwrite", false)):
+		root.queue_free()
+		return _failure("AnimationTree already has an AnimationNodeStateMachine tree_root.", ["animation_state_machine_exists"])
+	var machine := AnimationNodeStateMachine.new()
+	_set_properties(machine, operation.get("properties", {}))
+	tree.set("tree_root", machine)
+	var result := _save_instantiated_scene(root, scene_path)
+	if not result.get("ok", false):
+		return result
+	return _success("Animation state machine created.", {"scenePath": scene_path, "animationTreePath": tree_path})
+
+func _animation_state_machine_read(operation: Dictionary) -> Dictionary:
+	var loaded := _load_state_machine_context(operation)
+	if not loaded.get("ok", false):
+		return loaded
+	var output := _state_machine_summary(loaded["stateMachine"])
+	output["scenePath"] = loaded["scenePath"]
+	output["animationTreePath"] = loaded["animationTreePath"]
+	loaded["root"].queue_free()
+	return _success("Animation state machine read.", output)
+
+func _animation_state_machine_node_upsert(operation: Dictionary) -> Dictionary:
+	var loaded := _load_state_machine_context(operation)
+	if not loaded.get("ok", false):
+		return loaded
+	var machine: AnimationNodeStateMachine = loaded["stateMachine"]
+	var state_name := str(operation.get("stateName", ""))
+	var graph_node = machine.get_node(state_name) if machine.has_node(state_name) else null
+	var created := false
+	if graph_node == null:
+		var node_type := str(operation.get("nodeType", "AnimationNodeAnimation"))
+		graph_node = _instantiate(node_type)
+		if graph_node == null or not (graph_node is AnimationNode):
+			return _failure("Unable to instantiate animation graph node type: " + node_type, ["animation_graph_node_type_invalid"])
+		machine.add_node(state_name, graph_node, _decode_value(operation.get("position", {"$vector2": {"x": 0, "y": 0}})))
+		created = true
+	_set_properties(graph_node, operation.get("properties", {}))
+	if operation.has("position"):
+		machine.set_node_position(state_name, _decode_value(operation.get("position")))
+	var result := _save_instantiated_scene(loaded["root"], loaded["scenePath"])
+	if not result.get("ok", false):
+		return result
+	return _success("Animation state-machine node upserted.", {"scenePath": loaded["scenePath"], "animationTreePath": loaded["animationTreePath"], "stateName": state_name, "created": created})
+
+func _animation_state_machine_node_delete(operation: Dictionary) -> Dictionary:
+	var loaded := _load_state_machine_context(operation)
+	if not loaded.get("ok", false):
+		return loaded
+	var machine: AnimationNodeStateMachine = loaded["stateMachine"]
+	var state_name := str(operation.get("stateName", ""))
+	if not machine.has_node(state_name):
+		return _failure("Animation state-machine node not found: " + state_name, ["animation_graph_node_not_found"])
+	machine.remove_node(state_name)
+	var result := _save_instantiated_scene(loaded["root"], loaded["scenePath"])
+	if not result.get("ok", false):
+		return result
+	return _success("Animation state-machine node deleted.", {"scenePath": loaded["scenePath"], "animationTreePath": loaded["animationTreePath"], "stateName": state_name})
+
+func _animation_state_machine_transition_upsert(operation: Dictionary) -> Dictionary:
+	var loaded := _load_state_machine_context(operation)
+	if not loaded.get("ok", false):
+		return loaded
+	var machine: AnimationNodeStateMachine = loaded["stateMachine"]
+	var from_state := str(operation.get("fromState", ""))
+	var to_state := str(operation.get("toState", ""))
+	if not machine.has_node(from_state) or not machine.has_node(to_state):
+		return _failure("Animation state-machine transition endpoints must both exist.", ["animation_graph_endpoint_not_found"])
+	if machine.has_transition(from_state, to_state):
+		machine.remove_transition(from_state, to_state)
+	var transition := AnimationNodeStateMachineTransition.new()
+	_set_properties(transition, operation.get("properties", {}))
+	machine.add_transition(from_state, to_state, transition)
+	var result := _save_instantiated_scene(loaded["root"], loaded["scenePath"])
+	if not result.get("ok", false):
+		return result
+	return _success("Animation state-machine transition upserted.", {"scenePath": loaded["scenePath"], "animationTreePath": loaded["animationTreePath"], "fromState": from_state, "toState": to_state})
+
+func _animation_state_machine_transition_delete(operation: Dictionary) -> Dictionary:
+	var loaded := _load_state_machine_context(operation)
+	if not loaded.get("ok", false):
+		return loaded
+	var machine: AnimationNodeStateMachine = loaded["stateMachine"]
+	var from_state := str(operation.get("fromState", ""))
+	var to_state := str(operation.get("toState", ""))
+	if not machine.has_transition(from_state, to_state):
+		return _failure("Animation state-machine transition not found.", ["animation_graph_transition_not_found"])
+	machine.remove_transition(from_state, to_state)
+	var result := _save_instantiated_scene(loaded["root"], loaded["scenePath"])
+	if not result.get("ok", false):
+		return result
+	return _success("Animation state-machine transition deleted.", {"scenePath": loaded["scenePath"], "animationTreePath": loaded["animationTreePath"], "fromState": from_state, "toState": to_state})
+
 func _script_attach(operation: Dictionary) -> Dictionary:
 	var scene_path := _res_path(str(operation.get("scenePath", "")))
 	var root = _load_scene_root(scene_path)
@@ -451,6 +760,202 @@ func _batch_apply(operation: Dictionary) -> Dictionary:
 			return _failure("Batch operation failed.", ["batch_child_failed", str(child_operation.get("kind", ""))])
 	return _success("Batch applied.", {"results": results})
 
+func _load_animation_player_context(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	var root = _load_scene_root(scene_path)
+	if root == null:
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	var player_path := str(operation.get("animationPlayerPath", ""))
+	var player = _find_node(root, player_path)
+	if player == null:
+		root.queue_free()
+		return _failure("AnimationPlayer not found: " + player_path, ["animation_player_not_found"])
+	if not player.has_method("get_animation_library") or not player.has_method("get_animation_library_list"):
+		root.queue_free()
+		return _failure("Node is not an animation mixer: " + player_path, ["animation_player_invalid"])
+	return {"ok": true, "root": root, "scenePath": scene_path, "player": player, "animationPlayerPath": player_path}
+
+func _get_animation_library(player, library_name: String):
+	if not player.has_method("has_animation_library") or not player.has_method("get_animation_library"):
+		return null
+	if player.has_animation_library(library_name):
+		return player.get_animation_library(library_name)
+	return null
+
+func _get_or_create_animation_library(player, library_name: String):
+	var library = _get_animation_library(player, library_name)
+	if library != null:
+		return library
+	if not player.has_method("add_animation_library"):
+		return null
+	library = AnimationLibrary.new()
+	var err = player.add_animation_library(library_name, library)
+	if int(err) != OK:
+		return null
+	return library
+
+func _resolve_animation_clip(player, operation: Dictionary) -> Dictionary:
+	var library_name := str(operation.get("libraryName", ""))
+	var animation_name := str(operation.get("animationName", ""))
+	var library = _get_animation_library(player, library_name)
+	if library == null:
+		return _failure("Animation library not found: " + library_name, ["animation_library_not_found"])
+	if not library.has_animation(animation_name):
+		return _failure("Animation clip not found: " + animation_name, ["animation_clip_not_found"])
+	return {"ok": true, "libraryName": library_name, "animationName": animation_name, "library": library, "animation": library.get_animation(animation_name)}
+
+func _animation_clip_summary(library_name: String, animation_name: String, animation: Animation) -> Dictionary:
+	return {"libraryName": library_name, "animationName": animation_name, "length": animation.length, "loopMode": animation.loop_mode, "step": animation.step, "trackCount": animation.get_track_count()}
+
+func _animation_track_summary(animation: Animation, track_index: int, include_keys: bool, key_limit: int) -> Dictionary:
+	var keys := []
+	var key_count := animation.track_get_key_count(track_index)
+	if include_keys:
+		var effective_limit := key_limit if key_limit > 0 else 200
+		for key_index in range(min(key_count, effective_limit)):
+			keys.append({
+				"keyIndex": key_index,
+				"time": animation.track_get_key_time(track_index, key_index),
+				"transition": animation.track_get_key_transition(track_index, key_index),
+				"value": _encode_animation_key_value(animation, track_index, key_index),
+			})
+	return {
+		"trackIndex": track_index,
+		"type": animation.track_get_type(track_index),
+		"path": str(animation.track_get_path(track_index)),
+		"enabled": animation.track_is_enabled(track_index),
+		"imported": animation.track_is_imported(track_index),
+		"interpolation": animation.track_get_interpolation_type(track_index),
+		"keyCount": key_count,
+		"keys": keys,
+		"keysTruncated": include_keys and key_count > keys.size(),
+	}
+
+func _encode_animation_key_value(animation: Animation, track_index: int, key_index: int):
+	var track_type := animation.track_get_type(track_index)
+	if track_type == Animation.TYPE_ANIMATION:
+		return str(animation.animation_track_get_key_animation(track_index, key_index))
+	if track_type == Animation.TYPE_BEZIER:
+		return animation.bezier_track_get_key_value(track_index, key_index)
+	return _encode_value(animation.track_get_key_value(track_index, key_index))
+
+func _animation_insert_key(animation: Animation, track_index: int, time: float, raw_value, transition: float) -> int:
+	var track_type := animation.track_get_type(track_index)
+	var value = _decode_value(raw_value)
+	if track_type == Animation.TYPE_ANIMATION:
+		return animation.animation_track_insert_key(track_index, time, str(raw_value))
+	if track_type == Animation.TYPE_BEZIER:
+		return animation.bezier_track_insert_key(track_index, time, float(raw_value))
+	if track_type == Animation.TYPE_POSITION_3D:
+		return animation.position_track_insert_key(track_index, time, value)
+	if track_type == Animation.TYPE_ROTATION_3D:
+		return animation.rotation_track_insert_key(track_index, time, value)
+	if track_type == Animation.TYPE_SCALE_3D:
+		return animation.scale_track_insert_key(track_index, time, value)
+	if track_type == Animation.TYPE_BLEND_SHAPE:
+		return animation.blend_shape_track_insert_key(track_index, time, float(raw_value))
+	return animation.track_insert_key(track_index, time, value, transition)
+
+func _animation_track_type(value) -> int:
+	if typeof(value) == TYPE_INT or typeof(value) == TYPE_FLOAT:
+		return int(value)
+	match str(value).to_lower():
+		"value", "type_value":
+			return Animation.TYPE_VALUE
+		"position_3d", "position3d", "type_position_3d":
+			return Animation.TYPE_POSITION_3D
+		"rotation_3d", "rotation3d", "type_rotation_3d":
+			return Animation.TYPE_ROTATION_3D
+		"scale_3d", "scale3d", "type_scale_3d":
+			return Animation.TYPE_SCALE_3D
+		"blend_shape", "blendshape", "type_blend_shape":
+			return Animation.TYPE_BLEND_SHAPE
+		"method", "type_method":
+			return Animation.TYPE_METHOD
+		"bezier", "type_bezier":
+			return Animation.TYPE_BEZIER
+		"audio", "type_audio":
+			return Animation.TYPE_AUDIO
+		"animation", "type_animation":
+			return Animation.TYPE_ANIMATION
+		_:
+			return -1
+
+func _animation_interpolation_type(value) -> int:
+	if typeof(value) == TYPE_INT or typeof(value) == TYPE_FLOAT:
+		return int(value)
+	match str(value).to_lower():
+		"nearest":
+			return Animation.INTERPOLATION_NEAREST
+		"cubic":
+			return Animation.INTERPOLATION_CUBIC
+		"linear_angle":
+			return Animation.INTERPOLATION_LINEAR_ANGLE
+		"cubic_angle":
+			return Animation.INTERPOLATION_CUBIC_ANGLE
+		_:
+			return Animation.INTERPOLATION_LINEAR
+
+func _animation_update_mode(value) -> int:
+	if typeof(value) == TYPE_INT or typeof(value) == TYPE_FLOAT:
+		return int(value)
+	match str(value).to_lower():
+		"discrete":
+			return Animation.UPDATE_DISCRETE
+		"capture":
+			return Animation.UPDATE_CAPTURE
+		_:
+			return Animation.UPDATE_CONTINUOUS
+
+func _animation_loop_mode(value) -> int:
+	if typeof(value) == TYPE_INT or typeof(value) == TYPE_FLOAT:
+		return int(value)
+	match str(value).to_lower():
+		"linear", "loop_linear":
+			return Animation.LOOP_LINEAR
+		"pingpong", "ping_pong", "loop_pingpong":
+			return Animation.LOOP_PINGPONG
+		_:
+			return Animation.LOOP_NONE
+
+func _load_state_machine_context(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	var root = _load_scene_root(scene_path)
+	if root == null:
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	var tree_path := str(operation.get("animationTreePath", ""))
+	var tree = _find_node(root, tree_path)
+	if tree == null:
+		root.queue_free()
+		return _failure("AnimationTree not found: " + tree_path, ["animation_tree_not_found"])
+	if not (tree is AnimationTree):
+		root.queue_free()
+		return _failure("Node is not an AnimationTree: " + tree_path, ["animation_tree_invalid"])
+	var state_machine = tree.get("tree_root")
+	if state_machine == null or not (state_machine is AnimationNodeStateMachine):
+		root.queue_free()
+		return _failure("AnimationTree tree_root is not an AnimationNodeStateMachine.", ["animation_state_machine_not_found"])
+	return {"ok": true, "root": root, "scenePath": scene_path, "tree": tree, "animationTreePath": tree_path, "stateMachine": state_machine}
+
+func _state_machine_summary(machine: AnimationNodeStateMachine) -> Dictionary:
+	var nodes := []
+	for state_name in machine.get_node_list():
+		var graph_node = machine.get_node(state_name)
+		nodes.append({"name": str(state_name), "type": graph_node.get_class() if graph_node != null else "", "position": _encode_value(machine.get_node_position(state_name)), "properties": _selected_properties(graph_node, ["animation"]) if graph_node != null else {}})
+	var transitions := []
+	for index in range(machine.get_transition_count()):
+		var transition = machine.get_transition(index)
+		transitions.append({"index": index, "from": str(machine.get_transition_from(index)), "to": str(machine.get_transition_to(index)), "properties": _selected_properties(transition, ["advance_mode", "advance_condition", "xfade_time", "priority", "switch_mode"])})
+	return {"graphOffset": _encode_value(machine.get_graph_offset()), "nodes": nodes, "transitions": transitions}
+
+func _selected_properties(object: Object, names: Array) -> Dictionary:
+	var values := {}
+	if object == null:
+		return values
+	for property_name in names:
+		values[str(property_name)] = _encode_value(object.get(str(property_name)))
+	return values
+
 func _load_scene_root(scene_path: String):
 	var loaded = load(scene_path)
 	if loaded == null or not (loaded is PackedScene):
@@ -492,6 +997,12 @@ func _decode_value(value):
 		if value.has("$vector2"):
 			var vector = value["$vector2"]
 			return Vector2(float(vector.get("x", 0.0)), float(vector.get("y", 0.0)))
+		if value.has("$vector3"):
+			var vector = value["$vector3"]
+			return Vector3(float(vector.get("x", 0.0)), float(vector.get("y", 0.0)), float(vector.get("z", 0.0)))
+		if value.has("$quaternion"):
+			var quaternion = value["$quaternion"]
+			return Quaternion(float(quaternion.get("x", 0.0)), float(quaternion.get("y", 0.0)), float(quaternion.get("z", 0.0)), float(quaternion.get("w", 1.0)))
 		if value.has("$color"):
 			var color = value["$color"]
 			return Color(float(color.get("r", 0.0)), float(color.get("g", 0.0)), float(color.get("b", 0.0)), float(color.get("a", 1.0)))
@@ -504,6 +1015,10 @@ func _encode_value(value, depth := 0):
 		return {"$truncated": "max_depth", "text": str(value)}
 	if value is Vector2:
 		return {"$vector2": {"x": value.x, "y": value.y}}
+	if value is Vector3:
+		return {"$vector3": {"x": value.x, "y": value.y, "z": value.z}}
+	if value is Quaternion:
+		return {"$quaternion": {"x": value.x, "y": value.y, "z": value.z, "w": value.w}}
 	if value is Color:
 		return {"$color": {"r": value.r, "g": value.g, "b": value.b, "a": value.a}}
 	if value is Resource:
@@ -658,13 +1173,27 @@ func _operation_help(kind: String) -> Dictionary:
 		"node.inspect": {"kind": "node.inspect", "scenePath": "res://path/to/scene.tscn", "nodePath": ".", "includePropertyList": true, "propertyLimit": 40},
 		"resource.read": {"kind": "resource.read", "resourcePath": "res://path/to/resource.tres", "propertyNames": ["name"]},
 		"resource.properties": {"kind": "resource.properties", "resourcePath": "res://path/to/resource.tres"},
+		"animation.player.inspect": {"kind": "animation.player.inspect", "scenePath": "res://path/to/scene.tscn", "animationPlayerPath": "AnimationPlayer"},
+		"animation.clip.create": {"kind": "animation.clip.create", "scenePath": "res://path/to/scene.tscn", "animationPlayerPath": "AnimationPlayer", "animationName": "idle", "length": 1.0},
+		"animation.clip.read": {"kind": "animation.clip.read", "scenePath": "res://path/to/scene.tscn", "animationPlayerPath": "AnimationPlayer", "animationName": "idle", "includeKeys": true},
+		"animation.clip.delete": {"kind": "animation.clip.delete", "scenePath": "res://path/to/scene.tscn", "animationPlayerPath": "AnimationPlayer", "animationName": "idle"},
+		"animation.track.add": {"kind": "animation.track.add", "scenePath": "res://path/to/scene.tscn", "animationPlayerPath": "AnimationPlayer", "animationName": "idle", "trackType": "value", "trackPath": "Sprite2D:modulate:a"},
+		"animation.track.remove": {"kind": "animation.track.remove", "scenePath": "res://path/to/scene.tscn", "animationPlayerPath": "AnimationPlayer", "animationName": "idle", "trackIndex": 0},
+		"animation.keyframe.upsert": {"kind": "animation.keyframe.upsert", "scenePath": "res://path/to/scene.tscn", "animationPlayerPath": "AnimationPlayer", "animationName": "idle", "trackIndex": 0, "time": 0.0, "value": 1.0},
+		"animation.keyframe.delete": {"kind": "animation.keyframe.delete", "scenePath": "res://path/to/scene.tscn", "animationPlayerPath": "AnimationPlayer", "animationName": "idle", "trackIndex": 0, "time": 0.0},
+		"animation.state_machine.create": {"kind": "animation.state_machine.create", "scenePath": "res://path/to/scene.tscn", "animationTreePath": "AnimationTree"},
+		"animation.state_machine.read": {"kind": "animation.state_machine.read", "scenePath": "res://path/to/scene.tscn", "animationTreePath": "AnimationTree"},
+		"animation.state_machine.node.upsert": {"kind": "animation.state_machine.node.upsert", "scenePath": "res://path/to/scene.tscn", "animationTreePath": "AnimationTree", "stateName": "Idle", "nodeType": "AnimationNodeAnimation", "properties": {"animation": "idle"}},
+		"animation.state_machine.node.delete": {"kind": "animation.state_machine.node.delete", "scenePath": "res://path/to/scene.tscn", "animationTreePath": "AnimationTree", "stateName": "Idle"},
+		"animation.state_machine.transition.upsert": {"kind": "animation.state_machine.transition.upsert", "scenePath": "res://path/to/scene.tscn", "animationTreePath": "AnimationTree", "fromState": "Idle", "toState": "Run"},
+		"animation.state_machine.transition.delete": {"kind": "animation.state_machine.transition.delete", "scenePath": "res://path/to/scene.tscn", "animationTreePath": "AnimationTree", "fromState": "Idle", "toState": "Run"},
 		"class.search": {"kind": "class.search", "query": "Label"},
 		"class.info": {"kind": "class.info", "className": "Label", "propertyQuery": "text"},
 		"editor.state": {"kind": "editor.state"},
 	}
 	var example = examples.get(kind, {"kind": "editor.state"})
 	return {
-		"usage": "Use editor.operation.run with operation.kind, or prefer focused MCP tools: editor.state, editor.scene.tree, editor.node.inspect, editor.resource.read, editor.resource.properties, editor.class.search, editor.class.info.",
+		"usage": "Use editor.operation.run with operation.kind, or prefer focused MCP tools such as editor.state, editor.scene.tree, editor.node.inspect, editor.resource.read, editor.resource.properties, editor.class.search, editor.class.info, and editor.animation.*.",
 		"helpCommand": "gdh editor operation run --help",
 		"examples": [example],
 	}

package/node_modules/@gdh/core/dist/editor-operation-runner.js.map

@@ -1 +1 @@
-{"version":3,"file":"editor-operation-runner.js","sourceRoot":"","sources":["../src/editor-operation-runner.ts"],"names":[],"mappings":"AAAA,oGAAoG;AACpG,MAAM,UAAU,2BAA2B;IACzC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4pBR,CAAC;AACF,CAAC;AAED,MAAM,UAAU,oCAAoC;IAClD,MAAM,MAAM,GAAG,2BAA2B,EAAE,CAAC;IAC7C,MAAM,MAAM,GAAG,iEAAiE,CAAC;IACjF,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3C,IAAI,WAAW,GAAG,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;IAC5E,CAAC;IACD,OAAO,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;AACnC,CAAC"}
+{"version":3,"file":"editor-operation-runner.js","sourceRoot":"","sources":["../src/editor-operation-runner.ts"],"names":[],"mappings":"AAAA,oGAAoG;AACpG,MAAM,UAAU,2BAA2B;IACzC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6qCR,CAAC;AACF,CAAC;AAED,MAAM,UAAU,oCAAoC;IAClD,MAAM,MAAM,GAAG,2BAA2B,EAAE,CAAC;IAC7C,MAAM,MAAM,GAAG,iEAAiE,CAAC;IACjF,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3C,IAAI,WAAW,GAAG,CAAC,EAAE,CAAC;QACpB,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAC;IAC5E,CAAC;IACD,OAAO,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;AACnC,CAAC"}