gdharness 1.3.65 → 1.3.67

package/build/godot/addons/gdharness_editor/bridge_client.gd

@@ -48,6 +48,9 @@ const DAP_ASKED: String = "GDHARNESS_DAP_PORT"
 ## What a server that opened this editor says about itself, so that being opened by one is stated
 ## rather than guessed at from the ports. Kept in step with `OPENED_BY_A_SERVER` in src/launch.ts.
 const OPENED_BY_A_SERVER: String = "GDHARNESS_OPENED_BY_A_SERVER"
+## Set for an editor a server started on its hidden desktop. Kept in step with `DESKTOP_VARIABLE`
+## in src/desktop.ts.
+const DESKTOP_VARIABLE: String = "GDHARNESS_DESKTOP"
 ## Put into this editor's own environment as it loads, so every game it plays inherits it and
 ## the runtime addon can announce which editor played it. A game of the same project that some
 ## other server started has no such variable, or another editor's number, and that is what
@@ -357,8 +360,10 @@ func _handle_connect() -> void:
 			# Whether a session opening on the adapter is told this editor's breakpoints or takes
 			# them away, so a server can say which before it sets one.
 			"syncs_breakpoints": _syncs_breakpoints(),
-			# Whether this editor runs with no window, which for one opened by hand only it can say.
-			"hidden": DisplayServer.get_name() == "headless",
+			# Whether this editor runs with no window anybody sees, which for one opened by hand
+			# only
+			# it can say: headless, or a window on the hidden desktop a server started it on.
+			"hidden": DisplayServer.get_name() == "headless" or _on_the_hidden_desktop(),
 			# Whether a server started this editor, which is the only kind that can be started again
 			# as itself: the engine hands back none of the arguments it was given, so the arguments
 			# have to come from whoever wrote them. See `restart_editor` in play_tools.gd.
@@ -442,6 +447,12 @@ func _keep_breakpoints_through_sessions() -> void:
 	)
 
 
+## Whether a server started this editor on its hidden desktop, where its window draws and never
+## shows.
+static func _on_the_hidden_desktop() -> bool:
+	return OS.get_name() == "Windows" and not OS.get_environment(DESKTOP_VARIABLE).is_empty()
+
+
 ## Whether the editor shares its breakpoints with a session as it opens. See the setting.
 func _syncs_breakpoints() -> bool:
 	if not Engine.is_editor_hint():

package/build/godot/addons/gdharness_editor/picture_saves.gd

@@ -0,0 +1,48 @@
+extends RefCounted
+
+# How a captured picture is sized and saved, for the game's captures and the editor's alike.
+#
+# This file is the one beside the operations, and `bun run sync:gd` copies it into each addon,
+# because an addon is installed as a directory and cannot preload out of one.
+
+## Measured on a downstream game's 1280x720 frame: its interface text and pixel art read as they do
+## in the PNG, at a fifth of the PNG's size.
+const JPEG_QUALITY: float = 0.8
+
+
+## The size a capture drawn at [param drawn] is scaled to, from the width and height asked for, 0
+## being not asked. One side alone keeps the picture's proportions, since that is what asking for a
+## smaller picture means: it was ignored unless both came, so the full-size picture was sent back.
+static func scaled_to(drawn: Vector2i, width: int, height: int) -> Vector2i:
+	if width > 0 and height > 0:
+		return Vector2i(width, height)
+	if width > 0 and drawn.x > 0:
+		return Vector2i(width, maxi(1, roundi(float(drawn.y) * width / drawn.x)))
+	if height > 0 and drawn.y > 0:
+		return Vector2i(maxi(1, roundi(float(drawn.x) * height / drawn.y)), height)
+	return drawn
+
+
+## [param image] saved as a PNG at [param png_path], and as a JPEG beside it, which the server sends
+## instead when it is the smaller: a rendered frame is several times smaller as one, and every
+## picture sent stays in the caller's session. Not for a picture with transparency, which a JPEG
+## would flatten.
+static func saved(image: Image, png_path: String) -> Dictionary:
+	var save_error: Error = image.save_png(png_path)
+	if save_error != OK:
+		return {
+			"type": "error",
+			"message": "Failed to save screenshot as PNG: " + str(save_error),
+		}
+	var answer: Dictionary = {
+		"type": "screenshot_file",
+		"format": "png",
+		"width": image.get_width(),
+		"height": image.get_height(),
+		"path": png_path,
+	}
+	if image.detect_alpha() == Image.ALPHA_NONE:
+		var jpeg_path: String = png_path.get_basename() + ".jpg"
+		if image.save_jpg(jpeg_path, JPEG_QUALITY) == OK:
+			answer["jpegPath"] = jpeg_path
+	return answer

