@skillcap/gdh 3.2.1 → 3.2.3

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

@@ -0,0 +1,682 @@
+// Pure bridge-substrate renderers shared by runtime surface install and editor operation execution.
+export function renderEditorOperationRunner() {
+    return `extends SceneTree
+
+func _init() -> void:
+	var input_path := OS.get_environment("GDH_EDITOR_OPERATION_INPUT")
+	var output_path := OS.get_environment("GDH_EDITOR_OPERATION_OUTPUT")
+	var result := _run_operation(input_path)
+	_write_json(output_path, result)
+	quit(0)
+
+func _run_operation(input_path: String) -> Dictionary:
+	var input_text := FileAccess.get_file_as_string(input_path)
+	var parsed = JSON.parse_string(input_text)
+	if typeof(parsed) != TYPE_DICTIONARY:
+		return _failure("Invalid editor operation input JSON.", ["input_json_invalid"])
+	var operation = parsed.get("operation", {})
+	if typeof(operation) != TYPE_DICTIONARY:
+		return _failure("Missing editor operation payload.", ["operation_missing"])
+	return run_editor_operation(operation)
+
+func run_editor_operation(operation: Dictionary) -> Dictionary:
+	return _dispatch_operation(operation)
+
+func _dispatch_operation(operation: Dictionary) -> Dictionary:
+	var kind := str(operation.get("kind", ""))
+	if kind == "":
+		var type_value := str(operation.get("type", ""))
+		if type_value != "":
+			return _failure("Editor operation payload used type='" + type_value + "', but GDH dispatches editor operations with kind. Use operation.kind instead.", ["operation_kind_missing", "operation_type_unsupported"], _operation_help(type_value))
+		return _failure("Editor operation payload is missing kind.", ["operation_kind_missing"], _operation_help("editor.state"))
+	match kind:
+		"scene.create":
+			return _scene_create(operation)
+		"scene.tree":
+			return _scene_tree(operation)
+		"scene.save":
+			return _scene_save(operation)
+		"node.add":
+			return _node_add(operation)
+		"node.remove":
+			return _node_remove(operation)
+		"node.reparent":
+			return _node_reparent(operation)
+		"node.duplicate":
+			return _node_duplicate(operation)
+		"node.set_property":
+			return _node_set_property(operation)
+		"node.get_property":
+			return _node_get_property(operation)
+		"node.inspect":
+			return _node_inspect(operation)
+		"resource.create":
+			return _resource_create(operation)
+		"resource.read":
+			return _resource_read(operation)
+		"resource.properties":
+			return _resource_properties(operation)
+		"resource.set_property":
+			return _resource_set_property(operation)
+		"script.attach":
+			return _script_attach(operation)
+		"class.search":
+			return _class_search(operation)
+		"class.info":
+			return _class_info(operation)
+		"editor.state":
+			return _editor_state(operation)
+		"batch.apply":
+			return _batch_apply(operation)
+		_:
+			return _failure("Unsupported editor operation: " + kind, ["operation_unsupported"], _operation_help(kind))
+
+func _scene_create(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	if scene_path == "res://":
+		return _failure("scenePath is required.", ["scene_path_missing"])
+	var root_type := str(operation.get("rootNodeType", "Node"))
+	var root = _instantiate(root_type)
+	if root == null or not (root is Node):
+		return _failure("Unable to instantiate root node type: " + root_type, ["root_node_type_invalid"])
+	root.name = str(operation.get("rootNodeName", root_type))
+	_set_properties(root, operation.get("properties", {}))
+	var packed := PackedScene.new()
+	var pack_err := packed.pack(root)
+	if pack_err != OK:
+		return _failure("Failed to pack scene.", ["scene_pack_failed"])
+	_ensure_parent_dir(scene_path)
+	var save_err := ResourceSaver.save(packed, scene_path)
+	if save_err != OK:
+		return _failure("Failed to save scene: " + scene_path, ["scene_save_failed"])
+	return _success("Scene created.", {"scenePath": scene_path, "rootNodeType": root_type, "rootNodeName": root.name})
+
+func _scene_tree(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	if scene_path == "res://":
+		return _failure("scene.tree requires scenePath.", ["scene_path_missing"], _operation_help("scene.tree"))
+	var loaded = load(scene_path)
+	if loaded == null or not (loaded is PackedScene):
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	var root = loaded.instantiate()
+	if root == null:
+		return _failure("Scene could not be instantiated: " + scene_path, ["scene_instantiate_failed"])
+	var max_depth := int(operation.get("maxDepth", -1))
+	var tree := _node_summary(root, ".", 0, max_depth)
+	root.queue_free()
+	return _success("Scene tree loaded.", {"scenePath": scene_path, "tree": tree})
+
+func _scene_save(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"])
+	return _save_instantiated_scene(root, scene_path)
+
+func _node_add(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	var loaded = load(scene_path)
+	if loaded == null or not (loaded is PackedScene):
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	var root = loaded.instantiate()
+	var parent_path := str(operation.get("parentNodePath", "."))
+	var parent = _find_node(root, parent_path)
+	if parent == null:
+		return _failure("Parent node not found: " + parent_path, ["parent_node_not_found"])
+	var node_type := str(operation.get("nodeType", ""))
+	var node = _instantiate(node_type)
+	if node == null or not (node is Node):
+		return _failure("Unable to instantiate node type: " + node_type, ["node_type_invalid"])
+	node.name = str(operation.get("nodeName", node_type))
+	_set_properties(node, operation.get("properties", {}))
+	parent.add_child(node)
+	_set_owner_recursive(node, root)
+	var result := _save_instantiated_scene(root, scene_path)
+	if not result.get("ok", false):
+		return result
+	return _success("Node added.", {"scenePath": scene_path, "nodePath": str(root.get_path_to(node)), "nodeType": node_type, "nodeName": node.name})
+
+func _node_remove(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 node_path := str(operation.get("nodePath", ""))
+	var node = _find_node(root, node_path)
+	if node == null or node == root:
+		return _failure("Node not removable: " + node_path, ["node_not_removable"])
+	var parent = node.get_parent()
+	if parent == null:
+		return _failure("Node parent not found: " + node_path, ["node_parent_not_found"])
+	parent.remove_child(node)
+	node.free()
+	var result := _save_instantiated_scene(root, scene_path)
+	if not result.get("ok", false):
+		return result
+	return _success("Node removed.", {"scenePath": scene_path, "nodePath": node_path})
+
+func _node_reparent(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 node_path := str(operation.get("nodePath", ""))
+	var new_parent_path := str(operation.get("newParentNodePath", ""))
+	var node = _find_node(root, node_path)
+	var new_parent = _find_node(root, new_parent_path)
+	if node == null or node == root:
+		return _failure("Node not reparentable: " + node_path, ["node_not_reparentable"])
+	if new_parent == null:
+		return _failure("New parent node not found: " + new_parent_path, ["new_parent_node_not_found"])
+	if node == new_parent or node.is_ancestor_of(new_parent):
+		return _failure("Cannot reparent a node below itself.", ["node_reparent_cycle"])
+	var old_parent = node.get_parent()
+	if old_parent == null:
+		return _failure("Node parent not found: " + node_path, ["node_parent_not_found"])
+	old_parent.remove_child(node)
+	new_parent.add_child(node)
+	_set_owner_recursive(node, root)
+	var result := _save_instantiated_scene(root, scene_path)
+	if not result.get("ok", false):
+		return result
+	return _success("Node reparented.", {"scenePath": scene_path, "nodePath": str(root.get_path_to(node)), "newParentNodePath": new_parent_path})
+
+func _node_duplicate(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 node_path := str(operation.get("nodePath", ""))
+	var node = _find_node(root, node_path)
+	if node == null:
+		return _failure("Node not found: " + node_path, ["node_not_found"])
+	var parent_path := str(operation.get("parentNodePath", ""))
+	var parent = _find_node(root, parent_path) if not parent_path.is_empty() else node.get_parent()
+	if parent == null:
+		return _failure("Duplicate parent node not found.", ["duplicate_parent_node_not_found"])
+	var duplicate = node.duplicate()
+	if duplicate == null or not (duplicate is Node):
+		return _failure("Node could not be duplicated: " + node_path, ["node_duplicate_failed"])
+	var requested_name := str(operation.get("newNodeName", ""))
+	if not requested_name.is_empty():
+		duplicate.name = requested_name
+	parent.add_child(duplicate)
+	_set_owner_recursive(duplicate, root)
+	var result := _save_instantiated_scene(root, scene_path)
+	if not result.get("ok", false):
+		return result
+	return _success("Node duplicated.", {"scenePath": scene_path, "sourceNodePath": node_path, "nodePath": str(root.get_path_to(duplicate)), "nodeName": duplicate.name})
+
+func _node_set_property(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 node_path := str(operation.get("nodePath", ""))
+	var node = _find_node(root, node_path)
+	if node == null:
+		return _failure("Node not found: " + node_path, ["node_not_found"])
+	var property_name := str(operation.get("propertyName", ""))
+	node.set(property_name, _decode_value(operation.get("value")))
+	var result := _save_instantiated_scene(root, scene_path)
+	if not result.get("ok", false):
+		return result
+	return _success("Node property set.", {"scenePath": scene_path, "nodePath": node_path, "propertyName": property_name})
+
+func _node_get_property(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 node_path := str(operation.get("nodePath", ""))
+	var node = _find_node(root, node_path)
+	if node == null:
+		return _failure("Node not found: " + node_path, ["node_not_found"])
+	var property_name := str(operation.get("propertyName", ""))
+	var value = _encode_value(node.get(property_name))
+	root.queue_free()
+	return _success("Node property read.", {"scenePath": scene_path, "nodePath": node_path, "propertyName": property_name, "value": value})
+
+func _node_inspect(operation: Dictionary) -> Dictionary:
+	var scene_path := _res_path(str(operation.get("scenePath", "")))
+	if scene_path == "res://":
+		return _failure("node.inspect requires scenePath.", ["scene_path_missing"], _operation_help("node.inspect"))
+	var root = _load_scene_root(scene_path)
+	if root == null:
+		return _failure("Scene could not be loaded: " + scene_path, ["scene_load_failed"])
+	var node_path := str(operation.get("nodePath", "."))
+	var node = _find_node(root, node_path)
+	if node == null:
+		root.queue_free()
+		return _failure("Node not found: " + node_path, ["node_not_found"])
+	var property_names = operation.get("propertyNames", [])
+	var properties := {}
+	if typeof(property_names) == TYPE_ARRAY:
+		for property_name in property_names:
+			var key := str(property_name)
+			properties[key] = _encode_value(node.get(key))
+	var property_list := []
+	if bool(operation.get("includePropertyList", false)):
+		property_list = _filter_property_list(node.get_property_list(), str(operation.get("propertyQuery", "")), int(operation.get("propertyLimit", 50)))
+	var summary := _node_summary(node, node_path, 0, 0)
+	root.queue_free()
+	return _success("Node inspected.", {"scenePath": scene_path, "nodePath": node_path, "node": summary, "properties": properties, "propertyList": property_list})
+
+func _resource_create(operation: Dictionary) -> Dictionary:
+	var resource_path := _res_path(str(operation.get("resourcePath", "")))
+	var resource_type := str(operation.get("resourceType", ""))
+	var resource = _instantiate(resource_type)
+	if resource == null or not (resource is Resource):
+		return _failure("Unable to instantiate resource type: " + resource_type, ["resource_type_invalid"])
+	_set_properties(resource, operation.get("properties", {}))
+	_ensure_parent_dir(resource_path)
+	var save_err := ResourceSaver.save(resource, resource_path)
+	if save_err != OK:
+		return _failure("Failed to save resource: " + resource_path, ["resource_save_failed"])
+	return _success("Resource created.", {"resourcePath": resource_path, "resourceType": resource_type})
+
+func _resource_read(operation: Dictionary) -> Dictionary:
+	var resource_path := _res_path(str(operation.get("resourcePath", "")))
+	if resource_path == "res://":
+		return _failure("resource.read requires resourcePath.", ["resource_path_missing"], _operation_help("resource.read"))
+	var resource = load(resource_path)
+	if resource == null or not (resource is Resource):
+		return _failure("Resource could not be loaded: " + resource_path, ["resource_load_failed"])
+	var property_names = operation.get("propertyNames", [])
+	var properties := {}
+	if typeof(property_names) == TYPE_ARRAY:
+		for property_name in property_names:
+			var key := str(property_name)
+			properties[key] = _encode_value(resource.get(key))
+	var script = resource.get_script()
+	return _success("Resource read.", {"resourcePath": resource_path, "class": resource.get_class(), "scriptPath": script.resource_path if script else null, "properties": properties})
+
+func _resource_properties(operation: Dictionary) -> Dictionary:
+	var resource_path := _res_path(str(operation.get("resourcePath", "")))
+	if resource_path == "res://":
+		return _failure("resource.properties requires resourcePath.", ["resource_path_missing"], _operation_help("resource.properties"))
+	var resource = load(resource_path)
+	if resource == null or not (resource is Resource):
+		return _failure("Resource could not be loaded: " + resource_path, ["resource_load_failed"])
+	var script = resource.get_script()
+	var properties := _filter_property_list(resource.get_property_list(), str(operation.get("propertyQuery", "")), int(operation.get("propertyLimit", 80)))
+	return _success("Resource properties loaded.", {"resourcePath": resource_path, "class": resource.get_class(), "scriptPath": script.resource_path if script else null, "properties": properties, "propertiesTruncated": properties.size() >= int(operation.get("propertyLimit", 80))})
+
+func _resource_set_property(operation: Dictionary) -> Dictionary:
+	var resource_path := _res_path(str(operation.get("resourcePath", "")))
+	var resource = load(resource_path)
+	if resource == null or not (resource is Resource):
+		return _failure("Resource could not be loaded: " + resource_path, ["resource_load_failed"])
+	var property_name := str(operation.get("propertyName", ""))
+	resource.set(property_name, _decode_value(operation.get("value")))
+	var save_err := ResourceSaver.save(resource, resource_path)
+	if save_err != OK:
+		return _failure("Failed to save resource: " + resource_path, ["resource_save_failed"])
+	return _success("Resource property set.", {"resourcePath": resource_path, "propertyName": property_name})
+
+func _script_attach(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 node_path := str(operation.get("nodePath", ""))
+	var node = _find_node(root, node_path)
+	if node == null:
+		return _failure("Node not found: " + node_path, ["node_not_found"])
+	var script_path := _res_path(str(operation.get("scriptPath", "")))
+	var script = load(script_path)
+	if script == null or not (script is Script):
+		return _failure("Script could not be loaded: " + script_path, ["script_load_failed"])
+	node.set_script(script)
+	var result := _save_instantiated_scene(root, scene_path)
+	if not result.get("ok", false):
+		return result
+	return _success("Script attached.", {"scenePath": scene_path, "nodePath": node_path, "scriptPath": script_path})
+
+func _class_search(operation: Dictionary) -> Dictionary:
+	var query := str(operation.get("query", "")).to_lower()
+	var base_class := str(operation.get("baseClass", ""))
+	var instantiable_only := bool(operation.get("instantiableOnly", true))
+	var limit := int(operation.get("limit", 50))
+	var classes := []
+	var seen := {}
+	for class_id in ClassDB.get_class_list():
+		if query != "" and not str(class_id).to_lower().contains(query):
+			continue
+		if base_class != "" and class_id != base_class and not ClassDB.is_parent_class(class_id, base_class):
+			continue
+		if instantiable_only and not ClassDB.can_instantiate(class_id):
+			continue
+		classes.append({"name": class_id, "source": "class_db", "baseClass": ClassDB.get_parent_class(class_id), "instantiable": ClassDB.can_instantiate(class_id)})
+		seen[class_id] = true
+		if classes.size() >= limit:
+			break
+	for entry in ProjectSettings.get_global_class_list():
+		var class_id := str(entry.get("class", ""))
+		if seen.has(class_id):
+			continue
+		if query != "" and not class_id.to_lower().contains(query):
+			continue
+		if base_class != "" and str(entry.get("base", "")) != base_class:
+			continue
+		classes.append({"name": class_id, "source": "global_class", "baseClass": str(entry.get("base", "")), "path": str(entry.get("path", "")), "instantiable": true})
+		seen[class_id] = true
+		if classes.size() >= limit:
+			break
+	for entry in _script_class_entries():
+		var class_id := str(entry.get("class", ""))
+		if seen.has(class_id):
+			continue
+		if query != "" and not class_id.to_lower().contains(query):
+			continue
+		if base_class != "" and str(entry.get("base", "")) != base_class:
+			continue
+		classes.append({"name": class_id, "source": "script_scan", "baseClass": str(entry.get("base", "")), "path": str(entry.get("path", "")), "instantiable": true})
+		seen[class_id] = true
+		if classes.size() >= limit:
+			break
+	return _success("Class search completed.", {"classes": classes, "truncated": classes.size() >= limit})
+
+func _class_info(operation: Dictionary) -> Dictionary:
+	var class_id := str(operation.get("className", ""))
+	var property_query := str(operation.get("propertyQuery", "")).to_lower()
+	var property_limit := int(operation.get("propertyLimit", 50))
+	var properties := []
+	if ClassDB.class_exists(class_id):
+		for property in ClassDB.class_get_property_list(class_id, bool(operation.get("includeInherited", true))):
+			var name := str(property.get("name", ""))
+			if property_query != "" and not name.to_lower().contains(property_query):
+				continue
+			properties.append(_property_summary(property))
+			if properties.size() >= property_limit:
+				break
+		return _success("Class info loaded.", {"className": class_id, "source": "class_db", "parentClass": ClassDB.get_parent_class(class_id), "instantiable": ClassDB.can_instantiate(class_id), "properties": properties, "propertiesTruncated": properties.size() >= property_limit})
+	var script_class := _find_script_class(class_id)
+	if script_class.size() > 0:
+		var script_path := str(script_class.get("path", ""))
+		var script = load(script_path)
+		if script and script.has_method("get_script_property_list"):
+			for property in script.get_script_property_list():
+				var name := str(property.get("name", ""))
+				if property_query != "" and not name.to_lower().contains(property_query):
+					continue
+				properties.append(_property_summary(property))
+				if properties.size() >= property_limit:
+					break
+		return _success("Class info loaded.", {"className": class_id, "source": str(script_class.get("source", "script_scan")), "path": script_path, "parentClass": str(script_class.get("base", "")), "instantiable": true, "properties": properties, "propertiesTruncated": properties.size() >= property_limit})
+	return _failure("Class not found: " + class_id, ["class_not_found"])
+
+func _editor_state(_operation: Dictionary) -> Dictionary:
+	var editor_interface = _editor_interface()
+	var current_scene_path = null
+	var open_scenes := []
+	var selected_node_paths := []
+	if editor_interface != null:
+		if editor_interface.has_method("get_open_scenes"):
+			for scene_path in editor_interface.get_open_scenes():
+				open_scenes.append(str(scene_path))
+		var edited_root = editor_interface.get_edited_scene_root()
+		if edited_root != null:
+			current_scene_path = edited_root.scene_file_path
+		var selection = editor_interface.get_selection()
+		if selection != null:
+			for selected_node in selection.get_selected_nodes():
+				if edited_root != null and selected_node is Node:
+					selected_node_paths.append(str(edited_root.get_path_to(selected_node)))
+				else:
+					selected_node_paths.append(str(selected_node.get_path()))
+	return _success("Editor state loaded.", {
+		"projectName": ProjectSettings.get_setting("application/config/name", ""),
+		"engineVersion": Engine.get_version_info().get("string", ""),
+		"features": ProjectSettings.get_setting("application/config/features", []),
+		"godotProjectRootPath": ProjectSettings.globalize_path("res://"),
+		"editorContextAvailable": editor_interface != null,
+		"currentScenePath": current_scene_path,
+		"openScenes": open_scenes,
+		"dirtyScenes": [],
+		"selectedNodePaths": selected_node_paths,
+	})
+
+func _batch_apply(operation: Dictionary) -> Dictionary:
+	var operations = operation.get("operations", [])
+	if typeof(operations) != TYPE_ARRAY:
+		return _failure("batch.apply requires operations array.", ["batch_operations_invalid"])
+	var results := []
+	for child_operation in operations:
+		if typeof(child_operation) != TYPE_DICTIONARY:
+			return _failure("batch.apply child operation must be an object.", ["batch_child_operation_invalid"])
+		var result := _dispatch_operation(child_operation)
+		results.append(result)
+		if not result.get("ok", false):
+			return _failure("Batch operation failed.", ["batch_child_failed", str(child_operation.get("kind", ""))])
+	return _success("Batch applied.", {"results": results})
+
+func _load_scene_root(scene_path: String):
+	var loaded = load(scene_path)
+	if loaded == null or not (loaded is PackedScene):
+		return null
+	return loaded.instantiate()
+
+func _save_instantiated_scene(root: Node, scene_path: String) -> Dictionary:
+	var packed := PackedScene.new()
+	var pack_err := packed.pack(root)
+	if pack_err != OK:
+		return _failure("Failed to pack scene.", ["scene_pack_failed"])
+	var save_err := ResourceSaver.save(packed, scene_path)
+	if save_err != OK:
+		return _failure("Failed to save scene: " + scene_path, ["scene_save_failed"])
+	return _success("Scene saved.", {"scenePath": scene_path})
+
+func _instantiate(class_id: String):
+	if class_id == "":
+		return null
+	if ClassDB.class_exists(class_id) and ClassDB.can_instantiate(class_id):
+		return ClassDB.instantiate(class_id)
+	var script_class := _find_script_class(class_id)
+	if script_class.size() > 0:
+		var script = load(str(script_class.get("path", "")))
+		if script and script.has_method("new"):
+			return script.new()
+	return null
+
+func _set_properties(object: Object, properties) -> void:
+	if typeof(properties) != TYPE_DICTIONARY:
+		return
+	for property_name in properties.keys():
+		object.set(str(property_name), _decode_value(properties[property_name]))
+
+func _decode_value(value):
+	if typeof(value) == TYPE_DICTIONARY:
+		if value.has("$resource"):
+			return load(_res_path(str(value["$resource"])))
+		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("$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)))
+	return value
+
+func _encode_value(value, depth := 0):
+	if value == null:
+		return null
+	if depth >= 4:
+		return {"$truncated": "max_depth", "text": str(value)}
+	if value is Vector2:
+		return {"$vector2": {"x": value.x, "y": value.y}}
+	if value is Color:
+		return {"$color": {"r": value.r, "g": value.g, "b": value.b, "a": value.a}}
+	if value is Resource:
+		var resource_path: String = value.resource_path
+		return {"$resource": resource_path if resource_path != "" else null, "class": value.get_class(), "text": str(value)}
+	var value_type := typeof(value)
+	if value_type in [TYPE_BOOL, TYPE_INT, TYPE_FLOAT, TYPE_STRING]:
+		return value
+	if value_type == TYPE_ARRAY:
+		var encoded := []
+		var count := 0
+		for item in value:
+			if count >= 100:
+				encoded.append({"$truncated": "max_items"})
+				break
+			encoded.append(_encode_value(item, depth + 1))
+			count += 1
+		return encoded
+	if value_type == TYPE_DICTIONARY:
+		var encoded_dict := {}
+		var count := 0
+		for key in value.keys():
+			if count >= 100:
+				encoded_dict["$truncated"] = "max_items"
+				break
+			encoded_dict[str(key)] = _encode_value(value[key], depth + 1)
+			count += 1
+		return encoded_dict
+	return str(value)
+
+func _property_summary(property: Dictionary) -> Dictionary:
+	return {"name": str(property.get("name", "")), "type": int(property.get("type", TYPE_NIL)), "hint": int(property.get("hint", 0)), "usage": int(property.get("usage", 0))}
+
+func _filter_property_list(property_list: Array, query: String, limit: int) -> Array:
+	var lowered_query := query.to_lower()
+	var effective_limit := limit if limit > 0 else 50
+	var properties := []
+	for property in property_list:
+		var name := str(property.get("name", ""))
+		if lowered_query != "" and not name.to_lower().contains(lowered_query):
+			continue
+		properties.append(_property_summary(property))
+		if properties.size() >= effective_limit:
+			break
+	return properties
+
+func _editor_interface():
+	var plugin = get("_plugin")
+	if plugin == null:
+		return null
+	if plugin.has_method("get_editor_interface"):
+		return plugin.get_editor_interface()
+	return null
+
+func _find_script_class(class_id: String) -> Dictionary:
+	for entry in ProjectSettings.get_global_class_list():
+		if str(entry.get("class", "")) == class_id:
+			return {"class": class_id, "base": str(entry.get("base", "")), "path": str(entry.get("path", "")), "source": "global_class"}
+	for entry in _script_class_entries():
+		if str(entry.get("class", "")) == class_id:
+			return entry
+	return {}
+
+func _script_class_entries() -> Array:
+	var entries := []
+	_collect_script_class_entries("res://", entries)
+	return entries
+
+func _collect_script_class_entries(directory_path: String, entries: Array) -> void:
+	var dir := DirAccess.open(directory_path)
+	if dir == null:
+		return
+	dir.list_dir_begin()
+	var entry_name := dir.get_next()
+	while entry_name != "":
+		if entry_name.begins_with("."):
+			entry_name = dir.get_next()
+			continue
+		var entry_path := directory_path.path_join(entry_name)
+		if dir.current_is_dir():
+			_collect_script_class_entries(entry_path, entries)
+		elif entry_name.ends_with(".gd"):
+			var script_class := _read_script_class_entry(entry_path)
+			if script_class.size() > 0:
+				entries.append(script_class)
+		entry_name = dir.get_next()
+	dir.list_dir_end()
+
+func _read_script_class_entry(script_path: String) -> Dictionary:
+	var source := FileAccess.get_file_as_string(script_path)
+	var class_id := ""
+	var base_class := ""
+	for raw_line in source.split("\n"):
+		var line := str(raw_line).strip_edges()
+		if line.begins_with("class_name "):
+			var class_tokens := line.split(" ", false)
+			if class_tokens.size() >= 2:
+				class_id = str(class_tokens[1])
+		elif line.begins_with("extends "):
+			var extends_tokens := line.split(" ", false)
+			if extends_tokens.size() >= 2:
+				base_class = str(extends_tokens[1])
+	if class_id == "":
+		return {}
+	return {"class": class_id, "base": base_class, "path": script_path, "source": "script_scan"}
+
+func _node_summary(node: Node, node_path: String, depth: int, max_depth: int) -> Dictionary:
+	var children := []
+	if max_depth < 0 or depth < max_depth:
+		for child in node.get_children():
+			if child is Node:
+				children.append(_node_summary(child, str(node.get_path_to(child)), depth + 1, max_depth))
+	var script = node.get_script()
+	return {"path": node_path, "name": node.name, "type": node.get_class(), "scriptPath": script.resource_path if script else null, "childCount": node.get_child_count(), "children": children}
+
+func _find_node(root: Node, node_path: String):
+	if node_path == "" or node_path == ".":
+		return root
+	return root.get_node_or_null(NodePath(node_path))
+
+func _set_owner_recursive(node: Node, owner: Node) -> void:
+	node.owner = owner
+	for child in node.get_children():
+		if child is Node:
+			_set_owner_recursive(child, owner)
+
+func _res_path(value: String) -> String:
+	if value.begins_with("res://"):
+		return value
+	return "res://" + value.trim_prefix("/")
+
+func _ensure_parent_dir(res_path: String) -> void:
+	var absolute := ProjectSettings.globalize_path(res_path)
+	var dir := absolute.get_base_dir()
+	DirAccess.make_dir_recursive_absolute(dir)
+
+func _write_json(path: String, value: Dictionary) -> void:
+	var file := FileAccess.open(path, FileAccess.WRITE)
+	if file:
+		file.store_string(JSON.stringify(value))
+		file.close()
+
+func _success(summary: String, output: Dictionary) -> Dictionary:
+	return {"ok": true, "summary": summary, "reasons": [], "output": output}
+
+func _failure(summary: String, reasons: Array, help := {}) -> Dictionary:
+	return {"ok": false, "summary": summary, "reasons": reasons, "output": null, "help": help}
+
+func _operation_help(kind: String) -> Dictionary:
+	var examples := {
+		"scene.tree": {"kind": "scene.tree", "scenePath": "res://path/to/scene.tscn", "maxDepth": 3},
+		"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"},
+		"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.",
+		"helpCommand": "gdh editor operation run --help",
+		"examples": [example],
+	}
+`;
+}
+export function renderEditorOperationCatalogGdscript() {
+    const runner = renderEditorOperationRunner();
+    const marker = "func run_editor_operation(operation: Dictionary) -> Dictionary:";
+    const markerIndex = runner.indexOf(marker);
+    if (markerIndex < 0) {
+        throw new Error("Editor operation runner is missing the catalog marker.");
+    }
+    return runner.slice(markerIndex);
+}
+//# sourceMappingURL=editor-operation-runner.js.map