gdharness 1.3.8 → 1.3.9

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

@@ -172,6 +172,11 @@ func _cut_asked(params: Dictionary, in_window: bool) -> Dictionary:
 			return _refused(shape % JSON.stringify(region_given))
 		asked["region"] = region
 	if not node_path.is_empty():
+		# Before any refusal of the window: a headless game refused a path that named nothing for
+		# having no window, and the wrong path was found only after a restart with one.
+		var standing: Dictionary = GdhValues.node_at(_host.get_tree().root, node_path)
+		if standing.has("message"):
+			return standing
 		asked["node_path"] = node_path
 	return asked
 

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

@@ -493,6 +493,9 @@ func call_method(params: Dictionary) -> Dictionary:
 		answer["awaited"] = true
 	_keep_reported(answer, "errors", caught.raised)
 	_keep_reported(answer, "warnings", caught.warned)
+	# Main.explode, ended at a null it called into, answered result 0 as if it had counted something.
+	if caught.ended_at.has(named):
+		answer["ended_by_error_at"] = caught.ended_at[named]
 	var asked: Variant = params.get("properties")
 	if _reads_the_result(asked):
 		answer.merge(_read_off_result(result, asked))

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

@@ -21,15 +21,6 @@ const GdhMouse = preload("runtime_mouse.gd")
 ## everything that process starts. Kept in step with `DESKTOP_VARIABLE` in src/desktop.ts.
 const DESKTOP_VARIABLE: String = "GDHARNESS_DESKTOP"
 
-## Node.ProcessMode as its names, for a refusal to say which one is in force.
-const PROCESS_MODES: Dictionary[int, String] = {
-	Node.PROCESS_MODE_INHERIT: "INHERIT",
-	Node.PROCESS_MODE_PAUSABLE: "PAUSABLE",
-	Node.PROCESS_MODE_WHEN_PAUSED: "WHEN_PAUSED",
-	Node.PROCESS_MODE_ALWAYS: "ALWAYS",
-	Node.PROCESS_MODE_DISABLED: "DISABLED",
-}
-
 ## Whether this run has had the pointer note in full; the game process is the run.
 static var _pointer_explained: bool = false
 
@@ -151,7 +142,7 @@ func inject_action(params: Dictionary) -> Dictionary:
 		return {"type": "error", "message": "Action name required"}
 
 	if not InputMap.has_action(action):
-		return {"type": "error", "message": "Action not found: " + action}
+		return {"type": "error", "message": GdhValues.no_action(action)}
 	var holding: Variant = GdhValues.held_for(params)
 	if holding is String:
 		return {"type": "error", "message": holding}
@@ -159,6 +150,9 @@ func inject_action(params: Dictionary) -> Dictionary:
 
 	var focused: String = _focus_owner()
 	_say_action(action, whole or held, strength)
+	var shortcuts: Dictionary = {"shortcuts": [], "shortcut_pressed": null}
+	if whole or held:
+		shortcuts = await GdhValues.press_shortcuts(_host.get_tree().root, action)
 	var lasted: Variant = null
 	if whole:
 		# A frame between the halves at least, as a click has: a listener that acts on the press and
@@ -172,6 +166,8 @@ func inject_action(params: Dictionary) -> Dictionary:
 			"type": "input_injected",
 			"input_type": "action",
 			"action": action,
+			"shortcuts": shortcuts["shortcuts"],
+			"shortcut_pressed": shortcuts["shortcut_pressed"],
 			"pressed": held and not whole,
 			"whole": whole,
 			"held_frames": GdhValues.held_answer(whole, frames),
@@ -272,6 +268,7 @@ func inject_key(params: Dictionary) -> Dictionary:
 			"ctrl": event.ctrl_pressed,
 			"alt": event.alt_pressed,
 			"unicode": event.unicode,
+			"actions": GdhValues.actions_of(event),
 			"pressed": held and not whole,
 			"whole": whole,
 		},
@@ -317,7 +314,8 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 	# its drag from the press, which is where a real pointer would be.
 	var _moved: Vector2 = _arrive(position)
 	var supplied: bool = _follow_in_the_window(position)
