gdharness 1.3.60 → 1.3.61

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

@@ -20,14 +20,14 @@ static func menu_of(node: Node) -> PopupMenu:
 	return null
 
 
-## The items asked for, best first: the one at `index`; else the one whose whole words are `text`,
-## exactly and then case-insensitively; else every item `text` matches by the rules `says` has, a
+## The items asked for, best first: the one at `index`, else the one whose whole words are `text`,
+## exactly and then case-insensitively, else every item `text` matches by the rules `says` has, a
 ## plain word as a contains, a glob, and alternatives split at `|`, the enabled ones when any are.
 ## Empty when nothing matches, and more than one when several match equally well, which the caller
 ## refuses rather than guesses between.
 ##
 ## By the same rules as `says` because a caller who has learnt them from a click, a find and a wait
-## writes the same pattern here: "Leave*" was refused against a menu holding "Leave the hall", and
+## writes the same pattern here: "Leave*" was refused against a menu holding "Leave the shop", and
 ## the item had to be written out in full on a second call. The whole words still come first, so an
 ## item named in full is chosen over another whose words contain it.
 ##

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

@@ -21,7 +21,7 @@ static func read_point(params: Dictionary, x_key: String, y_key: String) -> Vari
 ## row, where the control draws it.
 ##
 ## For a control that draws its parts itself and hit-tests them in _gui_input, whose centre was all
-## a click could press; in a native window, where the game's window pixels do not reach, nothing
+## a click could press. In a native window, where the game's window pixels do not reach, nothing
 ## else could press the rest.
 static func point_in(params: Dictionary, node: Node, node_path: String, has_item: bool) -> Variant:
 	if not params.has("x") and not params.has("y"):