package/build/godot/addons/gdharness_editor/picture_saves.gd.uid

@@ -0,0 +1 @@
+uid://c2lleb9sm7gnl

package/build/godot/addons/gdharness_editor/plugin.gd

@@ -106,7 +106,10 @@ func _on_disconnected() -> void:
 ## Whether [param tool_name] waits for the editor to finish scanning or importing. A save during a
 ## scan updates the file list the scan's thread is writing out (see SceneFile.scan_later), and an
 ## import can run frames of the editor from inside itself, the one handling this call among them.
+## Every call waits out a capture, which shows a scene for frames before it reads the view.
 func turned_away(tool_name: String) -> bool:
+	if _tool_executor != null and _tool_executor.capturing():
+		return true
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
 	return (
 		not ANSWERED_WHILE_SCANNING.has(tool_name)
@@ -124,7 +127,7 @@ func _on_tool_requested(request_id: String, tool_name: String, args: Dictionary)
 		_client.send_busy(request_id, tool_name)
 		return
 
-	var result: Dictionary = _tool_executor.execute_tool(tool_name, args)
+	var result: Dictionary = await _tool_executor.execute_tool(tool_name, args)
 	var success: bool = result.get("ok", false)
 
 	if success:

package/build/godot/addons/gdharness_editor/scene_file.gd

@@ -1197,6 +1197,11 @@ func _strays(state: SceneState) -> Array[Array]:
 				continue
 			if not held and GdhHeadlessCheck.at_default(node, name):
 				continue
+			# Set in the file to what the node would have anyway, such as an instance naming the
+			# script its own scene gives it. The pack leaves it out, as the editor's does, and the
+			# node loads the same.
+			if held and not stored.has(name) and GdhSame.same(node.get(name), filed[name]):
+				continue
 			if _engine_kept.has("%d:%s" % [id, name]):
 				continue
 			stray.append([node, name, held, filed.get(name)])

package/build/godot/addons/gdharness_editor/tool_executor.gd

@@ -17,6 +17,7 @@ const GdhClassTools = preload("tools/class_tools.gd")
 const GdhSettingsTools = preload("tools/settings_tools.gd")
 const GdhFilesystemTools = preload("tools/filesystem_tools.gd")
 const GdhProfileTools = preload("tools/profile_tools.gd")
+const GdhViewTools = preload("tools/view_tools.gd")
 
 var _editor_plugin: EditorPlugin = null
 var _scene_tools: GdhSceneTools = null
@@ -31,6 +32,7 @@ var _class_tools: GdhClassTools = null
 var _settings_tools: GdhSettingsTools = null
 var _filesystem_tools: GdhFilesystemTools = null
 var _profile_tools: GdhProfileTools = null
+var _view_tools: GdhViewTools = null
 var _tool_map: Dictionary = {}
 var _initialized: bool = false
 
@@ -48,6 +50,7 @@ func set_editor_plugin(plugin: EditorPlugin) -> void:
 	_class_tools.set_editor_plugin(plugin)
 	_filesystem_tools.set_editor_plugin(plugin)
 	_profile_tools.set_editor_plugin(plugin)
+	_view_tools.set_editor_plugin(plugin)
 
 
 func _init_tools() -> void:
@@ -103,6 +106,10 @@ func _init_tools() -> void:
 	_profile_tools.name = "ProfileTools"
 	add_child(_profile_tools)
 
+	_view_tools = GdhViewTools.new()
+	_view_tools.name = "ViewTools"
+	add_child(_view_tools)
+
 	_tool_map = {
 		# Scene tools
 		"create_scene": [_scene_tools, "create_scene"],
@@ -148,6 +155,7 @@ func _init_tools() -> void:
 		# The script profiler on a game the editor plays
 		"profile_start": [_profile_tools, "profile_start"],
 		"profile_read": [_profile_tools, "profile_read"],
+		"capture_editor_view": [_view_tools, "capture_editor_view"],
 		# Animation tools
 		"read_animations": [_animation_tools, "read_animations"],
 		"read_animation_states": [_animation_tools, "read_animation_states"],
@@ -164,6 +172,11 @@ func _init_tools() -> void:
 	}
 
 
+## Whether a capture is waiting for the editor to draw, which another call must not move it from.
+func capturing() -> bool:
+	return _view_tools != null and _view_tools.capturing
+
+
 func execute_tool(tool_name: String, args: Dictionary) -> Dictionary:
 	if not _tool_map.has(tool_name):
 		return { "ok": false, "error": "Unknown tool: " + tool_name }
@@ -177,7 +190,8 @@ func execute_tool(tool_name: String, args: Dictionary) -> Dictionary:
 
 	GdhSceneFile.also_saved.clear()
 	GdhSceneFile.unmade_note = ""
-	var result: Variant = node.call(method, args)
+	# Awaited for the tools that wait for the editor to draw. The rest answer at once.
+	var result: Variant = await node.call(method, args)
 	if result is Dictionary:
 		var answered: Dictionary = result
 		if not GdhSceneFile.also_saved.is_empty():

package/build/godot/addons/gdharness_editor/tools/scene_placing.gd

@@ -163,14 +163,16 @@ static func reconnect(copies: Dictionary, top: Node) -> void:
 					)
 
 
-## Owns [param node] and the nodes under it to [param root], except those an instanced scene
-## inside it owns: giving those to the root made the pack write the instance's own nodes into this
-## scene as overrides.
-static func own(node: Node, root: Node) -> void:
+## Owns [param node] to [param root], and under it the nodes the root owns already and those of
+## [param placed], the copies a duplicate placed. A node nothing owns is not the scene's: a script's
+## _init made it, which a headless engine runs and the editor does not, and owning it saved it into
+## the scene, where the script makes it again at run time. An instanced scene's own nodes stay its
+## own: giving those to the root made the pack write them into this scene as overrides.
+static func own(node: Node, root: Node, placed: Dictionary = {}) -> void:
 	node.owner = root
 	for child: Node in node.get_children():
-		if child.owner == null or child.owner == root:
-			own(child, root)
+		if child.owner == root or placed.has(child):
+			own(child, root, placed)
 
 
 ## Why [param asked] is not a position [param node] can take among [param parent]'s children, or ""

package/build/godot/addons/gdharness_editor/tools/scene_tools.gd

@@ -482,7 +482,10 @@ func duplicate_node(args: Dictionary) -> Dictionary:
 	duplicated_node.name = new_name
 	target_parent.add_child(duplicated_node)
 	GdhPlacing.place(duplicated_node, place)
-	GdhPlacing.own(duplicated_node, root)
+	var made: Dictionary = {}
+	for copy: Variant in copies.values():
+		made[copy] = true
+	GdhPlacing.own(duplicated_node, root, made)
 	GdhPlacing.reconnect(copies, source)
 	scene.copied(copies)
 

package/build/godot/addons/gdharness_editor/tools/view_tools.gd

