gdharness 1.3.3 → 1.3.5

package/build/godot/operations/same_values.gd

@@ -0,0 +1,177 @@
+@tool
+extends RefCounted
+
+## Whether a value read back is the value that was given, as the tools that write properties judge
+## what a write kept and what it changed besides.
+
+const GdhRead = preload("reading.gd")
+const GdhSerialisation = preload("serialisation.gd")
+
+# The types made of floats, which a read back compares within float precision: a Vector2 property
+# stores 32-bit components, so 0.1 comes back as 0.100000001.
+const FLOAT_SHAPES: Array[int] = [
+	TYPE_VECTOR2,
+	TYPE_VECTOR3,
+	TYPE_VECTOR4,
+	TYPE_QUATERNION,
+	TYPE_COLOR,
+	TYPE_RECT2,
+	TYPE_TRANSFORM2D,
+	TYPE_BASIS,
+	TYPE_TRANSFORM3D,
+	TYPE_PLANE,
+	TYPE_AABB,
+	TYPE_PROJECTION,
+]
+
+const PACKED: Array[int] = [
+	TYPE_PACKED_BYTE_ARRAY,
+	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,
+]
+
+# The pairs of built-in resources being compared, so a resource that holds itself ends the
+# comparison instead of recursing into it for ever.
+static var _comparing: Array[Array] = []
+
+
+## Whether [param held] is [param given], as a property read back after a set answers it.
+##
+## Close enough rather than equal for anything made of floats: a Vector2 property stores 32-bit
+## components, so 0.1 comes back as 0.100000001. A packed array read back against the list it was
+## given compares element by element, since `==` between the two is an error rather than false.
+static func same(held: Variant, given: Variant) -> bool:
+	var held_type: int = typeof(held)
+	var given_type: int = typeof(given)
+	# An empty object property reads back as an Object that is null, not as nil, and the two are
+	# the same nothing.
+	var held_none: bool = held_type == TYPE_NIL or (held_type == TYPE_OBJECT and held == null)
+	var given_none: bool = given_type == TYPE_NIL or (given_type == TYPE_OBJECT and given == null)
+	if held_none or given_none:
+		return held_none == given_none
+	if held_type == TYPE_OBJECT or given_type == TYPE_OBJECT:
+		return _same_object(held, given)
+	if GdhSerialisation.NUMBERS.has(held_type) and GdhSerialisation.NUMBERS.has(given_type):
+		if held_type == TYPE_BOOL or given_type == TYPE_BOOL:
+			return held_type == given_type and held == given
+		var held_number: float = GdhRead.as_float(held)
+		var given_number: float = GdhRead.as_float(given)
+		return (is_nan(held_number) and is_nan(given_number)) or is_equal_approx(held_number, given_number)
+	if GdhSerialisation.TEXTS.has(held_type) and GdhSerialisation.TEXTS.has(given_type):
+		return str(held) == str(given)
+	if _listed(held_type) and _listed(given_type):
+		var held_items: Array = type_convert(held, TYPE_ARRAY)
+		var given_items: Array = type_convert(given, TYPE_ARRAY)
+		if held_items.size() != given_items.size():
+			return false
+		for index: int in held_items.size():
+			if not same(held_items[index], given_items[index]):
+				return false
+		return true
+	if held_type == TYPE_DICTIONARY and given_type == TYPE_DICTIONARY:
+		var held_entries: Dictionary = held
+		var given_entries: Dictionary = given
+		return _same_entries(held_entries, given_entries)
+	if held_type != given_type:
+		return false
+	return _same_shape(held, given)
+
+
+static func _same_object(held: Variant, given: Variant) -> bool:
+	if typeof(held) != TYPE_OBJECT or typeof(given) != TYPE_OBJECT:
+		return false
+	if is_same(held, given):
+		return true
+	if not held is Resource or not given is Resource:
+		return false
+	var held_resource: Resource = held
+	var given_resource: Resource = given
+	if not _built_in(held_resource):
+		return held_resource.resource_path == given_resource.resource_path
+	if held_resource.get_class() != given_resource.get_class():
+		return false
+	# A resource local to the scene is duplicated for every instance, so the copy read back is
+	# another object of the same class.
+	if held_resource.resource_local_to_scene:
+		return true
+	return _built_in(given_resource) and _same_stored(held_resource, given_resource)
+
+
+## A resource no other file can refer to: one with no path, or one of a file's own sub-resources,
+## whose path is the file's with "::" and an id after it.
+static func _built_in(resource: Resource) -> bool:
+	return resource.resource_path.is_empty() or resource.resource_path.contains("::")
+
+
+## Two built-in resources of one class, by every property they store. Neither has a path to be
+## known by, and a file loaded again holds a new object for each, so a Curve written into a
+## resource file and read back was judged lost by the save that had just kept it.
+static func _same_stored(held: Resource, given: Resource) -> bool:
+	for pair: Array in _comparing:
+		if is_same(pair[0], held) and is_same(pair[1], given):
+			return true
+	_comparing.append([held, given])
+	var alike: bool = true
+	for property: Dictionary in held.get_property_list():
+		var usage: int = GdhRead.as_int(property.get("usage", 0))
+		var name: String = str(property.get("name", ""))
+		if (
+			not (usage & PROPERTY_USAGE_STORAGE)
+			or (name.begins_with("resource_") and name != "resource_name")
+		):
+			continue
+		if not same(held.get(name), given.get(name)):
+			alike = false
+			break
+	_comparing.pop_back()
+	return alike
+
+
+static func _same_entries(held: Dictionary, given: Dictionary) -> bool:
+	if held.size() != given.size():
+		return false
+	for key: Variant in given:
+		var found: bool = false
+		for held_key: Variant in held:
+			if same(held_key, key):
+				found = same(held[held_key], given[key])
+				break
+		if not found:
+			return false
+	return true
+
+
+## Two values of one type made of floats, compared component by component through the type's own
+## text form, which lists every component: each type has its own is_equal_approx, and reaching it
+## through a Variant is a call the typed gate refuses.
+static func _same_shape(held: Variant, given: Variant) -> bool:
+	if typeof(held) not in FLOAT_SHAPES:
+		return held == given
+	var held_parts: Array[float] = _components(held)
+	var given_parts: Array[float] = _components(given)
+	if held_parts.size() != given_parts.size():
+		return false
+	for index: int in held_parts.size():
+		if not same(held_parts[index], given_parts[index]):
+			return false
+	return true
+
+
+static func _components(value: Variant) -> Array[float]:
+	var parts: Array[float] = []
+	var text: String = var_to_str(value)
+	var inner: String = text.substr(text.find("(") + 1).trim_suffix(")")
+	for part: String in inner.split(",", false):
+		parts.append(part.strip_edges().to_float())
+	return parts
+
+
+static func _listed(type: int) -> bool:
+	return type == TYPE_ARRAY or PACKED.has(type)

package/build/godot/operations/serialisation.gd

@@ -121,6 +121,10 @@ const BUILDERS: Dictionary = {
 	"Dictionary": "_build_dictionary",
 }
 
+## The built-in resources being described, outermost first, so one holding itself somewhere inside
+## is answered by its class rather than without end.
+var _describing: Array[Resource] = []
+
 
 # Converts a Godot value into something JSON can carry. A type with no entry in the table
 # passes through as itself, which is what the JSON-native ones want.
@@ -665,9 +669,21 @@ func _serialize_object(value: Object) -> Variant:
 		return _describe_input_event(event)
 	if value is Resource:
 		var resource: Resource = value
-		if resource.resource_path.is_empty():
-			return {"class": resource.get_class(), "_type": "Resource"}
-		return {"path": resource.resource_path, "class": resource.get_class(), "_type": "Resource"}
+		# A file's built-in resources load with a path of the file's own and "::", which no other
+		# file can refer to.
+		if resource.resource_path.is_empty() or resource.resource_path.contains("::"):
+			return _describe_built_in(resource)
+		var filed: Dictionary = {
+			"path": resource.resource_path, "class": resource.get_class(), "_type": "Resource"
+		}
+		# The engine class of a resource with a script is the one its script extends, so a Stats
+		# file read as a Resource and nothing said it was a Stats.
+		var attached: Variant = resource.get_script()
+		if attached is Script:
+			var script: Script = attached
+			if not script.get_global_name().is_empty():
+				filed["scriptClass"] = str(script.get_global_name())
+		return filed
 	if value is Node:
 		var node: Node = value
 		if node.is_inside_tree():
@@ -675,6 +691,62 @@ func _serialize_object(value: Object) -> Variant:
 	return _describe_object(value)
 
 
+## A resource built into the file it was read from, in the form a write builds one from: its class
+## under _type beside every property it stores away from its default. As its class alone it said
+## nothing of what it held, so a CollisionShape2D's radius could not be read, and it could not be
+## written back.
+func _describe_built_in(resource: Resource) -> Dictionary:
+	if _describing.has(resource):
+		return {"class": resource.get_class(), "_type": "Resource"}
+	_describing.append(resource)
+	var described: Dictionary = {"_type": resource.get_class()}
+	var attached: Variant = resource.get_script()
+	var script: Script = null
+	if attached is Script:
+		script = attached
+		described["script"] = serialize_value(script)
+	var fresh: Object = _fresh(script)
+	for property: Dictionary in resource.get_property_list():
+		var usage: int = property.get("usage", 0)
+		var name: String = str(property.get("name", ""))
+		if (
+			not (usage & PROPERTY_USAGE_STORAGE)
+			or name == "script"
+			or (name.begins_with("resource_") and name != "resource_name")
+		):
+			continue
+		var held: Variant = resource.get(name)
+		var default: Variant = ClassDB.class_get_property_default_value(resource.get_class(), name)
+		if fresh != null:
+			default = fresh.get(name)
+		elif script != null and usage & PROPERTY_USAGE_SCRIPT_VARIABLE:
+			default = script.get_property_default_value(name)
+		if typeof(held) == typeof(default) and held == default:
+			continue
+		described[name] = serialize_value(held)
+	_describing.pop_back()
+	return described
+
+
+## A new instance of [param script] to read defaults off, or null where none should be made. What
+## the script's own code sets as it is made (a resource_name in _init, a list built by a
+## constructor, which the engine reports no default for) is then a default rather than a value
+## the file holds. None is made for a script whose _init needs arguments, nor in the editor for one
+## that is not a tool: the editor never runs those, and can_instantiate says so.
+static func _fresh(script: Script) -> Object:
+	if script == null or not script.can_instantiate():
+		return null
+	for method: Dictionary in script.get_script_method_list():
+		if str(method.get("name", "")) == "_init":
+			var arguments: Array = method.get("args", [])
+			var defaults: Array = method.get("default_args", [])
+			if arguments.size() > defaults.size():
+				return null
+	# Called by name: new() is declared on each kind of script rather than on Script.
+	var made: Variant = script.call("new")
+	return made if made is Object else null
+
+
 ## An input event, by what it is bound to: the engine's own words for it and every field it stores
 ## away from its default. As a bare resource it was its class and nothing else, so an input action
 ## read back from project.godot could not say whether it was bound to Space or to a joypad button.

package/build/keeper.js

