gdharness 1.3.45 → 1.3.47

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

@@ -560,11 +560,12 @@ func reparent_node(args: Dictionary) -> Dictionary:
 	GdhPlacing.own(node, root)
 	if GdhRead.as_bool(args.get("keepGlobalTransform", true)):
 		GdhPlacing.keep_in_place(node, old_parent)
-		# Unasked, a headless write takes the move on a node whose script is not a tool for the
-		# script's doing and puts the node back as the file held it.
-		var placed: Array[String] = GdhHeadlessCheck.differing(node, stored_before, {})
-		if not placed.is_empty():
-			scene.asked(node, placed)
+	# Unasked, a headless write takes the move on a node whose script is not a tool for the script's
+	# doing and puts the node back as the file held it. A new parent changes more than where the
+	# node is drawn: a container gives a Control its own layout mode.
+	var placed: Array[String] = GdhHeadlessCheck.differing(node, stored_before, {})
+	if not placed.is_empty():
+		scene.asked(node, placed)
 	var also_changed: Dictionary = {}
 	for property: String in drawn_at:
 		var now: Variant = _properties.read_at(node, property)
@@ -572,6 +573,18 @@ func reparent_node(args: Dictionary) -> Dictionary:
 			also_changed[property] = {
 				"was": _readable(node, drawn_at[property]), "now": _readable(node, now),
 			}
+	var drawn_in: Array[String] = GdhPlacing.placed_in(node)
+	for property: String in placed:
+		if property in drawn_in or also_changed.has(property):
+			continue
+		var was: Variant = (
+			stored_before[property]
+			if stored_before.has(property)
+			else GdhHeadlessCheck.default_of(node, property)
+		)
+		also_changed[property] = {
+			"was": _readable(node, was), "now": _readable(node, node.get(property)),
+		}
 	var sheared: String = ""
 	if node is Node3D and GdhPlacing.sheared((node as Node3D).basis):
 		var spatial: Node3D = node
@@ -705,6 +718,15 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 		if property != "name" and property in node and not named.has(property):
 			named.append(property)
 	var source: String = scene.values_from(node, old_path)
