gdharness 1.3.4 → 1.3.6

package/build/godot/tests/listed.gd

@@ -0,0 +1,241 @@
+extends SceneTree
+
+## gdUnit4's command-line runner over the suites a file lists, in the file's order. One `-a` a suite
+## outgrows the command line once a game has a few hundred suites (Windows stops at 32767
+## characters), so the suites come from the file named after `--` with [constant LISTED], and the
+## cases to leave out from the one named with [constant SKIPPING]. Every other argument is gdUnit4's
+## own, as `GdUnitCmdTool.gd` takes them.
+##
+## Started from outside the project, `-s` with this file's absolute path, so it declares no class of
+## its own and reaches gdUnit4 through the project's global classes. Besides the file of suites it
+## finds each case by its id in a dictionary ([GdhIndexedSession]), can compile the suites together
+## before gdUnit4 loads them ([constant TOGETHER]), can turn off the reports the caller does
+## not read ([constant REPORTS_OFF]), and writes the errors each suite declares it expects
+## ([constant EXPECTED_OUT]).
+
+const LISTED: String = "--suites-in"
+const SKIPPING: String = "--skipping-in"
+## The flags turning off a report, with the gdUnit4 hook that writes it. A gate reads what a run
+## prints, and each report finds every case it hears of in the session to write them all out as the
+## run ends; project_test reads the JUnit one and turns off only the HTML one.
+const REPORTS_OFF: Dictionary[String, String] = {
+	"--html-report-off": "res://addons/gdUnit4/src/core/hooks/GdUnitHtmlReporterTestSessionHook.gd",
+	"--junit-report-off": "res://addons/gdUnit4/src/core/hooks/GdUnitXMLReporterTestSessionHook.gd",
+}
+## Compiles the suites together beside every class of the game ([method compiled_together]) before
+## gdUnit4 loads them. A gate asks for it, since it runs every suite and wants every script that
+## does not compile named. project_test does not: its answer is about the scripts its run reached,
+## and the compile names every broken script of the game, then once more as the one script it made.
+const TOGETHER: String = "--compile-together"
+## The file to write the errors every suite declares it expects into, as JSON keyed by suite path and
+## then case name.
+const EXPECTED_OUT: String = "--expected-errors-out"
+## The constant a suite declares its expected errors in: case name to the exact texts it prints.
+const EXPECTED: String = "GDHARNESS_EXPECTED_ERRORS"
+## The tool name gdUnit4 reads its options after.
+const TOOL: String = "GdUnitCmdTool.gd"
+## How long a windowless engine sleeps after each frame. The engine's own default is the
+## low-processor pause, 6.8 ms measured, which a run of suites awaiting frames spends thousands of
+## times; zero makes a frame's delta round to nothing, and a tween then never moves.
+const FRAME_SLEEP_USEC: int = 1000
+
+var _runner: GdhRunner = null
+## The suites of the run, compiled by [method compiled_together] and held for as long as it runs.
+var _together: GDScript = null
+
+
+## gdUnit4's runner reading its options after this script's path rather than after its own tool's,
+## which it looks for by name and otherwise finds none of them, printing its help.
+class GdhRunner:
+	extends GdUnitTestCIRunner
+
+	var own_path: String = ""
+
+	func get_cmdline_args() -> PackedStringArray:
+		return options_of(OS.get_cmdline_args(), own_path)
+
+	## The session gdUnit4 has just made, swapped for a [GdhIndexedSession] of the same cases as it
+	## is announced: everything that reads the session, the hooks, the cases and the console printing
+	## every case, is handed it after this.
+	func _on_gdunit_event(event: GdUnitEvent) -> void:
+		if event.type() == GdUnitEvent.SESSION_START:
+			_test_session = GdhIndexedSession.of(_test_session)
+		super(event)
+
+	## [param args] with everything up to the script at [param own] given as gdUnit4's tool name. The
+	## path is compared with its separators and, on Windows, its case folded, since the engine
+	## reports the script as `X:/a/listed.gd` when it was started as `X:\a\listed.gd`.
+	static func options_of(args: PackedStringArray, own: String) -> PackedStringArray:
+		var wanted: String = spelt(own)
+		var at: int = -1
+		for index: int in args.size():
+			if spelt(args[index]) == wanted:
+				at = index
+				break
+		if at < 0:
+			return args
+		var options: PackedStringArray = [TOOL]
+		options.append_array(args.slice(at + 1))
+		return options
+
+	static func spelt(path: String) -> String:
+		var forward: String = path.replace("\\", "/")
+		return forward.to_lower() if OS.get_name() == "Windows" else forward
+
+
+## gdUnit4's session finding a case by its id in a dictionary, where its own walks every case of the
+## session, `GdUnitTestSession.find_test_by_id`: the console asks it twice a case and each report
+## twice more, so a run's time in it grew with the square of its cases (17.9 s of processor time
+## in an engine of 2300 cases).
+class GdhIndexedSession:
+	extends GdUnitTestSession
+
+	var _by_id: Dictionary[String, GdUnitTestCase] = {}
+
+	func _init(cases: Array[GdUnitTestCase], reports_in: String) -> void:
+		super(cases, reports_in)
+		for test: GdUnitTestCase in _test_cases:
+			_by_id[str(test.guid)] = test
+
+	func find_test_by_id(id: GdUnitGUID) -> GdUnitTestCase:
+		var found: GdUnitTestCase = _by_id.get(str(id), null)
+		return found
+
+	## [param made] as an indexed session of its cases, reporting where it does; one already indexed
+	## as it is.
+	static func of(made: GdUnitTestSession) -> GdUnitTestSession:
+		if made is GdhIndexedSession:
+			return made
+		return GdhIndexedSession.new(made._test_cases, made.report_path)
+
+
+func _initialize() -> void:
+	OS.low_processor_usage_mode_sleep_usec = FRAME_SLEEP_USEC
+	var asked: PackedStringArray = OS.get_cmdline_user_args()
+	var unread: PackedStringArray = []
+	for flag: String in REPORTS_OFF:
+		if asked.has(flag):
+			var _unread: bool = unread.append(REPORTS_OFF[flag])
+	if not unread.is_empty():
+		var _off: PackedStringArray = unread_off(GdUnitTestSessionHookService.instance(), unread)
+	var suites: PackedStringArray = listed(asked, LISTED)
+	if asked.has(TOGETHER):
+		_together = compiled_together(suites)
+	var expected_out: String = argument_after(asked, EXPECTED_OUT)
+	if not expected_out.is_empty():
+		write_expected(expected_out, suites)
+	_runner = GdhRunner.new()
+	_runner.own_path = get_script().resource_path
+	_runner.add_test_suites(suites)
+	_runner.skip_test_suites(listed(asked, SKIPPING))
+	root.add_child(_runner)
+
+
+## As gdUnit4's own `GdUnitCmdTool.gd` ends, which names in a verbose run the nodes left orphaned.
+func _finalize() -> void:
+	queue_delete(_runner)
+	if OS.is_stdout_verbose():
+		print("Orphan nodes left as the run ends:")
+		Window.print_orphan_nodes()
+
+
+## Turns off the hooks among [param hooks] whose scripts [param unread] names, answering the scripts
+## of those it turned off. Through the mark gdUnit4's own `is_enabled` reads, rather than its
+## `enable_hook`, which writes the setting into `project.godot`: a run changes nothing in the tree.
+static func unread_off(hooks: GdUnitTestSessionHookService, unread: PackedStringArray) -> PackedStringArray:
+	var off: PackedStringArray = []
+	for hook: GdUnitTestSessionHook in hooks.enigne_hooks:
+		var path: String = hook.get_script().resource_path
+		if unread.has(path):
+			hook.set_meta("enabled", false)
+			var _added: bool = off.append(path)
+	return off
+
+
+## [param suites] compiled inside one script, answered for the caller to hold so gdUnit4's own loads
+## find them compiled. The engine keeps what it read of a class only while the compile that asked for
+## it runs (`GDScriptCache`), so a suite compiled on its own reads again every class it reaches a
+## member of, some seventy milliseconds a suite. As the preloads of one script naming every class of
+## the game's own first, held from that script's compile, they share one reading of each: two hundred
+## suites compiled in a third of the time they took one at a time. The names are public, since a
+## private one unread is a warning and every warning an error, and each a variable, since a class is
+## no constant expression. A suite that does not compile fails here and again when gdUnit4 loads it,
+## which reports it as it would have. A directory listed is left to gdUnit4 to walk.
+static func compiled_together(suites: PackedStringArray) -> GDScript:
+	var lines: PackedStringArray = ["extends RefCounted"]
+	var at: int = 0
+	for named: String in held_classes():
+		var _held: bool = lines.append("var held_%d: Variant = %s" % [at, named])
+		at += 1
+	at = 0
+	for path: String in suites:
+		if not path.ends_with(".gd"):
+			continue
+		var _suite: bool = lines.append('var suite_%d: Variant = preload("%s")' % [at, path])
+		at += 1
+	var together: GDScript = GDScript.new()
+	together.source_code = "\n".join(lines) + "\n"
+	var _compiled: Error = together.reload()
+	return together
+
+
+## The classes [method compiled_together] names before the suites: the game's own GDScript classes,
+## none of an addon's or a suite's, then gdUnit4's suite. Only GDScript shares the engine's reading,
+## and a sandboxed mod's SafeGDScript class would load the sandbox's compiler, some 290 MB and up to
+## 2.5 s, for nothing.
+static func held_classes(
+	classes: Array[Dictionary] = ProjectSettings.get_global_class_list()
+) -> PackedStringArray:
+	var held: PackedStringArray = []
+	for known: Dictionary in classes:
+		var path: String = known["path"]
+		var own: bool = not path.begins_with("res://addons/") and not path.ends_with("_test.gd")
+		if own and known["language"] == &"GDScript":
+			var _own: bool = held.append(str(known["class"]))
+	var _suite: bool = held.append("GdUnitTestSuite")
+	return held
+
+
+## What the file after [param flag] in [param args] names, one a line in order, or none when no file
+## is named: gdUnit4 then says it found nothing, which a gate refuses.
+static func listed(args: PackedStringArray, flag: String) -> PackedStringArray:
+	var path: String = argument_after(args, flag)
+	if path.is_empty():
+		return PackedStringArray()
+	var named: PackedStringArray = []
+	for line: String in FileAccess.get_file_as_string(path).split("\n", false):
+		if not line.strip_edges().is_empty():
+			var _named: bool = named.append(line.strip_edges())
+	return named
+
+
+## The argument after [param flag] in [param args], or "" when there is none.
+static func argument_after(args: PackedStringArray, flag: String) -> String:
+	var at: int = args.find(flag)
+	if at < 0 or at + 1 >= args.size():
+		return ""
+	return args[at + 1]
+
+
+## The errors each of [param suites] declares it expects, by suite path and then case name, read off
+## the compiled suite's constants so a declaration is whatever the engine made of it. A suite
+## declaring none is left out.
+static func expected_by_suite(suites: PackedStringArray) -> Dictionary:
+	var expected: Dictionary = {}
+	for path: String in suites:
+		if not path.ends_with(".gd") or not ResourceLoader.exists(path):
+			continue
+		var suite: Script = load(path)
+		var declared: Variant = suite.get_script_constant_map().get(EXPECTED)
+		if declared is Dictionary:
+			expected[path] = declared
+	return expected
+
+
+static func write_expected(path: String, suites: PackedStringArray) -> void:
+	var file: FileAccess = FileAccess.open(path, FileAccess.WRITE)
+	if file == null:
+		push_error("Could not write the expected errors to %s: %s" % [path, FileAccess.get_open_error()])
+		return
+	var _stored: bool = file.store_string(JSON.stringify(expected_by_suite(suites)))
+	file.close()

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,
@@ -96,6 +106,9 @@ public static class GdharnessDesktop {
   [DllImport("kernel32.dll")] static extern bool GetExitCodeProcess(IntPtr handle, out uint code);
   [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr handle);
   [DllImport("kernel32.dll")] static extern bool TerminateProcess(IntPtr handle, uint code);
+  [DllImport("kernel32.dll")] static extern uint SetErrorMode(uint mode);
+  const uint FailCriticalErrors = 0x1;
+  const uint NoOpenFileErrorBox = 0x8000;
 
   delegate bool EachWindow(IntPtr window, IntPtr unused);
   [DllImport("user32.dll")] static extern bool EnumWindows(EachWindow each, IntPtr unused);
@@ -169,6 +182,11 @@ public static class GdharnessDesktop {
     startup.output = GetStdHandle(-11);
     startup.error = startup.output;
     Started started;
+    // Inherited by what it starts: without SEM_NOGPFAULTERRORBOX, Windows Error Reporting runs when
+    // the target crashes and writes its dump, and with the other two no hard-error box can open.
+    // Set outright rather than cleared from this process's own: Windows PowerShell changes the mode
+    // it inherited as it starts, and was seen reading 0x1 here, without the open-file bit.
+    SetErrorMode(FailCriticalErrors | NoOpenFileErrorBox);
     if (noActivate) {
       LockSetForegroundWindow(LockForeground);
     }
@@ -350,6 +368,33 @@ function throughHelper(how, command, args, files, assembly = helperAssembly()) {
   };
 }
 
+// src/error-mode.ts
+import process3 from "node:process";
+var NO_FAULT_ERROR_BOX = 2;
+var cleared = process3.platform !== "win32";
+async function letWindowsReportCrashes() {
+  if (cleared || !("bun" in process3.versions)) {
+    return;
+  }
+  try {
+    const { dlopen, FFIType } = await import("bun:ffi");
+    const kernel32 = dlopen("kernel32.dll", {
+      GetErrorMode: { args: [], returns: FFIType.u32 },
+      SetErrorMode: { args: [FFIType.u32], returns: FFIType.u32 }
+    });
+    try {
+      const mode = kernel32.symbols.GetErrorMode();
+      kernel32.symbols.SetErrorMode(mode & ~NO_FAULT_ERROR_BOX);
+      cleared = true;
+    } finally {
+      kernel32.close();
+    }
+  } catch {}
+}
+function crashesReported() {
+  return cleared;
+}
+
 // src/game-debugger.ts
 import { createServer } from "node:net";
 
@@ -1031,7 +1076,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 {
@@ -1132,7 +1177,7 @@ import { mkdtempSync as mkdtempSync2, rmSync as rmSync2 } from "node:fs";
 import { connect, createServer as createServer2 } from "node:net";
 import { tmpdir as tmpdir2 } from "node:os";
 import { join as join2 } from "node:path";
-import process3 from "node:process";
+import process4 from "node:process";
 var DEBUG_PREFIX = "debug ";
 function endedOrWhyNot(end) {
   try {
@@ -1159,7 +1204,7 @@ function errorText(error) {
 async function listenForTheServer(end, debug) {
   let directory = null;
   try {
-    directory = process3.platform === "win32" ? null : mkdtempSync2(join2(tmpdir2(), "gdharness-keeper-"));
+    directory = process4.platform === "win32" ? null : mkdtempSync2(join2(tmpdir2(), "gdharness-keeper-"));
     const address = directory === null ? `\\\\.\\pipe\\gdharness-keeper-${randomUUID()}` : join2(directory, "keeper.sock");
     const server = createServer2((socket) => {
       socket.setEncoding("utf8");
@@ -1253,8 +1298,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 +1343,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 +1388,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 +1428,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 +1503,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 process4 from "node:process";
+import { join as join6 } from "node:path";
+import process5 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}-${process5.pid}-`));
 }
 function discardWith(remove, paths) {
   const left = [];
@@ -1519,7 +1568,7 @@ function lastTryOnExit() {
     return;
   }
   lastTryWatched = true;
-  process4.once("exit", () => {
+  process5.once("exit", () => {
     for (const path of [...waiting, ...atExit]) {
       try {
         remove(path);
@@ -1921,16 +1970,16 @@ 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 where = spec.desktop === undefined ? "without activation" : `on the ${spec.desktop} desktop`;
+  const pidFile = join7(scratch, "pid");
+  const errorFile = join7(scratch, "error");
+  const where = spec.desktop !== undefined ? `on the ${spec.desktop} desktop` : spec.noActivate === true ? "without activation" : "through the desktop helper";
   try {
     const compiled = await ensureHelperCompiled();
     if (compiled !== null) {
       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 +2023,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;
@@ -2006,10 +2055,10 @@ async function startDetached(spec, output, hidden, stopFile = "") {
   return throughTheHelper(spec) ? await startThroughHelper(spec, output, stopFile) : await startDirectly(spec, output, hidden);
 }
 function throughTheHelper(spec) {
-  return process.platform === "win32" && (spec.desktop !== undefined || spec.noActivate === true);
+  return needsItsHelperKept(spec) || process.platform === "win32" && !crashesReported();
 }
 function needsItsHelperKept(spec) {
-  return throughTheHelper(spec);
+  return process.platform === "win32" && (spec.desktop !== undefined || spec.noActivate === true);
 }
 async function launch() {
   const spec = await receivedSpec();
@@ -2077,8 +2126,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 +2157,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,10 +2171,29 @@ 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);
 }
+await letWindowsReportCrashes();
 var mode = process.argv[2];
 if (mode === "launch") {
   await launch();

package/package.json

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