@@ -0,0 +1,121 @@
+@tool
+extends Node
+## Pictures of a scene as the editor draws it, with what its @tool scripts draw only there.
+##
+## A game never runs a script's editor branch, so runtime_capture cannot show it, and a headless
+## engine draws nothing at all. The editor's own 2D and 3D views are the one place it is drawn.
+
+const GdhRead = preload("../reading.gd")
+const GdhSceneFile = preload("../scene_file.gd")
+const GdhPictures = preload("../picture_saves.gd")
+const HEADLESS_DISPLAY: String = "headless"
+## Frames let pass once the scene is shown: the first lays the screen out, and the next run the
+## redraws its @tool scripts queued as they entered the tree.
+const SETTLING_FRAMES: int = 3
+
+## Whether a capture is under way, during which the editor turns other calls away, since one that
+## switched scenes between the open and the read would be what was captured.
+var capturing: bool = false
+var _editor_plugin: EditorPlugin = null
+## The main screen the editor shows, as it last said, or "" before it has said.
+var _screen: String = ""
+
+
+func set_editor_plugin(plugin: EditorPlugin) -> void:
+	_editor_plugin = plugin
+	if not plugin.main_screen_changed.is_connected(_on_main_screen_changed):
+		var joined: int = plugin.main_screen_changed.connect(_on_main_screen_changed)
+		if joined != OK:
+			push_warning("gdharness: following the editor's main screen: %s" % error_string(joined))
+
+
+func _on_main_screen_changed(screen_name: String) -> void:
+	_screen = screen_name
+
+
+## The scene at scenePath as the editor's 2D or 3D view draws it, saved at output_path, which the
+## server names. The editor is left showing the scene and the screen it showed before.
+func capture_editor_view(args: Dictionary) -> Dictionary:
+	var output_path: String = str(args.get("output_path", ""))
+	if output_path.is_empty():
+		return { "ok": false, "error": "output_path required" }
+	if DisplayServer.get_name() == HEADLESS_DISPLAY:
+		return {
+			"ok": false,
+			"error":
+			(
+				"This editor runs headless, so it draws nothing to capture. Use a visible "
+				+ "editor, or a hidden one on Windows."
+			),
+		}
+	var project_path: String = str(args.get("projectPath", ""))
+	var scene_path: String = GdhSceneFile.res_path(project_path, str(args.get("scenePath", "")))
+	if not ResourceLoader.exists(scene_path, "PackedScene"):
+		return { "ok": false, "error": "Scene not found: " + scene_path }
+	var view: String = str(args.get("view", ""))
+	var shown: Node = EditorInterface.get_edited_scene_root()
+	var previous: String = shown.scene_file_path if shown != null else ""
+	var was_open: bool = EditorInterface.get_open_scenes().has(scene_path)
+	var screen_before: String = _screen
+
+	capturing = true
+	EditorInterface.open_scene_from_path(scene_path)
+	var root: Node = EditorInterface.get_edited_scene_root()
+	if root == null or root.scene_file_path != scene_path:
+		capturing = false
+		return { "ok": false, "error": "The editor did not open %s." % scene_path }
+	if view.is_empty():
+		view = "3d" if root is Node3D else "2d"
+	EditorInterface.set_main_screen_editor("3D" if view == "3d" else "2D")
+	for frame: int in SETTLING_FRAMES:
+		await get_tree().process_frame
+	var viewport: SubViewport = (
+		EditorInterface.get_editor_viewport_3d(0)
+		if view == "3d"
+		else EditorInterface.get_editor_viewport_2d()
+	)
+	var image: Image = viewport.get_texture().get_image()
+	var unsaved: bool = GdhSceneFile.unsaved(scene_path)
+
+	if not was_open:
+		var closing: Error = EditorInterface.close_scene()
+		if closing != OK:
+			push_warning(
+				"gdharness: closing %s after its capture: %s" % [scene_path, error_string(closing)]
+			)
+	if not previous.is_empty() and previous != scene_path:
+		EditorInterface.open_scene_from_path(previous)
+	if not screen_before.is_empty() and screen_before != ("3D" if view == "3d" else "2D"):
+		EditorInterface.set_main_screen_editor(screen_before)
+	capturing = false
+
+	if image == null or image.is_empty():
+		return { "ok": false, "error": "The editor's %s view held no picture." % view.to_upper() }
+	var drawn: Vector2i = image.get_size()
+	var target: Vector2i = GdhPictures.scaled_to(
+		drawn, GdhRead.as_int(args.get("width", 0)), GdhRead.as_int(args.get("height", 0))
+	)
+	if target != drawn:
+		image.resize(target.x, target.y)
+	# The server makes the folder for each capture and takes it away when it stops waiting.
+	if not DirAccess.dir_exists_absolute(output_path.get_base_dir()):
+		return {
+			"ok": false,
+			"error":
+			(
+				"The folder to save the capture in, %s, is gone because the server that asked "
+				+ "for it stopped waiting."
+			)
+			% output_path.get_base_dir(),
+		}
+	var answer: Dictionary = GdhPictures.saved(image, output_path)
+	if answer.get("type", "") == "error":
+		return { "ok": false, "error": str(answer.get("message", "")) }
+	answer["ok"] = true
+	answer["scenePath"] = scene_path
+	answer["view"] = view
+	if target != drawn:
+		answer["drawnAt"] = { "width": drawn.x, "height": drawn.y }
+	if unsaved:
+		answer["unsavedInEditor"] = true
+	return answer

package/build/godot/addons/gdharness_editor/tools/view_tools.gd.uid

@@ -0,0 +1 @@
+uid://bbvurjno0b6f8

package/build/godot/addons/gdharness_runtime/picture_saves.gd