@@ -3,9 +3,33 @@
 // src/keeper.ts
 import { closeSync as closeSync2, existsSync as existsSync3, mkdtempSync as mkdtempSync4, openSync as openSync3, readFileSync as readFileSync3, rmSync as rmSync6, writeFileSync as writeFileSync3 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 
+// src/alive.ts
+import process2 from "node:process";
+function exitOf(child) {
+  if (child.exitCode !== null || child.signalCode !== null) {
+    return Promise.resolve({ code: child.exitCode, signal: child.signalCode });
+  }
+  return new Promise((resolve) => {
+    child.once("exit", (code, signal) => {
+      resolve({ code, signal });
+    });
+  });
+}
+function alive(pid) {
+  if (pid === undefined || pid === null) {
+    return false;
+  }
+  try {
+    process2.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+
 // src/desktop.ts
 import { createHash } from "node:crypto";
 import {
@@ -23,20 +47,6 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 
-// src/alive.ts
-import process2 from "node:process";
-function alive(pid) {
-  if (pid === undefined || pid === null) {
-    return false;
-  }
-  try {
-    process2.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
-
 // src/spawn.ts
 import {
   execFile,
@@ -1031,7 +1041,7 @@ class GameDebugger {
     }
     if (!held.hasStack) {
       this.forget("debug_enter");
-      this.send("next", [], held.thread);
+      this.send("step", [], held.thread);
       const again = await this.next(GameDebugger.named("debug_enter"), STEP_MS);
       if (again === null) {
         return {
@@ -1253,8 +1263,28 @@ function readLaunched(printed) {
 
 // src/run-record.ts
 import { createHash as createHash2 } from "node:crypto";
-import { mkdirSync, openSync as openSync2, readdirSync, readFileSync as readFileSync2, realpathSync, rmSync as rmSync4, statSync as statSync2 } from "node:fs";
-import { basename, dirname as dirname2, join as join4, resolve as resolve2 } from "node:path";
+import { mkdirSync, openSync as openSync2, readdirSync, readFileSync as readFileSync2, rmSync as rmSync4, statSync as statSync3 } from "node:fs";
+import { basename as basename2, join as join5, resolve as resolve3 } from "node:path";
+
+// src/paths.ts
+import { realpathSync, statSync as statSync2 } from "node:fs";
+import { basename, dirname, isAbsolute, join as join3, relative, resolve, sep } from "node:path";
+function realAsFarAsItExists(path) {
+  const missing = [];
+  let at = path;
+  for (;; ) {
+    try {
+      return join3(realpathSync.native(at), ...missing);
+    } catch {
+      const parent = dirname(at);
+      if (parent === at) {
+        return path;
+      }
+      missing.unshift(basename(at));
+      at = parent;
+    }
+  }
+}
 
 // src/windows-ask.ts
 var SCRIPT = [
@@ -1278,7 +1308,7 @@ var SCRIPT = [
 
 // src/runtime-client.ts
 import { tmpdir as tmpdir3 } from "node:os";
-import { dirname, join as join3, resolve } from "node:path";
+import { dirname as dirname2, join as join4, resolve as resolve2 } from "node:path";
 
 // src/launch.ts
 function envValue(name, variables = process.env) {
@@ -1323,7 +1353,7 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join3(perUser ?? tmpdir3(), "gdharness");
+  return join4(perUser ?? tmpdir3(), "gdharness");
 }
 var ERROR_REPORT_KEEP_MS = 60 * 60 * 1000;
 var verdicts = new Map;
@@ -1363,31 +1393,15 @@ function writeWhole(path, text) {
 
 // src/run-record.ts
 function runsDirectory() {
-  return join4(runtimeDirectory(), "runs");
-}
-function realAsFarAsItExists(path) {
-  const missing = [];
-  let at = path;
-  for (;; ) {
-    try {
-      return join4(realpathSync.native(at), ...missing);
-    } catch {
-      const parent = dirname2(at);
-      if (parent === at) {
-        return path;
-      }
-      missing.unshift(basename(at));
-      at = parent;
-    }
-  }
+  return join5(runtimeDirectory(), "runs");
 }
 function projectKey(projectPath) {
-  const real = realAsFarAsItExists(resolve2(projectPath)).replace(/[\\/]+$/, "");
+  const real = realAsFarAsItExists(resolve3(projectPath)).replace(/[\\/]+$/, "");
   const folded = process.platform === "win32" || process.platform === "darwin" ? real.toLowerCase() : real;
   return createHash2("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join4(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join5(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function writeRunRecord(record) {
   mkdirSync(runsDirectory(), { recursive: true });
@@ -1454,14 +1468,14 @@ function recordAt(path) {
 // src/scratch.ts
 import { existsSync as existsSync2, mkdtempSync as mkdtempSync3, readdirSync as readdirSync2, rmSync as rmSync5 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 import process4 from "node:process";
 var SWEPT = { recursive: true, force: true };
 var AGAIN_AFTER_MS = [250, 500, 1000, 2000, 4000, 8000, 16000];
 var waiting = new Set;
 var atExit = new Set;
 function scratchDirectory(kind) {
-  return mkdtempSync3(join5(tmpdir4(), `gdharness-${kind}-${process4.pid}-`));
+  return mkdtempSync3(join6(tmpdir4(), `gdharness-${kind}-${process4.pid}-`));
 }
 function discardWith(remove, paths) {
   const left = [];
@@ -1921,8 +1935,8 @@ async function startDirectly(spec, output, hidden, detached = true, errors = out
 }
 async function startThroughHelper(spec, output, stopFile) {
   const scratch = scratchDirectory("desktop");
-  const pidFile = join6(scratch, "pid");
-  const errorFile = join6(scratch, "error");
+  const pidFile = join7(scratch, "pid");
+  const errorFile = join7(scratch, "error");
   const where = spec.desktop === undefined ? "without activation" : `on the ${spec.desktop} desktop`;
   try {
     const compiled = await ensureHelperCompiled();
@@ -1930,7 +1944,7 @@ async function startThroughHelper(spec, output, stopFile) {
       return { error: `it could not be started ${where}: ${compiled}` };
     }
     const wrapper = throughHelper({ ...spec, directory: process.cwd() }, spec.command, spec.args, {
-      spec: join6(scratch, "spec.json"),
+      spec: join7(scratch, "spec.json"),
       pid: pidFile,
       error: errorFile,
       stop: stopFile
@@ -1974,7 +1988,7 @@ function profiledBy(path, projectPath) {
   };
   let projectGodot = null;
   try {
-    projectGodot = readFileSync3(join6(projectPath, "project.godot"), "utf8");
+    projectGodot = readFileSync3(join7(projectPath, "project.godot"), "utf8");
   } catch {}
   const observer = new ProfileObserver((totals) => {
     const first = latest === null;
@@ -2077,8 +2091,8 @@ async function keep() {
   const debuggerPeer = run === undefined || run.debugged === false ? null : await GameDebugger.open(run.breakpoints ?? [], profiled === null ? [] : [profiled.observer]);
   const toStart = debuggerPeer === null ? spec : { ...spec, args: withEngineArguments(spec.args, debuggerPeer.engineArguments) };
   const transcript = run === undefined ? "ignore" : openSync3(run.transcript, "a");
-  const own = run !== undefined && throughTheHelper(spec) ? mkdtempSync4(join6(tmpdir5(), "gdharness-stop-")) : null;
-  const stopFile = own === null ? "" : join6(own, "stop");
+  const own = run !== undefined && throughTheHelper(spec) ? mkdtempSync4(join7(tmpdir5(), "gdharness-stop-")) : null;
+  const stopFile = own === null ? "" : join7(own, "stop");
   let started;
   try {
     started = await startDetached(toStart, transcript, run === undefined, stopFile);
@@ -2108,26 +2122,8 @@ async function keep() {
   if (record !== null) {
     writeNoteIfItCan(record);
   }
+  const exited = exitOf(child);
   let listening = null;
-  child.once("exit", (code, signal) => {
-    const finish = () => {
-      profiled?.finish();
-      if (run !== undefined) {
-        recordRunEnded(run.projectPath, pid, { exitCode: code, exitSignal: code === null ? signal : null });
-      }
-      debuggerPeer?.close();
-      listening?.close();
-      if (own !== null) {
-        rmSync6(own, { recursive: true, force: true });
-      }
-      process.exit(0);
-    };
-    if (debuggerPeer === null) {
-      finish();
-    } else {
-      debuggerPeer.drained(DRAIN_MS).then(finish);
-    }
-  });
   if (record !== null) {
     listening = await listenForTheServer(() => {
       if (stopFile !== "") {
@@ -2140,9 +2136,27 @@ async function keep() {
       writeNoteIfItCan({ ...record, keeper: listening.address });
     }
   }
-  process.stdout.write(`pid ${pid}
-`);
-  process.stdout.end();
+  await new Promise((resolve) => {
+    process.stdout.once("error", () => {
+      resolve();
+    });
+    process.stdout.end(`pid ${pid}
+`, resolve);
+  });
+  const { code, signal } = await exited;
+  if (debuggerPeer !== null) {
+    await debuggerPeer.drained(DRAIN_MS);
+  }
+  profiled?.finish();
+  if (run !== undefined) {
+    recordRunEnded(run.projectPath, pid, { exitCode: code, exitSignal: code === null ? signal : null });
+  }
+  debuggerPeer?.close();
+  listening?.close();
+  if (own !== null) {
+    rmSync6(own, { recursive: true, force: true });
+  }
+  process.exit(0);
 }
 var mode = process.argv[2];
 if (mode === "launch") {

package/package.json

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