-	Input.parse_input_event(_button(position, button, whole or held, double))
+	var press: InputEventMouseButton = _button(position, button, whole or held, double)
+	Input.parse_input_event(press)
 	var lasted: Variant = null
 	if notch:
 		Input.parse_input_event(_button(position, button, false, false))
@@ -326,7 +324,12 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 		# press and one that acts on the release each get a frame to do it in.
 		lasted = await GdhValues.hold(_host.get_tree(), frames)
 		Input.parse_input_event(_button(position, button, false, false))
-		await _host.get_tree().process_frame
+	# Input hands the events on at the next frame, so the control under the pointer is read after it.
+	await _host.get_tree().process_frame
+	var hovered: Control = _hover.hovered_in(_host.get_viewport())
+	var hovered_path: Variant = null
+	if hovered != null:
+		hovered_path = str(hovered.get_path())
 
 	var at: Array[Vector2] = [position]
 	var said: Dictionary = _pointer_noted(
@@ -338,6 +341,8 @@ func inject_mouse_click(params: Dictionary) -> Dictionary:
 				"held_for": lasted,
 				"position": [position.x, position.y],
 				"button": button,
+				"hovered": hovered_path,
+				"actions": GdhValues.actions_of(press),
 				"pressed": held and not whole,
 				"whole": whole,
 				"double": double
@@ -653,7 +658,8 @@ func click(params: Dictionary) -> Dictionary:
 	var was_pressed: Variant = null
 	if toggle != null and toggle.toggle_mode:
 		was_pressed = toggle.button_pressed
-	_press_button(viewport, _button(position, button, true, double))
+	var press: InputEventMouseButton = _button(position, button, true, double)
+	_press_button(viewport, press)
 	await _host.get_tree().process_frame
 	_press_button(viewport, _button(position, button, false, false))
 	# The release is what a button acts on, and a queue_free it causes lands at the end of
@@ -675,9 +681,16 @@ func click(params: Dictionary) -> Dictionary:
 		"double": double,
 		"hovered": hovered_path,
 		"landed": landed,
+		"actions": GdhValues.actions_of(press),
 		"control_afterwards": afterwards,
 		"scrolled_into_view": scrolled,
 	}
+	# A Label and a TextureRect ignore the pointer unless told otherwise, so the click goes to what is
+	# under them, and landed false with that control as hovered said nothing of why.
+	if not landed and control.mouse_filter == Control.MOUSE_FILTER_IGNORE:
+		answer["why_not_landed"] = (
+			"%s's mouse_filter is ignore, so the pointer passes through it to what is under it" % node_path
+		)
 	if found != null:
 		answer["found"] = found
 	if was_pressed != null:
@@ -718,7 +731,7 @@ func _takes_no_click(control: Control, node_path: String) -> String:
 			% [node_path, on]
 		)
 	if not control.can_process():
-		var why: String = _why_it_does_not_process(control, node_path)
+		var why: String = GdhTargets.why_it_does_not_process(control, node_path)
 		var over: Node = GdhTargets.drawn_over(control)
 		var cover: String = "" if over == null else "; %s is drawn over it" % over.get_path()
 		if _host.get_tree().paused:
@@ -730,23 +743,6 @@ func _takes_no_click(control: Control, node_path: String) -> String:
 	return ""
 
 
-## Which node's process_mode keeps [param control] from processing, and what it is. A node set to
-## inherit takes its parent's, so the one deciding can be any node above it: the game turning a
-## whole screen off while a menu shows over it reads, on the button, as a button turned off.
-static func _why_it_does_not_process(control: Control, node_path: String) -> String:
-	var deciding: Node = control
-	while deciding.process_mode == Node.PROCESS_MODE_INHERIT and deciding.get_parent() != null:
-		deciding = deciding.get_parent()
-	# The root inherits from nothing, which processes as pausable.
-	var value: int = deciding.process_mode
-	if value == Node.PROCESS_MODE_INHERIT:
-		value = Node.PROCESS_MODE_PAUSABLE
-	var mode: String = PROCESS_MODES.get(value, str(value))
-	if deciding == control:
-		return "its process_mode is %s" % mode
-	return "%s inherits process_mode %s from %s" % [node_path, mode, deciding.get_path()]
-
-
 ## Why a click at [param control]'s centre would reach nothing, or "" when it would reach it: the
 ## centre outside the viewport it is drawn in, at [param local]; outside the viewport showing that
 ## one on the screen, which [param reached] holds with the centre there; or clipped away by a

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