@@ -0,0 +1,48 @@
+extends RefCounted
+
+# How a captured picture is sized and saved, for the game's captures and the editor's alike.
+#
+# This file is the one beside the operations, and `bun run sync:gd` copies it into each addon,
+# because an addon is installed as a directory and cannot preload out of one.
+
+## Measured on a downstream game's 1280x720 frame: its interface text and pixel art read as they do
+## in the PNG, at a fifth of the PNG's size.
+const JPEG_QUALITY: float = 0.8
+
+
+## The size a capture drawn at [param drawn] is scaled to, from the width and height asked for, 0
+## being not asked. One side alone keeps the picture's proportions, since that is what asking for a
+## smaller picture means: it was ignored unless both came, so the full-size picture was sent back.
+static func scaled_to(drawn: Vector2i, width: int, height: int) -> Vector2i:
+	if width > 0 and height > 0:
+		return Vector2i(width, height)
+	if width > 0 and drawn.x > 0:
+		return Vector2i(width, maxi(1, roundi(float(drawn.y) * width / drawn.x)))
+	if height > 0 and drawn.y > 0:
+		return Vector2i(maxi(1, roundi(float(drawn.x) * height / drawn.y)), height)
+	return drawn
+
+
+## [param image] saved as a PNG at [param png_path], and as a JPEG beside it, which the server sends
+## instead when it is the smaller: a rendered frame is several times smaller as one, and every
+## picture sent stays in the caller's session. Not for a picture with transparency, which a JPEG
+## would flatten.
+static func saved(image: Image, png_path: String) -> Dictionary:
+	var save_error: Error = image.save_png(png_path)
+	if save_error != OK:
+		return {
+			"type": "error",
+			"message": "Failed to save screenshot as PNG: " + str(save_error),
+		}
+	var answer: Dictionary = {
+		"type": "screenshot_file",
+		"format": "png",
+		"width": image.get_width(),
+		"height": image.get_height(),
+		"path": png_path,
+	}
+	if image.detect_alpha() == Image.ALPHA_NONE:
+		var jpeg_path: String = png_path.get_basename() + ".jpg"
+		if image.save_jpg(jpeg_path, JPEG_QUALITY) == OK:
+			answer["jpegPath"] = jpeg_path
+	return answer

package/build/godot/addons/gdharness_runtime/picture_saves.gd.uid

@@ -0,0 +1 @@
+uid://c3m5b63kjrfs2

package/build/godot/addons/gdharness_runtime/runtime_capture.gd

@@ -5,12 +5,10 @@ const GdhRead = preload("reading.gd")
 const GdhValues = preload("runtime_values.gd")
 const GdhQueries = preload("runtime_queries.gd")
 const GdhScreen = preload("runtime_screen.gd")
+const GdhPictures = preload("picture_saves.gd")
 ## How far zoom enlarges at most. Sixteen makes a 3-pixel ring 48 pixels across, past any need to
 ## see it, and a 200-pixel region 3200, past the size anybody reads a picture at.
 const ZOOM_MOST: int = 16
-## Measured on a downstream game's 1280x720 frame: its interface text and pixel art read as they do
-## in the PNG, at a fifth of the PNG's size.
-const JPEG_QUALITY: float = 0.8
 
 var _host: Node
 var _values: GdhValues
@@ -116,19 +114,6 @@ func _lay_native_windows(image: Image) -> void:
 		)
 
 
-## The size a capture drawn at [param drawn] is scaled to, from the width and height asked for, 0
-## being not asked. One side alone keeps the picture's proportions, since that is what asking for a
-## smaller picture means: it was ignored unless both came, so the full-size picture was sent back.
-static func scaled_to(drawn: Vector2i, width: int, height: int) -> Vector2i:
-	if width > 0 and height > 0:
-		return Vector2i(width, height)
-	if width > 0 and drawn.x > 0:
-		return Vector2i(width, maxi(1, roundi(float(drawn.y) * width / drawn.x)))
-	if height > 0 and drawn.y > 0:
-		return Vector2i(maxi(1, roundi(float(drawn.x) * height / drawn.y)), height)
-	return drawn
-
-
 ## What part of the picture a capture is cut to and how far it is enlarged, from what was asked, or
 ## a refusal saying what is wrong with the asking. Read before a frame is waited for, so a call that
 ## cannot be answered costs no wait.
