gdharness 0.13.5 → 0.13.7

package/build/cli.js

@@ -15741,7 +15741,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_run",
-      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice. When it is not listening, mayYetAnnounce says whether that is final: false is a runtime that is not coming, true is a game still on its way up, which editor_status will see and runtimeWaitMs waits longer for.",
+      description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice. When it is not listening, mayYetAnnounce says whether that is final: false is a runtime that is not coming, true is a game still on its way up, which editor_status will see and runtimeWaitMs waits longer for. A start this server made also answers with transcript, the file both the run's streams are written to, so a watch on it can be armed off the start rather than off a second call.",
       parameters: {
         projectPath: PROJECT_PATH,
         scene: {
@@ -15817,7 +15817,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_rescan",
-      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure measured downstream is a change to the declaring script, saved, and then a rescan: the change on its own left every affected file reporting the same errors, and the rescan after it cleared them. Whether a rescan alone would have done it there is not known, because the rescans in that report may have answered before the scan ran, which is the timing this tool no longer has. editor_launch restart also does it, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve can go out of that file with it, which one project saw and two could not reproduce; where it happens the answer names what the file lost under cacheLost, before a fresh engine, a CI run or a clone inherits it. Needs the editor connected.",
+      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure measured downstream is a change to the declaring script, saved, and then a rescan: the change on its own left every affected file reporting the same errors, and the rescan after it cleared them. Whether a rescan alone would have done it there is not known, because the rescans in that report may have answered before the scan ran, which is the timing this tool no longer has. editor_launch restart also does it, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. Needs the editor connected.",
       parameters: {
         projectPath: PROJECT_PATH,
         timeoutMs: { type: "number", description: "How long to wait for the scan. Default 30000." }
@@ -16109,7 +16109,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["until"],
-          description: "until: wait for these words to appear anywhere under nodePath instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, hidden nodes included."
+          description: "until: wait for these words to appear anywhere under nodePath instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, hidden nodes included. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property."
         },
         timeoutMs: {
           type: "number",
@@ -26630,13 +26630,14 @@ var require_fast_uri = __commonJS(function(exports, module) {
       if (!malformedIPLiteral) {
         malformedHost = canonicalizeHost(parsed, options, schemeHandler, isIP);
       }
-      if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
-        if (uri.indexOf("%") !== -1) {
-          if (parsed.host !== undefined && !malformedIPLiteral) {
-            const host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
-            parsed.host = reescapeHostDelimiters(host, isIP);
-          }
+      if (uri.indexOf("%") !== -1 && parsed.host !== undefined && !malformedIPLiteral) {
+        let host = isIP ? parsed.host : normalizePercentEncoding(parsed.host, true);
+        if (!isIP) {
+          host = normalizePercentEncoding(host.toLowerCase());
         }
+        parsed.host = reescapeHostDelimiters(host, isIP);
+      }
+      if (!schemeHandler || schemeHandler && !schemeHandler.skipNormalize) {
         if (parsed.path) {
           parsed.path = normalizePathEncoding(parsed.path);
         }
@@ -37887,6 +37888,7 @@ class GodotServer {
       };
     }));
     const playing = await this.editorPlayingState();
+    await this.pickUpWhatTheEditorIsPlaying();
     return this.jsonTextResponse({
       editor: {
         ...this.getEditorStatusPayload(),
@@ -38097,6 +38099,7 @@ class GodotServer {
       through: "gdharness",
       pid: started.process.pid ?? null,
       arguments: cmdArgs,
+      transcript: started.transcript,
       refreshedClasses: refreshed.value,
       endedPreviousRun: ended ?? undefined,
       runtime: await this.runtimeUp(project.value.path, alreadyPlaying, runtimeWaitMs),
@@ -38321,6 +38324,33 @@ class GodotServer {
       closeSync(handle);
     }
   }
+  async pickUpWhatTheEditorIsPlaying() {
+    if (this.activeProcess !== null || !this.godotBridge.isConnected()) {
+      return;
+    }
+    const playing = await this.editorPlayingState();
+    if (playing?.playing !== true) {
+      return;
+    }
+    try {
+      await this.dap().connect();
+    } catch (error) {
+      this.logDebug(`Picked up an editor-played run without its adapter: ${errorMessage(error)}`);
+    }
+    this.activeProcess = {
+      process: null,
+      pid: null,
+      log: new GameLog,
+      transcript: null,
+      readOffset: 0,
+      projectPath: this.godotBridge.getStatus().projectPath ?? null,
+      startedAt: Date.now(),
+      exitCode: null,
+      throughEditor: true,
+      brokeOn: null,
+      pickedUpPlaying: true
+    };
+  }
   adoptRecordedRun() {
     const record = readRunRecord();
     if (record === null || !this.couldBeOurs(record.projectPath)) {
@@ -38402,6 +38432,7 @@ class GodotServer {
     });
   }
   async handleWaitForRun(args) {
+    await this.pickUpWhatTheEditorIsPlaying();
     const run = this.currentRun();
     if (!run) {
       return this.createErrorResponse(this.nothingOfOursIsRunning());
@@ -38416,6 +38447,7 @@ class GodotServer {
     return await this.handleGetDebugOutput(args, stillRunning(run) ? budgetMs : undefined);
   }
   async handleGetDebugOutput(args, waitedMs) {
+    await this.pickUpWhatTheEditorIsPlaying();
     const run = this.currentRun();
     if (!run) {
       return this.createErrorResponse(this.nothingOfOursIsRunning());
@@ -38443,6 +38475,9 @@ class GodotServer {
     if (run.endedUnwatched === true) {
       notes.push("This run outlived the server that started it and is over now, so its exit code was never collected. Everything it printed is below, read back from its transcript.");
     }
+    if (run.pickedUpPlaying === true) {
+      notes.push("The editor was already playing this when this server reached it, so this is not the run from its start: what it printed before that went with the server that was listening then. It is the run the editor is holding now, which is the one the debug_* tools answer for.");
+    }
     if (typeof run.endedHere === "string") {
       notes.push(`This run was ended here, by ${run.endedHere}.`);
     } else if (!stillRunning(run) && !run.throughEditor && run.exitCode !== null) {
@@ -38473,6 +38508,7 @@ class GodotServer {
     });
   }
   async handleStopProject() {
+    await this.pickUpWhatTheEditorIsPlaying();
     const stopped = this.currentRun();
     if (!stopped) {
       return this.createErrorResponse(this.nothingOfOursIsRunning());
@@ -38498,7 +38534,7 @@ class GodotServer {
     const projectPath = typeof args["projectPath"] === "string" ? args["projectPath"] : "";
     const before = projectPath === "" ? null : cachedClasses(projectPath);
     const writtenBefore = projectPath === "" ? null : cacheWrittenAt(projectPath);
-    const blind = projectPath === "" ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
+    const blind = await this.classesTheEditorCannotSee(args);
     const atRisk = before === null ? [] : blind.unseen.filter((one) => before.has(one.className));
     const first = await this.handleViaBridge("rescan_filesystem", args);
     if (first.isError) {
@@ -38511,7 +38547,7 @@ class GodotServer {
       const pending = Boolean(status["pending"]) && Date.now() - started < SCAN_START_MS;
       busy = Boolean(status["scanning"]) || Boolean(status["importing"]) || pending;
     }
-    if (!busy && atRisk.length > 0) {
+    if (!busy && projectPath !== "" && (atRisk.length > 0 || blind.unchecked !== undefined)) {
       const until = Date.now() + CACHE_WRITE_MS;
       while (Date.now() < until && cacheWrittenAt(projectPath) === writtenBefore) {
         await new Promise((settle) => setTimeout(settle, 100));
@@ -38519,18 +38555,33 @@ class GodotServer {
     }
     const after = projectPath === "" || busy ? null : cachedClasses(projectPath);
     const lost = before === null || after === null ? [] : [...before.keys()].filter((name) => !after.has(name));
+    const restored = lost.length > 0 ? await this.rebuildCacheAfterLoss(projectPath, lost) : [];
     const checked = busy ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
     const unseen = checked.unseen;
+    const stillGone = lost.filter((name) => !restored.includes(name));
     return this.jsonTextResponse({
-      ok: !busy && unseen.length === 0 && lost.length === 0 && checked.unchecked === undefined,
+      ok: !busy && unseen.length === 0 && stillGone.length === 0 && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
       unseenByEditor: unseen.length > 0 ? unseen : undefined,
       cacheLost: lost.length > 0 ? lost : undefined,
+      cacheRestored: restored.length > 0 ? restored : undefined,
       classesUnchecked: checked.unchecked,
-      note: busy ? "The editor was still scanning or importing when the wait ran out, so new files may not be visible yet." : lost.length > 0 ? "The scan wrote the class cache from the list this editor is holding, and that list is shorter than the file was: these classes were in it before the scan and are not now. Every engine that reads the cache next, including a test run, will report them as unknown identifiers in files nobody touched. Run project_import refresh_classes to put them back, and do not rescan again until the editor has been restarted with editor_launch restart, because it will write the same short list over it." : unseen.length > 0 ? "The scan finished and these classes are still not in the list the editor resolves against, so every use of them reads as an unknown identifier. Its walk skips a file another engine has already imported. Change the declaring script and rescan, or restart the editor with editor_launch restart." : undefined
+      note: busy ? "The editor was still scanning or importing when the wait ran out, so new files may not be visible yet." : stillGone.length > 0 ? "The scan wrote the class cache from the list this editor is holding, that list is shorter than the file was, and rebuilding the cache from the files did not bring these back. Every engine that reads the cache next, including a test run, will report them as unknown identifiers. Restart the editor with editor_launch restart before scanning again." : lost.length > 0 ? "The scan wrote the class cache from the list this editor is holding, which is shorter than the file was, so the cache was rebuilt from the files and these classes are back in it. Nothing was lost, but this editor is still holding the short list: do not rescan again until it has been restarted with editor_launch restart, because it will write the same list over the file each time." : unseen.length > 0 ? "The scan finished and these classes are still not in the list the editor resolves against, so every use of them reads as an unknown identifier. Its walk skips a file another engine has already imported. Change the declaring script and rescan, or restart the editor with editor_launch restart." : undefined
     });
   }
+  async rebuildCacheAfterLoss(projectPath, lost) {
+    if (projectPath === "") {
+      return [];
+    }
+    const rebuilt = await this.operation("refresh_class_cache", {}, projectPath);
+    if (!rebuilt.ok) {
+      this.logDebug(`Could not rebuild the class cache after a scan: ${rebuilt.message}`);
+      return [];
+    }
+    const now = cachedClasses(projectPath);
+    return now === null ? [] : lost.filter((name) => now.has(name));
+  }
   async alsoSayWhatTheEditorCannotSee(answered, args) {
     const first = answered.content[0];
     if (answered.isError || first?.type !== "text" || typeof first.text !== "string") {

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

@@ -0,0 +1,294 @@
+@tool
+extends RefCounted
+
+## What a caller writes for a property, read against the type that property declares, and the
+## question of whether it can be written at all.
+##
+## One parser for the three tools that write properties into files. There were three, each with its
+## own short list of tags it knew: scenes handled eighteen types, resources seven, animation tracks
+## three. A Quaternion keyframe was stored as the dictionary it arrived as, a Rect2 written to a
+## resource likewise, and both were saved that way, so the same value written through two tools
+## came out as two different things and only one of them was the value.
+##
+## The tags themselves are the shared serialiser's, so every shape a read answers with is a shape a
+## write accepts. What is here on top of it is the part only a property knows: the type wanted, so a
+## dictionary shaped like a vector or a bare pair of numbers can be read as one.
+
+const Read = preload("reading.gd")
+const Serialisation = preload("serialisation.gd")
+
+# What each packed array holds, for the four whose elements are not types JSON has. A polygon is
+# written as a list of pairs, and only the property knows that each pair is a Vector2 rather than a
+# list of two numbers: without being told, every element was read as itself and the engine turned
+# the lot into zeroes on the way into the property.
+const PACKED_ELEMENTS: Dictionary = {
+	TYPE_PACKED_VECTOR2_ARRAY: TYPE_VECTOR2,
+	TYPE_PACKED_VECTOR3_ARRAY: TYPE_VECTOR3,
+	TYPE_PACKED_VECTOR4_ARRAY: TYPE_VECTOR4,
+	TYPE_PACKED_COLOR_ARRAY: TYPE_COLOR,
+}
+
+var _values: Serialisation = Serialisation.new()
+
+# Why the value being parsed cannot be written, when the parse is what found out. A resource is
+# built inside the parse and there is nowhere in a parsed value to put the reason it is wrong.
+var _refused: String = ""
+
+
+## Turns what arrived over the wire into the Godot value a property wants.
+##
+## Three separate questions, asked in order, because a caller may say what it means in three
+## ways: a dictionary that names its own type, a dictionary shaped like the type the property
+## declares, or a bare array positional for a vector. Each is its own function; asking all three
+## in one was twenty-four exits deep and impossible to follow.
+func parse(value: Variant, expected_type: int = TYPE_NIL) -> Variant:
+	if value is Dictionary:
+		var fields: Dictionary = value
+		var tagged: Array = _parse_tagged_dictionary(fields)
+		if tagged[0]:
+			return tagged[1]
+		return _parse_shaped_dictionary(fields, expected_type)
+	if value is Array:
+		var items: Array = value
+		return _parse_array(items, expected_type)
+	# The same fitting the running game does, so "2.5" written to a float property here and there
+	# mean the same thing. It leaves a value it cannot fit alone rather than casting it, which is
+	# what lets the write be refused instead of landing as whatever the cast produced.
+	return _values.fitted(value, expected_type)
+
+
+## Why [param property] on [param holder] cannot be given [param value], or "" when it can.
+##
+## Object.set converts rather than refuses, and the conversion is silent and lossy: a word written
+## to an int property is stored as 0, to a bool as true, to a Vector2 as (0, 0). The file is then
+## saved holding a value nobody asked for and the tool reports the change as made, which is worse
+## than refusing and worse than failing, because there is nothing anywhere to read afterwards that
+## says the value is not the one that was sent.
+func cannot_hold(holder: String, property: String, value: Variant, expected_type: int) -> String:
+	var held: String = type_string(expected_type)
+	var cost: String = " Setting it would save a different value than the one asked for."
+	if not Serialisation.acceptable(value, expected_type):
+		var shape: String = "%s.%s is %s and the value given is %s, which cannot become one."
+		return shape % [holder, property, held, type_string(typeof(value))] + cost
+
+	# And the same question of each element, because a list is accepted for a packed array whatever
+	# is in it: a polygon written as [{"x": 1}] passes the check above and lands as one zero vector.
+	var element: int = Read.as_int(PACKED_ELEMENTS.get(expected_type, TYPE_NIL), TYPE_NIL)
+	if element == TYPE_NIL or not value is Array:
+		return ""
+	var items: Array = value
+	for index: int in items.size():
+		if not Serialisation.acceptable(items[index], element):
+			var shape: String = "%s.%s is %s and item %d of the list given is %s, not %s."
+			var named: Array = [
+				holder, property, held, index, type_string(typeof(items[index])), type_string(element)
+			]
+			return shape % named + cost
+	return ""
+
+
+## Writes each of [param properties] onto [param target], stopping at the first it cannot write and
+## answering with why, or "" when every one of them went on.
+##
+## In the order they were given, because a property list is not fixed: a ShaderMaterial has no
+## `shader_parameter/tint` until its `shader` is set, so a pass that checked them all before writing
+## any would refuse the pair that works.
+##
+## Nothing here saves, so a refusal partway leaves the change in memory and the file as it was. The
+## caller returns the refusal instead of saving.
+func write_all(target: Object, properties: Dictionary) -> String:
+	for key: Variant in properties:
+		var property: String = str(key)
+		if not has_property(target, property):
+			return "%s has no property %s" % [target.get_class(), property]
+		var expected_type: int = property_type(target, property)
+		var raw: Variant = properties[key]
+
+		# A resource-valued property takes the path of one, which is how a caller names a TileSet,
+		# a material or a theme: there is no other way to hand a tool a Resource.
+		if expected_type == TYPE_OBJECT and typeof(raw) == TYPE_STRING:
+			var found: Array = _resource_at(str(raw), property)
+			if not found[0]:
+				return str(found[1])
+			target.set(property, found[1])
+			continue
+
+		_refused = ""
+		var value: Variant = parse(raw, expected_type)
+		if not _refused.is_empty():
+			return _refused
+		var refusal: String = cannot_hold(target.get_class(), property, value, expected_type)
+		if not refusal.is_empty():
+			return refusal
+		target.set(property, value)
+	return ""
+
+
+## The resource [param path] names, as [found, resource or why not].
+##
+## The project boundary is enforced here as well as on the server, because only the engine knows
+## that this property is one holding a path: an absolute path and a user:// one both load, and
+## neither names a file this project owns. A path nothing is at is refused too, since Object.set
+## stores the null that load answers with and the file is saved having quietly lost the reference.
+func _resource_at(path: String, property: String) -> Array:
+	if not (path.begins_with("res://") or path.begins_with("uid://")):
+		return [false, "%s takes a res:// or uid:// path, not %s" % [property, path]]
+	if path.split("/").has(".."):
+		return [false, "%s leaves the project: %s" % [property, path]]
+	if not ResourceLoader.exists(path):
+		return [false, "No resource at %s for %s" % [path, property]]
+	return [true, load(path)]
+
+
+## Whether [param target] declares [param property] at all. Object.set ignores a name it does not
+## know, so without this a typo saved a file that had not changed and reported it as one that had.
+func has_property(target: Object, property: String) -> bool:
+	for declared: Dictionary in target.get_property_list():
+		if str(declared.get("name", "")) == property:
+			return true
+	return false
+
+
+## The type [param property] is declared as, or TYPE_NIL where nothing declares one.
+func property_type(target: Object, property: String) -> int:
+	for declared: Dictionary in target.get_property_list():
+		if str(declared.get("name", "")) == property:
+			return Read.as_int(declared.get("type", TYPE_NIL), TYPE_NIL)
+	return TYPE_NIL
+
+
+## A dictionary carrying its own type name, as the serialiser writes it.
+##
+## Answers [handled, value] rather than just the value, because a handled tag may legitimately
+## produce null: a Resource with no path is "this is nothing", not "this is not mine". A tag
+## that names a type but lacks the keys to build it is left unhandled on purpose, so the caller
+## can still read it against the type the property declares.
+func _parse_tagged_dictionary(value: Dictionary) -> Array:
+	var type_tag: String = str(value.get("_type", value.get("type", "")))
+	if type_tag == "Resource":
+		var resource_path: String = str(value.get("path", ""))
+		return [true, null if resource_path.is_empty() else load(resource_path)]
+
+	# The shared builder is the same one the answer was written by, so every shape it writes comes
+	# back as itself. `type` as the tag is read as `_type`: it is what these tools answered with
+	# before the serialisers were made one, and a caller who kept an answer can still send it.
+	var tagged: Dictionary = value
+	if not value.has("_type") and not type_tag.is_empty():
+		tagged = value.duplicate()
+		tagged["_type"] = type_tag
+	var rebuilt: Variant = _values.deserialize_value(tagged)
+	if not rebuilt is Dictionary:
+		return [true, rebuilt]
+
+	return _parse_new_resource(type_tag, value)
+
+
+## A tag naming a Resource class builds a fresh one, its other keys set as properties, so a
+## NavigationRegion2D can arrive with its NavigationPolygon and an AnimationTree with its root
+## state machine in the same add as any other property.
+func _parse_new_resource(type_tag: String, value: Dictionary) -> Array:
+	if (
+		type_tag.is_empty()
+		or not ClassDB.class_exists(type_tag)
+		or not ClassDB.is_parent_class(type_tag, "Resource")
+		or not ClassDB.can_instantiate(type_tag)
+	):
+		return [false, null]
+
+	var built: Resource = ClassDB.instantiate(type_tag)
+	var wanted: Dictionary = {}
+	for key: Variant in value:
+		var property: String = str(key)
+		if property != "_type" and property != "type":
+			wanted[property] = value[key]
+	var refused: String = write_all(built, wanted)
+	if not refused.is_empty():
+		_refused = refused
+		return [true, null]
+	return [true, built]
+
+
+## A dictionary with no tag, read against the type the property declares. Falls back to the
+## dictionary itself, since a property may genuinely want one.
+func _parse_shaped_dictionary(value: Dictionary, expected_type: int) -> Variant:
+	match expected_type:
+		TYPE_VECTOR2:
+			if value.has("x") and value.has("y"):
+				return Vector2(Read.as_float(value["x"]), Read.as_float(value["y"]))
+		TYPE_VECTOR2I:
+			if value.has("x") and value.has("y"):
+				return Vector2i(Read.as_int(value["x"]), Read.as_int(value["y"]))
+		TYPE_VECTOR3:
+			if value.has("x") and value.has("y") and value.has("z"):
+				return Vector3(
+					Read.as_float(value["x"]), Read.as_float(value["y"]), Read.as_float(value["z"])
+				)
+		TYPE_VECTOR3I:
+			if value.has("x") and value.has("y") and value.has("z"):
+				return Vector3i(Read.as_int(value["x"]), Read.as_int(value["y"]), Read.as_int(value["z"]))
+		TYPE_VECTOR4:
+			if value.has("x") and value.has("y") and value.has("z") and value.has("w"):
+				return Vector4(
+					Read.as_float(value["x"]),
+					Read.as_float(value["y"]),
+					Read.as_float(value["z"]),
+					Read.as_float(value["w"])
+				)
+		TYPE_COLOR:
+			if value.has("r") and value.has("g") and value.has("b"):
+				return Color(
+					Read.as_float(value["r"]),
+					Read.as_float(value["g"]),
+					Read.as_float(value["b"]),
+					Read.as_float(value.get("a", 1), 1.0)
+				)
+		TYPE_RECT2:
+			if value.has("x") and value.has("y") and value.has("width") and value.has("height"):
+				return Rect2(
+					Read.as_float(value["x"]),
+					Read.as_float(value["y"]),
+					Read.as_float(value["width"]),
+					Read.as_float(value["height"])
+				)
+		TYPE_NODE_PATH:
+			if value.has("path"):
+				return NodePath(str(value["path"]))
+	return value
+
+
+## An array, either positional for a vector the property declares, or a list to parse per item.
+func _parse_array(value: Array, expected_type: int) -> Variant:
+	if PACKED_ELEMENTS.has(expected_type):
+		var element: int = Read.as_int(PACKED_ELEMENTS[expected_type], TYPE_NIL)
+		return value.map(func(item: Variant) -> Variant: return parse(item, element))
+
+	match expected_type:
+		TYPE_VECTOR2:
+			if value.size() >= 2:
+				return Vector2(Read.as_float(value[0]), Read.as_float(value[1]))
+		TYPE_VECTOR2I:
+			if value.size() >= 2:
+				return Vector2i(Read.as_int(value[0]), Read.as_int(value[1]))
+		TYPE_VECTOR3:
+			if value.size() >= 3:
+				return Vector3(Read.as_float(value[0]), Read.as_float(value[1]), Read.as_float(value[2]))
+		TYPE_VECTOR3I:
+			if value.size() >= 3:
+				return Vector3i(Read.as_int(value[0]), Read.as_int(value[1]), Read.as_int(value[2]))
+		TYPE_VECTOR4:
+			if value.size() >= 4:
+				return Vector4(
+					Read.as_float(value[0]),
+					Read.as_float(value[1]),
+					Read.as_float(value[2]),
+					Read.as_float(value[3])
+				)
+		TYPE_COLOR:
+			if value.size() >= 3:
+				return Color(
+					Read.as_float(value[0]),
+					Read.as_float(value[1]),
+					Read.as_float(value[2]),
+					Read.as_float(value[3]) if value.size() >= 4 else 1.0
+				)
+	return value.map(func(item: Variant) -> Variant: return parse(item))

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

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

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

@@ -10,6 +10,27 @@ extends RefCounted
 
 const Read = preload("reading.gd")
 
+# What the engine carries from one to another without complaint, which is what a value written to a
+# property or handed to a parameter may arrive as. Numbers include bool because the engine counts it
+# as one, and the three text types are one string wearing three hats.
+const NUMBERS: Array[int] = [TYPE_BOOL, TYPE_INT, TYPE_FLOAT]
+const TEXTS: Array[int] = [TYPE_STRING, TYPE_STRING_NAME, TYPE_NODE_PATH]
+
+# The types that cross as a plain JSON list and have to be built back into themselves. A list is
+# what a caller can write by hand and what the serialiser answers with, and the parameter or
+# property being written is the only thing that knows which of these it wanted.
+const LIST_TYPES: Array[int] = [
+	TYPE_PACKED_INT32_ARRAY,
+	TYPE_PACKED_INT64_ARRAY,
+	TYPE_PACKED_FLOAT32_ARRAY,
+	TYPE_PACKED_FLOAT64_ARRAY,
+	TYPE_PACKED_STRING_ARRAY,
+	TYPE_PACKED_VECTOR2_ARRAY,
+	TYPE_PACKED_VECTOR3_ARRAY,
+	TYPE_PACKED_VECTOR4_ARRAY,
+	TYPE_PACKED_COLOR_ARRAY,
+]
+
 # What each Godot type becomes on the wire, as one table you can read rather than an order you
 # have to trust. Keyed on typeof() rather than written as a chain of `is` tests, because the
 # order mattered: Resource had to be tested before Object or every resource came back as a bare
@@ -163,6 +184,91 @@ func deserialize_value(value: Variant) -> Variant:
 	return call(builder, fields)
 
 
+## Whether two values can be compared without the comparison itself failing.
+##
+## GDScript's `==` is not total. An Object against a String is a hard error rather than false, and
+## an error raised inside a game is not a wrong answer: it stops the game. A caller who asked
+## `runtime_wait until` for the wrong kind of value got their game held at a debugger break, every
+## later call answering "did not respond within 10000ms, it may be stuck in a long frame", and
+## nothing anywhere naming the argument that did it. A wrong argument costs a refusal, never the
+## session's game.
+##
+## Only an object is special. Every other pair the engine answers, false where they differ, and
+## refusing those would refuse calls that work: an int against a float is the same number to a
+## caller waiting for 1 on a property holding 1.0.
+static func comparable(one: Variant, other: Variant) -> bool:
+	var left: int = typeof(one)
+	var right: int = typeof(other)
+	if left != TYPE_OBJECT and right != TYPE_OBJECT:
+		return true
+	# An object compares with another object and with null. Anything else is the error above.
+	return (left == TYPE_OBJECT or left == TYPE_NIL) and (right == TYPE_OBJECT or right == TYPE_NIL)
+
+
+## Whether [param value] can be given to something declared as [param type] without damage.
+##
+## Here rather than beside either caller because the running game and the editor ask it of the same
+## values and must not answer differently. What it protects against differs by side and both are
+## silent: `callv` and `==` raise inside a running game, which holds it at a debugger break, while
+## `Object.set` in the editor converts instead and writes the result to the scene file. A word where
+## an int goes is stored as 0, where a bool goes as true, where a Vector2 goes as (0, 0), and the
+## tool reports the change as made. The property keeps a value nobody asked for and the scene is
+## saved with it.
+##
+## A list of what is accepted rather than of what is refused, which is the way round that errs
+## safely. The engine's own conversion table is not readable from GDScript, so either list is a
+## guess at it; guessing narrow costs a caller a refusal naming both types, and guessing wide costs
+## them the damage above. A refusal is the cheaper mistake, and it is the one they can act on.
+static func acceptable(value: Variant, type: int) -> bool:
+	if type == TYPE_NIL:
+		return true
+	var given: int = typeof(value)
+	if given == type:
+		return true
+	# null is a value for anything that holds an object, and for nothing else.
+	if given == TYPE_NIL:
+		return type == TYPE_OBJECT
+	if NUMBERS.has(given) and NUMBERS.has(type):
+		return true
+	if TEXTS.has(given) and TEXTS.has(type):
+		return true
+	return given == TYPE_ARRAY and LIST_TYPES.has(type)
+
+
+## A value from the wire fitted to the type a property or parameter declares. Arguments arrive
+## as strings often enough, and callv refuses a "2.0" where a float is wanted, so a string that
+## reads as the wanted scalar is read as one.
+##
+## The conversion is also what restores a packed array's exact type. Those cross as the plain JSON
+## lists they fit into, so what comes back from the wire is an Array, and the parameter is what says
+## it was a PackedStringArray.
+func fitted(value: Variant, type: int) -> Variant:
+	var rebuilt: Variant = deserialize_value(value)
+	if type == TYPE_NIL or typeof(rebuilt) == type:
+		return rebuilt
+
+	if rebuilt is Array and LIST_TYPES.has(type):
+		return type_convert(rebuilt, type)
+
+	var simple: Array[int] = [TYPE_BOOL, TYPE_INT, TYPE_FLOAT, TYPE_STRING]
+	if not simple.has(type) or not simple.has(typeof(rebuilt)):
+		return rebuilt
+
+	if rebuilt is String and type != TYPE_STRING:
+		var text: String = rebuilt
+		var parsed: Variant = JSON.parse_string(text)
+		# A string that does not read as the type wanted is handed back as the string it is, so
+		# whoever asked can refuse it. type_convert answers 0 for "not an index" and true for any
+		# text at all, and a caller who sent a word got back a number they never sent: get_child
+		# answered about child 0 with no refusal and no note, which is a halt traded for a plausible
+		# wrong answer, and the wrong answer is the worse of the two.
+		if typeof(parsed) == TYPE_NIL or typeof(parsed) == TYPE_STRING:
+			return rebuilt
+		rebuilt = parsed
+
+	return type_convert(rebuilt, type)
+
+
 ## Whether [param fields] carries every key of any one of [param alternatives].
 ##
 ## More than one spelling because a rectangle has two: the two corners it is answered with, and the

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

@@ -3,9 +3,11 @@ extends Node
 
 ## Animations and animation trees, edited in the open editor.
 
+const PropertyValues = preload("../property_values.gd")
 const Read = preload("../reading.gd")
 
 var _editor_plugin: EditorPlugin = null
+var _properties: PropertyValues = PropertyValues.new()
 
 
 func set_editor_plugin(plugin: EditorPlugin) -> void:
@@ -70,33 +72,14 @@ func _find_node(root: Node, path: String) -> Node:
 	return root.get_node_or_null(path)
 
 
+## A keyframe value or a method argument, read as whatever it says it is.
+##
+## No type to read it against, unlike a property write: what a track animates is named by a path
+## that has still to be resolved against a scene this tool does not hold. So the tags are what
+## decide, which is why they have to be all of them. Three were handled here, and a Quaternion,
+## a Rect2 or a Transform2D keyframe was stored as the dictionary it arrived as.
 func _parse_value(value: Variant) -> Variant:
-	if typeof(value) == TYPE_DICTIONARY:
-		var fields: Dictionary = value
-		if fields.has("type") or fields.has("_type"):
-			var t: Variant = fields.get("type", fields.get("_type", ""))
-			match t:
-				"Vector2":
-					return Vector2(Read.as_float(fields.get("x", 0)), Read.as_float(fields.get("y", 0)))
-				"Vector3":
-					return Vector3(
-						Read.as_float(fields.get("x", 0)),
-						Read.as_float(fields.get("y", 0)),
-						Read.as_float(fields.get("z", 0))
-					)
-				"Color":
-					return Color(
-						Read.as_float(fields.get("r", 1), 1.0),
-						Read.as_float(fields.get("g", 1), 1.0),
-						Read.as_float(fields.get("b", 1), 1.0),
-						Read.as_float(fields.get("a", 1), 1.0)
-					)
-	if typeof(value) == TYPE_ARRAY:
-		var result: Array = []
-		for item: Variant in value:
-			result.append(_parse_value(item))
-		return result
-	return value
+	return _properties.parse(value)
 
 
 func _parse_json_maybe(value: Variant) -> Variant: