gdharness 1.2.2 → 1.2.4

package/build/cli.js

@@ -42117,6 +42117,30 @@ function projectKey(projectPath) {
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
   return join24(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
+function latestRunPath(servedBy, directory = runtimeDirectory()) {
+  return join24(directory, "runs", `latest-${projectKey(servedBy)}.json`);
+}
+function writeLatestRun(servedBy, latest) {
+  try {
+    mkdirSync14(runsDirectory(), { recursive: true });
+    writeFileSync16(latestRunPath(servedBy), JSON.stringify(latest, null, 2), "utf8");
+  } catch {}
+}
+function readLatestRun(servedBy, directory = runtimeDirectory()) {
+  try {
+    const fields = JSON.parse(readFileSync21(latestRunPath(servedBy, directory), "utf8"));
+    if (typeof fields !== "object" || fields === null) {
+      return null;
+    }
+    const { projectPath, pid, startedAt } = fields;
+    if (typeof projectPath !== "string" || typeof startedAt !== "number") {
+      return null;
+    }
+    return { projectPath, pid: typeof pid === "number" ? pid : null, startedAt };
+  } catch {
+    return null;
+  }
+}
 function openTranscript(startedAt) {
   mkdirSync14(runsDirectory(), { recursive: true });
   const path = join24(runsDirectory(), `run-${startedAt}.log`);
@@ -42866,6 +42890,9 @@ function runIsUp(run, editorSays, editorPlay = null, now = Date.now()) {
 function noCodeWillCome(run) {
   return !exited(run);
 }
+function transcriptNote(transcript, going) {
+  return going ? `Everything this run has printed is in ${transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: a transcript that stops growing is a run between prints. running above is asked of the operating system while there is a process to ask about, and for an editor-played run that announced no runtime it is the editor's answer instead, which can lag after the game has gone.` : `Everything this run printed is in ${transcript}, uncapped and complete, since the run is over.`;
+}
 function stopWaitMs() {
   return waitFromEnv("GDHARNESS_STOP_WAIT_MS", 1e4);
 }
@@ -46560,6 +46587,7 @@ class GodotServer {
       ...which === null ? {} : { play: which }
     };
     this.activeProcess = played;
+    this.noteTheLatestRun({ projectPath, pid: null, startedAt });
     this.watchThePlayedConsole();
     writeEditorRunNote({
       projectPath,
@@ -46912,6 +46940,7 @@ class GodotServer {
       return launched;
     }
     const startedBy = Date.now();
+    this.noteTheLatestRun({ projectPath, pid: launched.pid, startedAt });
     sweepTranscripts();
     const noted = readRunRecord(projectPath);
     const keeper = noted?.pid === launched.pid ? noted.keeper : undefined;
@@ -47150,7 +47179,8 @@ class GodotServer {
   async adoptRecordedRun() {
     const project = this.ourProject();
     const found = project === null ? [] : [readRunRecord(project), this.startedForUs(project)];
-    const record = found.reduce((newest, one) => one !== null && (newest === null || one.startedAt > newest.startedAt) ? one : newest, null);
+    const latest = project === null ? null : readLatestRun(project);
+    const record = latest === null ? found.reduce((newest, one) => one !== null && (newest === null || one.startedAt > newest.startedAt) ? one : newest, null) : found.find((one) => one !== null && one.pid === latest.pid && one.startedAt === latest.startedAt) ?? null;
     if (record === null || !(this.couldBeOurs(record.projectPath) || this.couldBeOurs(record.servedBy ?? ""))) {
       return null;
     }
@@ -47190,6 +47220,12 @@ class GodotServer {
     const mine = this.ourProject();
     return mine === null ? {} : { servedBy: mine };
   }
+  noteTheLatestRun(latest) {
+    const mine = this.ourProject();
+    if (mine !== null) {
+      writeLatestRun(mine, latest);
+    }
+  }
   startedForUs(project) {
     return everyRunRecord().find((one) => one.servedBy !== undefined && isSameDirectory(one.servedBy, project) && !(one.projectPath !== "" && isSameDirectory(one.projectPath, project))) ?? null;
   }
@@ -47601,7 +47637,7 @@ class GodotServer {
       notes.push(`The debug adapter this run's console arrives over went away while the run was going, so what is below has a hole in it and the counts are of what was heard rather than of what was printed. ${back ? "It is connected again, and the line marking where is in the log." : "It is still gone, so nothing further will arrive here."} The project's own user://logs/godot.log has the rest, and "no entries" here means "not heard" rather than a quiet run.`);
     }
     if (run.transcript !== null && selected.omitted > 0) {
-      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: a transcript that stops growing is a run between prints. running above is asked of the operating system while there is a process to ask about, and for an editor-played run that announced no runtime it is the editor's answer instead, which can lag after the game has gone.`);
+      notes.push(transcriptNote(run.transcript, going));
     }
     return this.jsonTextResponse({
       running: going,

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

@@ -377,10 +377,15 @@ 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 is shown beside the nearest. 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.
-## "" when nothing on the way up says so.
+## 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.
+##
+## 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
+## outermost hidden node: a game hides a screen by hiding the screen's root, and the nearest hidden
+## node can be a panel deep inside it whose siblings are hidden with it. "" when nothing on the way
+## up says the node is hidden.
 static func why_hidden(node: Node) -> String:
 	var hiding: Array[Node] = _hiding(node)
 	if hiding.is_empty():
@@ -391,27 +396,71 @@ static func why_hidden(node: Node) -> String:
 			named.append("its own visible is false")
 		else:
 			named.append("%s is hidden%s" % [one.get_path(), "" if named.is_empty() else " too"])
+	var control: Control = node as Control
+	var instead: Node = null if control == null else drawn_at(control)
+	if instead != null:
+		return " (%s; a click where it would be reaches %s)" % [", and ".join(named), instead.get_path()]
+	var outermost: Node = hiding.back()
 	var beside: Array[String] = []
-	var parent: Node = hiding[0].get_parent()
+	var parent: Node = outermost.get_parent()
 	if parent != null:
 		for sibling: Node in parent.get_children():
-			if sibling != hiding[0] and _shown(sibling):
+			if sibling != outermost and _shown(sibling):
 				beside.append(str(sibling.get_path()))
-	return " (%s%s)" % [", and ".join(named), _shown_beside(beside)]
+	return " (%s%s)" % [", and ".join(named), _shown_beside(beside, outermost)]
+
+
+## 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
+## 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)
+	var point: Vector2 = _centre_of(target)
+	var none: Dictionary[ScrollContainer, Vector2] = {}
+	var viewport: Viewport = target.get_viewport()
+	var best: Control = null
+	for each: Node in drawn:
+		var window: Window = each as Window
+		if window != null:
+			if _window_over(target, point, window):
+				return window
+			continue
+		var control: Control = each
+		if control.is_ancestor_of(target) or target.is_ancestor_of(control):
+			continue
+		if control.get_viewport() != viewport or not _holds(control, point):
+			continue
+		if _clipped_away(control, point, none):
+			continue
+		if best == null or _drawn_above(control, best):
+			best = control
+	return best
+
+
+## Whether [param control] is drawn above [param other]: on a higher canvas layer, or later on the
+## same one.
+static func _drawn_above(control: Control, other: Control) -> bool:
+	var layer: int = _layer_of(control)
+	var other_layer: int = _layer_of(other)
+	return layer > other_layer or (layer == other_layer and control.is_greater_than(other))
 
 
-## "; A, B and C beside it are shown" for [param beside], naming three at most and counting the rest.
-static func _shown_beside(beside: Array[String]) -> String:
+## "; 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.
+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 beside it is shown" % beside[0]
+		return "; %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 beside it are shown" % [", ".join(listed), rest]
+		return "; %s and %d more are shown beside %s" % [", ".join(listed), rest, at]
 	var last: String = listed.pop_back()
-	return "; %s and %s beside it are shown" % [", ".join(listed), last]
+	return "; %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

package/build/index.js

@@ -32922,6 +32922,30 @@ function projectKey(projectPath) {
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
   return join19(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
+function latestRunPath(servedBy, directory = runtimeDirectory()) {
+  return join19(directory, "runs", `latest-${projectKey(servedBy)}.json`);
+}
+function writeLatestRun(servedBy, latest) {
+  try {
+    mkdirSync11(runsDirectory(), { recursive: true });
+    writeFileSync13(latestRunPath(servedBy), JSON.stringify(latest, null, 2), "utf8");
+  } catch {}
+}
+function readLatestRun(servedBy, directory = runtimeDirectory()) {
+  try {
+    const fields = JSON.parse(readFileSync18(latestRunPath(servedBy, directory), "utf8"));
+    if (typeof fields !== "object" || fields === null) {
+      return null;
+    }
+    const { projectPath, pid, startedAt } = fields;
+    if (typeof projectPath !== "string" || typeof startedAt !== "number") {
+      return null;
+    }
+    return { projectPath, pid: typeof pid === "number" ? pid : null, startedAt };
+  } catch {
+    return null;
+  }
+}
 var SHARED_NOTE = "run.json";
 function openTranscript(startedAt) {
   mkdirSync11(runsDirectory(), { recursive: true });
@@ -35294,6 +35318,9 @@ function runIsUp(run, editorSays, editorPlay = null, now = Date.now()) {
 function noCodeWillCome(run) {
   return !exited(run);
 }
+function transcriptNote(transcript, going) {
+  return going ? `Everything this run has printed is in ${transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: a transcript that stops growing is a run between prints. running above is asked of the operating system while there is a process to ask about, and for an editor-played run that announced no runtime it is the editor's answer instead, which can lag after the game has gone.` : `Everything this run printed is in ${transcript}, uncapped and complete, since the run is over.`;
+}
 function stopWaitMs() {
   return waitFromEnv("GDHARNESS_STOP_WAIT_MS", 1e4);
 }
@@ -39057,6 +39084,7 @@ class GodotServer {
       ...which === null ? {} : { play: which }
     };
     this.activeProcess = played;
+    this.noteTheLatestRun({ projectPath, pid: null, startedAt });
     this.watchThePlayedConsole();
     writeEditorRunNote({
       projectPath,
@@ -39409,6 +39437,7 @@ class GodotServer {
       return launched;
     }
     const startedBy = Date.now();
+    this.noteTheLatestRun({ projectPath, pid: launched.pid, startedAt });
     sweepTranscripts();
     const noted = readRunRecord(projectPath);
     const keeper = noted?.pid === launched.pid ? noted.keeper : undefined;
@@ -39647,7 +39676,8 @@ class GodotServer {
   async adoptRecordedRun() {
     const project = this.ourProject();
     const found = project === null ? [] : [readRunRecord(project), this.startedForUs(project)];
-    const record = found.reduce((newest, one) => one !== null && (newest === null || one.startedAt > newest.startedAt) ? one : newest, null);
+    const latest = project === null ? null : readLatestRun(project);
+    const record = latest === null ? found.reduce((newest, one) => one !== null && (newest === null || one.startedAt > newest.startedAt) ? one : newest, null) : found.find((one) => one !== null && one.pid === latest.pid && one.startedAt === latest.startedAt) ?? null;
     if (record === null || !(this.couldBeOurs(record.projectPath) || this.couldBeOurs(record.servedBy ?? ""))) {
       return null;
     }
@@ -39687,6 +39717,12 @@ class GodotServer {
     const mine = this.ourProject();
     return mine === null ? {} : { servedBy: mine };
   }
+  noteTheLatestRun(latest) {
+    const mine = this.ourProject();
+    if (mine !== null) {
+      writeLatestRun(mine, latest);
+    }
+  }
   startedForUs(project) {
     return everyRunRecord().find((one) => one.servedBy !== undefined && isSameDirectory(one.servedBy, project) && !(one.projectPath !== "" && isSameDirectory(one.projectPath, project))) ?? null;
   }
@@ -40098,7 +40134,7 @@ class GodotServer {
       notes.push(`The debug adapter this run's console arrives over went away while the run was going, so what is below has a hole in it and the counts are of what was heard rather than of what was printed. ${back ? "It is connected again, and the line marking where is in the log." : "It is still gone, so nothing further will arrive here."} The project's own user://logs/godot.log has the rest, and "no entries" here means "not heard" rather than a quiet run.`);
     }
     if (run.transcript !== null && selected.omitted > 0) {
-      notes.push(`Everything this run has printed is in ${run.transcript}, uncapped and still being written. Read it for output, not for whether the run is alive: a transcript that stops growing is a run between prints. running above is asked of the operating system while there is a process to ask about, and for an editor-played run that announced no runtime it is the editor's answer instead, which can lag after the game has gone.`);
+      notes.push(transcriptNote(run.transcript, going));
     }
     return this.jsonTextResponse({
       running: going,

package/package.json

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