@@ -390,7 +375,7 @@ func _capture(viewport: Viewport, params: Dictionary, with_windows: bool = false
 		described["zoom"] = zoom
 	else:
 		var drawn: Vector2i = Vector2i(image.get_width(), image.get_height())
-		var target: Vector2i = scaled_to(
+		var target: Vector2i = GdhPictures.scaled_to(
 			drawn, GdhRead.as_int(params.get("width", 0)), GdhRead.as_int(params.get("height", 0))
 		)
 		if target != drawn:
@@ -412,31 +397,6 @@ func _capture(viewport: Viewport, params: Dictionary, with_windows: bool = false
 				% screenshot_path.get_base_dir()
 			)
 		)
-	var answer: Dictionary = saved(image, screenshot_path)
+	var answer: Dictionary = GdhPictures.saved(image, screenshot_path)
 	answer.merge(described)
 	return answer
-
-
-## [param image] saved as a PNG at [param png_path], and as a JPEG beside it, which the server sends
-## instead when it is the smaller: a rendered frame is several times smaller as one, and every
-## picture sent stays in the caller's session. Not for a picture with transparency, which a JPEG
-## would flatten.
-static func saved(image: Image, png_path: String) -> Dictionary:
-	var save_error: Error = image.save_png(png_path)
-	if save_error != OK:
-		return {
-			"type": "error",
-			"message": "Failed to save screenshot as PNG: " + str(save_error),
-		}
-	var answer: Dictionary = {
-		"type": "screenshot_file",
-		"format": "png",
-		"width": image.get_width(),
-		"height": image.get_height(),
-		"path": png_path,
-	}
-	if image.detect_alpha() == Image.ALPHA_NONE:
-		var jpeg_path: String = png_path.get_basename() + ".jpg"
-		if image.save_jpg(jpeg_path, JPEG_QUALITY) == OK:
-			answer["jpegPath"] = jpeg_path
-	return answer

package/build/godot/operations/gdscript_analysis.gd

@@ -331,6 +331,23 @@ static func _not_a_script(path: String) -> String:
 			)
 		"tres", "res":
 			return said + ": resource_edit read reads a resource."
+		"":
+			# A class name given where the path goes.
+			var named: String = path.get_file()
+			for entry: Dictionary in ProjectSettings.get_global_class_list():
+				if str(entry.get("class", "")) == named:
+					return (
+						said
+						+ (
+							": %s is the class_name of %s. Call script_info with that path."
+							% [named, str(entry.get("path", ""))]
+						)
+					)
+			if ClassDB.class_exists(named):
+				return (
+					said
+					+ ": %s is an engine class. Call editor_classes info for its members." % named
+				)
 	return said + "."
 
 

package/build/godot/operations/picture_saves.gd

@@ -0,0 +1,48 @@
+extends RefCounted
+
+# How a captured picture is sized and saved, for the game's captures and the editor's alike.
+#
+# This file is the one beside the operations, and `bun run sync:gd` copies it into each addon,
+# because an addon is installed as a directory and cannot preload out of one.
+
+## Measured on a downstream game's 1280x720 frame: its interface text and pixel art read as they do
+## in the PNG, at a fifth of the PNG's size.
+const JPEG_QUALITY: float = 0.8
+
+
+## The size a capture drawn at [param drawn] is scaled to, from the width and height asked for, 0
+## being not asked. One side alone keeps the picture's proportions, since that is what asking for a
+## smaller picture means: it was ignored unless both came, so the full-size picture was sent back.
+static func scaled_to(drawn: Vector2i, width: int, height: int) -> Vector2i:
+	if width > 0 and height > 0:
+		return Vector2i(width, height)
+	if width > 0 and drawn.x > 0:
+		return Vector2i(width, maxi(1, roundi(float(drawn.y) * width / drawn.x)))
+	if height > 0 and drawn.y > 0:
+		return Vector2i(maxi(1, roundi(float(drawn.x) * height / drawn.y)), height)
+	return drawn
+
+
+## [param image] saved as a PNG at [param png_path], and as a JPEG beside it, which the server sends
+## instead when it is the smaller: a rendered frame is several times smaller as one, and every
+## picture sent stays in the caller's session. Not for a picture with transparency, which a JPEG
+## would flatten.
+static func saved(image: Image, png_path: String) -> Dictionary:
+	var save_error: Error = image.save_png(png_path)
+	if save_error != OK:
+		return {
+			"type": "error",
+			"message": "Failed to save screenshot as PNG: " + str(save_error),
+		}
+	var answer: Dictionary = {
+		"type": "screenshot_file",
+		"format": "png",
+		"width": image.get_width(),
+		"height": image.get_height(),
+		"path": png_path,
+	}
+	if image.detect_alpha() == Image.ALPHA_NONE:
+		var jpeg_path: String = png_path.get_basename() + ".jpg"
+		if image.save_jpg(jpeg_path, JPEG_QUALITY) == OK:
+			answer["jpegPath"] = jpeg_path
+	return answer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.3.65",
+  "version": "1.3.67",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",