+	# Read before the write, which frees the node.
+	var unsaved: Array[String] = []
+	for declared: Dictionary in node.get_property_list():
+		var declared_name: String = str(declared.get("name", ""))
+		if (
+			named.has(declared_name)
+			and not GdhRead.as_int(declared.get("usage", 0)) & PROPERTY_USAGE_STORAGE
+		):
+			unsaved.append(declared_name)
 	var carried: GdhPaths = GdhPaths.new()
 	var _rewritten: int = carried.carry(
 		scene,
@@ -738,7 +760,7 @@ func set_node_properties(args: Dictionary) -> Dictionary:
 		answer["droppedNodes"] = dropped["nodes"]
 	_note_put_back(answer, scene, id, new_path)
 	_note_loads_as(answer, scene, new_path)
-	_note_left_out(answer, scene.written_pack, new_path, named, source)
+	_note_left_out(answer, scene.written_pack, new_path, named, unsaved, source)
 	if new_path != old_path:
 		answer.merge(GdhKin.follow(scene_path, old_path, new_path, carried))
 	return answer
@@ -780,9 +802,15 @@ static func _note_put_back(answer: Dictionary, scene: GdhSceneFile, id: int, at:
 
 ## Notes under notStored each of [param named] the file saved from [param pack] does not set on the
 ## node at [param at]: a set gave it the value the node has without it, so the packer leaves it out,
-## as the editor does, and it follows [param source], or its default, from then on.
+## as the editor does, and it follows [param source], or its default, from then on. [param unsaved]
+## are those of them the node never stores by name.
 static func _note_left_out(
-	answer: Dictionary, pack: PackedScene, at: String, named: Array[String], source: String
+	answer: Dictionary,
+	pack: PackedScene,
+	at: String,
+	named: Array[String],
+	unsaved: Array[String],
+	source: String
 ) -> void:
 	var stored: Dictionary = {}
 	var state: SceneState = pack.get_state()
@@ -790,9 +818,13 @@ static func _note_left_out(
 		if str(state.get_node_path(index)).trim_prefix("./") == at:
 			for property: int in state.get_node_property_count(index):
 				stored[str(state.get_node_property_name(index, property))] = true
+	# A property the file never holds by name, as a Control's position, which its offsets hold, is
+	# stored when what changed with it is.
+	var also: Dictionary = answer.get("alsoChanged", {})
+	var held_with_it: bool = also.keys().any(func(other: Variant) -> bool: return stored.has(other))
 	var left: Array[String] = []
 	for asked: String in named:
-		if not stored.has(asked):
+		if not stored.has(asked) and not (held_with_it and unsaved.has(asked)):
 			left.append(asked)
 	if left.is_empty():
 		return

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

@@ -92,6 +92,19 @@ func connect_signal(args: Dictionary) -> Dictionary:
 	if unbinds > 0:
 		callable = callable.unbind(unbinds)
 	var method_found: bool = target.has_method(method_name)
+	if not method_found and (not binds.is_empty() or unbinds > 0):
+		var named_to: String = str(target.name) if target == scene.root else target_node_path
+		return scene.refuse(
+			(
+				(
+					"%s has no method %s, and the engine connects a signal that binds or unbinds "
+					+ "arguments only to a method its target has, so the scene would load without "
+					+ "the connection. Add the method to the target's script first, or connect "
+					+ "without binds and unbinds."
+				)
+				% [named_to, method_name]
+			)
+		)
 	var misfit: String = _misfit(source, signal_name, callable, flags)
 	if not before.is_empty():
 		var held: Callable = before["callable"]
@@ -102,6 +115,7 @@ func connect_signal(args: Dictionary) -> Dictionary:
 
 	var from: String = scene.path_of(source)
 	var to: String = scene.path_of(target)
+	var _replaced: Dictionary = scene.drop_unmade(from, signal_name, to, method_name)
 	var saved: Dictionary = {}
 	var written: Dictionary = scene.write(
 		func(loaded: Node) -> String:
@@ -464,7 +478,11 @@ func disconnect_signal(args: Dictionary) -> Dictionary:
 	# A connection that was never there saved the scene unchanged and answered as removed, so a
 	# typo in either name read as success.
 	var held: Dictionary = _saved(scene.root, from, signal_name, to, method_name)
-	if held.is_empty():
+	# One the engine could not make is in the file alone, and the write drops it.
+	var unmade: Dictionary = scene.drop_unmade(from, signal_name, to, method_name)
+	if held.is_empty() and not unmade.is_empty():
+		held = { "flags": unmade["flags"], "binds": unmade["binds"], "unbinds": unmade["unbinds"] }
+	elif held.is_empty():
 		# The root's path is ".", which before ".method" read as "..method".
 		var said_from: String = str(source.name) if source == scene.root else from
 		var said_to: String = str(target.name) if target == scene.root else to
@@ -492,8 +510,9 @@ func disconnect_signal(args: Dictionary) -> Dictionary:
 				)
 			)
 		)
-	var callable: Callable = held["callable"]
-	source.disconnect(signal_name, callable)
+	if held.has("callable"):
+		var callable: Callable = held["callable"]
+		source.disconnect(signal_name, callable)
 
 	var written: Dictionary = scene.write(
 		func(loaded: Node) -> String:

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

@@ -303,6 +303,13 @@ func set_tilemap_cells(args: Dictionary) -> Dictionary:
 		wanted.append([at, source_id, atlas_coords, alternative])
 		if source_id == -1:
 			erased += 1
+	# An erased cell leaves the layer's data at its next update, which a layer outside the tree
+	# never has, so the pack wrote it as a cell naming no tile, where the editor's save leaves it
+	# out.
+	if layered != null:
+		layered.update_internals()
+	else:
+		single.update_internals()
 
 	var at_path: String = scene.path_of(node)
 	var written: Dictionary = scene.write(

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

@@ -62,6 +62,15 @@ func set_property(params: Dictionary) -> Dictionary:
 			"type": "error",
 			"message": GdhPaths.nothing_there(holder, named, str(reached["called"])),
 		}
+	if GdhPaths.is_constant(holder, named):
+		return {
+			"type": "error",
+			"message":
+			(
+				"%s:%s is a constant its script declares, and a constant cannot be set"
+				% [reached["called"], named]
+			),
+		}
 	var old_value: Variant = GdhPaths.read_under(holder, named)
 	var slot: Dictionary = GdhValues.slot_declared(holder, named)
 	var declared: int = slot["type"]

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

@@ -503,7 +503,7 @@ static func can_read(holder: Variant, named: String) -> bool:
 		var object: Object = holder
 		if not method.is_empty():
 			return call_refused(object, method, "", args.size()).is_empty()
-		return _has_property(object, named)
+		return _has_property(object, named) or not constant_of(object, named).is_empty()
 	return false
 
 
@@ -876,7 +876,7 @@ static func read_under(holder: Variant, named: String) -> Variant:
 	if not method.is_empty():
 		var args: Array = arguments_of(named)["args"]
 		return object.callv(method, args)
-	return object.get(named)
+	return constant_of(object, named)[0] if is_constant(object, named) else object.get(named)
 
 
 ## Where [param named] lands in a list of [param size], or -1 for a step that is not in it.
@@ -1030,3 +1030,30 @@ static func _has_property(holder: Object, named: String) -> bool:
 		if str(entry["name"]) == named:
 			return true
 	return false
+
+
+## The constant [param named] that [param holder]'s script or a script it extends declares, in a
+## list of one, or an empty list. A constant is no property, so the property list never names it,
+## and `get` answers null for one.
+static func constant_of(holder: Variant, named: String) -> Array:
+	if not holder is Object:
+		return []
+	var object: Object = holder
+	var attached: Variant = object.get_script()
+	if not attached is Script:
+		return []
+	var script: Script = attached
+	while script != null:
+		var constants: Dictionary = script.get_script_constant_map()
+		if constants.has(named):
+			return [constants[named]]
+		script = script.get_base_script()
+	return []
+
+
+## Whether [param named] reaches a constant on [param holder] rather than a property.
+static func is_constant(holder: Variant, named: String) -> bool:
+	if not holder is Object:
+		return false
+	var object: Object = holder
+	return not _has_property(object, named) and not constant_of(object, named).is_empty()

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

@@ -17,6 +17,11 @@ const MOST_FRAMES: int = 600
 ## How long a wait for words leaves between looks, as a multiple of what the last look took: nine
 ## gives looking about a tenth of the time.
 const LOOKS_APART: int = 9
+## The longest a wait for words holds one of the game's frames while it looks, in microseconds: a
+## look over a screen too large to read in that time carries on in the next frame from where it
+## stopped. Read whole, a look over an interface of about 1,000 labels held a frame for 28ms every
+## few dozen, which a game logging its own frame times took for a hitch of its own.
+const LOOK_SLICE_USEC: int = 2000
 ## How a property wait compares what it reads with the value: equality by default, and order for a
 ## number that steps rather than lands, as a day counter on a fast clock goes from 31 to 34 between
 ## two looks and a wait for 32 never sees it.
@@ -785,9 +790,12 @@ static func _declared_slot(holder: Variant, named: String) -> Dictionary:
 ## looking takes about a tenth of the time. Every frame on a hall of 3,500 nodes held the game at a
 ## sixth of its frame rate, and its clock, which advances by the frame's delta, lost three quarters
 ## of its time, so a wait for a date timed out on a clock that turned a day every thirty seconds.
-## The answer says how many frames the wait spanned, how many looks it took and how long they took
-## between them, which is how a caller sees what it cost and whether the game lost its speed to the
-## looks or to something else.
+## Each look is read a slice at a time, [constant LOOK_SLICE_USEC] to a frame, so the frames it runs
+## in keep their length; the last is read whole, since the wait answers on it.
+##
+## The answer says how many frames the wait spanned, how many looks it took, how long they took
+## between them and the longest they held one frame, which is how a caller sees what it cost and
+## whether the game lost its speed, or a frame its length, to the looks or to something else.
 func _wait_until_said(
 	node_path: String, said: String, timeout_ms: int, include_hidden: bool
 ) -> Dictionary:
@@ -795,18 +803,29 @@ func _wait_until_said(
 	var frames: int = 0
 	var looks: int = 0
 	var looked_usec: int = 0
+	var held_usec: int = 0
 	var next_look: int = 0
 	var looked_at_frame: int = 0
 	var found: bool = false
+	var look: GdhLook = null
+	var look_began: int = 0
 	while true:
-		if Time.get_ticks_usec() >= next_look:
-			var looking: int = Time.get_ticks_usec()
-			found = _anything_says(node_path, said, include_hidden)
-			looks += 1
-			var took: int = Time.get_ticks_usec() - looking
-			looked_usec += took
-			next_look = Time.get_ticks_usec() + took * LOOKS_APART
+		if look == null and Time.get_ticks_usec() >= next_look:
+			look = GdhLook.new(_under(node_path), said, include_hidden)
+			look_began = Time.get_ticks_usec()
+		if look != null:
+			var held: int = look.go_on(LOOK_SLICE_USEC)
+			looked_usec += held
+			held_usec = maxi(held_usec, held)
 			looked_at_frame = frames
+			if look.done:
+				looks += 1
+				found = look.found
+				# From where the look began, since the frames it was read across are the game's:
+				# counted from its end, a look spread over a third of a second waited out its nine
+				# lengths after that, and a wait on 3,500 nodes looked four times in two seconds.
+				next_look = look_began + look.took_usec * (LOOKS_APART + 1)
+				look = null
 		if found or Time.get_ticks_msec() - started >= timeout_ms:
 			break
 		await _host.get_tree().process_frame
@@ -815,14 +834,18 @@ func _wait_until_said(
 	# never having come. Taken once a whole frame has run since the last look, which is two frame
 	# starts: a first look that outlasted the timeout otherwise left none, so the wait answered with
 	# the game not having run at all, and a command sent during that look not yet read.
+	var heard: bool = found
 	if not found:
 		while frames - looked_at_frame < 2:
 			await _host.get_tree().process_frame
 			frames += 1
-		var last: int = Time.get_ticks_usec()
-		found = _anything_says(node_path, said, include_hidden)
+		var last: GdhLook = GdhLook.new(_under(node_path), said, include_hidden)
+		var held: int = last.go_on(-1)
 		looks += 1
-		looked_usec += Time.get_ticks_usec() - last
+		looked_usec += held
+		held_usec = maxi(held_usec, held)
+		found = last.found
+		heard = last.heard
 
 	var answer: Dictionary = {
 		"type": "condition",
@@ -834,10 +857,11 @@ func _wait_until_said(
 		"frames": frames,
 		"looks": looks,
 		"looking_ms": looked_usec / 1000.0,
+		"longest_hold_ms": held_usec / 1000.0,
 	}
 	# Words that are there and cannot be read look, from a wait that ran out, like words that never
 	# came.
-	if not found and not include_hidden and _anything_says(node_path, said, true):
+	if not found and heard:
 		answer["unseen_note"] = (
 			(
 				"Something under %s says it, but is hidden or drawn outside the viewport or a "
@@ -849,22 +873,8 @@ func _wait_until_said(
 	return answer
 
 
-## Whether anything under [param node_path] says [param said], the node itself included, and where
-## the player can read it unless hidden ones are wanted too. Matched as a find and a click match
-## `says`, a glob over the whole text when it has `*` or `?`: read as literal words, a glob a click
-## had just pressed by was waited on for the whole timeout with its label on screen, and answered as
-## words never arriving.
-func _anything_says(node_path: String, said: String, include_hidden: bool) -> bool:
-	var root: Node = _host.get_tree().root.get_node_or_null(node_path)
-	if root == null:
-		return false
-	var pending: Array[Node] = [root]
-	while not pending.is_empty():
-		var node: Node = pending.pop_back()
-		if GdhSays.says(node, said) and (include_hidden or GdhQueries.readable(node)):
-			return true
-		pending.append_array(node.get_children(true))
-	return false
+func _under(node_path: String) -> Node:
+	return _host.get_tree().root.get_node_or_null(node_path)
 
 
 ## Remembers that a signal fired and what it carried, for a wait that polls rather than
@@ -942,6 +952,56 @@ class GdhTrace:
 			dropped += 1
 
 
+## One look for whether anything under a node says some words, the node itself included, and where
+## the player can read it unless hidden ones are wanted too. Matched as a find and a click match
+## `says`, a glob over the whole text when it has `*` or `?`: read as literal words, a glob a click
+## had just pressed by was waited on for the whole timeout with its label on screen, and answered as
+## words never arriving.
+class GdhLook:
+	extends RefCounted
+	## Whether a node that counts says the words.
+	var found: bool = false
+	## Whether any node says them, hidden or not: words that are there and cannot be read look,
+	## from a wait that ran out, like words that never came.
+	var heard: bool = false
+	var done: bool = false
+	## How long the look has taken over every frame it has run in.
+	var took_usec: int = 0
+	var _said: String
+	var _include_hidden: bool
+	## Untyped, since a node waiting here can be freed between two frames of the look.
+	var _pending: Array = []
+
+	func _init(root: Node, said: String, include_hidden: bool) -> void:
+		_said = said
+		_include_hidden = include_hidden
+		if root != null:
+			_pending.append(root)
+
+	## Reads on until the look is done or [param budget_usec] has passed, -1 for no limit, and
+	## answers how long it read.
+	func go_on(budget_usec: int) -> int:
+		var from: int = Time.get_ticks_usec()
+		while not _pending.is_empty():
+			if budget_usec >= 0 and Time.get_ticks_usec() - from >= budget_usec:
+				break
+			var next: Variant = _pending.pop_back()
+			if not is_instance_valid(next):
+				continue
+			var node: Node = next
+			if GdhSays.says(node, _said):
+				heard = true
+				if _include_hidden or GdhQueries.readable(node):
+					found = true
+					_pending.clear()
+					break
+			_pending.append_array(node.get_children(true))
+		done = _pending.is_empty()
+		var read: int = Time.get_ticks_usec() - from
+		took_usec += read
+		return read
+
+
 ## A signal recorded from when it was armed until it is collected.
 class GdhWatch:
 	extends RefCounted

package/build/godot/operations/animation_reads.gd

@@ -11,6 +11,11 @@ const LOOP_MODE_NAMES: Dictionary[int, String] = {
 	Animation.LOOP_LINEAR: "linear",
 	Animation.LOOP_PINGPONG: "pingpong",
 }
+const UPDATE_MODE_NAMES: Dictionary[int, String] = {
+	Animation.UPDATE_CONTINUOUS: "continuous",
+	Animation.UPDATE_DISCRETE: "discrete",
+	Animation.UPDATE_CAPTURE: "capture",
+}
 const TRACK_TYPE_NAMES: Dictionary[int, String] = {
 	Animation.TYPE_VALUE: "property",
 	Animation.TYPE_POSITION_3D: "position_3d",
@@ -166,6 +171,9 @@ static func _track(anim: Animation, track: int, values: GdhSerialisation) -> Dic
 	var property: String = str(path.get_concatenated_subnames())
 	if not property.is_empty():
 		shaped["property"] = property
+	if kind == Animation.TYPE_VALUE:
+		var mode: int = anim.value_track_get_update_mode(track)
+		shaped["update"] = UPDATE_MODE_NAMES.get(mode, str(mode))
 	var keyframes: Array[Dictionary] = []
 	var methods: Dictionary = {}
 	for key: int in anim.track_get_key_count(track):

package/build/godot/operations/editor_tools.gd

@@ -81,6 +81,8 @@ static func run(params: Dictionary) -> Dictionary:
 		var answered: Dictionary = answer
 		if not GdhSceneFile.also_saved.is_empty():
 			answered["alsoSaved"] = GdhSceneFile.also_saved.duplicate(true)
+		if not GdhSceneFile.unmade_note.is_empty():
+			answered["unmadeConnections"] = GdhSceneFile.unmade_note
 		if not GdhSceneUids.by_path.is_empty():
 			answered["namedByPath"] = (
 				(

package/build/godot/operations/export_presets.gd

@@ -121,6 +121,26 @@ static func _runnable(config: ConfigFile, section: String) -> bool:
 	return GdhRead.as_bool(config.get_value(section, "runnable", false))
 
 
+## The name of the preset [param platform] runs, or "" when it has none: the one its section names,
+## or in a file saved before that section, the last preset of the platform keeping the key, which is
+## the one the editor ends up running. Read from the section alone, a file of that age had no
+## runnable preset, so a preset added for its platform took the place of the one it had.
+static func _runnable_name(config: ConfigFile, platform: String) -> String:
+	if config.has_section_key(RUNNABLE_SECTION, platform):
+		return str(config.get_value(RUNNABLE_SECTION, platform))
+	var named: String = ""
+	var at: int = 0
+	while config.has_section("preset." + str(at)):
+		var section: String = "preset." + str(at)
+		if (
+			str(config.get_value(section, "platform", "")) == platform
+			and GdhRead.as_bool(config.get_value(section, "runnable", false))
+		):
+			named = str(config.get_value(section, "name", ""))
+		at += 1
+	return named
+
+
 ## Adds an export preset to export_presets.cfg, written with the keys the editor's Project > Export
 ## writes for a new one, and every option in [code]known_options[/code] (what
 ## [method export_options] answers for the platform) at its default. The editor also writes the
@@ -160,7 +180,7 @@ func add_export_preset(params: Dictionary) -> Dictionary:
 			)
 		index += 1
 	# A platform with no preset to run takes the new one, as the editor's dialog does.
-	var runnable: bool = not config.has_section_key(RUNNABLE_SECTION, platform)
+	var runnable: bool = _runnable_name(config, platform).is_empty()
 	if runnable:
 		config.set_value(RUNNABLE_SECTION, platform, preset_name)
 
@@ -609,6 +629,7 @@ func remove_export_preset(params: Dictionary) -> Dictionary:
 	var index: int = found["index"]
 	var section: String = found["section"]
 	var platform: String = str(config.get_value(section, "platform", ""))
+	var was_runnable: bool = _runnable_name(config, platform) == preset_name
 	var last: int = index
 	while config.has_section("preset." + str(last + 1)):
 		last += 1
@@ -622,11 +643,17 @@ func remove_export_preset(params: Dictionary) -> Dictionary:
 		if keeping != OK:
 			return _log.failure("Failed to save %s: %s" % [CREDENTIALS_FILE, error_string(keeping)])
 		answer["credentials"] = CREDENTIALS_FILE
-	if str(config.get_value(RUNNABLE_SECTION, platform, "")) == preset_name:
-		config.set_value(RUNNABLE_SECTION, platform, null)
-		answer["runnableNow"] = null
+	if was_runnable:
+		if config.has_section_key(RUNNABLE_SECTION, platform):
+			config.set_value(RUNNABLE_SECTION, platform, null)
+		# A file saved before the section can mark another preset of the platform too, which the
+		# editor then runs.
+		var kept: String = _runnable_name(config, platform)
+		answer["runnableNow"] = kept
+		if kept.is_empty():
+			answer["runnableNow"] = null
 		var at: int = 0
-		while config.has_section("preset." + str(at)):
+		while kept.is_empty() and config.has_section("preset." + str(at)):
 			if str(config.get_value("preset." + str(at), "platform", "")) == platform:
 				var next: String = str(config.get_value("preset." + str(at), "name", ""))
 				config.set_value(RUNNABLE_SECTION, platform, next)

package/build/godot/operations/patterns.gd

@@ -96,6 +96,11 @@ static func without_annotations(line: String) -> String:
 # brace opens before the `#` and closes on a later line. Held by a case, since the argument for the
 # difference is not visible from the code and reads like an oversight beside its neighbours.
 static func without_comment(line: String) -> String:
+	var start: int = _comment_start(line)
+	return (line if start == -1 else line.substr(0, start)).strip_edges()
+
+
+static func _comment_start(line: String) -> int:
 	var quote: String = ""
 	for i: int in range(line.length()):
 		var ch: String = line[i]
@@ -104,10 +109,30 @@ static func without_comment(line: String) -> String:
 				quote = ""
 			continue
 		if ch == "#":
-			return line.substr(0, i).strip_edges()
+			return i
 		if ch == '"' or ch == "'":
 			quote = ch
-	return line.strip_edges()
+	return -1
+
+
+## The code in front of each TODO or FIXME comment in [param content], one entry a comment.
+##
+## Read from the comments alone, as the editor highlights them, so `#TODO` counts and the same
+## words inside a string or a multi-line string do not.
+static func noted_work(content: String) -> Array[String]:
+	var noted: Array[String] = []
+	var in_string: bool = false
+	for line: String in content.split("\n"):
+		if in_string:
+			in_string = triple_quotes(line) % 2 == 0
+			continue
+		var start: int = _comment_start(line)
+		var code: String = line if start == -1 else line.substr(0, start)
+		if triple_quotes(code) % 2 == 1:
+			in_string = true
+		elif start != -1 and compiled("^#+\\s*(?:TODO|FIXME)\\b").search(line.substr(start)):
+			noted.append(code.strip_edges())
+	return noted
 
 
 ## How many triple quotes of either kind [param line] holds. An odd count opens or closes a string

package/build/godot/operations/project_diagnostics.gd

@@ -5,6 +5,7 @@ const GdhFileWalk = preload("file_walk.gd")
 const GdhImportPipeline = preload("import_pipeline.gd")
 const GdhInputActions = preload("input_actions.gd")
 const GdhLog = preload("logger.gd")
+const GdhPatterns = preload("patterns.gd")
 const GdhRead = preload("reading.gd")
 const GdhSceneConnections = preload("scene_connections.gd")
 const GdhScriptCheck = preload("script_check.gd")
@@ -87,7 +88,7 @@ func get_project_health(params: Dictionary) -> Dictionary:
 				var content: String = file.get_as_text()
 				file.close()
 
-				if "# TODO" in content or "# FIXME" in content:
+				if not GdhPatterns.noted_work(content).is_empty():
 					todo_count += 1
 
 		# Work noted for later, which no script fails on, so said rather than failed. A count of

package/build/godot/operations/project_validation.gd

@@ -8,6 +8,7 @@ const GdhFileWalk = preload("file_walk.gd")
 const GdhImportPipeline = preload("import_pipeline.gd")
 const GdhInputActions = preload("input_actions.gd")
 const GdhLog = preload("logger.gd")
+const GdhPatterns = preload("patterns.gd")
 const GdhRead = preload("reading.gd")
 const GdhSceneConnections = preload("scene_connections.gd")
 const GdhScriptCheck = preload("script_check.gd")
@@ -205,11 +206,12 @@ func validate_project(params: Dictionary) -> Dictionary:
 			var content: String = file.get_as_text()
 			file.close()
 
-			if "# TODO" in content or "# FIXME" in content:
+			var noted: Array[String] = GdhPatterns.noted_work(content)
+			if not noted.is_empty():
 				script_issues.append(
 					{ "path": script_path, "issue": "Contains TODO/FIXME comments" }
 				)
-			if "pass # TODO" in content:
+			if "pass" in noted:
 				script_issues.append(
 					{ "path": script_path, "issue": "Contains unimplemented functions" }
 				)

package/build/keeper.js

@@ -8895,6 +8895,7 @@ function frameEndLine() {
   return frameEnd;
 }
 var READ_MS = 5000;
+var EVALUATE_MS = 60000;
 var REPLIES = new Set([
   "debug_enter",
   "debug_exit",
@@ -9478,10 +9479,10 @@ class GameDebugger {
     }
     this.forget("evaluation_return");
     this.send("evaluate", [expression, frame], held.thread);
-    const answered = await this.next(GameDebugger.named("evaluation_return"), READ_MS);
+    const answered = await this.next(GameDebugger.named("evaluation_return"), EVALUATE_MS);
     if (answered === null || !("data" in answered)) {
       return {
-        refused: `The game worked out nothing for ${expression} within ${READ_MS / 1000}s. Ask again.`
+        refused: `The game worked out nothing for ${expression} within ${EVALUATE_MS / 1000}s. The first expression a game evaluates loads the script of every global class in the project first, static initialisers included, so one of those may still be running. Ask again.`
       };
     }
     const [, , type, value, hint] = answered.data;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.3.45",
+  "version": "1.3.47",
   "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",