@@ -405,10 +405,13 @@ static func _arity(object: Object, method: String) -> Dictionary:
 ##
 ## A path is read, and a wait reads it every frame, so a call in one has to be a read. The engine
 ## marks its own reading methods const and `queue_free()`, `free()` and `set_name()` not, measured on
-## 4.7.2. A game's methods carry no such mark, so one declared `-> void` is taken at its word, as
-## doing something and answering nothing, and one left untyped is trusted. Without this a find
-## with property "queue_free()" freed every node it matched, and a wait on "advance_day()" called
-## it once a frame and then reported the state it had driven the game to.
+## 4.7.2, though it leaves some reads unmarked as well, `Engine.get_frames_drawn()` and
+## `get_time_scale()` among them; so the refusal says the mark is missing, not that the method
+## changes anything, and points at runtime_invoke call, which calls it. A game's methods carry no
+## such mark, so one declared `-> void` is taken at its word, as doing something and answering
+## nothing, and one left untyped is trusted. Without this a find with property "queue_free()" freed
+## every node it matched, and a wait on "advance_day()" called it once a frame and then reported the
+## state it had driven the game to.
 ##
 ## Given [param given] arguments, a call is the engine's and marked as reading, or it is refused. A
 ## game's method taking arguments is trusted on nothing at all: one answering a value can as well
@@ -450,7 +453,10 @@ static func call_refused(object: Object, method: String, called_as: String, give
 			)
 		return ""
 	if _native_flags(object, method) & METHOD_FLAG_CONST == 0:
-		return "%s.%s changes what it is called on rather than reading it%s" % [called_as, method, READS_ONLY]
+		return (
+			"%s.%s is not one the engine marks as only reading%s; runtime_invoke call calls it"
+			% [called_as, method, READS_ONLY]
+		)
 	return ""
 
 

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

@@ -723,6 +723,8 @@ func get_metrics(params: Dictionary) -> Dictionary:
 		"frame_time": frame_time,
 		"frame_time_max": frame_time_max,
 		"frames_timed": timed,
+		"process_frames": Engine.get_process_frames(),
+		"physics_frames": Engine.get_physics_frames(),
 		"physics_steps_per_second": physics_steps_per_second,
 		"physics_ticks_per_second": Engine.physics_ticks_per_second,
 		"max_physics_steps_per_frame": Engine.max_physics_steps_per_frame,

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

@@ -13,6 +13,15 @@ const GdhWords = preload("runtime_words.gd")
 ## How many of the controls saying the same words a refusal names, with the index for each.
 const LISTED_CANDIDATES: int = 10
 
+## Node.ProcessMode as its names, for a refusal to say which one is in force.
+const PROCESS_MODES: Dictionary[int, String] = {
+	Node.PROCESS_MODE_INHERIT: "INHERIT",
+	Node.PROCESS_MODE_PAUSABLE: "PAUSABLE",
+	Node.PROCESS_MODE_WHEN_PAUSED: "WHEN_PAUSED",
+	Node.PROCESS_MODE_ALWAYS: "ALWAYS",
+	Node.PROCESS_MODE_DISABLED: "DISABLED",
+}
+
 ## What a game started without a window gets whatever the project settings say, and the usual
 ## reason a control is out of reach. Only worth telling somebody when it is what they have.
 const HEADLESS_VIEWPORT: Vector2 = Vector2(64, 64)
@@ -954,3 +963,20 @@ static func _out_of_reach_exactly(nodes: Array[Node], why: Array[String]) -> Str
 	if nodes.size() == 1:
 		return "1 control says exactly that and cannot be clicked: %s" % first
 	return "%d controls say exactly that and cannot be clicked, such as %s" % [nodes.size(), first]