@@ -29,7 +29,7 @@ static func point_in(params: Dictionary, node: Node, node_path: String, has_item
 	if node is Node3D:
 		return (
 			(
-				"%s is a 3D node, clicked where it is drawn; x and y name a point in a Control's "
+				"%s is a 3D node, clicked where it is drawn. x and y name a point in a Control's "
 				+ "own space"
 			)
 			% node_path
@@ -70,7 +70,7 @@ static func aim_of(params: Dictionary, root: Window) -> Variant:
 ## Where [param local], in the space of the node [param aim] names, arrives: {"viewport",
 ## "position"}, the viewport the pointer reaches it through and the point in that viewport's pixels,
 ## which is what an event sent there names. A Window's space is its own pixels, as the game's window
-## pixels are the root's; a canvas item's is its own, the one it draws and reads _gui_input in.
+## pixels are the root's. A canvas item's is its own, the one it draws and reads _gui_input in.
 static func carried(aim: Dictionary, local: Vector2, root: Window) -> Dictionary:
 	var node: Node = aim.get("node", root)
 	var reached: Dictionary = {}
@@ -192,7 +192,7 @@ static func outside_noted(
 					"%s is outside %s viewport, %s in window pixels, so no control there receives"
 					% [point, which, shown]
 				)
-				+ " it; the game's _input and _unhandled_input still do."
+				+ " it. The game's _input and _unhandled_input still do."
 			)
 			break
 	return answer
@@ -270,7 +270,7 @@ static func takes_no_click(control: Control, node_path: String, paused: bool) ->
 	if not control.can_process():
 		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()
+		var cover: String = "" if over == null else ", and %s is drawn over it" % over.get_path()
 		if paused:
 			return (
 				(

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

@@ -297,10 +297,10 @@ const READS_ONLY: String = (
 ## read it, "board:size()" or "inbox:keys()", listed in [constant LIST_CALLS] and
 ## [constant MAP_CALLS]. An engine method that reads takes literal arguments in the brackets,
 ## "get_theme_stylebox(\"panel\"):content_margin_top", since what a control's theme gives it is only
-## reachable by naming what is asked for; see [method arguments_of].
+## reachable by naming what is asked for. See [method arguments_of].
 ##
 ## A step into a vector, a colour, a rectangle or a transform reads one of its components,
-## "size:x" or "global_transform:origin:y", by the names GDScript gives them; see
+## "size:x" or "global_transform:origin:y", by the names GDScript gives them. See
 ## [method GdhSerialisation.components_of]. It answers the calls in [constant VALUE_CALLS] too,
 ## "linear_velocity:length()".
 ##
@@ -337,7 +337,7 @@ static func walk_to(node: Object, node_path: String, reaching: String) -> Dictio
 ## `{"message": ...}` saying why it names none.
 ##
 ## A colon path read from [param node], the node the call was made on, the way the method's own
-## path is: "_ladder:shop:_wares:-15". One beginning with a slash starts at the node it names
+## path is: "_league:store:_items:-15". One beginning with a slash starts at the node it names
 ## instead, "/root/Main/Hud" or "/root/Main:_game:run". A res:// or uid:// path names a resource
 ## file, which is loaded the way the game loads one, so a resource the game already holds is handed
 ## over as that instance. The records a read answers a node and a filed resource with carry such a
@@ -387,7 +387,7 @@ static func object_at(root: Node, node: Node, node_path: String, given: Variant)
 
 
 ## Why [param record], a dictionary given where an object goes, names none. A resource built into a
-## scene is read as its class beside its properties and has no path; the runtime builds no resource
+## scene is read as its class beside its properties and has no path. The runtime builds no resource
 ## from those, so the remedy is the file, not the path the other records are told to use.
 static func _no_path_in(record: Dictionary) -> String:
 	if record.has("id"):
@@ -439,7 +439,7 @@ static func _resource_at(path: String) -> Dictionary:
 		return { "message": "No resource at %s" % path }
 	var loaded: Resource = load(path)
 	if loaded == null:
-		return { "message": "%s did not load; the game's output says why" % path }
+		return { "message": "%s did not load. The game's output says why" % path }
 	return { "object": loaded }
 
 
@@ -580,7 +580,7 @@ static func can_read(holder: Variant, named: String) -> bool:
 ## counted as unclean for a read.
 ##
 ## A step written in double quotes is the key inside them, so a key holding a colon is one step:
-## Game D keys its stock by namespaced ids, "stock:\"base:dew\"", and split at that colon the
+## Game D keys its stock by namespaced ids, "stock:\"base:water\"", and split at that colon the
 ## step named a key "base" the map had never had.
 static func _key_in(map: Dictionary, named: String) -> Array:
 	var word: String = key_written(named)
@@ -625,8 +625,8 @@ static func step_naming(key: Variant) -> String:
 
 ## [param reaching] split into its steps at each colon, except one inside a call's brackets or a
 ## quoted argument or key: `get_node("/root/Main"):name` is two steps, and so is
-## `stock:"base:dew"`; split at every colon a quoted argument holding one became a step that names
-## nothing.
+## `stock:"base:water"`. Split at every colon a quoted argument holding one became a step that
+## names nothing.
 static func steps_of(reaching: String) -> PackedStringArray:
 	var steps: PackedStringArray = []
 	var step: String = ""
@@ -734,7 +734,7 @@ 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, 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
+## `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
@@ -756,7 +756,7 @@ static func call_refused(
 	var scripted: Dictionary = _script_method(object, method)
 	if not scripted.is_empty() and (given > 0 or least > 0):
 		var why: String = (
-			"since nothing marks one as only reading%s; runtime_invoke call takes them" % READS_ONLY
+			"since nothing marks one as only reading%s. runtime_invoke call takes them" % READS_ONLY
 		)
 		return (
 			"%s.%s is the game's own and a path gives a game's method no arguments, %s"
@@ -784,7 +784,7 @@ static func call_refused(
 		return ""
 	if _native_flags(object, method) & METHOD_FLAG_CONST == 0:
 		return (
-			"%s.%s is not one the engine marks as only reading%s; runtime_invoke call calls it"
+			"%s.%s is not one the engine marks as only reading%s. runtime_invoke call calls it"
 			% [called_as, method, READS_ONLY]
 		)
 	return ""
@@ -817,14 +817,14 @@ static func with_methods_offered(said: String, object: Object, method: String) -
 	var close: PackedStringArray = GdhRead.nearest(method, PackedStringArray(every))
 	if not close.is_empty():
 		return (
-			"%s; the nearest it has %s %s"
-			% [said, "is" if close.size() == 1 else "are", ", ".join(close)]
+			"%s The nearest it has %s %s"
+			% [GdhRead.ended(said), "is" if close.size() == 1 else "are", ", ".join(close)]
 		)
 	if own.is_empty():
 		return said
 	own.sort()
-	var offered: String = "its static functions are" if object is Script else "its script declares"
-	return "%s; %s %s" % [said, offered, ", ".join(PackedStringArray(own))]
+	var offered: String = "Its static functions are" if object is Script else "Its script declares"
+	return "%s %s %s" % [GdhRead.ended(said), offered, ", ".join(PackedStringArray(own))]
 
 
 ## The entry a script attached to [param object] declares for [param method], or an empty one when
@@ -851,7 +851,7 @@ static func _native_flags(object: Object, method: String) -> int:
 
 ## Put [param value] where [param named] points, and answer the holder written into. Only ever
 ## called once [method can_read] agrees. Lists and maps are reference types, so writing into one
-## reaches the game's own copy; a vector or a transform is a copy, and the one answered is the
+## reaches the game's own copy. A vector or a transform is a copy, and the one answered is the
 ## changed copy, for [method write_back] to put where it came from.
 static func write(holder: Variant, named: String, value: Variant) -> Variant:
 	if holder is Array:
@@ -1018,7 +1018,7 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 		var rest: String = ""
 		if keys.size() > 8:
 			rest = " and %d more" % [keys.size() - 8]
-		return "%s has no key %s; it is keyed by %s%s" % [called_as, named, ", ".join(some), rest]
+		return "%s has no key %s. It is keyed by %s%s" % [called_as, named, ", ".join(some), rest]
 	if composite(holder):
 		var kind: String = type_string(typeof(holder))
 		var sort: String = ("an " if kind.left(1) in ["A", "E", "I", "O", "U"] else "a ") + kind
@@ -1036,11 +1036,11 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 			return (
 				(
 					"%s is %s, and %s() is not one of the calls a path makes on one, which read it"
-					+ " and take no arguments: %s; its components are %s"
+					+ " and take no arguments: %s. Its components are %s"
 				)
 				% [called_as, sort, container_call, ", ".join(spelled), has]
 			)
-		return "%s is %s, so it has no %s; it has %s" % [called_as, sort, named, has]
+		return "%s is %s, so it has no %s. It has %s" % [called_as, sort, named, has]
 	if not holder is Object:
 		return (
 			"%s is %s, which has nothing to read %s off"
@@ -1054,7 +1054,7 @@ static func nothing_there(holder: Variant, named: String, called_as: String) ->
 	# for, and the caller is one pair of brackets away from what they meant.
 	if object.has_method(named):
 		return (
-			"%s has no property %s; it has a method of that name, which a path calls as %s()"
+			"%s has no property %s. It has a method of that name, which a path calls as %s()"
 			% [called_as, named, named]
 		)
 	return GdhRead.near_property("%s has no property %s" % [called_as, named], object, named)

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

@@ -16,7 +16,7 @@ const FIND_LIMIT: int = 100
 ## What a find can be narrowed by, which is also what it refuses to answer without. Named once so
 ## the refusal lists the same set the walk reads.
 const FILTERS: PackedStringArray = ["class", "script", "name", "group", "says"]
-## The most lines one read answers with, unless asked for fewer. A screen is a few dozen; a
+## The most lines one read answers with, unless asked for fewer. A screen is a few dozen. A
 ## thousand is a tree somebody pointed this at by mistake.
 const READ_LIMIT: int = 500
 ## The most either can be asked for. A limit above it is refused rather than cut to it: the ceiling
@@ -117,7 +117,7 @@ func find_nodes(params: Dictionary) -> Dictionary:
 	var names: Array[String] = GdhSays.split_at_bars(wanted["name"])
 	if not wanted["name"].is_empty() and names.is_empty():
 		var bars_only: String = (
-			'name "%s" is only bars, so it names no node; write the names between them'
+			'name "%s" is only bars, so it names no node. Write the names between them'
 		)
 		return { "type": "error", "message": bars_only % wanted["name"] }
 
@@ -244,7 +244,7 @@ func find_nodes(params: Dictionary) -> Dictionary:
 			. append(
 				(
 					(
-						"name is matched as a glob against the whole name; %d %snode %s %s, which "
+						"name is matched as a glob against the whole name. %d %snode %s %s, which "
 						+ '"%s"%s would find'
 					)
 					% [
@@ -265,7 +265,7 @@ func find_nodes(params: Dictionary) -> Dictionary:
 			. append(
 				(
 					(
-						"says with a wildcard is matched as a glob against a node\'s whole text; "
+						"says with a wildcard is matched as a glob against a node\'s whole text. "
 						+ '"%s"%s would find %d %snode%s'
 					)
 					% [
@@ -284,7 +284,7 @@ func find_nodes(params: Dictionary) -> Dictionary:
 		answer["hidden"] = hidden
 		notes.append(
 			(
-				"%d matching node%s hidden and left out; includeHidden true answers with them too"
+				"%d matching node%s hidden and left out. includeHidden true answers with them too"
 				% [hidden, "" if hidden == 1 else "s"]
 			)
 		)
@@ -296,14 +296,14 @@ func find_nodes(params: Dictionary) -> Dictionary:
 				(
 					(
 						"%d matching node%s drawn outside the viewport or scrolled out of a "
-						+ "ScrollContainer and left out; includeHidden true answers with them too"
+						+ "ScrollContainer and left out. includeHidden true answers with them too"
 					)
 					% [out_of_view, "" if out_of_view == 1 else "s"]
 				)
 			)
 		)
 	if not notes.is_empty():
-		answer["note"] = " ".join(notes)
+		answer["note"] = ". ".join(notes) + "."
 	return answer
 
 
@@ -451,7 +451,7 @@ func _matches_apart_from_name(node: Node, wanted: Dictionary[String, String]) ->
 ## own class_name, or one it extends at any distance.
 ##
 ## The class_name alone answered 0 for `Card` over a tree of rows whose scripts extend Card two
-## steps down, IntakeRow extends DocketCard extends Card, while `is_class` reaches every native
+## steps down, InboxRow extends TicketCard extends Card, while `is_class` reaches every native
 ## subclass. A caller naming a class means what extends it, whichever side of the line the class
 ## is declared on.
 static func _script_is(attached: Script, wanted: String) -> bool:
@@ -468,15 +468,15 @@ static func _script_is(attached: Script, wanted: String) -> bool:
 ## The question a caller asks most often, and the one that cost the most to answer: reading a panel
 ## was a find for every label with the path of each beside it, a few hundred characters apiece to
 ## carry a sentence of six words. Long is the smaller half of it. A find answers off nodes nobody
-## can see, and a panel keeps its empty state in the tree beside its rows, so "Nothing posted" came
-## back next to the three things posted and was believed twice in one session.
+## can see, and a panel keeps its empty state in the tree beside its rows, so "Nothing listed" came
+## back next to the three things listed and was believed twice in one session.
 ##
 ## A hidden node is left out and so is everything under it, because what a player reads is what is
 ## drawn. [param include_hidden] asks for the lot instead, which is what a caller checking that
 ## something is not showing wants.
 ##
 ## [param limit] is the first few lines rather than all of them, which is how the top of a screen
-## is read without the hall under it: the bar along the top of a guild is eleven lines and the
+## is read without the rest under it: the bar along the top of a screen is eleven lines and the
 ## panel it sits on is two hundred. `omitted` says how many lines that left behind, so a screen
 ## whose interesting half is below the cut says so in a number rather than in a flag.
 func read_text(params: Dictionary) -> Dictionary:
@@ -519,7 +519,7 @@ func read_text(params: Dictionary) -> Dictionary:
 				(
 					(
 						"%d line%s drawn outside the viewport or scrolled out of a "
-						+ "ScrollContainer, where the player cannot read them, left out; "
+						+ "ScrollContainer, where the player cannot read them, left out. "
 						+ "includeHidden true answers with them too"
 					)
 					% [tally["out_of_view"], "" if tally["out_of_view"] == 1 else "s"]
@@ -545,7 +545,7 @@ func read_text(params: Dictionary) -> Dictionary:
 			)
 		)
 	if not notes.is_empty():
-		answer["note"] = " ".join(notes)
+		answer["note"] = ". ".join(notes) + "."
 	return answer
 
 

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

@@ -10,11 +10,11 @@ const ESCAPED_BAR: String = ""
 ## given and the same words widened, and anything past a handful is a caller that has moved on.
 const SPLITS_KEPT: int = 8
 
-## Each `says` split into alternatives, by what was written; see [method alternatives].
+## Each `says` split into alternatives, by what was written. See [method alternatives].
 static var _splits: Dictionary[String, Array] = {}
-## Each `says` as the globs [method matches] tries first, by what was written; see [method _loose].
+## Each `says` as the globs [method matches] tries first, by what was written. See [method _loose].
 static var _globs: Dictionary[String, Array] = {}
-## Every space separator Unicode has besides the plain space, built once; see [method spaced].
+## Every space separator Unicode has besides the plain space, built once. See [method spaced].
 static var _spaces: RegEx = null
 
 
@@ -71,7 +71,7 @@ static func _loose(wanted: String) -> Array[String]:
 
 ## [param text] with every Unicode space separator written as a plain space, which is what a caller
 ## types for any of them. A game keeping a name on one line writes it with a non-breaking space, and
-## "Deskanem Bonituk" typed with a plain one found nothing while the screen showed exactly those
+## "Teodor Vasquelle" typed with a plain one found nothing while the screen showed exactly those
 ## words. One character for one, so a place found in the result is the same place in [param text].
 ##
 ## Text that is all ASCII holds none of them and is handed back as it is, which is most of a screen.
@@ -101,7 +101,7 @@ static func spaced(text: String) -> String:
 ## pattern that matches every node there is.
 ##
 ## Kept once split, since a find, a click or a wait asks about the same words for every node on the
-## screen: split afresh for each of them, one look over a hall of twenty thousand nodes took 210ms
+## screen: split afresh for each of them, one look over twenty thousand nodes took 210ms
 ## rather than 155ms. The array handed back is shared and not to be changed.
 static func alternatives(wanted: String) -> Array[String]:
 	var kept: Variant = _splits.get(wanted)

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

@@ -48,8 +48,8 @@ const WHOLE: int = 1
 ## counting from 0 in rank order.
 ##
 ## A control with something drawn over its centre that a pointer there would reach instead is not
-## on screen for a player, and a click at it lands on the thing on top. The screen a game shows
-## over its hall covers the hall's drawers without hiding them, so their words matched as well.
+## on screen for a player, and a click at it lands on the thing on top. A panel a game shows
+## over a screen covers its drawers without hiding them, so their words matched as well.
 static func control_saying(
 	root: Node, root_path: String, wanted: String, which: Variant
 ) -> Dictionary:
@@ -60,7 +60,7 @@ static func control_saying(
 	# The words of the control that matched, which a button pressed on a label's behalf has none of.
 	var said: Array[String] = []
 	var exact: Array[bool] = []
-	# Whether the words are only inside longer words there, "out" in "Scout".
+	# Whether the words are only inside longer words there, "away" in "Faraway".
 	var inside: Array[bool] = []
 	var hidden: Array[Node] = []
 	# Controls saying exactly the words that a click cannot reach, kept to say what a match on
@@ -150,8 +150,8 @@ static func control_saying(
 			if cover == null:
 				cover = over
 	# Stable, so matches of one rank keep the order they are drawn in. Words only inside longer
-	# words come after everything else: ranked as a button saying them as part of more, "Scout, 90"
-	# was pressed for "Out" over a control saying exactly "Out", and spent a game's silver.
+	# words come after everything else: ranked as a button saying them as part of more, a card was
+	# pressed over a control saying exactly the words, and spent something in the game.
 	open.sort_custom(
 		func(a: int, b: int) -> bool:
 			if inside[a] != inside[b]:
@@ -203,7 +203,7 @@ static func control_saying(
 			"type": "error",
 			"message":
 			(
-				"%s, so which to click is not clear; pass index, counting from 0%s: %s"
+				"%s, so which to click is not clear. Pass index, counting from 0%s: %s"
 				% [_described(best, ranks[0], wanted, under), order, _candidates(targets, lines)]
 			),
 		}
@@ -225,9 +225,9 @@ static func control_saying(
 			"index %s picks nothing: %s: %s" % [given, among, _candidates(targets, lines)],
 		}
 	# A match saying the words as part of more, while another control says exactly them, is a
-	# stand-in for that one, not the control meant: a tab reading "Out" sat in a collapsed drawer
-	# and a dispatch saying somebody "fell out in the hall" was pressed, and with the tab's own
-	# words on screen in a control that is not a button, a card reading "Scout, 90" was. Pressed
+	# stand-in for that one, not the control meant: a tab reading "Away" sat in a collapsed drawer
+	# and a line saying somebody "went away for good" was pressed, and with the tab's own
+	# words on screen in a control that is not a button, a card reading "Faraway, 90" was. Pressed
 	# only when asked for by index, which is the caller saying the match is what they meant.
 	var exact_elsewhere: Array[Node] = exact_out_of_reach.duplicate()
 	var elsewhere_as: Array[String] = out_of_reach_as.duplicate()
@@ -250,7 +250,7 @@ static func control_saying(
 			(
 				(
 					'no %s on screen%s says exactly "%s", so nothing was clicked: %s %s says it as '
-					+ 'part of "%s", while %s; pass index %d to press %s anyway'
+					+ 'part of "%s", while %s. Pass index %d to press %s anyway'
 				)
 				% [
 					"button" if exact_elsewhere.size() > exact_out_of_reach.size() else "control",
@@ -272,7 +272,7 @@ static func control_saying(
 			(
 				(
 					'no control on screen%s says "%s" as a word of its own, so nothing was '
-					+ 'clicked: %s %s has it only inside a longer word, "%s"; pass index %d to '
+					+ 'clicked: %s %s has it only inside a longer word, "%s". Pass index %d to '
 					+ "press %s anyway"
 				)
 				% [
@@ -287,8 +287,8 @@ static func control_saying(
 			),
 		}
 	# Words in a sentence on a control that lets the pointer through: the press lands on whatever is
-	# under it, which is nothing the words name. A line saying what "is out there" was the best
-	# match left for "Out" once the cards saying "Scout" were passed over.
+	# under it, which is nothing the words name. A line saying what "is far away" was the best
+	# match left for "Away" once the cards saying "Faraway" were passed over.
 	if (
 		which == null
 		and not wholes[index]
@@ -301,7 +301,7 @@ static func control_saying(
 				(
 					'no control on screen%s that takes a click says "%s", so nothing was clicked: '
 					+ '%s %s says it as part of "%s" and lets the pointer through to what is under '
-					+ "it; pass index %d to click there anyway"
+					+ "it. Pass index %d to click there anyway"
 				)
 				% [
 					under,
@@ -325,7 +325,7 @@ static func control_saying(
 				% [targets.size() - 1, _passed_over(ranks[0], ranks.slice(1), false)]
 			)
 		)
-		found["picked"] = "%s; %s" % [_described(1, ranks[0], wanted, under), others]
+		found["picked"] = "%s, and %s" % [_described(1, ranks[0], wanted, under), others]
 	if covered > 0:
 		found["covered"] = covered
 	var answer: Dictionary = { "path": str(targets[index].get_path()), "found": found }
@@ -377,9 +377,9 @@ static func pointer_turned_off_by(control: Control) -> Control:
 ## Whether one of [param wanted]'s alternatives is the whole of [param said], or the whole of one of
 ## its lines. A glob is matched against the whole text already, so every match of one is whole.
 ##
-## A line counts because a card is a title over a description: "WARD" over "wards 3" is the card
-## named WARD, and read as its words run together it said WARD only as part of more, level with
-## "WARDSPITE" over its own description, and a click on WARD was refused as not clear.
+## A line counts because a card is a title over a description: "GLOW" over "glows 3" is the card
+## named GLOW, and read as its words run together it said GLOW only as part of more, level with
+## "GLOWSHADE" over its own description, and a click on GLOW was refused as not clear.
 static func _says_exactly(written: String, wanted: String) -> bool:
 	var said: String = GdhSays.spaced(written)
 	for words: String in GdhSays.alternatives(wanted):
@@ -397,8 +397,8 @@ static func _says_exactly(written: String, wanted: String) -> bool:
 
 
 ## Whether [param written] has the plain words [param wanted] asks for only inside longer words,
-## never starting where a word starts: "out" in "Scout". Words starting a longer one count as said,
-## "Recruit" in "Recruits", and so does anything matched by a pattern.
+## never starting where a word starts: "away" in "Faraway". Words starting a longer one count as
+## said, "Recruit" in "Recruits", and so does anything matched by a pattern.
 static func _inside_a_word(written: String, wanted: String) -> bool:
 	var said: String = GdhSays.spaced(written).to_lower()
 	var found: bool = false
@@ -477,7 +477,7 @@ static func _offered_note(from: Node, drawn: Array[Node], areas: Array[Rect2]) -
 			and _cover_of(button, drawn, areas, aim) == null
 		)
 	var words: String = GdhWords.pressable_words(from, open, LISTED_CANDIDATES)
-	return "" if words.is_empty() else "; the buttons on screen say %s" % words
+	return "" if words.is_empty() else ". The buttons on screen say %s" % words
 
 
 ## What to add to a refusal that found nothing on screen, when words matched hidden controls: how
@@ -490,9 +490,9 @@ static func _hidden_note(hidden: Array[Node]) -> String:
 	for node: Node in hidden.slice(0, NAMED_HIDDEN):
 		named.append("%s%s" % [node.get_path(), why_hidden(node)])
 	if hidden.size() == 1:
-		return "; 1 hidden control says it, %s" % named[0]
+		return ". 1 hidden control says it, %s" % named[0]
 	return (
-		"; %d hidden controls say it, among them %s and %s"
+		". %d hidden controls say it, among them %s and %s"
 		% [hidden.size(), ", ".join(named.slice(0, -1)), named[-1]]
 	)
 
@@ -503,7 +503,7 @@ static func _outside_note(outside: int, root: Node) -> String:
 	if outside == 0:
 		return ""
 	var note: String = (
-		"; %d control%s it outside what the screen shows"
+		". %d control%s it outside what the screen shows"
 		% [outside, " says" if outside == 1 else "s say"]
 	)
 	var window: Window = root as Window
@@ -537,9 +537,9 @@ static func _covered_note(covered: int, cover: Node) -> String:
 	if covered == 0:
 		return ""
 	if covered == 1:
-		return "; 1 control says it under %s, which is drawn over it" % cover.get_path()
+		return ". 1 control says it under %s, which is drawn over it" % cover.get_path()
 	return (
-		"; %d controls say it under what is drawn over them, such as %s"
+		". %d controls say it under what is drawn over them, such as %s"
 		% [covered, cover.get_path()]
 	)
 
@@ -564,8 +564,8 @@ static func drawn_over(target: Control) -> Node:
 
 ## Why [param node], which is not visible in the tree, is not, as a parenthesis to follow its path:
 ## which nodes hide it, nearest first, and what has taken its place. Reading visible off the node
-## itself says true when only an ancestor is hidden, so without this a caller had nothing to unhide;
-## every hidden one is named because unhiding only the nearest leaves the rest hiding it.
+## itself says true when only an ancestor is hidden, so without this a caller had nothing to unhide.
+## Every hidden one is named because unhiding only the nearest leaves the rest hiding it.
 ##
 ## What has taken its place is what a click at its centre reaches now, which is the screen a game
 ## shows instead. Without a control there, as for a 3D node, it is what is shown beside the
@@ -586,7 +586,7 @@ static func why_hidden(node: Node) -> String:
 	var instead: Node = null if control == null else drawn_at(control)
 	if instead != null:
 		return (
-			" (%s; a click where it would be reaches %s)"
+			" (%s, and a click where it would be reaches %s)"
 			% [", and ".join(named), instead.get_path()]
 		)
 	var outermost: Node = hiding.back()
@@ -602,7 +602,7 @@ static func why_hidden(node: Node) -> String:
 ## What a click at the centre of [param target], which is hidden, would reach instead, or null.
 ##
 ## The topmost thing there that takes the pointer, whatever order it is drawn in relative to the
-## target, since the target is not drawn at all; and never a node holding the target, which covers
+## target, since the target is not drawn at all, and never a node holding the target, which covers
 ## its place by containing it and is not what took it.
 static func drawn_at(target: Control) -> Node:
 	var drawn: Array[Node] = _pointer_takers(target.get_tree().root)
@@ -636,20 +636,20 @@ static func _drawn_above(control: Control, other: Control) -> bool:
 	return layer > other_layer or (layer == other_layer and control.is_greater_than(other))
 
 
-## "; A, B and C are shown beside N" for [param beside] and the hidden node [param hidden], naming
-## three at most and counting the rest.
+## `", and A, B and C are shown beside N"` for [param beside] and the hidden node [param hidden].
+## It names three at most and counts the rest.
 static func _shown_beside(beside: Array[String], hidden: Node) -> String:
 	if beside.is_empty():
 		return ""
 	var at: String = str(hidden.get_path())
 	if beside.size() == 1:
-		return "; %s is shown beside %s" % [beside[0], at]
+		return ", and %s is shown beside %s" % [beside[0], at]
 	var listed: Array[String] = beside.slice(0, 3)
 	var rest: int = beside.size() - listed.size()
 	if rest > 0:
-		return "; %s and %d more are shown beside %s" % [", ".join(listed), rest, at]
+		return ", and %s and %d more are shown beside %s" % [", ".join(listed), rest, at]
 	var last: String = listed.pop_back()
-	return "; %s and %s are shown beside %s" % [", ".join(listed), last, at]
+	return ", and %s and %s are shown beside %s" % [", ".join(listed), last, at]
 
 
 ## The nodes whose visible is false and keeps [param node] from being drawn, nearest first. Walked
@@ -728,7 +728,7 @@ static func _pointer_takers(root: Node) -> Array[Node]:
 ## a control's however it is turned or scaled.
 ##
 ## Worked out once for a click rather than once for each match. A plain word on a screen of prose
-## matches a hundred labels, and asking all four thousand controls of a hall for their transform
+## matches a hundred labels, and asking all four thousand controls on screen for their transform
 ## for each of them took a click by words 80 ms, where the matching alone takes half that.
 static func _areas_of(drawn: Array[Node]) -> Array[Rect2]:
 	var areas: Array[Rect2] = []
@@ -856,7 +856,7 @@ static func _holds(control: Control, point: Vector2) -> bool:
 	# A control scaled to nothing holds no point, and inverting its transform is an engine error.
 	if is_zero_approx(placed.determinant()):
 		return false
-	# The rectangle, which is the engine's own answer unless a script overrides `_has_point`; the
+	# The rectangle, which is the engine's own answer unless a script overrides `_has_point`. The
 	# engine does not offer the overridden answer to scripts.
 	return Rect2(Vector2.ZERO, control.size).has_point(placed.affine_inverse() * point)
 
@@ -964,7 +964,7 @@ static func _candidates(targets: Array[Control], said: Array[String]) -> String:
 
 ## What to add to a refusal that found nothing on screen, when an open menu has an item saying the
 ## words: a menu draws its items rather than holding a control for each, so a click finds none,
-## while a wait for the words finds the item. A wait met on "Leave the hall" was followed by a click
+## while a wait for the words finds the item. A wait met on "Leave the shop" was followed by a click
 ## on it refused as nothing on screen saying it, with no word of the call that chooses it.
 static func _open_menu_note(root: Node, wanted: String) -> String:
 	var pending: Array[Node] = [root]
@@ -981,7 +981,7 @@ static func _open_menu_note(root: Node, wanted: String) -> String:
 					)
 					return (
 						(
-							'; the open menu %s has an item saying it, "%s", which a click cannot '
+							'. The open menu %s has an item saying it, "%s", which a click cannot '
 							+ 'reach: choose it with runtime_input choose, path %s and text "%s"'
 						)
 						% [menu.get_path(), text, named.get_path(), text]

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

@@ -83,7 +83,7 @@ func inject_text(params: Dictionary) -> Dictionary:
 	if ended_editing(focused, before):
 		answer["editing_ended"] = true
 	# A control drawing its own field takes characters in its gui_input, so typing at one is not
-	# refused; but a focused button answered that the text went into it, which read as typed.
+	# refused, but a focused button answered that the text went into it, which read as typed.
 	if into != null and before.is_empty():
 		answer["note"] = (
 			(
@@ -98,7 +98,7 @@ func inject_text(params: Dictionary) -> Dictionary:
 
 
 ## What [param focused] says and whether it is being edited, read before keys go in, for
-## [method field_noted] and [method ended_editing] to compare with; empty where the focus is no
+## [method field_noted] and [method ended_editing] to compare with. Empty where the focus is no
 ## field. A [TextEdit] has no editing state of its own and counts as always edited.
 static func field_before(focused: Control) -> Dictionary:
 	var field: LineEdit = focused as LineEdit
@@ -333,7 +333,7 @@ func choose(params: Dictionary) -> Dictionary:
 	# whatever is behind it, and before the item is looked for, because opening is when a game fills
 	# a menu: one rebuilt on about_to_popup was read as it stood before, measured on 4.7.2, and the
 	# index found in the old items chose another item of the new ones. An OptionButton opens its
-	# own; a bare PopupMenu is popped where it already sits, which leaves a menu already open where
+	# own. A bare PopupMenu is popped where it already sits, which leaves a menu already open where
 	# it is.
 	var opened: bool = GdhMenus.open_the_menu(node, menu)
 	await _host.get_tree().process_frame