+
+
+## Which node's process_mode keeps [param control] from processing, and what it is. A node set to
+## inherit takes its parent's, so the one deciding can be any node above it: the game turning a
+## whole screen off while a menu shows over it reads, on the button, as a button turned off.
+static func why_it_does_not_process(control: Control, node_path: String) -> String:
+	var deciding: Node = control
+	while deciding.process_mode == Node.PROCESS_MODE_INHERIT and deciding.get_parent() != null:
+		deciding = deciding.get_parent()
+	# The root inherits from nothing, which processes as pausable.
+	var value: int = deciding.process_mode
+	if value == Node.PROCESS_MODE_INHERIT:
+		value = Node.PROCESS_MODE_PAUSABLE
+	var mode: String = PROCESS_MODES.get(value, str(value))
+	if deciding == control:
+		return "its process_mode is %s" % mode
+	return "%s inherits process_mode %s from %s" % [node_path, mode, deciding.get_path()]

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

@@ -31,6 +31,9 @@ const SINGLETONS: Array[String] = [
 ## The most frames a press is held in one call, as many as a frames wait takes.
 const MOST_HELD: int = 600
 
+## Read by [method _key_names], once a game.
+static var _named_keys: PackedStringArray = []
+
 var _shared: GdhSerialisation = GdhSerialisation.new()
 
 
@@ -160,12 +163,7 @@ static func glyph_of(keycode: Key, shifted: bool) -> int:
 ## engine's own names, printable keys and the special ones above [constant KEY_SPECIAL], since the
 ## game takes any name OS.find_keycode_from_string does.
 static func unknown_key(name: String) -> String:
-	var names: PackedStringArray = []
-	for code: int in range(32, 127) + range(KEY_SPECIAL + 1, KEY_SPECIAL + 0x100):
-		var spelled: String = OS.get_keycode_string(code as Key)
-		if not spelled.is_empty() and OS.find_keycode_from_string(spelled) == code:
-			var _named: bool = names.append(spelled)
-	var close: PackedStringArray = GdhRead.nearest(name, names)
+	var close: PackedStringArray = GdhRead.nearest(name, _key_names())
 	var said: String = "No key is called %s." % name
 	if close.size() == 1:
 		said += " The nearest key name is %s." % close[0]
@@ -178,6 +176,107 @@ static func unknown_key(name: String) -> String:
 	)
 
 
+## Every key name the engine takes, read once a game. The engine spells a code it has no name for as
+## the character it would be, and past the last code point that is an error it prints: 136 of them
+## for the special range, two seconds of console on a fast machine, more than a call's whole wait on
+## a loaded one, and each in the game's log as an error the game never made. So they are asked with
+## the engine's error printing off, which no other line of the main thread runs beside.
+static func _key_names() -> PackedStringArray:
+	if not _named_keys.is_empty():
+		return _named_keys
+	var printing: bool = Engine.print_error_messages
+	Engine.print_error_messages = false
+	for code: int in range(32, 127) + range(KEY_SPECIAL + 1, KEY_SPECIAL + 0x100):
+		var spelled: String = OS.get_keycode_string(code as Key)
+		if not spelled.is_empty() and OS.find_keycode_from_string(spelled) == code:
+			var _named: bool = _named_keys.append(spelled)
+	Engine.print_error_messages = printing
+	return _named_keys
+
+
+## The refusal for [param action], which the input map lacks, with the nearest of the project's own
+## actions, or else all of them. The engine's ui_ ones are in every project, and offered for any name
+## they only buried the project's ("dance" is near ui_cancel), so they are offered for a ui_ name only.
+static func no_action(action: String) -> String:
+	var engine: PackedStringArray = []
+	var own: PackedStringArray = []
+	for named: StringName in InputMap.get_actions():
+		if str(named).begins_with("ui_"):
+			var _listed: bool = engine.append(str(named))
+		else:
+			var _owned: bool = own.append(str(named))
+	own.sort()
+	var said: String = "Action not found: %s" % action
+	var close: PackedStringArray = GdhRead.nearest(action, engine if action.begins_with("ui_") else own)
+	if not close.is_empty():
+		return "%s; the nearest %s %s." % [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+	if own.is_empty():
+		return "%s; the project defines no actions of its own, and the engine's are the ui_ ones." % said
+	return "%s; the project's own actions are %s, beside the engine's ui_ ones." % [said, ", ".join(own)]
+
+
+## The actions of the input map that [param event] stands for, as Input reads it for
+## is_action_pressed: a key or a button bound to an action presses that action too, so a game
+## counting the action counted the key, and the answer had said only that a key went in.
+static func actions_of(event: InputEvent) -> Array[String]:
+	var named: Array[String] = []
+	for action: StringName in InputMap.get_actions():
+		if InputMap.event_is_action(event, action):
+			named.append(str(action))
+	named.sort()
+	return named
+
+
+## Presses the buttons under [param root] whose Shortcut [param action] matches, as the player's key
+## bound to it would, and answers their paths under "shortcuts" and the one that took the press
+## under "shortcut_pressed". A Viewport hands a shortcut only keys, joypad buttons and
+## InputEventShortcut, so an action pressed on its own never reached a Button whose Shortcut holds
+## that action, which is how a game gives a button a binding the player can change.
+##
+## A key goes to the shortcuts last in the tree first and stops at the first button that takes it,
+## while an InputEventShortcut reaches only the buttons holding that one Shortcut. So each Shortcut
+## is sent in that order, a frame apart, until a button is pressed; a button still decides by its
+## disabled, its visibility and its shortcut context, as it does for the key.
+static func press_shortcuts(root: Node, action: String) -> Dictionary:
+	var pressing: InputEventAction = InputEventAction.new()
+	pressing.action = action
+	pressing.pressed = true
+	var buttons: Array[BaseButton] = []
+	for node: Node in root.find_children("*", "BaseButton", true, false):
+		var button: BaseButton = node
+		if button.shortcut != null and button.shortcut.matches_event(pressing):
+			buttons.append(button)
+	var paths: Array[String] = []
+	for button: BaseButton in buttons:
+		paths.append(str(button.get_path()))
+	buttons.reverse()
+	var taken: Array[String] = []
+	var heard: Array[Callable] = []
+	for button: BaseButton in buttons:
+		var path: String = str(button.get_path())
+		var hearing: Callable = func() -> void: taken.append(path)
+		heard.append(hearing)
+		var _listening: int = button.pressed.connect(hearing)
+	var sent: Dictionary = {}
+	for button: BaseButton in buttons:
+		if not taken.is_empty():
+			break
+		if sent.has(button.shortcut):
+			continue
+		sent[button.shortcut] = true
+		var through: InputEventShortcut = InputEventShortcut.new()
+		through.shortcut = button.shortcut
+		Input.parse_input_event(through)
+		await root.get_tree().process_frame
+	for at: int in buttons.size():
+		if is_instance_valid(buttons[at]):
+			buttons[at].pressed.disconnect(heard[at])
+	var pressed: Variant = null
+	if not taken.is_empty():
+		pressed = taken[0]
+	return {"shortcuts": paths, "shortcut_pressed": pressed}
+
+
 ## What [param path] names: a node under [param root], as [method node_at] reads it, or an engine
 ## singleton by its name. Answers the object under "object", and under "node" the node that objects
 ## named in a value are found from, which for a singleton is [param root].

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

@@ -142,28 +142,29 @@ func serialize_value(value: Variant) -> Variant:
 		return value
 	var carried: Variant = call(serialiser, value)
 	# The fixed shapes carry their components as bare floats, so an infinite one in a Vector2 is
-	# tagged here; containers reach their members through this function already.
-	return carried if typeof(value) in [TYPE_ARRAY, TYPE_DICTIONARY] else _finite(carried)
+	# tagged here, and a 32-bit one shortened; containers reach their members through this already.
+	var type: int = typeof(value)
+	return carried if type in [TYPE_ARRAY, TYPE_DICTIONARY] else _finite(carried, GdhRead.holds_singles(type))
 
 
 # [param carried] with every non-finite float in it tagged. JSON has no spelling for infinity or
 # NaN: the engine writes 1e99999 and null, and the server, reading 1e99999 as Infinity, writes it
 # back out as null, so a property holding INF was answered as holding nothing.
-func _finite(carried: Variant) -> Variant:
+func _finite(carried: Variant, single: bool = false) -> Variant:
 	if carried is float:
 		var number: float = carried
-		return _serialize_float(number)
+		return _serialize_float(GdhRead.single(number) if single else number)
 	if carried is Dictionary:
 		var fields: Dictionary = carried
 		var tagged: Dictionary = {}
 		for key: Variant in fields:
-			tagged[key] = _finite(fields[key])
+			tagged[key] = _finite(fields[key], single)
 		return tagged
 	if carried is Array:
 		var items: Array = carried
 		var tagged_items: Array = []
 		for item: Variant in items:
-			tagged_items.append(_finite(item))
+			tagged_items.append(_finite(item, single))
 		return tagged_items
 	return carried
 
@@ -189,7 +190,7 @@ func _serialize_floats(value: Variant) -> Variant:
 			for each: float in numbers:
 				items.append(_serialize_float(each))
 			return items
-	return value
+	return numbers if value is PackedFloat32Array else value
 
 
 # Rebuilds a Godot value from the shape serialize_value gave it.

package/build/godot/operations/editor_tools.gd

@@ -7,6 +7,7 @@ extends RefCounted
 ## made here passes the same checks and answers in the same shape. What the engine does that an
 ## editor does not, running every script, is put back in scene_file.gd and headless_check.gd.
 
+const GdhAnimationStates = preload("../addons/gdharness_editor/tools/animation_states.gd")
 const GdhAnimationTools = preload("../addons/gdharness_editor/tools/animation_tools.gd")
 const GdhResourceTools = preload("../addons/gdharness_editor/tools/resource_tools.gd")
 const GdhSceneTools = preload("../addons/gdharness_editor/tools/scene_tools.gd")
@@ -36,11 +37,16 @@ const RESOURCE_COMMANDS: Array[String] = [
 const ANIMATION_COMMANDS: Array[String] = [
 	"create_animation",
 	"add_animation_track",
+	"remove_animation_track",
 	"set_animation",
 	"rename_animation",
 	"remove_animation",
+]
+const ANIMATION_STATE_COMMANDS: Array[String] = [
 	"add_animation_state",
 	"connect_animation_states",
+	"remove_animation_state",
+	"disconnect_animation_states",
 ]
 
 
@@ -60,6 +66,8 @@ static func run(params: Dictionary) -> Dictionary:
 		tools = GdhResourceTools.new()
 	elif command in ANIMATION_COMMANDS:
 		tools = GdhAnimationTools.new()
+	elif command in ANIMATION_STATE_COMMANDS:
+		tools = GdhAnimationStates.new()
 	else:
 		return {"ok": false, "error": "No editor tool runs headless as " + command}
 	var answer: Variant = tools.call(command, arguments)

package/build/godot/operations/file_reads.gd

@@ -119,6 +119,9 @@ static func _laid(scene_path: String) -> Dictionary:
 		return {"ok": false, "error": refused}
 	if not nodes.has("."):
 		return {"ok": false, "error": "%s holds no nodes" % scene_path}
+	var base: SceneState = packed.get_state().get_base_scene_state()
+	if base != null:
+		nodes["."]["inherits"] = base.get_path()
 	return {"ok": true, "nodes": nodes}
 
 
@@ -175,6 +178,10 @@ static func _lay(
 				nodes[path] = _made(str(state.get_node_type(index)))
 			if ids[index] >= 0:
 				nodes[path]["uniqueId"] = ids[index]
+			# Laid at the root with no scene handed in is a scene the one being read inherits, and the
+			# deepest is laid first, so this is the file that makes the node.
+			if prefix == "." and loaded == null:
+				nodes[path]["inheritedFrom"] = state.get_path()
 		# The name is the state's even for an entry laid already, since an inherited scene names its
 		# root itself; a root instanced inside another scene is renamed by that scene once laid.
 		if not recovered:
@@ -324,6 +331,12 @@ static func _entry(
 		data["instanceOf"] = node["instanceOf"]
 		if node.has("editableChildren"):
 			data["editableChildren"] = node["editableChildren"]
+	# An inherited scene's file holds only what it changes, so the read says what it inherits and
+	# which nodes come from there, as the editor greys them.
+	if node.has("inherits"):
+		data["inherits"] = node["inherits"]
+	elif node.has("inheritedFrom"):
+		data["inheritedFrom"] = node["inheritedFrom"]
 	var groups: Array[String] = node["groups"]
 	if not groups.is_empty():
 		var sorted: Array[String] = groups.duplicate()

package/build/godot/operations/gdscript_analysis.gd

@@ -76,6 +76,9 @@ func get_gdscript_info(params: Dictionary) -> Dictionary:
 	if not full_script_path.begins_with("res://"):
 		full_script_path = "res://" + full_script_path
 
+	# Read as GDScript, a scene came back as a script extending RefCounted with nothing in it.
+	if full_script_path.get_extension().to_lower() != "gd":
+		return _log.failure(_not_a_script(full_script_path))
 	if not FileAccess.file_exists(full_script_path):
 		return _log.failure(
 			GdhFileWalk.new().with_nearest_files(
@@ -334,6 +337,17 @@ func _inner_class(
 	return body
 
 
+## The refusal for [param path], which is not a .gd file, with the tool that reads what it is.
+static func _not_a_script(path: String) -> String:
+	var said: String = "%s is not a GDScript file, and script_info reads .gd files only" % path
+	match path.get_extension().to_lower():
+		"tscn", "scn":
+			return said + ": scene_tree reads a scene's nodes, and with properties the script each carries."
+		"tres", "res":
+			return said + ": resource_edit read reads a resource."
+	return said + "."
+
+
 static func _indentation(line: String) -> String:
 	return line.substr(0, line.length() - line.strip_edges(true, false).length())
 

package/build/godot/operations/gdscript_authoring.gd

@@ -259,7 +259,7 @@ func modify_gdscript(params: Dictionary) -> Dictionary:
 			)
 		return _log.failure(
 			(
-				"Nothing was changed: %s parses as it is and would not with these additions: %s"
+				"Nothing was changed: %s parses now, and would not with these additions: %s"
 				% [script_path, _reasons(caught.raised, full_script_path)]
 			)
 		)

package/build/godot/operations/godot_operations.gd

@@ -247,6 +247,8 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 			payload = GdhProjectConfig.new(_log).get_project_setting(params)
 		"set_project_setting":
 			payload = GdhProjectConfig.new(_log).set_project_setting(params)
+		"unset_project_setting":
+			payload = GdhProjectConfig.new(_log).unset_project_setting(params)
 		"add_autoload":
 			payload = GdhProjectConfig.new(_log).add_autoload(params)
 		"remove_autoload":

package/build/godot/operations/input_actions.gd

@@ -3,6 +3,8 @@ extends RefCounted
 const GdhRead = preload("reading.gd")
 const GdhLog = preload("logger.gd")
 const GdhProjectFile = preload("project_file.gd")
+## The device an event matches every device with, InputMap's ALL_DEVICES, which GDScript is not given.
+const ALL_DEVICES: int = -1
 
 # The key names a caller may write, and what the engine calls them.
 const KEY_NAMES: Dictionary = {
@@ -108,7 +110,13 @@ func _init(p_log: GdhLog) -> void:
 func add_input_action(params: Dictionary) -> Dictionary:
 	var action_name: String = str(params.get("action_name", ""))
 	var events: Array = params.get("events", [])
-	var deadzone: float = GdhRead.as_float(params.get("deadzone", 0.5), 0.5)
+	var setting: String = "input/" + action_name
+	var held: Variant = ProjectSettings.get_setting(setting) if ProjectSettings.has_setting(setting) else null
+	var old: Dictionary = held if held is Dictionary else {}
+	var old_deadzone: float = GdhRead.as_float(old.get("deadzone", 0.5), 0.5)
+	# A rebind that names no deadzone keeps the one the action has, which a caller adding a key did
+	# not mean to change.
+	var deadzone: float = GdhRead.as_float(params.get("deadzone", old_deadzone), old_deadzone)
 
 	_log.info("Adding input action: " + action_name)
 	# The editor's Input Map refuses these, since project.godot keys an action by its name and
@@ -150,7 +158,9 @@ func add_input_action(params: Dictionary) -> Dictionary:
 				if key_value == KEY_NONE:
 					return _log.failure(_unknown_key(keycode))
 
-				var event_config: Dictionary = {"class_name": "InputEventKey", "keycode": key_value}
+				var event_config: Dictionary = {"class_name": "InputEventKey"}
+				var physical: bool = GdhRead.as_bool(fields.get("physical", false))
+				event_config["physical_keycode" if physical else "keycode"] = key_value
 				if fields.get("ctrl", false):
 					event_config["ctrl_pressed"] = true
 				if fields.get("alt", false):
@@ -190,7 +200,6 @@ func add_input_action(params: Dictionary) -> Dictionary:
 
 	# An action that exists is rebound, which is how one of the engine's ui_ actions is changed, so
 	# what it held is answered rather than lost without a word.
-	var setting: String = "input/" + action_name
 	var answer: Dictionary = {
 		"action_name": action_name,
 		"events_count": events_config.size(),
@@ -199,8 +208,6 @@ func add_input_action(params: Dictionary) -> Dictionary:
 		"was_new": not ProjectSettings.has_setting(setting),
 	}
 	if not answer["was_new"]:
-		var held: Variant = ProjectSettings.get_setting(setting)
-		var old: Dictionary = held if held is Dictionary else {}
 		var old_events: Array[Dictionary] = []
 		var listed: Variant = old.get("events", [])
 		if listed is Array:
@@ -210,7 +217,7 @@ func add_input_action(params: Dictionary) -> Dictionary:
 					var bound: InputEvent = event
 					old_events.append(_shaped(bound))
 		answer["old_events"] = old_events
-		answer["old_deadzone"] = GdhRead.as_float(old.get("deadzone", 0.5), 0.5)
+		answer["old_deadzone"] = old_deadzone
 
 	# Through ProjectSettings so the file is saved the way the editor saves it, header and
 	# every other line kept; a ConfigFile of project.godot drops the comments on the way out.
@@ -226,9 +233,12 @@ func add_input_action(params: Dictionary) -> Dictionary:
 ## under text, which also covers a kind of event that form has no fields for.
 static func _shaped(event: InputEvent) -> Dictionary:
 	var shaped: Dictionary = {"class_name": event.get_class(), "text": event.as_text()}
+	if event.device != ALL_DEVICES:
+		shaped["device"] = event.device
 	if event is InputEventKey:
 		var key: InputEventKey = event
-		shaped["keycode"] = key.keycode
+		if key.keycode != KEY_NONE or key.physical_keycode == KEY_NONE:
+			shaped["keycode"] = key.keycode
 		if key.physical_keycode != KEY_NONE:
 			shaped["physical_keycode"] = key.physical_keycode
 		for modifier: String in ["ctrl_pressed", "alt_pressed", "shift_pressed"]:
@@ -328,6 +338,7 @@ func build_input_action(deadzone: float, events: Array) -> Dictionary:
 			"InputEventKey":
 				var key: InputEventKey = InputEventKey.new()
 				key.keycode = GdhRead.as_int(event.get("keycode", 0)) as Key
+				key.physical_keycode = GdhRead.as_int(event.get("physical_keycode", 0)) as Key
 				key.ctrl_pressed = GdhRead.as_bool(event.get("ctrl_pressed", false))
 				key.alt_pressed = GdhRead.as_bool(event.get("alt_pressed", false))
 				key.shift_pressed = GdhRead.as_bool(event.get("shift_pressed", false))
@@ -354,6 +365,10 @@ func build_input_action(deadzone: float, events: Array) -> Dictionary:
 
 			_:
 				return _log.failure("Unknown input event class: " + evt_class)
+		# Every device, as the editor's Input Map binds an event: a new event names one device, and
+		# an action bound to it ignored a second joypad.
+		var bound: InputEvent = built.back()
+		bound.device = ALL_DEVICES
 
 	return {"deadzone": deadzone, "events": built}