gdharness 1.3.5 → 1.3.6

package/build/cli.js

@@ -7953,16 +7953,16 @@ var init_paths = __esm(() => {
 // src/runner.ts
 import { existsSync as existsSync3 } from "node:fs";
 import { dirname as dirname3, join as join4 } from "node:path";
-import process3 from "node:process";
+import process4 from "node:process";
 function currentRunner() {
-  const versions = process3.versions;
+  const versions = process4.versions;
   return versions["bun"] === undefined ? "npx" : "bunx";
 }
 function runLine(runner, version, rest = "") {
   const flag = runner === "npx" ? "-y " : "";
   return `${runner} ${flag}gdharness@${version}${rest === "" ? "" : ` ${rest}`}`;
 }
-function spawnFor(runner, version, execPath = process3.execPath) {
+function spawnFor(runner, version, execPath = process4.execPath) {
   const spec = `gdharness@${version}`;
   if (runner !== currentRunner()) {
     return { command: runner, args: runner === "npx" ? ["-y", spec] : ["--bun", spec] };
@@ -7973,7 +7973,7 @@ function spawnFor(runner, version, execPath = process3.execPath) {
   return { command: alongside(execPath, "npx") ?? "npx", args: ["-y", spec] };
 }
 function alongside(execPath, name) {
-  const runner = join4(dirname3(execPath), process3.platform === "win32" ? `${name}.cmd` : name);
+  const runner = join4(dirname3(execPath), process4.platform === "win32" ? `${name}.cmd` : name);
   return existsSync3(runner) ? runner : undefined;
 }
 var init_runner = () => {};
@@ -8315,8 +8315,8 @@ var init_engine_run = __esm(() => {
 import { existsSync as existsSync5, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
 import { homedir as homedir3 } from "node:os";
 import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute2, join as join6 } from "node:path";
-import process5 from "node:process";
-function editorCacheDirectory(godotPath, platform = process5.platform, env = process5.env, home = homedir3()) {
+import process6 from "node:process";
+function editorCacheDirectory(godotPath, platform = process6.platform, env = process6.env, home = homedir3()) {
   const beside = dirname5(godotPath);
   const bundle = platform === "darwin" && basename4(beside) === "MacOS" && basename4(dirname5(beside)) === "Contents" ? dirname5(dirname5(dirname5(beside))) : null;
   for (const folder of bundle === null ? [beside] : [beside, bundle]) {
@@ -8471,13 +8471,23 @@ function importRecord(projectPath, resourcePath) {
 var init_reimport = () => {};
 
 // src/alive.ts
-import process6 from "node:process";
+import process7 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 {
-    process6.kill(pid, 0);
+    process7.kill(pid, 0);
     return true;
   } catch (error) {
     return error.code === "EPERM";
@@ -8489,9 +8499,9 @@ var init_alive = () => {};
 import { existsSync as existsSync8, mkdtempSync, readdirSync as readdirSync5, rmSync as rmSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
 import { join as join9 } from "node:path";
-import process7 from "node:process";
+import process8 from "node:process";
 function scratchDirectory(kind) {
-  return mkdtempSync(join9(tmpdir2(), `gdharness-${kind}-${process7.pid}-`));
+  return mkdtempSync(join9(tmpdir2(), `gdharness-${kind}-${process8.pid}-`));
 }
 function sweepAbandonedScratch(directory = tmpdir2()) {
   let entries;
@@ -8566,7 +8576,7 @@ function lastTryOnExit() {
     return;
   }
   lastTryWatched = true;
-  process7.once("exit", () => {
+  process8.once("exit", () => {
     for (const path of [...waiting, ...atExit]) {
       try {
         remove(path);
@@ -9743,7 +9753,7 @@ var init_server_version = __esm(() => {
 
 // src/issues.ts
 import { createHash as createHash2 } from "node:crypto";
-import process8 from "node:process";
+import process9 from "node:process";
 function feedbackNotice(every) {
   return JSON.stringify({
     gdharness_feedback: {
@@ -9754,9 +9764,9 @@ function feedbackNotice(every) {
   }, null, 2);
 }
 function runtime() {
-  const versions = process8.versions;
+  const versions = process9.versions;
   const bun = versions["bun"];
-  return bun === undefined ? `node ${process8.versions.node}` : `bun ${bun}`;
+  return bun === undefined ? `node ${process9.versions.node}` : `bun ${bun}`;
 }
 function defectSignature(where, message) {
   const normalised = `${where}
@@ -9768,7 +9778,7 @@ function facts(where, message, godotVersion) {
     ["Where", where],
     ["Error", message],
     ["Version", `gdharness ${SERVER_VERSION}`],
-    ["Runtime", `${runtime()}, ${process8.platform} ${process8.arch}`],
+    ["Runtime", `${runtime()}, ${process9.platform} ${process9.arch}`],
     ["Godot", godotVersion ?? "not known at the point this failed"],
     ["Signature", defectSignature(where, message)]
   ];
@@ -9778,7 +9788,7 @@ function filledTemplate(where, message, godotVersion) {
     `**gdharness version**: ${SERVER_VERSION}`,
     `**Godot version**: ${godotVersion ?? ""}`,
     `**Bun version**: ${runtime()}`,
-    `**OS**: ${process8.platform} ${process8.arch}`,
+    `**OS**: ${process9.platform} ${process9.arch}`,
     "**MCP client**:",
     "",
     "## What you did",
@@ -10526,13 +10536,16 @@ function isToolScript(source) {
 function declaredClasses(projectPath) {
   const declared = new Map;
   eachScript(projectPath, (script, source) => {
-    const found = DECLARATION.exec(source);
-    if (found?.[1]) {
-      declared.set(found[1], script);
+    const found = declaredClassOf(source);
+    if (found !== null) {
+      declared.set(found, script);
     }
   });
   return declared;
 }
+function declaredClassOf(source) {
+  return DECLARATION.exec(source)?.[1] ?? null;
+}
 function eachScript(projectPath, each) {
   const visit = (directory, prefix) => {
     if (existsSync11(join13(directory, ".gdignore"))) {
@@ -11654,6 +11667,22 @@ function shippedAddonsDirectory() {
 function shippedOperationsScript() {
   return join15(dirname8(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
 }
+function shippedListedRunner() {
+  return join15(dirname8(fileURLToPath(import.meta.url)), "godot", "tests", "listed.gd");
+}
+function gdUnit4Unusable(projectPath) {
+  const marker = "addons/gdUnit4/plugin.cfg";
+  if (!existsSync13(join15(projectPath, ...marker.split("/")))) {
+    return { missing: true, reason: `gdUnit4 is not installed in this project: no ${marker}` };
+  }
+  if (!existsSync13(join15(projectPath, ...GDUNIT4_CI_RUNNER.split("/")))) {
+    return {
+      missing: false,
+      reason: `gdUnit4 in this project is older than 6.0, which the shipped runner needs: no ${GDUNIT4_CI_RUNNER}`
+    };
+  }
+  return null;
+}
 function installAddons(projectPath, from = shippedAddonsDirectory()) {
   const installed = [];
   for (const name of ADDONS) {
@@ -11827,7 +11856,7 @@ function inspectProject(projectPath) {
     problems
   };
 }
-var ADDONS, EDITOR_PLUGINS, RUNTIME_AUTOLOAD, SCRIPT_RUNS_SETTING = "gdharness/runtime/serve_script_runs", BIND_ADDRESS_SETTING = "gdharness/runtime/bind_address", PORT_SETTING = "gdharness/runtime/port", DIGEST_MARKER = ".gdharness-digest", RUNTIME_ADDON = "gdharness_runtime", shippedDigest, shippedRuntime;
+var ADDONS, EDITOR_PLUGINS, RUNTIME_AUTOLOAD, SCRIPT_RUNS_SETTING = "gdharness/runtime/serve_script_runs", BIND_ADDRESS_SETTING = "gdharness/runtime/bind_address", PORT_SETTING = "gdharness/runtime/port", DIGEST_MARKER = ".gdharness-digest", RUNTIME_ADDON = "gdharness_runtime", shippedDigest, shippedRuntime, GDUNIT4_CI_RUNNER = "addons/gdUnit4/src/core/runners/GdUnitTestCIRunner.gd";
 var init_setup = __esm(() => {
   init_class_cache();
   init_headless();
@@ -13011,8 +13040,9 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_launch",
-      title: "Open, restart or close the editor",
-      description: "Opens the Godot editor on a project, or restarts or closes the one already connected. close saves open scenes, quits the editor and waits for its process to go, which is the only way to end a hidden one short of killing it; settingsDropped in its answer names what that save took out of project.godot, and is left out when it took nothing; settingsNote says so when the file could not be read to tell. An editor this server opened that has not connected yet has nothing of this server's to save, so close stops its process instead and answers beforeConnecting. open answers once the process has started, and the editor dials in after its import; a call needing the editor made before then waits for the one this server opened, for as long as a restart waits, and is refused naming it if it has not arrived. open refuses while an editor of the project is already running and has not reached this server, naming its pid, rather than putting a second on the project. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out and answers with the version that came back. An editor a server opened is started again by the server, visible unless hidden: true is passed again, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart says which under settingsDropped in its own answer because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so under restartInterrupted in editor_status rather than waiting for an editor that is not coming, and open finishes it, saying so under finishesRestart. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
+      title: "Open, restart or close the editor, or bind its debug adapter again",
+      description: "Opens the Godot editor on a project, or restarts or closes the one already connected, or binds its debug adapter again. close saves open scenes, quits the editor and waits for its process to go, which is the only way to end a hidden one short of killing it; an editor this server opened that has not connected yet has nothing of this server's to save, so close stops its process instead. open answers once the process has started, and the editor dials in after its import; a call needing the editor made before then waits for the one this server opened, for as long as a restart waits, and is refused naming it if it has not arrived. open refuses while an editor of the project is already running and has not reached this server, naming its pid, rather than putting a second on the project. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out. An editor a server opened is started again by the server, visible unless hidden: true is passed again, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. Godot tries each server port once, as the editor starts, so a restart binds a debug adapter that came back without its port again, in the editor that came back. rebind does the same for the connected editor without restarting it, whoever opened it; a debug session open on the adapter ends with it and is opened again by the next debug call. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so in editor_status rather than waiting for an editor that is not coming, and open finishes it. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
+      answer: "close answers settingsDropped, naming what its save took out of project.godot and left out when it took nothing, and settingsNote when the file could not be read to tell; an editor stopped before it connected is answered with beforeConnecting. restart answers with the version that came back, and says under settingsDropped which keys its save dropped, because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart answers lspListening and dapListening once the editor's servers are up, and debugAdapterRebound says whether binding the debug adapter again took. serversSaid gives the lines the editor's log panel has about its servers, the one place Godot says why a port would not bind. Godot clears that panel whenever a game is played, unless its run/output/always_clear_output_on_play setting is off, so after a play the lines from the editor's own start are gone. rebind answers rebound, with lspListening, dapListening and serversSaid. A restart that a server's end interrupted shows as restartInterrupted in editor_status, and the open that finishes it says so under finishesRestart.",
       parameters: {
         projectPath: { ...PROJECT_PATH, ops: ["open"] },
         hidden: {
@@ -13038,6 +13068,11 @@ var init_tool_definitions = __esm(() => {
           effect: "destructive",
           summary: "save and quit the connected editor, and wait for it to go",
           requires: []
+        },
+        rebind: {
+          effect: "destructive",
+          summary: "stop and start the connected editor's debug adapter in place, ending its debug sessions, and answer whether it listens",
+          requires: []
         }
       },
       defaultOperation: "open"
@@ -13248,8 +13283,8 @@ var init_tool_definitions = __esm(() => {
       name: "editor_status",
       title: "Editor status",
       effect: "read",
-      description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and which games with the runtime addon are reachable, of this project and of every other on the machine. Read connected with mayYetConnect: the editor dials this server and backs off between tries, so for the first half-minute after a server starts false means not reached yet as often as no editor; mayYetConnect true is worth waiting out, false is final, and editorCannotConnect, restartInterrupted, restartUnderway, closedHere and editorsNotYetConnected say why. An editor that has connected and not yet greeted reports nothing about itself, and every other call made in that window waits up to ten seconds for it to settle. playingInEditor null means unanswered rather than nothing playing: processActive and runtimes do not depend on the editor answering. game.run names the run editor_output and editor_run stop answer for, and stays named after it ends. addonIsStale, on a connected editor and on each running game (absent with neither), says it runs addon code other than what this server ships, and staleNote says which half moves: the project, by a gdharness upgrade it spells out to run in a shell, the editor by a restart, or this server by a reconnect. A false editor.lspListening or editor.dapListening comes with serversNote, and editor_launch restart binds the port again. editor.scan says whether the editor is scanning, which editor_run waits out before starting a game. A game announced in a protocol this server does not speak is listed under unreadable, during an upgrade that moves the protocol, until the halves match.",
-      answer: "projectIs, when present, is the gdharness version of the addons in the project, which differs from this server's (project_info says which of the two to move), and configIs, when present, the version the project's MCP config starts, which differs from this server's, so the next connection runs that one. server names this server: its pid, its version, and lifecycleLog, the file every gdharness server of the user appends a line to when it starts, when its client first names itself, when it replaces another server of its project, and when it ends, with why it ended (the client closing its end as stdin:end, a signal by name, superseded with the successor's pid, an uncaught exception or rejection with its stack, or the exit code) and the calls it was answering then. The parent's command line follows on its own line a few seconds after the start. A server killed without warning writes no ended line, and on Windows every kill is that, so a started line with no ended line after it is a server something killed. " + "runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. Its play says which play the editor is on: play.play counts the plays that editor has started since it opened, whoever started them, and play.editorPid is the editor, so two reads with different pairs are two plays even when both say playing. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it. It stays named after the run ends, beside processActive false, so editor_output can still read what that run printed; null when there is no run at all. startedAt says when it began, and endedAt when it ended, wherever something saw the end: a run adopted from a note another server wrote can have ended hours before this server started. editor.lspListening and editor.dapListening say whether anything accepts connections on the ports the editor names, lspPort and dapPort: Godot binds each once, as the editor starts, and reports a failure only in the log panel of the editor itself, so a false comes with serversNote, and editor_launch restart binds it again. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs the gdharness upgrade command, spelled out to run in a shell, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. A runtime_* call to such a game is refused with the staleNote and not sent. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside editorCannotConnect is a project without the gdharness editor addon installed or enabled, where no editor can ever dial in, however young the server or whichever editor is open; its remedies say how to install or enable it. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. Any editor of this project running and not yet connected, whoever opened it, makes it true as well and is named under editorsNotYetConnected with its pid and start time, so a restart a reconnect interrupted after its launch is not read as nothing being there. settingsDropped appears here once when the editor this server opened saved project.godot on its way in and took a key out of it, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. A stale editor is asked nothing but to quit: every other call to it is refused with staleNote, which names editor_launch restart, the upgrade command or a reconnect. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and from the socket opening until its greeting and that read are done, identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window. serverVersion is the gdharness version of this server. bridgeAvailable says the editor bridge is listening; when it failed to start, startupError gives the error, and retryingBridge is true while this server tries again. announcedAt is the file where this server told editors of its project which port to dial. connectedAt is when the editor connected, and lastPongAt when it last answered this server's keep-alive ping. addonDigest is a hash of the editor addon's code, which addonIsStale compares with what this server ships. debugPort is the port of the editor's remote debugger, the one games it plays connect to. openedByAServer says a gdharness server started this editor, and syncsBreakpoints that it keeps its breakpoints when a debug session opens, which Godot otherwise clears. pendingRequests counts the requests sent to the editor and not yet answered, and queuedResources the files with writes waiting behind another write to the same file.",
+      description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and which games with the runtime addon are reachable, of this project and of every other on the machine. Read connected with mayYetConnect: the editor dials this server and backs off between tries, so for the first half-minute after a server starts false means not reached yet as often as no editor; mayYetConnect true is worth waiting out, false is final, and editorCannotConnect, restartInterrupted, restartUnderway, closedHere and editorsNotYetConnected say why. An editor that has connected and not yet greeted reports nothing about itself, and every other call made in that window waits up to ten seconds for it to settle. playingInEditor null means unanswered rather than nothing playing: processActive and runtimes do not depend on the editor answering. game.run names the run editor_output and editor_run stop answer for, and stays named after it ends. addonIsStale, on a connected editor and on each running game (absent with neither), says it runs addon code other than what this server ships, and staleNote says which half moves: the project, by a gdharness upgrade it spells out to run in a shell, the editor by a restart, or this server by a reconnect. A false editor.lspListening or editor.dapListening comes with serversNote: editor_launch rebind binds the debug adapter again in place, and editor_launch restart the language server. editor.scan says whether the editor is scanning, which editor_run waits out before starting a game. A game announced in a protocol this server does not speak is listed under unreadable, during an upgrade that moves the protocol, until the halves match.",
+      answer: "projectIs, when present, is the gdharness version of the addons in the project, which differs from this server's (project_info says which of the two to move), and configIs, when present, the version the project's MCP config starts, which differs from this server's, so the next connection runs that one. server names this server: its pid, its version, and lifecycleLog, the file every gdharness server of the user appends a line to when it starts, when its client first names itself, when it replaces another server of its project, and when it ends, with why it ended (the client closing its end as stdin:end, a signal by name, superseded with the successor's pid, an uncaught exception or rejection with its stack, or the exit code) and the calls it was answering then. The parent's command line follows on its own line a few seconds after the start. A server killed without warning writes no ended line, and on Windows every kill is that, so a started line with no ended line after it is a server something killed. " + "runtimeConnected counts the games of the project this server serves, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. Its play says which play the editor is on: play.play counts the plays that editor has started since it opened, whoever started them, and play.editorPid is the editor, so two reads with different pairs are two plays even when both say playing. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it. It stays named after the run ends, beside processActive false, so editor_output can still read what that run printed; null when there is no run at all. startedAt says when it began, and endedAt when it ended, wherever something saw the end: a run adopted from a note another server wrote can have ended hours before this server started. editor.lspListening and editor.dapListening say whether anything accepts connections on the ports the editor names, lspPort and dapPort: Godot binds each once, as the editor starts, and reports a failure only in the log panel of the editor itself, so a false comes with serversNote: editor_launch rebind binds the debug adapter again in place, and editor_launch restart the language server. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout; for the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself; a game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say); addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs the gdharness upgrade command, spelled out to run in a shell, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. A runtime_* call to such a game is refused with the staleNote and not sent. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out; false is an editor that is not there. False beside editorCannotConnect is a project without the gdharness editor addon installed or enabled, where no editor can ever dial in, however young the server or whichever editor is open; its remedies say how to install or enable it. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for; editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. Any editor of this project running and not yet connected, whoever opened it, makes it true as well and is named under editorsNotYetConnected with its pid and start time, so a restart a reconnect interrupted after its launch is not read as nothing being there. settingsDropped appears here once when the editor this server opened saved project.godot on its way in and took a key out of it, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. A stale editor is asked nothing but to quit: every other call to it is refused with staleNote, which names editor_launch restart, the upgrade command or a reconnect. port is the one the editor bridge is on; when that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds; bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it; startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and from the socket opening until its greeting and that read are done, identifying is true and connected false; one started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window. serverVersion is the gdharness version of this server. bridgeAvailable says the editor bridge is listening; when it failed to start, startupError gives the error, and retryingBridge is true while this server tries again. announcedAt is the file where this server told editors of its project which port to dial. connectedAt is when the editor connected, and lastPongAt when it last answered this server's keep-alive ping. addonDigest is a hash of the editor addon's code, which addonIsStale compares with what this server ships. debugPort is the port of the editor's remote debugger, the one games it plays connect to. openedByAServer says a gdharness server started this editor, and syncsBreakpoints that it keeps its breakpoints when a debug session opens, which Godot otherwise clears. pendingRequests counts the requests sent to the editor and not yet answered, and queuedResources the files with writes waiting behind another write to the same file.",
       parameters: {},
       requires: []
     },
@@ -14069,6 +14104,361 @@ var init_tool_reference = __esm(() => {
   init_tool_definitions();
 });
 
+// src/desktop.ts
+import { createHash as createHash4 } from "node:crypto";
+import {
+  closeSync,
+  existsSync as existsSync15,
+  mkdtempSync as mkdtempSync2,
+  openSync,
+  readFileSync as readFileSync12,
+  rmSync as rmSync7,
+  statSync as statSync8,
+  writeFileSync as writeFileSync8,
+  writeSync
+} from "node:fs";
+import { tmpdir as tmpdir4 } from "node:os";
+import { join as join17 } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+function helperAssembly(directory = tmpdir4()) {
+  return join17(directory, `gdharness-desktop-${DIGEST}.dll`);
+}
+async function ensureHelperCompiled(directory = tmpdir4(), budgetMs = HELPER_COMPILE_MS, wait = true) {
+  const assembly = helperAssembly(directory);
+  const lock = `${assembly}.compiling`;
+  const until = Date.now() + budgetMs;
+  while (Date.now() < until) {
+    if (existsSync15(assembly)) {
+      return null;
+    }
+    let mine = false;
+    try {
+      const held = openSync(lock, "wx");
+      writeSync(held, String(process.pid));
+      closeSync(held);
+      mine = true;
+    } catch {}
+    if (mine) {
+      try {
+        return await compileHelper(directory, assembly, until - Date.now());
+      } finally {
+        rmSync7(lock, { force: true });
+      }
+    }
+    try {
+      const holder = Number(readFileSync12(lock, "utf8").trim());
+      const old = Date.now() - statSync8(lock).mtimeMs > budgetMs;
+      if (old || Number.isInteger(holder) && holder > 0 && !alive(holder)) {
+        rmSync7(lock, { force: true });
+        continue;
+      }
+    } catch {}
+    if (!wait) {
+      return null;
+    }
+    await delay(200);
+  }
+  return `the desktop helper was not compiled within ${String(budgetMs)} ms`;
+}
+async function compileHelper(directory, assembly, budgetMs) {
+  const scratch = mkdtempSync2(join17(directory, "gdharness-desktop-source-"));
+  const source = join17(scratch, "helper.cs");
+  writeFileSync8(source, SOURCE, "utf8");
+  const literal = (path) => `'${path.replaceAll("'", "''")}'`;
+  const script = [
+    "$ErrorActionPreference = 'Stop'",
+    "try {",
+    `  $partial = ${literal(assembly)} + '.' + $PID`,
+    `  Add-Type -TypeDefinition ([IO.File]::ReadAllText(${literal(source)}, [Text.Encoding]::UTF8)) -OutputAssembly $partial`,
+    `  Move-Item -LiteralPath $partial -Destination ${literal(assembly)}`,
+    "} catch {",
+    "  [Console]::Error.WriteLine($_.Exception.Message)",
+    "  exit 1",
+    "}"
+  ].join(`
+`);
+  try {
+    return await new Promise((resolve) => {
+      const compiler = spawnHidden("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-EncodedCommand",
+        Buffer.from(script, "utf16le").toString("base64")
+      ], { stdio: ["ignore", "ignore", "pipe"] });
+      let complained = "";
+      compiler.stderr.on("data", (chunk) => {
+        complained += chunk.toString();
+      });
+      const timer = setTimeout(() => {
+        compiler.kill();
+      }, budgetMs);
+      compiler.once("error", (error) => {
+        clearTimeout(timer);
+        resolve(`Windows PowerShell did not start: ${error.message}`);
+      });
+      compiler.once("close", (code) => {
+        clearTimeout(timer);
+        resolve(existsSync15(assembly) ? null : `Windows PowerShell could not compile it${code === null ? " in time" : ""}: ${complained.trim() || `exit code ${String(code)}`}`);
+      });
+    });
+  } finally {
+    rmSync7(scratch, { recursive: true, force: true });
+  }
+}
+function quoted(argument) {
+  if (argument !== "" && !/[\s"]/.test(argument)) {
+    return argument;
+  }
+  let text = '"';
+  let backslashes = 0;
+  for (const character of argument) {
+    if (character === "\\") {
+      backslashes += 1;
+      continue;
+    }
+    text += character === '"' ? `${"\\".repeat(backslashes * 2 + 1)}"` : `${"\\".repeat(backslashes)}${character}`;
+    backslashes = 0;
+  }
+  return `${text}${"\\".repeat(backslashes * 2)}"`;
+}
+function windowsCommandLine(command, args) {
+  return [command, ...args].map(quoted).join(" ");
+}
+function throughHelper(how, command, args, files, assembly = helperAssembly()) {
+  const spec = {
+    desktop: how.desktop ?? "",
+    noActivate: how.noActivate === true,
+    commandLine: windowsCommandLine(command, args),
+    pidFile: files.pid,
+    stopFile: files.stop,
+    directory: how.directory,
+    assembly
+  };
+  writeFileSync8(files.spec, JSON.stringify(spec), "utf8");
+  const literal = (path) => `'${path.replaceAll("'", "''")}'`;
+  const script = [
+    "$ErrorActionPreference = 'Stop'",
+    "try {",
+    `  $spec = [IO.File]::ReadAllText(${literal(files.spec)}, [Text.Encoding]::UTF8) | ConvertFrom-Json`,
+    "  Add-Type -LiteralPath $spec.assembly",
+    "  $code = [GdharnessDesktop]::Run($spec.desktop, $spec.commandLine, $spec.pidFile, [bool]$spec.noActivate, $spec.stopFile, $spec.directory)",
+    "} catch {",
+    `  [IO.File]::WriteAllText(${literal(files.error)}, $_.Exception.Message)`,
+    "  exit 1",
+    "}",
+    "exit $code"
+  ].join(`
+`);
+  return {
+    command: "powershell.exe",
+    args: [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-EncodedCommand",
+      Buffer.from(script, "utf16le").toString("base64")
+    ]
+  };
+}
+var HIDDEN_DESKTOP = "gdharness", DESKTOP_VARIABLE = "GDHARNESS_DESKTOP", SOURCE = `using System;
+using System.ComponentModel;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public static class GdharnessDesktop {
+  const uint GenericAll = 0x10000000;
+  const int UseStdHandles = 0x100;
+  const int UseShowWindow = 0x1;
+  const short ShowNoActivate = 4;
+  // No console at all, rather than a hidden one: a console's host would sit on the desktop too.
+  const uint DetachedProcess = 0x00000008;
+  const uint Infinite = 0xFFFFFFFF;
+
+  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+  struct StartupInfo {
+    public int cb;
+    public string reserved;
+    public string desktop;
+    public string title;
+    public int x, y, xSize, ySize, xCount, yCount, fill, flags;
+    public short show, reservedSize;
+    public IntPtr reservedBytes, input, output, error;
+  }
+
+  [StructLayout(LayoutKind.Sequential)]
+  struct Started {
+    public IntPtr process, thread;
+    public int processId, threadId;
+  }
+
+  [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+  static extern IntPtr CreateDesktopW(string name, IntPtr device, IntPtr mode, uint flags, uint access, IntPtr attributes);
+
+  [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+  static extern bool CreateProcessW(string application, StringBuilder commandLine, IntPtr processAttributes, IntPtr threadAttributes, bool inherit, uint flags, IntPtr environment, string directory, ref StartupInfo startup, out Started started);
+
+  [DllImport("kernel32.dll")] static extern IntPtr GetStdHandle(int which);
+  [DllImport("kernel32.dll")] static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
+  [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);
+  [DllImport("user32.dll")] static extern bool IsWindowVisible(IntPtr window);
+  [DllImport("user32.dll")] static extern uint GetWindowThreadProcessId(IntPtr window, out uint processId);
+  [DllImport("user32.dll")] static extern bool LockSetForegroundWindow(uint code);
+  const uint LockForeground = 1;
+  const uint UnlockForeground = 2;
+  const uint TimedOut = 0x102;
+
+  static bool ShowsAWindow(int processId) {
+    bool shown = false;
+    EnumWindows(delegate(IntPtr window, IntPtr unused) {
+      uint owner;
+      GetWindowThreadProcessId(window, out owner);
+      if (owner == (uint)processId && IsWindowVisible(window)) {
+        shown = true;
+        return false;
+      }
+      return true;
+    }, IntPtr.Zero);
+    return shown;
+  }
+
+  // Keeps the foreground where it is while the process starts: its own call to take it fails while
+  // the foreground is locked, and the user's own Alt+Tab or click still moves it. Released once its
+  // window has been showing for a while, since a program takes the foreground as it shows its window
+  // and not afterwards, or when it exits, or after two minutes whatever happens.
+  static void HoldTheForeground(Started started) {
+    DateTime until = DateTime.UtcNow.AddMinutes(2);
+    DateTime? shownAt = null;
+    while (DateTime.UtcNow < until) {
+      if (WaitForSingleObject(started.process, 100) != TimedOut) {
+        return;
+      }
+      if (shownAt == null && ShowsAWindow(started.processId)) {
+        shownAt = DateTime.UtcNow;
+      }
+      if (shownAt != null && DateTime.UtcNow - shownAt.Value > TimeSpan.FromSeconds(10)) {
+        return;
+      }
+    }
+  }
+
+  // Starts the command line, both of its streams on this process's output, writes its pid, and
+  // waits for it: the answer is its exit code. On the named desktop when there is one, whose handle
+  // is held until then, since a desktop goes when the last handle to it does, and on this process's
+  // own otherwise. With noActivate its first window is shown without being activated, which is
+  // what a program's first ShowWindow does whatever it asks for when the start names a show state,
+  // and the foreground is held while it starts, since Godot also asks for it outright. The process
+  // is ended through the handle held here once stopFile appears, which is how a keeper ends a game
+  // it did not start itself: a handle names one process, where a pid can name the next one too. The
+  // process starts in directory rather than in this one's, which is a temporary directory: Windows
+  // PowerShell saves its module cache relative to where it runs when the profile does not resolve.
+  public static int Run(string desktop, string commandLine, string pidFile, bool noActivate, string stopFile, string directory) {
+    StartupInfo startup = new StartupInfo();
+    startup.cb = Marshal.SizeOf(typeof(StartupInfo));
+    if (desktop.Length > 0) {
+      IntPtr held = CreateDesktopW(desktop, IntPtr.Zero, IntPtr.Zero, 0, GenericAll, IntPtr.Zero);
+      if (held == IntPtr.Zero) {
+        throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateDesktopW " + desktop);
+      }
+      startup.desktop = desktop;
+    }
+    startup.flags = UseStdHandles;
+    if (noActivate) {
+      startup.flags |= UseShowWindow;
+      startup.show = ShowNoActivate;
+    }
+    startup.input = GetStdHandle(-10);
+    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);
+    }
+    try {
+    if (!CreateProcessW(null, new StringBuilder(commandLine), IntPtr.Zero, IntPtr.Zero, true, DetachedProcess, IntPtr.Zero, directory, ref startup, out started)) {
+      throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateProcessW " + commandLine);
+    }
+    File.WriteAllText(pidFile, started.processId.ToString());
+    if (noActivate) {
+      HoldTheForeground(started);
+    }
+    } finally {
+      if (noActivate) {
+        LockSetForegroundWindow(UnlockForeground);
+      }
+    }
+    if (stopFile.Length == 0) {
+      WaitForSingleObject(started.process, Infinite);
+    } else {
+      bool stopped = false;
+      while (WaitForSingleObject(started.process, 100) == TimedOut) {
+        if (!stopped && File.Exists(stopFile)) {
+          TerminateProcess(started.process, 1);
+          stopped = true;
+        }
+      }
+    }
+    uint code;
+    GetExitCodeProcess(started.process, out code);
+    CloseHandle(started.thread);
+    CloseHandle(started.process);
+    return unchecked((int)code);
+  }
+}
+`, DIGEST, HELPER_COMPILE_MS = 180000;
+var init_desktop = __esm(() => {
+  init_alive();
+  init_spawn();
+  DIGEST = createHash4("sha256").update(SOURCE).digest("hex").slice(0, 16);
+});
+
+// src/whole-file.ts
+import { renameSync as renameSync2, rmSync as rmSync9, writeFileSync as writeFileSync9 } from "node:fs";
+function writeWhole(path, text) {
+  const partial = `${path}.${process.pid}.partial`;
+  try {
+    writeFileSync9(partial, text, "utf8");
+  } catch {
+    return false;
+  }
+  const until = Date.now() + HELD_FILE_MS;
+  for (;; ) {
+    try {
+      renameSync2(partial, path);
+      return true;
+    } catch (error) {
+      const code = error.code ?? "";
+      if (!HELD_BY_A_READER.has(code) || Date.now() >= until) {
+        try {
+          rmSync9(partial, { force: true });
+        } catch {}
+        return false;
+      }
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, HELD_FILE_RETRY_MS);
+    }
+  }
+}
+var HELD_FILE_MS = 1000, HELD_FILE_RETRY_MS = 10, HELD_BY_A_READER;
+var init_whole_file = __esm(() => {
+  HELD_BY_A_READER = new Set(["EPERM", "EACCES", "EBUSY"]);
+});
+
 // node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
 var __create2, __defProp2, __getOwnPropDesc, __getOwnPropNames2, __getProtoOf2, __hasOwnProp2, __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports), __exportAll = (all, symbols) => {
   let target = {};
@@ -33667,7 +34057,7 @@ var init_ajvProvider_CEoC__sr = __esm(() => {
 });
 
 // node_modules/@modelcontextprotocol/server/dist/shimsNode.mjs
-import process10 from "node:process";
+import process13 from "node:process";
 var init_shimsNode = __esm(() => {
   init_ajvProvider_CEoC__sr();
 });
@@ -35481,7 +35871,7 @@ var swallowsErrorsAfterClose, StdioServerTransport = class {
   _readBuffer;
   _started = false;
   _closed = false;
-  constructor(_stdin = process10.stdin, _stdout = process10.stdout, options) {
+  constructor(_stdin = process13.stdin, _stdout = process13.stdout, options) {
     this._stdin = _stdin;
     this._stdout = _stdout;
     this._readBuffer = new ReadBuffer({ maxBufferSize: options?.maxBufferSize });
@@ -35670,13 +36060,13 @@ var init_stdio = __esm(() => {
 });
 
 // src/autoload-failure.ts
-import { existsSync as existsSync15, readFileSync as readFileSync13 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync18 } from "node:fs";
+import { join as join22 } from "node:path";
 function scriptsAutoloaded(projectPath) {
   const scripts = new Map;
   let settings;
   try {
-    settings = parseProjectGodot(readFileSync13(join18(projectPath, "project.godot"), "utf8"));
+    settings = parseProjectGodot(readFileSync18(join22(projectPath, "project.godot"), "utf8"));
   } catch {
     return scripts;
   }
@@ -35685,12 +36075,12 @@ function scriptsAutoloaded(projectPath) {
       scripts.set(`res://${path}`, name);
       continue;
     }
-    const scene = join18(projectPath, path);
-    if (!existsSync15(scene)) {
+    const scene = join22(projectPath, path);
+    if (!existsSync19(scene)) {
       continue;
     }
     try {
-      for (const named of readFileSync13(scene, "utf8").matchAll(/^\[ext_resource\b[^\]]*\btype="Script"[^\]]*\bpath="(res:\/\/[^"]+)"/gm)) {
+      for (const named of readFileSync18(scene, "utf8").matchAll(/^\[ext_resource\b[^\]]*\btype="Script"[^\]]*\bpath="(res:\/\/[^"]+)"/gm)) {
         scripts.set(named[1] ?? "", name);
       }
     } catch {}
@@ -35709,31 +36099,31 @@ var init_autoload_failure = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync16, readdirSync as readdirSync10, readFileSync as readFileSync14, statSync as statSync8, unlinkSync as unlinkSync2 } from "node:fs";
+import { existsSync as existsSync20, readdirSync as readdirSync12, readFileSync as readFileSync19, statSync as statSync12, unlinkSync as unlinkSync2 } from "node:fs";
 import { createConnection } from "node:net";
-import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname11, join as join19, resolve as resolve4 } from "node:path";
-import { setTimeout as delay } from "node:timers/promises";
+import { tmpdir as tmpdir5 } from "node:os";
+import { dirname as dirname12, join as join23, resolve as resolve5 } from "node:path";
+import { setTimeout as delay4 } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
   if (explicit) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join19(perUser ?? tmpdir4(), "gdharness");
+  return join23(perUser ?? tmpdir5(), "gdharness");
 }
 function runtimeDirectories(variables = process.env) {
   const candidates = [runtimeDirectory(variables)];
   const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
   for (const base of fallbacks) {
-    candidates.push(join19(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join23(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
-  return [...new Set(candidates.map((path) => resolve4(path)))];
+  return [...new Set(candidates.map((path) => resolve5(path)))];
 }
 function errorReportOf(pid, directories = runtimeDirectories()) {
   for (const directory of directories) {
-    const path = join19(directory, `runtime-${pid}.log`);
-    if (existsSync16(path)) {
+    const path = join23(directory, `runtime-${pid}.log`);
+    if (existsSync20(path)) {
       return path;
     }
   }
@@ -35764,7 +36154,7 @@ function reportAlreadyInTranscript(transcript, report) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync14(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync19(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -35781,7 +36171,7 @@ function parseAnnouncement(file, pid) {
   };
   let announcedAt;
   try {
-    announcedAt = statSync8(file).mtimeMs;
+    announcedAt = statSync12(file).mtimeMs;
   } catch {}
   const when = announcedAt === undefined ? {} : { announcedAt };
   if (protocol !== RUNTIME_PROTOCOL) {
@@ -35834,7 +36224,7 @@ function discoverRuntimes(directories = runtimeDirectories()) {
 function wentAway(file, pid) {
   let project = "";
   try {
-    const fields = asParams(JSON.parse(readFileSync14(file, "utf8")));
+    const fields = asParams(JSON.parse(readFileSync19(file, "utf8")));
     project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
   } catch {
     return;
@@ -35877,29 +36267,29 @@ function strangersAmong(candidates, now, startTimes = startTimesOf) {
   }).map((one) => one.file));
 }
 function announcedIn(directory) {
-  if (!existsSync16(directory)) {
+  if (!existsSync20(directory)) {
     return [];
   }
   const found = [];
   const candidates = [];
   const entries = [];
-  for (const entry of readdirSync10(directory)) {
+  for (const entry of readdirSync12(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
-      sweepErrorReport(join19(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      sweepErrorReport(join23(directory, entry), Number.parseInt(report[1] ?? "", 10));
       continue;
     }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
     }
-    const file = join19(directory, entry);
+    const file = join23(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const running = alive(pid);
     entries.push({ file, pid, running });
     if (running) {
       try {
-        candidates.push({ file, pid, writtenAt: statSync8(file).mtimeMs });
+        candidates.push({ file, pid, writtenAt: statSync12(file).mtimeMs });
       } catch {}
     }
   }
@@ -35921,16 +36311,16 @@ function announcedIn(directory) {
     found.push(announced);
   }
   const held = new Set(entries.map((one) => one.file));
-  const here = join19(directory, ".");
+  const here = join23(directory, ".");
   for (const file of verdicts.keys()) {
-    if (dirname11(file) === here && !held.has(file)) {
+    if (dirname12(file) === here && !held.has(file)) {
       verdicts.delete(file);
     }
   }
   return found;
 }
 async function announcementEnded(pid, directories = runtimeDirectories()) {
-  const files = directories.map((directory) => join19(directory, `runtime-${pid}.json`)).filter((file) => existsSync16(file));
+  const files = directories.map((directory) => join23(directory, `runtime-${pid}.json`)).filter((file) => existsSync20(file));
   const first = files[0];
   if (first === undefined) {
     return;
@@ -35941,7 +36331,7 @@ async function announcementEnded(pid, directories = runtimeDirectories()) {
     if (left <= 0) {
       return;
     }
-    await delay(Math.min(LOOK_EVERY_MS, left));
+    await delay4(Math.min(LOOK_EVERY_MS, left));
   }
   wentAway(first, pid);
   for (const file of files) {
@@ -35956,7 +36346,7 @@ function sweepErrorReport(path, pid, now = Date.now()) {
     return;
   }
   try {
-    if (now - statSync8(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
+    if (now - statSync12(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
       unlinkSync2(path);
     }
   } catch {}
@@ -35973,7 +36363,7 @@ async function announcedSince(projectPath, before, waiting = {}) {
     if (left <= 0 || waiting.giveUp?.() === true) {
       return [];
     }
-    await delay(Math.min(LOOK_EVERY_MS, left));
+    await delay4(Math.min(LOOK_EVERY_MS, left));
   }
 }
 function describe2(endpoint) {
@@ -35986,7 +36376,7 @@ function theOneProject(endpoints) {
   if (endpoints.some((endpoint) => endpoint.project.path === "")) {
     return;
   }
-  const paths = new Set(endpoints.map((endpoint) => realAsFarAsItExists(resolve4(endpoint.project.path))));
+  const paths = new Set(endpoints.map((endpoint) => realAsFarAsItExists(resolve5(endpoint.project.path))));
   const only = [...paths][0];
   return paths.size === 1 ? only : undefined;
 }
@@ -36017,7 +36407,7 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
     if (named !== undefined) {
       if (projectPath !== undefined && !isSameDirectory(named.project.path, projectPath)) {
         return {
-          problem: `The game with pid ${pid} is running ${named.project.path}, not ${resolve4(projectPath)}. Running: ${endpoints.map(describe2).join("; ")}.`
+          problem: `The game with pid ${pid} is running ${named.project.path}, not ${resolve5(projectPath)}. Running: ${endpoints.map(describe2).join("; ")}.`
         };
       }
       return { endpoint: named };
@@ -36057,7 +36447,7 @@ function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
     };
   }
   if (projectPath !== undefined) {
-    const wanted = resolve4(projectPath);
+    const wanted = resolve5(projectPath);
     const matching = endpoints.filter((endpoint) => isSameDirectory(endpoint.project.path, wanted));
     if (matching.length === 0) {
       return {
@@ -36349,14 +36739,14 @@ var init_runtime_client = __esm(() => {
 });
 
 // src/boot-note.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname12, join as join20 } from "node:path";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname13, join as join24 } from "node:path";
 function bootNotePath(projectPath) {
-  return join20(projectPath, ".godot", "gdharness-boot.json");
+  return join24(projectPath, ".godot", "gdharness-boot.json");
 }
 function readScenes(projectPath) {
   try {
-    return asParams(asParams(JSON.parse(readFileSync15(bootNotePath(projectPath), "utf8")))["scenes"]);
+    return asParams(asParams(JSON.parse(readFileSync20(bootNotePath(projectPath), "utf8")))["scenes"]);
   } catch {
     return {};
   }
@@ -36372,7 +36762,7 @@ function readBootNote(projectPath, scene) {
 function writeBootNote(projectPath, scene, announcedAfterMs) {
   try {
     const path = bootNotePath(projectPath);
-    mkdirSync6(dirname12(path), { recursive: true });
+    mkdirSync9(dirname13(path), { recursive: true });
     const scenes = {
       ...readScenes(projectPath),
       [scene]: {
@@ -36380,7 +36770,7 @@ function writeBootNote(projectPath, scene, announcedAfterMs) {
         at: new Date().toISOString()
       }
     };
-    writeFileSync8(path, JSON.stringify({ scenes }, null, 2), "utf8");
+    writeFileSync11(path, JSON.stringify({ scenes }, null, 2), "utf8");
   } catch {}
 }
 function halfAsLongAgain(lastBootMs) {
@@ -36398,10 +36788,10 @@ var init_boot_note = __esm(() => {
 });
 
 // src/breakpoint-note.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync16, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname13, isAbsolute as isAbsolute4, join as join21, relative as relative3 } from "node:path";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync21, rmSync as rmSync11, writeFileSync as writeFileSync12 } from "node:fs";
+import { dirname as dirname14, isAbsolute as isAbsolute5, join as join25, relative as relative4 } from "node:path";
 function breakpointNotePath(projectPath) {
-  return join21(projectPath, ".godot", "gdharness-breakpoints.json");
+  return join25(projectPath, ".godot", "gdharness-breakpoints.json");
 }
 function writeBreakpointNote(projectPath, held) {
   const path = breakpointNotePath(projectPath);
@@ -36409,17 +36799,17 @@ function writeBreakpointNote(projectPath, held) {
   const inside = held.map((one) => ({ scriptPath: realAsFarAsItExists(one.scriptPath), lines: one.lines })).filter((one) => one.lines.length > 0 && withinProject(root, one.scriptPath));
   try {
     if (inside.length === 0) {
-      rmSync7(path, { force: true });
+      rmSync11(path, { force: true });
       return;
     }
     const note = {
       breakpoints: inside.map((one) => ({
-        script: relative3(root, one.scriptPath).replaceAll("\\", "/"),
+        script: relative4(root, one.scriptPath).replaceAll("\\", "/"),
         lines: [...one.lines]
       }))
     };
-    mkdirSync7(dirname13(path), { recursive: true });
-    writeFileSync9(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync10(dirname14(path), { recursive: true });
+    writeFileSync12(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the breakpoints at ${path}: ${errorMessage(error)}`);
@@ -36427,7 +36817,7 @@ function writeBreakpointNote(projectPath, held) {
 }
 function readBreakpointNote(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync16(breakpointNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync21(breakpointNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.breakpoints)) {
       return [];
     }
@@ -36437,12 +36827,12 @@ function readBreakpointNote(projectPath) {
         continue;
       }
       const { script, lines: listed } = entry;
-      if (typeof script !== "string" || isAbsolute4(script) || script.split("/").includes("..")) {
+      if (typeof script !== "string" || isAbsolute5(script) || script.split("/").includes("..")) {
         continue;
       }
       const lines = Array.isArray(listed) ? listed.filter((line) => Number.isInteger(line) && line > 0) : [];
       if (lines.length > 0) {
-        held.push({ scriptPath: realAsFarAsItExists(join21(projectPath, script)), lines });
+        held.push({ scriptPath: realAsFarAsItExists(join25(projectPath, script)), lines });
       }
     }
     return held;
@@ -36451,54 +36841,23 @@ function readBreakpointNote(projectPath) {
   }
 }
 function withinProject(projectPath, scriptPath) {
-  const rel = relative3(projectPath, scriptPath);
-  return rel !== "" && !rel.startsWith("..") && !isAbsolute4(rel);
+  const rel = relative4(projectPath, scriptPath);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute5(rel);
 }
 var init_breakpoint_note = __esm(() => {
   init_errors();
   init_paths();
 });
 
-// src/whole-file.ts
-import { renameSync as renameSync2, rmSync as rmSync8, writeFileSync as writeFileSync10 } from "node:fs";
-function writeWhole(path, text) {
-  const partial = `${path}.${process.pid}.partial`;
-  try {
-    writeFileSync10(partial, text, "utf8");
-  } catch {
-    return false;
-  }
-  const until = Date.now() + HELD_FILE_MS;
-  for (;; ) {
-    try {
-      renameSync2(partial, path);
-      return true;
-    } catch (error) {
-      const code = error.code ?? "";
-      if (!HELD_BY_A_READER.has(code) || Date.now() >= until) {
-        try {
-          rmSync8(partial, { force: true });
-        } catch {}
-        return false;
-      }
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, HELD_FILE_RETRY_MS);
-    }
-  }
-}
-var HELD_FILE_MS = 1000, HELD_FILE_RETRY_MS = 10, HELD_BY_A_READER;
-var init_whole_file = __esm(() => {
-  HELD_BY_A_READER = new Set(["EPERM", "EACCES", "EBUSY"]);
-});
-
 // src/class-note.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync17 } from "node:fs";
-import { dirname as dirname14, join as join22 } from "node:path";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync22 } from "node:fs";
+import { dirname as dirname15, join as join26 } from "node:path";
 function classNotePath(projectPath) {
-  return join22(projectPath, ".godot", "gdharness-classes.json");
+  return join26(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync17(classNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync22(classNotePath(projectPath), "utf8")));
     const rebuiltWith = readArray(fields, "rebuiltWith");
     if (rebuiltWith === undefined || !rebuiltWith.every((name) => typeof name === "string")) {
       return null;
@@ -36528,7 +36887,7 @@ function unfinishedScanIn(value) {
 function writeClassNote(projectPath, note) {
   const path = classNotePath(projectPath);
   try {
-    mkdirSync8(dirname14(path), { recursive: true });
+    mkdirSync11(dirname15(path), { recursive: true });
   } catch {
     return;
   }
@@ -36540,16 +36899,16 @@ var init_class_note = __esm(() => {
 });
 
 // src/config-pin.ts
-import { existsSync as existsSync17, readFileSync as readFileSync18 } from "node:fs";
-import { join as join23 } from "node:path";
+import { existsSync as existsSync21, readFileSync as readFileSync23 } from "node:fs";
+import { join as join27 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join23(projectPath, ".mcp.json");
-  if (!existsSync17(config)) {
+  const config = join27(projectPath, ".mcp.json");
+  if (!existsSync21(config)) {
     return [];
   }
   let text;
   try {
-    text = readFileSync18(config, "utf8");
+    text = readFileSync23(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -36570,30 +36929,30 @@ var init_config_pin = __esm(() => {
 });
 
 // src/cut-test-run.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync19, rmSync as rmSync9, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname15, join as join24 } from "node:path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync24, rmSync as rmSync12, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname16, join as join28 } from "node:path";
 function keptAt(projectPath) {
-  return join24(projectPath, ".godot", "gdharness-reports", "cut-run.json");
+  return join28(projectPath, ".godot", "gdharness-reports", "cut-run.json");
 }
 function keepCutTestRun(projectPath, run) {
   const path = keptAt(projectPath);
   try {
-    mkdirSync9(dirname15(path), { recursive: true });
-    writeFileSync11(path, `${JSON.stringify(run, null, 2)}
+    mkdirSync12(dirname16(path), { recursive: true });
+    writeFileSync13(path, `${JSON.stringify(run, null, 2)}
 `, "utf8");
   } catch {}
 }
 function takeCutTestRun(projectPath) {
   const path = keptAt(projectPath);
-  if (!existsSync18(path)) {
+  if (!existsSync22(path)) {
     return null;
   }
   try {
-    const run = JSON.parse(readFileSync19(path, "utf8"));
-    rmSync9(path, { force: true });
+    const run = JSON.parse(readFileSync24(path, "utf8"));
+    rmSync12(path, { force: true });
     return typeof run.cutAt === "string" && Array.isArray(run.paths) && run.paths.every((path) => typeof path === "string") ? run : null;
   } catch {
-    rmSync9(path, { force: true });
+    rmSync12(path, { force: true });
     return null;
   }
 }
@@ -36733,7 +37092,7 @@ var init_ports = __esm(() => {
 
 // src/dap_client.ts
 import { createConnection as createConnection2 } from "node:net";
-import { setTimeout as delay2 } from "node:timers/promises";
+import { setTimeout as delay5 } from "node:timers/promises";
 function fileKey(path) {
   return process.platform === "win32" ? path.replaceAll("\\", "/").toLowerCase() : path;
 }
@@ -37205,7 +37564,7 @@ class GodotDAPClient {
     await this.sendRequest(command, { threadId: resolvedThreadId });
     const deadline = Date.now() + this.stepPatienceMs;
     while (this.stops === before && this.connected && Date.now() < deadline) {
-      await delay2(50);
+      await delay5(50);
     }
     return this.stops !== before;
   }
@@ -37231,7 +37590,7 @@ class GodotDAPClient {
           return answered;
         }
       } catch {}
-      await delay2(200);
+      await delay5(200);
     }
     return null;
   }
@@ -37252,7 +37611,7 @@ class GodotDAPClient {
           break;
         }
       } catch {}
-      await delay2(200);
+      await delay5(200);
     }
     if (scopes.length === 0) {
       throw new ReadRefusal(`The scopes of frame ${String(frame["id"])} did not arrive from the game within ${this.scopesPatienceMs / 1000}s. They come from the game through the editor, so a busy machine can take longer: ask again`);
@@ -37399,288 +37758,28 @@ var init_dap_client = __esm(() => {
   };
 });
 
-// src/desktop.ts
-import { createHash as createHash4 } from "node:crypto";
-import {
-  closeSync,
-  existsSync as existsSync19,
-  mkdtempSync as mkdtempSync2,
-  openSync,
-  readFileSync as readFileSync20,
-  rmSync as rmSync10,
-  statSync as statSync9,
-  writeFileSync as writeFileSync12,
-  writeSync
-} from "node:fs";
-import { tmpdir as tmpdir5 } from "node:os";
-import { join as join25 } from "node:path";
-import { setTimeout as delay3 } from "node:timers/promises";
-function helperAssembly(directory = tmpdir5()) {
-  return join25(directory, `gdharness-desktop-${DIGEST}.dll`);
-}
-async function ensureHelperCompiled(directory = tmpdir5(), budgetMs = HELPER_COMPILE_MS, wait = true) {
-  const assembly = helperAssembly(directory);
-  const lock = `${assembly}.compiling`;
-  const until = Date.now() + budgetMs;
-  while (Date.now() < until) {
-    if (existsSync19(assembly)) {
-      return null;
-    }
-    let mine = false;
-    try {
-      const held = openSync(lock, "wx");
-      writeSync(held, String(process.pid));
-      closeSync(held);
-      mine = true;
-    } catch {}
-    if (mine) {
-      try {
-        return await compileHelper(directory, assembly, until - Date.now());
-      } finally {
-        rmSync10(lock, { force: true });
-      }
-    }
-    try {
-      const holder = Number(readFileSync20(lock, "utf8").trim());
-      const old = Date.now() - statSync9(lock).mtimeMs > budgetMs;
-      if (old || Number.isInteger(holder) && holder > 0 && !alive(holder)) {
-        rmSync10(lock, { force: true });
-        continue;
-      }
-    } catch {}
-    if (!wait) {
-      return null;
-    }
-    await delay3(200);
-  }
-  return `the desktop helper was not compiled within ${String(budgetMs)} ms`;
-}
-async function compileHelper(directory, assembly, budgetMs) {
-  const scratch = mkdtempSync2(join25(directory, "gdharness-desktop-source-"));
-  const source = join25(scratch, "helper.cs");
-  writeFileSync12(source, SOURCE, "utf8");
-  const literal = (path) => `'${path.replaceAll("'", "''")}'`;
-  const script = [
-    "$ErrorActionPreference = 'Stop'",
-    "try {",
-    `  $partial = ${literal(assembly)} + '.' + $PID`,
-    `  Add-Type -TypeDefinition ([IO.File]::ReadAllText(${literal(source)}, [Text.Encoding]::UTF8)) -OutputAssembly $partial`,
-    `  Move-Item -LiteralPath $partial -Destination ${literal(assembly)}`,
-    "} catch {",
-    "  [Console]::Error.WriteLine($_.Exception.Message)",
-    "  exit 1",
-    "}"
-  ].join(`
-`);
-  try {
-    return await new Promise((resolve) => {
-      const compiler = spawnHidden("powershell.exe", [
-        "-NoProfile",
-        "-NonInteractive",
-        "-ExecutionPolicy",
-        "Bypass",
-        "-EncodedCommand",
-        Buffer.from(script, "utf16le").toString("base64")
-      ], { stdio: ["ignore", "ignore", "pipe"] });
-      let complained = "";
-      compiler.stderr.on("data", (chunk) => {
-        complained += chunk.toString();
-      });
-      const timer = setTimeout(() => {
-        compiler.kill();
-      }, budgetMs);
-      compiler.once("error", (error) => {
-        clearTimeout(timer);
-        resolve(`Windows PowerShell did not start: ${error.message}`);
-      });
-      compiler.once("close", (code) => {
-        clearTimeout(timer);
-        resolve(existsSync19(assembly) ? null : `Windows PowerShell could not compile it${code === null ? " in time" : ""}: ${complained.trim() || `exit code ${String(code)}`}`);
-      });
-    });
-  } finally {
-    rmSync10(scratch, { recursive: true, force: true });
-  }
-}
-var HIDDEN_DESKTOP = "gdharness", SOURCE = `using System;
-using System.ComponentModel;
-using System.IO;
-using System.Runtime.InteropServices;
-using System.Text;
-
-public static class GdharnessDesktop {
-  const uint GenericAll = 0x10000000;
-  const int UseStdHandles = 0x100;
-  const int UseShowWindow = 0x1;
-  const short ShowNoActivate = 4;
-  // No console at all, rather than a hidden one: a console's host would sit on the desktop too.
-  const uint DetachedProcess = 0x00000008;
-  const uint Infinite = 0xFFFFFFFF;
-
-  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
-  struct StartupInfo {
-    public int cb;
-    public string reserved;
-    public string desktop;
-    public string title;
-    public int x, y, xSize, ySize, xCount, yCount, fill, flags;
-    public short show, reservedSize;
-    public IntPtr reservedBytes, input, output, error;
-  }
-
-  [StructLayout(LayoutKind.Sequential)]
-  struct Started {
-    public IntPtr process, thread;
-    public int processId, threadId;
-  }
-
-  [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
-  static extern IntPtr CreateDesktopW(string name, IntPtr device, IntPtr mode, uint flags, uint access, IntPtr attributes);
-
-  [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
-  static extern bool CreateProcessW(string application, StringBuilder commandLine, IntPtr processAttributes, IntPtr threadAttributes, bool inherit, uint flags, IntPtr environment, string directory, ref StartupInfo startup, out Started started);
-
-  [DllImport("kernel32.dll")] static extern IntPtr GetStdHandle(int which);
-  [DllImport("kernel32.dll")] static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
-  [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);
-
-  delegate bool EachWindow(IntPtr window, IntPtr unused);
-  [DllImport("user32.dll")] static extern bool EnumWindows(EachWindow each, IntPtr unused);
-  [DllImport("user32.dll")] static extern bool IsWindowVisible(IntPtr window);
-  [DllImport("user32.dll")] static extern uint GetWindowThreadProcessId(IntPtr window, out uint processId);
-  [DllImport("user32.dll")] static extern bool LockSetForegroundWindow(uint code);
-  const uint LockForeground = 1;
-  const uint UnlockForeground = 2;
-  const uint TimedOut = 0x102;
-
-  static bool ShowsAWindow(int processId) {
-    bool shown = false;
-    EnumWindows(delegate(IntPtr window, IntPtr unused) {
-      uint owner;
-      GetWindowThreadProcessId(window, out owner);
-      if (owner == (uint)processId && IsWindowVisible(window)) {
-        shown = true;
-        return false;
-      }
-      return true;
-    }, IntPtr.Zero);
-    return shown;
-  }
-
-  // Keeps the foreground where it is while the process starts: its own call to take it fails while
-  // the foreground is locked, and the user's own Alt+Tab or click still moves it. Released once its
-  // window has been showing for a while, since a program takes the foreground as it shows its window
-  // and not afterwards, or when it exits, or after two minutes whatever happens.
-  static void HoldTheForeground(Started started) {
-    DateTime until = DateTime.UtcNow.AddMinutes(2);
-    DateTime? shownAt = null;
-    while (DateTime.UtcNow < until) {
-      if (WaitForSingleObject(started.process, 100) != TimedOut) {
-        return;
-      }
-      if (shownAt == null && ShowsAWindow(started.processId)) {
-        shownAt = DateTime.UtcNow;
-      }
-      if (shownAt != null && DateTime.UtcNow - shownAt.Value > TimeSpan.FromSeconds(10)) {
-        return;
-      }
-    }
-  }
-
-  // Starts the command line, both of its streams on this process's output, writes its pid, and
-  // waits for it: the answer is its exit code. On the named desktop when there is one, whose handle
-  // is held until then, since a desktop goes when the last handle to it does, and on this process's
-  // own otherwise. With noActivate its first window is shown without being activated, which is
-  // what a program's first ShowWindow does whatever it asks for when the start names a show state,
-  // and the foreground is held while it starts, since Godot also asks for it outright. The process
-  // is ended through the handle held here once stopFile appears, which is how a keeper ends a game
-  // it did not start itself: a handle names one process, where a pid can name the next one too. The
-  // process starts in directory rather than in this one's, which is a temporary directory: Windows
-  // PowerShell saves its module cache relative to where it runs when the profile does not resolve.
-  public static int Run(string desktop, string commandLine, string pidFile, bool noActivate, string stopFile, string directory) {
-    StartupInfo startup = new StartupInfo();
-    startup.cb = Marshal.SizeOf(typeof(StartupInfo));
-    if (desktop.Length > 0) {
-      IntPtr held = CreateDesktopW(desktop, IntPtr.Zero, IntPtr.Zero, 0, GenericAll, IntPtr.Zero);
-      if (held == IntPtr.Zero) {
-        throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateDesktopW " + desktop);
-      }
-      startup.desktop = desktop;
-    }
-    startup.flags = UseStdHandles;
-    if (noActivate) {
-      startup.flags |= UseShowWindow;
-      startup.show = ShowNoActivate;
-    }
-    startup.input = GetStdHandle(-10);
-    startup.output = GetStdHandle(-11);
-    startup.error = startup.output;
-    Started started;
-    if (noActivate) {
-      LockSetForegroundWindow(LockForeground);
-    }
-    try {
-    if (!CreateProcessW(null, new StringBuilder(commandLine), IntPtr.Zero, IntPtr.Zero, true, DetachedProcess, IntPtr.Zero, directory, ref startup, out started)) {
-      throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateProcessW " + commandLine);
-    }
-    File.WriteAllText(pidFile, started.processId.ToString());
-    if (noActivate) {
-      HoldTheForeground(started);
-    }
-    } finally {
-      if (noActivate) {
-        LockSetForegroundWindow(UnlockForeground);
-      }
-    }
-    if (stopFile.Length == 0) {
-      WaitForSingleObject(started.process, Infinite);
-    } else {
-      bool stopped = false;
-      while (WaitForSingleObject(started.process, 100) == TimedOut) {
-        if (!stopped && File.Exists(stopFile)) {
-          TerminateProcess(started.process, 1);
-          stopped = true;
-        }
-      }
-    }
-    uint code;
-    GetExitCodeProcess(started.process, out code);
-    CloseHandle(started.thread);
-    CloseHandle(started.process);
-    return unchecked((int)code);
-  }
-}
-`, DIGEST, HELPER_COMPILE_MS = 180000;
-var init_desktop = __esm(() => {
-  init_alive();
-  init_spawn();
-  DIGEST = createHash4("sha256").update(SOURCE).digest("hex").slice(0, 16);
-});
-
 // src/editor-log.ts
 import {
-  closeSync as closeSync2,
-  existsSync as existsSync20,
-  mkdirSync as mkdirSync10,
-  openSync as openSync2,
-  readFileSync as readFileSync21,
-  readSync,
-  rmSync as rmSync11,
-  statSync as statSync10,
-  writeFileSync as writeFileSync13
+  closeSync as closeSync4,
+  existsSync as existsSync23,
+  mkdirSync as mkdirSync13,
+  openSync as openSync4,
+  readFileSync as readFileSync25,
+  readSync as readSync2,
+  rmSync as rmSync13,
+  statSync as statSync13,
+  writeFileSync as writeFileSync14
 } from "node:fs";
-import { dirname as dirname16, join as join26 } from "node:path";
+import { dirname as dirname17, join as join29 } from "node:path";
 function editorLogPath(projectPath) {
-  return join26(projectPath, ".godot", "gdharness-editor.log");
+  return join29(projectPath, ".godot", "gdharness-editor.log");
 }
 function editorLogNotePath(projectPath) {
-  return join26(projectPath, ".godot", "gdharness-editor.json");
+  return join29(projectPath, ".godot", "gdharness-editor.json");
 }
 function readEditorLogNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync21(editorLogNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync25(editorLogNotePath(projectPath), "utf8")));
     const pid = readNumber(fields, "pid");
     const startedAt = readString(fields, "startedAt");
     return pid !== undefined && Number.isInteger(pid) && pid > 0 && startedAt !== undefined ? { pid, startedAt } : null;
@@ -37691,16 +37790,16 @@ function readEditorLogNote(projectPath) {
 function clearEditorLog(projectPath) {
   try {
     const path = editorLogPath(projectPath);
-    mkdirSync10(dirname16(path), { recursive: true });
-    rmSync11(path, { force: true });
-    rmSync11(editorLogNotePath(projectPath), { force: true });
+    mkdirSync13(dirname17(path), { recursive: true });
+    rmSync13(path, { force: true });
+    rmSync13(editorLogNotePath(projectPath), { force: true });
   } catch {}
 }
 function writeEditorLogNote(projectPath, pid) {
   try {
     const path = editorLogNotePath(projectPath);
-    mkdirSync10(dirname16(path), { recursive: true });
-    writeFileSync13(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
+    mkdirSync13(dirname17(path), { recursive: true });
+    writeFileSync14(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
 function theConsoleWasNotCaptured(why, projectPath) {
@@ -37721,7 +37820,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
     return { kind: "another editor", notedPid: noted?.pid ?? null };
   }
   const path = editorLogPath(projectPath);
-  if (!existsSync20(path)) {
+  if (!existsSync23(path)) {
     return { kind: "not written" };
   }
   const log = new GameLog;
@@ -37777,20 +37876,20 @@ function foldProgress(text) {
 `);
 }
 function theFirstOf(path) {
-  const whole = statSync10(path).size;
+  const whole = statSync13(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
-    return { text: readFileSync21(path, "utf8") };
+    return { text: readFileSync25(path, "utf8") };
   }
-  const handle = openSync2(path, "r");
+  const handle = openSync4(path, "r");
   try {
     const buffer = Buffer.alloc(MOST_CONSOLE_BYTES);
-    const read = readSync(handle, buffer, 0, MOST_CONSOLE_BYTES, 0);
+    const read = readSync2(handle, buffer, 0, MOST_CONSOLE_BYTES, 0);
     const decoded = buffer.subarray(0, read).toString("utf8");
     const lastLine = decoded.lastIndexOf(`
 `);
     return { text: lastLine === -1 ? decoded : decoded.slice(0, lastLine + 1), of: whole };
   } finally {
-    closeSync2(handle);
+    closeSync4(handle);
   }
 }
 function shapeOf2(text) {
@@ -37940,8 +38039,8 @@ var init_editor_log = __esm(() => {
 });
 
 // src/rename.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync11, readFileSync as readFileSync22, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync14 } from "node:fs";
-import { dirname as dirname17, posix as posix2 } from "node:path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync14, readFileSync as readFileSync26, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync15 } from "node:fs";
+import { dirname as dirname18, posix as posix4 } from "node:path";
 
 class Script {
   path;
@@ -38054,13 +38153,13 @@ class ClassGraph {
 }
 function resolvedPath(written, from) {
   if (written.startsWith("res://")) {
-    return `res://${posix2.normalize(written.slice("res://".length))}`;
+    return `res://${posix4.normalize(written.slice("res://".length))}`;
   }
-  const directory = posix2.dirname(from.slice("res://".length));
-  return `res://${posix2.normalize(posix2.join(directory, written))}`;
+  const directory = posix4.dirname(from.slice("res://".length));
+  return `res://${posix4.normalize(posix4.join(directory, written))}`;
 }
 function relativeTo(target, from) {
-  return posix2.relative(posix2.dirname(from.slice("res://".length)), target.slice("res://".length));
+  return posix4.relative(posix4.dirname(from.slice("res://".length)), target.slice("res://".length));
 }
 function scriptsOf(texts) {
   const scripts = new Map;
@@ -38645,25 +38744,25 @@ function rewritesOf(plan, texts, move) {
 }
 function applyRewrites(rewrites) {
   for (const rewrite of rewrites) {
-    const now = readFileSync22(rewrite.absolute, "utf8");
+    const now = readFileSync26(rewrite.absolute, "utf8");
     if (now !== rewrite.before) {
       throw new Error(`${rewrite.path} changed on disk while the rename was being worked out; nothing was written`);
     }
-    if (rewrite.writeTo !== rewrite.absolute && existsSync21(rewrite.writeTo)) {
+    if (rewrite.writeTo !== rewrite.absolute && existsSync24(rewrite.writeTo)) {
       throw new Error(`${rewrite.writeTo} already exists; nothing was written`);
     }
   }
   const done = [];
   try {
     for (const rewrite of rewrites) {
-      mkdirSync11(dirname17(rewrite.writeTo), { recursive: true });
+      mkdirSync14(dirname18(rewrite.writeTo), { recursive: true });
       const staging = `${rewrite.writeTo}.gdharness-rename`;
-      writeFileSync14(staging, rewrite.after, "utf8");
+      writeFileSync15(staging, rewrite.after, "utf8");
       renameSync3(staging, rewrite.writeTo);
       let movedUid = false;
       if (rewrite.writeTo !== rewrite.absolute) {
         unlinkSync3(rewrite.absolute);
-        if (existsSync21(`${rewrite.absolute}.uid`)) {
+        if (existsSync24(`${rewrite.absolute}.uid`)) {
           renameSync3(`${rewrite.absolute}.uid`, `${rewrite.writeTo}.uid`);
           movedUid = true;
         }
@@ -38673,7 +38772,7 @@ function applyRewrites(rewrites) {
   } catch (error) {
     for (const { rewrite, movedUid } of done.reverse()) {
       try {
-        writeFileSync14(rewrite.absolute, rewrite.before, "utf8");
+        writeFileSync15(rewrite.absolute, rewrite.before, "utf8");
         if (rewrite.writeTo !== rewrite.absolute) {
           unlinkSync3(rewrite.writeTo);
           if (movedUid) {
@@ -38709,11 +38808,11 @@ var init_rename = __esm(() => {
 });
 
 // src/lsp_client.ts
-import { existsSync as existsSync22, realpathSync as realpathSync3 } from "node:fs";
+import { existsSync as existsSync25, realpathSync as realpathSync3 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname18, join as join27, resolve as resolve5 } from "node:path";
-import { setTimeout as delay4 } from "node:timers/promises";
+import { dirname as dirname19, join as join30, resolve as resolve6 } from "node:path";
+import { setTimeout as delay6 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function initializeTimeoutMs() {
   const override = Number.parseInt(envValue("GDHARNESS_LSP_INITIALIZE_TIMEOUT_MS") ?? "", 10);
@@ -38779,7 +38878,7 @@ class GodotLSPClient {
         if (Date.now() >= until) {
           throw new LanguageServerNotListening(this.port, this.timeouts.listenMs);
         }
-        await delay4(LANGUAGE_SERVER_RETRY_MS);
+        await delay6(LANGUAGE_SERVER_RETRY_MS);
       }
     }
   }
@@ -38874,7 +38973,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname18(resolve5(filePath));
+    const rootPath = this.rootPath ?? dirname19(resolve6(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params, timeoutMs = this.timeouts.requestMs) {
@@ -39016,7 +39115,7 @@ class GodotLSPClient {
     });
   }
   toFileUri(filePath) {
-    return pathToFileURL(resolve5(filePath)).href;
+    return pathToFileURL(resolve6(filePath)).href;
   }
   syncDocument(filePath, content) {
     const uri = this.toFileUri(filePath);
@@ -39060,7 +39159,7 @@ class GodotLSPClient {
   }
   async initialize(rootPath) {
     await this.ensureConnected();
-    const resolvedRootPath = resolve5(rootPath);
+    const resolvedRootPath = resolve6(rootPath);
     const rootUri = pathToFileURL(resolvedRootPath).href;
     this.forgetServedWorkspace();
     const result = await this.sendRequest("initialize", {
@@ -39283,7 +39382,7 @@ function normalizeLSPError(error, port) {
 function asRecord(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
-function named(value, names) {
+function named2(value, names) {
   return typeof value === "number" && Number.isInteger(value) ? names[value - 1] ?? value : value;
 }
 function shownPosition(position) {
@@ -39302,7 +39401,7 @@ function shownDiagnostic(entry) {
   const { range, severity, message, code } = asRecord(entry);
   return {
     ...shownRange(range),
-    severity: named(severity, SEVERITIES),
+    severity: named2(severity, SEVERITIES),
     message,
     ...code === undefined || code === null || code === 0 || code === "" ? {} : { code }
   };
@@ -39331,7 +39430,7 @@ function shownSymbol(entry, lastOfDocument) {
   const { documentation, native_class: nativeClass, deprecated, detail } = symbol;
   return {
     name: symbol["name"],
-    kind: named(symbol["kind"], SYMBOL_KINDS),
+    kind: named2(symbol["kind"], SYMBOL_KINDS),
     ...typeof detail === "string" && detail !== "" ? { detail } : {},
     ...at === null ? {} : { line: at.line, column: at.column },
     ...last === null ? {} : { lastLine: last },
@@ -39365,7 +39464,7 @@ function narrowedCompletions(completions, typed) {
 }
 function shownCompletion(entry) {
   const { data: _request, kind, ...rest } = asRecord(entry);
-  return { ...rest, kind: named(kind, COMPLETION_KINDS) };
+  return { ...rest, kind: named2(kind, COMPLETION_KINDS) };
 }
 function shownHover(hover) {
   if (hover === null || typeof hover !== "object") {
@@ -39383,14 +39482,14 @@ function protocolPosition(args) {
   return { line: line - 1, character: character - 1 };
 }
 async function resolveLSPPaths(projectPathValue, scriptPathValue) {
-  const requestedProjectPath = resolve5(projectPathValue);
+  const requestedProjectPath = resolve6(projectPathValue);
   let projectPath;
   try {
     projectPath = await realpath(requestedProjectPath);
   } catch {
     throw new ArgumentRefusal(`Project path does not exist: ${requestedProjectPath}`);
   }
-  if (!existsSync22(join27(projectPath, "project.godot"))) {
+  if (!existsSync25(join30(projectPath, "project.godot"))) {
     throw new ArgumentRefusal(`Not a Godot project: ${projectPath}. Point projectPath at the directory holding project.godot.`);
   }
   const contained = resolveWithinProject(projectPath, scriptPathValue);
@@ -39550,10 +39649,10 @@ var init_lsp_client = __esm(() => {
 });
 
 // src/rename-symbol.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync12, readdirSync as readdirSync11, realpathSync as realpathSync4, rmSync as rmSync12, writeFileSync as writeFileSync15 } from "node:fs";
-import { basename as basename8, dirname as dirname19, join as join28, relative as relative4, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync26, mkdirSync as mkdirSync15, readdirSync as readdirSync13, realpathSync as realpathSync4, rmSync as rmSync14, writeFileSync as writeFileSync16 } from "node:fs";
+import { basename as basename8, dirname as dirname20, join as join31, relative as relative5, resolve as resolve7 } from "node:path";
 function resourcePathOf(projectPath, absolute) {
-  const inside = relative4(onDiskSpelling(projectPath), onDiskSpelling(absolute));
+  const inside = relative5(onDiskSpelling(projectPath), onDiskSpelling(absolute));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
     return null;
   }
@@ -39561,14 +39660,14 @@ function resourcePathOf(projectPath, absolute) {
 }
 function onDiskSpelling(path) {
   const missing = [];
-  let at = resolve6(path);
+  let at = resolve7(path);
   for (;; ) {
     try {
-      return join28(realpathSync4.native(at), ...missing.reverse());
+      return join31(realpathSync4.native(at), ...missing.reverse());
     } catch {
-      const parent = dirname19(at);
+      const parent = dirname20(at);
       if (parent === at) {
-        return resolve6(path);
+        return resolve7(path);
       }
       missing.push(basename8(at));
       at = parent;
@@ -39618,7 +39717,7 @@ async function renameSymbol(request, services) {
         reason: `newScriptPath must be a .gd path inside the project, and ${request.newScriptPath} is not.`
       };
     }
-    if (existsSync23(request.newScriptPath)) {
+    if (existsSync26(request.newScriptPath)) {
       return { ok: false, reason: `${moveTo} already exists, so the script cannot be moved there.` };
     }
   }
@@ -39794,7 +39893,7 @@ async function renameSymbol(request, services) {
       scripts,
       moves: new Map([[declaringPath, moveTo]]),
       named: [declaringPath],
-      exists: (path) => existsSync23(`${projectPath}/${path.slice("res://".length)}`)
+      exists: (path) => existsSync26(`${projectPath}/${path.slice("res://".length)}`)
     }, plan);
   }
   plan = mentionIgnored(plan, ignoredTexts(projectPath), symbol, moveTo === null ? [] : [declaringPath]);
@@ -39993,15 +40092,15 @@ ${mention.kind}`;
   };
 }
 function writeLeftAloneDetail(projectPath, symbol, detail) {
-  const directory = join28(projectPath, ".godot", "gdharness-renames");
-  mkdirSync12(directory, { recursive: true });
+  const directory = join31(projectPath, ".godot", "gdharness-renames");
+  mkdirSync15(directory, { recursive: true });
   detailWrites += 1;
-  const path = join28(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
-  writeFileSync15(path, `${JSON.stringify(detail, null, 2)}
+  const path = join31(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
+  writeFileSync16(path, `${JSON.stringify(detail, null, 2)}
 `, "utf8");
-  const kept = readdirSync11(directory).filter((name) => name.endsWith(".json")).sort().reverse();
+  const kept = readdirSync13(directory).filter((name) => name.endsWith(".json")).sort().reverse();
   for (const old of kept.slice(10)) {
-    rmSync12(join28(directory, old), { force: true });
+    rmSync14(join31(directory, old), { force: true });
   }
   return path;
 }
@@ -40042,25 +40141,25 @@ var init_rename_symbol = __esm(() => {
 
 // src/file-move.ts
 import {
-  existsSync as existsSync24,
-  mkdirSync as mkdirSync13,
-  readdirSync as readdirSync12,
-  readFileSync as readFileSync23,
+  existsSync as existsSync27,
+  mkdirSync as mkdirSync16,
+  readdirSync as readdirSync14,
+  readFileSync as readFileSync27,
   renameSync as renameSync4,
-  statSync as statSync11,
-  writeFileSync as writeFileSync16
+  statSync as statSync14,
+  writeFileSync as writeFileSync17
 } from "node:fs";
-import { basename as basename9, dirname as dirname20, extname as extname3, join as join29, relative as relative5 } from "node:path";
+import { basename as basename9, dirname as dirname21, extname as extname3, join as join32, relative as relative6 } from "node:path";
 function filesUnder(directory) {
-  return readdirSync12(directory, { withFileTypes: true }).flatMap((entry) => {
-    const path = join29(directory, entry.name);
+  return readdirSync14(directory, { withFileTypes: true }).flatMap((entry) => {
+    const path = join32(directory, entry.name);
     return entry.isDirectory() ? filesUnder(path) : [path];
   });
 }
 function sameFile(one, other) {
   try {
-    const a = statSync11(one);
-    const b = statSync11(other);
+    const a = statSync14(one);
+    const b = statSync14(other);
     return a.ino === b.ino && a.dev === b.dev;
   } catch {
     return false;
@@ -40074,8 +40173,8 @@ function unseenByTheEngine(projectPath, path) {
       return `${path} is under ${step}, and the engine passes over every directory whose name starts with a dot`;
     }
     if (at < steps.length - 1) {
-      directory = join29(directory, step);
-      if (existsSync24(join29(directory, ".gdignore"))) {
+      directory = join32(directory, step);
+      if (existsSync27(join32(directory, ".gdignore"))) {
         return `${path} is under a directory holding a .gdignore, which the engine does not load`;
       }
     }
@@ -40087,21 +40186,21 @@ function installedAddonOf(projectPath, path) {
   if (steps[0] !== "addons" || steps[1] === undefined) {
     return null;
   }
-  return existsSync24(join29(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
+  return existsSync27(join32(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
 }
 function binaryResources(projectPath) {
   const found = [];
   const visit = (directory, prefix) => {
-    if (existsSync24(join29(directory, ".gdignore"))) {
+    if (existsSync27(join32(directory, ".gdignore"))) {
       return;
     }
-    for (const entry of readdirSync12(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync14(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
       }
       const path = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join29(directory, entry.name), `${path}/`);
+        visit(join32(directory, entry.name), `${path}/`);
       } else if (/\.(scn|res)$/i.test(entry.name)) {
         found.push(path);
       }
@@ -40111,7 +40210,7 @@ function binaryResources(projectPath) {
   return found;
 }
 function targetPathOf(projectPath, absolute) {
-  const inside = relative5(onDiskSpelling(projectPath), join29(onDiskSpelling(dirname20(absolute)), basename9(absolute)));
+  const inside = relative6(onDiskSpelling(projectPath), join32(onDiskSpelling(dirname21(absolute)), basename9(absolute)));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
     return null;
   }
@@ -40129,13 +40228,13 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   if (to === null) {
     return { ok: false, reason: `newPath must be a path inside the project, and ${absoluteTo} is not.` };
   }
-  if (!existsSync24(absoluteFrom)) {
+  if (!existsSync27(absoluteFrom)) {
     return { ok: false, reason: `There is nothing at ${from} to move.` };
   }
   if (from === to) {
     return { ok: false, reason: `${from} is already there; nothing to move.` };
   }
-  const isDirectory = statSync11(absoluteFrom).isDirectory();
+  const isDirectory = statSync14(absoluteFrom).isDirectory();
   if (from === "res://project.godot") {
     return {
       ok: false,
@@ -40158,7 +40257,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   if (isDirectory && to.startsWith(`${from}/`)) {
     return { ok: false, reason: `${from} cannot be moved into itself.` };
   }
-  if (existsSync24(absoluteTo) && !sameFile(absoluteFrom, absoluteTo)) {
+  if (existsSync27(absoluteTo) && !sameFile(absoluteFrom, absoluteTo)) {
     return { ok: false, reason: `${to} already exists, so nothing was moved there.` };
   }
   const unseen = unseenByTheEngine(projectPath, to);
@@ -40166,7 +40265,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
     return { ok: false, reason: `${unseen}, so nothing there could load what was moved.` };
   }
   if (!isDirectory) {
-    const owner = SIDECARS.map((sidecar) => from.endsWith(sidecar) ? from.slice(0, -sidecar.length) : null).find((path) => path !== null && existsSync24(join29(projectPath, path.slice("res://".length))));
+    const owner = SIDECARS.map((sidecar) => from.endsWith(sidecar) ? from.slice(0, -sidecar.length) : null).find((path) => path !== null && existsSync27(join32(projectPath, path.slice("res://".length))));
     if (owner !== undefined && owner !== null) {
       return { ok: false, reason: `${from} belongs to ${owner} and moves with it: move ${owner} instead.` };
     }
@@ -40188,7 +40287,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   } else {
     moves.set(from, to);
     for (const sidecar of SIDECARS) {
-      if (existsSync24(`${absoluteFrom}${sidecar}`)) {
+      if (existsSync27(`${absoluteFrom}${sidecar}`)) {
         moves.set(`${from}${sidecar}`, `${to}${sidecar}`);
       }
     }
@@ -40200,12 +40299,12 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
     scripts,
     moves,
     named: [from],
-    exists: (path) => existsSync24(join29(projectPath, path.slice("res://".length)))
+    exists: (path) => existsSync27(join32(projectPath, path.slice("res://".length)))
   }, { edits: [], mentions: [] });
   plan = mentionIgnored(plan, ignoredTexts(projectPath), null, [from]);
   const binaries = [];
   for (const path of binaryResources(projectPath)) {
-    const bytes = readFileSync23(join29(projectPath, path.slice("res://".length)));
+    const bytes = readFileSync27(join32(projectPath, path.slice("res://".length)));
     const names = [...moves.keys()].find((moving) => bytes.includes(moving));
     if (names !== undefined) {
       binaries.push({
@@ -40224,7 +40323,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   }));
   const left = leftAloneReport(mentions);
   const rewrites = rewritesOf(plan, texts, null);
-  const absoluteOf = (path) => join29(projectPath, path.slice("res://".length));
+  const absoluteOf = (path) => join32(projectPath, path.slice("res://".length));
   const rewritten = new Map(rewrites.map((rewrite) => [rewrite.path, rewrite]));
   const moved = [...moves].map(([source, target]) => {
     const rewrite = rewritten.get(source);
@@ -40266,24 +40365,24 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
 }
 function applyFileMove(outcome) {
   for (const rewrite of outcome.inPlace) {
-    if (readFileSync23(rewrite.absolute, "utf8") !== rewrite.before) {
+    if (readFileSync27(rewrite.absolute, "utf8") !== rewrite.before) {
       throw new Error(`${rewrite.path} changed on disk while the move was being worked out; nothing was written`);
     }
   }
   for (const file of outcome.moved) {
-    if (!existsSync24(file.absoluteFrom)) {
+    if (!existsSync27(file.absoluteFrom)) {
       throw new Error(`${file.from} is gone from disk; nothing was written`);
     }
-    if (file.text !== null && readFileSync23(file.absoluteFrom, "utf8") !== file.text.before) {
+    if (file.text !== null && readFileSync27(file.absoluteFrom, "utf8") !== file.text.before) {
       throw new Error(`${file.from} changed on disk while the move was being worked out; nothing was written`);
     }
-    if (existsSync24(file.absoluteTo) && !sameFile(file.absoluteFrom, file.absoluteTo)) {
+    if (existsSync27(file.absoluteTo) && !sameFile(file.absoluteFrom, file.absoluteTo)) {
       throw new Error(`${file.to} already exists; nothing was written`);
     }
   }
   const undo = [];
   const rename = (source, target) => {
-    mkdirSync13(dirname20(target), { recursive: true });
+    mkdirSync16(dirname21(target), { recursive: true });
     renameSync4(source, target);
     undo.push(() => {
       renameSync4(target, source);
@@ -40292,10 +40391,10 @@ function applyFileMove(outcome) {
   try {
     for (const rewrite of outcome.inPlace) {
       const staging = `${rewrite.absolute}.gdharness-move`;
-      writeFileSync16(staging, rewrite.after, "utf8");
+      writeFileSync17(staging, rewrite.after, "utf8");
       renameSync4(staging, rewrite.absolute);
       undo.push(() => {
-        writeFileSync16(rewrite.absolute, rewrite.before, "utf8");
+        writeFileSync17(rewrite.absolute, rewrite.before, "utf8");
       });
     }
     if (outcome.directory !== null) {
@@ -40307,9 +40406,9 @@ function applyFileMove(outcome) {
       }
       if (file.text !== null) {
         const { before, after } = file.text;
-        writeFileSync16(file.absoluteTo, after, "utf8");
+        writeFileSync17(file.absoluteTo, after, "utf8");
         undo.push(() => {
-          writeFileSync16(file.absoluteTo, before, "utf8");
+          writeFileSync17(file.absoluteTo, before, "utf8");
         });
       }
     }
@@ -43945,13 +44044,13 @@ var init_godot_bridge = __esm(() => {
 });
 
 // src/import-freshness.ts
-import { createHash as createHash5 } from "node:crypto";
-import { existsSync as existsSync25, readdirSync as readdirSync13, readFileSync as readFileSync24, statSync as statSync12 } from "node:fs";
-import { join as join30 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { existsSync as existsSync28, readdirSync as readdirSync15, readFileSync as readFileSync28, statSync as statSync15 } from "node:fs";
+import { join as join33 } from "node:path";
 function md5Of(file) {
   let stats;
   try {
-    stats = statSync12(file);
+    stats = statSync15(file);
   } catch {
     return null;
   }
@@ -43961,7 +44060,7 @@ function md5Of(file) {
   }
   let md5;
   try {
-    md5 = createHash5("md5").update(readFileSync24(file)).digest("hex");
+    md5 = createHash6("md5").update(readFileSync28(file)).digest("hex");
   } catch {
     return null;
   }
@@ -43991,7 +44090,7 @@ function listed2(value) {
   return [...(value ?? "").matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((match) => match[1] ?? "");
 }
 function onDisk(projectPath, resPath) {
-  return join30(projectPath, resPath.slice("res://".length));
+  return join33(projectPath, resPath.slice("res://".length));
 }
 function behind(projectPath, resPath, sidecar) {
   const remap = sectionOf(sidecar, "remap");
@@ -44000,14 +44099,14 @@ function behind(projectPath, resPath, sidecar) {
     return null;
   }
   const outputs = listed2(sectionOf(sidecar, "deps").get("dest_files"));
-  if (outputs.some((output) => !existsSync25(onDisk(projectPath, output)))) {
+  if (outputs.some((output) => !existsSync28(onDisk(projectPath, output)))) {
     return "its imported output is not on disk";
   }
   const name = resPath.slice(resPath.lastIndexOf("/") + 1);
-  const record = join30(projectPath, ".godot", "imported", `${name}-${createHash5("md5").update(resPath, "utf8").digest("hex")}.md5`);
+  const record = join33(projectPath, ".godot", "imported", `${name}-${createHash6("md5").update(resPath, "utf8").digest("hex")}.md5`);
   let recorded = "";
   try {
-    recorded = /^source_md5="([0-9a-f]*)"/m.exec(readFileSync24(record, "utf8"))?.[1] ?? "";
+    recorded = /^source_md5="([0-9a-f]*)"/m.exec(readFileSync28(record, "utf8"))?.[1] ?? "";
   } catch {
     recorded = "";
   }
@@ -44020,12 +44119,12 @@ function behind(projectPath, resPath, sidecar) {
 function staleImports(projectPath) {
   const stale = [];
   const visit = (directory, resDirectory) => {
-    if (existsSync25(join30(directory, ".gdignore")) || existsSync25(join30(directory, VERSION_MARKER))) {
+    if (existsSync28(join33(directory, ".gdignore")) || existsSync28(join33(directory, VERSION_MARKER))) {
       return;
     }
     let entries;
     try {
-      entries = readdirSync13(directory, { withFileTypes: true });
+      entries = readdirSync15(directory, { withFileTypes: true });
     } catch {
       return;
     }
@@ -44036,7 +44135,7 @@ function staleImports(projectPath) {
       }
       const resPath = `${resDirectory}${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join30(directory, entry.name), `${resPath}/`);
+        visit(join33(directory, entry.name), `${resPath}/`);
         continue;
       }
       if (!entry.isFile()) {
@@ -44049,7 +44148,7 @@ function staleImports(projectPath) {
         }
         let sidecar;
         try {
-          sidecar = readFileSync24(join30(directory, entry.name), "utf8");
+          sidecar = readFileSync28(join33(directory, entry.name), "utf8");
         } catch {
           continue;
         }
@@ -44169,25 +44268,25 @@ var DEBUG_PREFIX = "debug ";
 var init_keeper_channel = () => {};
 
 // src/lifecycle-log.ts
-import { appendFileSync, mkdirSync as mkdirSync14, renameSync as renameSync5, statSync as statSync13 } from "node:fs";
-import { dirname as dirname21, join as join31 } from "node:path";
-import process11 from "node:process";
+import { appendFileSync, mkdirSync as mkdirSync17, renameSync as renameSync5, statSync as statSync16 } from "node:fs";
+import { dirname as dirname22, join as join34 } from "node:path";
+import process14 from "node:process";
 function lifecycleLogPath() {
-  return join31(runtimeDirectory(), "servers.log");
+  return join34(runtimeDirectory(), "servers.log");
 }
 function writeLifecycle(event, fields = {}) {
   const path = lifecycleLogPath();
   try {
-    mkdirSync14(dirname21(path), { recursive: true });
-    if ((statSync13(path, { throwIfNoEntry: false })?.size ?? 0) > LIFECYCLE_LOG_LIMIT) {
+    mkdirSync17(dirname22(path), { recursive: true });
+    if ((statSync16(path, { throwIfNoEntry: false })?.size ?? 0) > LIFECYCLE_LOG_LIMIT) {
       try {
         renameSync5(path, `${path}.1`);
       } catch {}
     }
     const line = {
       at: new Date().toISOString(),
-      pid: process11.pid,
-      ppid: process11.ppid,
+      pid: process14.pid,
+      ppid: process14.ppid,
       version: SERVER_VERSION,
       event
     };
@@ -44353,7 +44452,11 @@ function notListeningNote(servers, greetedAgoMs) {
   const named = down.map((one) => `its ${one.name} on port ${one.port}`).join(" and ");
   const needs = down.map((one) => one.name === "debug adapter" ? "played runs and the debug tools need the debug adapter" : "diagnostics, symbols and renames need the language server").join(", and ");
   const starting = greetedAgoMs !== null && greetedAgoMs < STARTING_MS ? ` The editor greeted ${Math.round(greetedAgoMs / 1000)}s ago, so ${down.length === 1 ? "it" : "they"} may still be starting: ask again in a few seconds.` : "";
-  return `The editor names ${named}, and nothing accepts connections there. Godot binds each once, as the editor starts, and reports a failure only in the editor's own log panel; ${needs}. editor_launch restart binds ${down.length === 1 ? "it" : "them"} again.${starting}`;
+  const cures = [
+    ...servers.dap.listening === false ? ["editor_launch rebind binds the debug adapter again in place"] : [],
+    ...servers.lsp.listening === false ? ["editor_launch restart binds the language server again"] : []
+  ].join(", and ");
+  return `The editor names ${named}, and nothing accepts connections there. Godot binds each once, as the editor starts, and reports a failure only in the editor's own log panel; ${needs}. ${cures}.${starting}`;
 }
 var STARTING_MS = 20000;
 var init_port_probe = () => {};
@@ -44533,16 +44636,16 @@ var init_prompts = __esm(() => {
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync15, readFileSync as readFileSync25, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "node:fs";
-import { dirname as dirname22, join as join32 } from "node:path";
+import { mkdirSync as mkdirSync18, readFileSync as readFileSync29, rmSync as rmSync15, writeFileSync as writeFileSync18 } from "node:fs";
+import { dirname as dirname23, join as join35 } from "node:path";
 function restartNotePath(projectPath) {
-  return join32(projectPath, ".godot", "gdharness-restart.json");
+  return join35(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync15(dirname22(path), { recursive: true });
-    writeFileSync17(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync18(dirname23(path), { recursive: true });
+    writeFileSync18(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
@@ -44550,7 +44653,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync25(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync29(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -44565,7 +44668,7 @@ function restartOwed(projectPath) {
 }
 function restartSettled(projectPath) {
   try {
-    rmSync13(restartNotePath(projectPath), { force: true });
+    rmSync15(restartNotePath(projectPath), { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
   }
@@ -44575,32 +44678,32 @@ var init_restart_note = __esm(() => {
 });
 
 // src/run-record.ts
-import { createHash as createHash6 } from "node:crypto";
-import { mkdirSync as mkdirSync16, openSync as openSync3, readdirSync as readdirSync14, readFileSync as readFileSync26, rmSync as rmSync14, statSync as statSync14 } from "node:fs";
-import { basename as basename10, join as join33, resolve as resolve7 } from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+import { mkdirSync as mkdirSync19, openSync as openSync5, readdirSync as readdirSync16, readFileSync as readFileSync30, rmSync as rmSync16, statSync as statSync17 } from "node:fs";
+import { basename as basename10, join as join36, resolve as resolve8 } from "node:path";
 function runsDirectory() {
-  return join33(runtimeDirectory(), "runs");
+  return join36(runtimeDirectory(), "runs");
 }
 function projectKey(projectPath) {
-  const real = realAsFarAsItExists(resolve7(projectPath)).replace(/[\\/]+$/, "");
+  const real = realAsFarAsItExists(resolve8(projectPath)).replace(/[\\/]+$/, "");
   const folded = process.platform === "win32" || process.platform === "darwin" ? real.toLowerCase() : real;
-  return createHash6("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
+  return createHash7("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join33(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join36(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function latestRunPath(servedBy, directory = runtimeDirectory()) {
-  return join33(directory, "runs", `latest-${projectKey(servedBy)}.json`);
+  return join36(directory, "runs", `latest-${projectKey(servedBy)}.json`);
 }
 function writeLatestRun(servedBy, latest) {
   try {
-    mkdirSync16(runsDirectory(), { recursive: true });
+    mkdirSync19(runsDirectory(), { recursive: true });
     writeWhole(latestRunPath(servedBy), JSON.stringify(latest, null, 2));
   } catch {}
 }
 function readLatestRun(servedBy, directory = runtimeDirectory()) {
   try {
-    const fields = JSON.parse(readFileSync26(latestRunPath(servedBy, directory), "utf8"));
+    const fields = JSON.parse(readFileSync30(latestRunPath(servedBy, directory), "utf8"));
     if (typeof fields !== "object" || fields === null) {
       return null;
     }
@@ -44614,24 +44717,24 @@ function readLatestRun(servedBy, directory = runtimeDirectory()) {
   }
 }
 function openTranscript(startedAt) {
-  mkdirSync16(runsDirectory(), { recursive: true });
-  const path = join33(runsDirectory(), `run-${startedAt}.log`);
-  return { path, fd: openSync3(path, "a") };
+  mkdirSync19(runsDirectory(), { recursive: true });
+  const path = join36(runsDirectory(), `run-${startedAt}.log`);
+  return { path, fd: openSync5(path, "a") };
 }
 function profilePath(startedAt) {
-  return join33(runsDirectory(), `run-${startedAt}.profile.json`);
+  return join36(runsDirectory(), `run-${startedAt}.profile.json`);
 }
 function profileMarkPath(startedAt) {
-  return join33(runsDirectory(), `run-${startedAt}.profile-mark.json`);
+  return join36(runsDirectory(), `run-${startedAt}.profile-mark.json`);
 }
 function noteIsAbout(note, playing) {
   return note.play !== undefined && playing !== null && note.play.play === playing.play && note.play.editorPid === playing.editorPid;
 }
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join33(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join36(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
-  mkdirSync16(runsDirectory(), { recursive: true });
+  mkdirSync19(runsDirectory(), { recursive: true });
   const path = editorNotePath(note.projectPath);
   if (!writeWhole(path, JSON.stringify(note, null, 2))) {
     throw new Error(`the editor run note could not be written at ${path}`);
@@ -44649,7 +44752,7 @@ function readEditorRunNote(projectPath) {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync26(path, "utf8"));
+    parsed = JSON.parse(readFileSync30(path, "utf8"));
   } catch {
     return null;
   }
@@ -44681,13 +44784,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync14(join33(directory, "runs"));
+      entries = readdirSync16(join36(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join33(directory, "runs", entry));
+        const record = recordAt(join36(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -44699,7 +44802,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync26(path, "utf8"));
+    parsed = JSON.parse(readFileSync30(path, "utf8"));
   } catch {
     return null;
   }
@@ -44758,7 +44861,7 @@ async function runningAs(pid) {
     const began = await startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync26(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync30(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = (await runHidden("ps", ["-p", String(pid), "-o", "args="], { timeout: 15000 })).stdout.trim();
@@ -44896,13 +44999,13 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
     try {
-      rmSync14(runRecordPath(projectPath, directory), { force: true });
+      rmSync16(runRecordPath(projectPath, directory), { force: true });
     } catch {}
   }
 }
 function ageMs(path, now) {
   try {
-    return now - statSync14(path).mtimeMs;
+    return now - statSync17(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -44916,7 +45019,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
   ]));
   let entries;
   try {
-    entries = readdirSync14(directory);
+    entries = readdirSync16(directory);
   } catch {
     return;
   }
@@ -44925,12 +45028,12 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!transcript && !entry.endsWith(".partial")) {
       continue;
     }
-    const path = join33(directory, entry);
+    const path = join36(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
     try {
-      rmSync14(path);
+      rmSync16(path);
     } catch {}
   }
 }
@@ -44946,10 +45049,10 @@ var init_run_record = __esm(() => {
 });
 
 // src/script-profile.ts
-import { readFileSync as readFileSync27 } from "node:fs";
+import { readFileSync as readFileSync31 } from "node:fs";
 function readProfileFile(path) {
   try {
-    const parsed = JSON.parse(readFileSync27(path, "utf8"));
+    const parsed = JSON.parse(readFileSync31(path, "utf8"));
     return typeof parsed === "object" && typeof parsed.connected === "boolean" ? parsed : null;
   } catch {
     return null;
@@ -45006,7 +45109,7 @@ function writeProfileMark(path, mark) {
 }
 function readProfileMark(path) {
   try {
-    const parsed = JSON.parse(readFileSync27(path, "utf8"));
+    const parsed = JSON.parse(readFileSync31(path, "utf8"));
     return typeof parsed === "object" && typeof parsed.totals === "object" ? parsed : null;
   } catch {
     return null;
@@ -45173,16 +45276,16 @@ var init_server_instructions = __esm(() => {
 });
 
 // src/test-selection.ts
-import { existsSync as existsSync26, readFileSync as readFileSync28 } from "node:fs";
-import { basename as basename11, join as join34 } from "node:path";
+import { existsSync as existsSync29, readFileSync as readFileSync32 } from "node:fs";
+import { basename as basename11, join as join37 } from "node:path";
 function casesIn(projectPath, suite) {
-  const text = readFileSync28(join34(projectPath, suite.slice("res://".length)), "utf8");
+  const text = readFileSync32(join37(projectPath, suite.slice("res://".length)), "utf8");
   return [...text.matchAll(/^func\s+(test_\w*)\s*\(/gm)].map((match) => match[1] ?? "");
 }
 function suitesUnder(projectPath, asked) {
   const scripts = projectFiles(projectPath, [".gd"]).map((path) => `res://${path}`);
   return [
-    ...new Set(asked.flatMap((path) => path.endsWith(".gd") ? existsSync26(join34(projectPath, path.slice("res://".length))) ? [path] : [] : scripts.filter((script) => script.startsWith(`${path}/`))))
+    ...new Set(asked.flatMap((path) => path.endsWith(".gd") ? existsSync29(join37(projectPath, path.slice("res://".length))) ? [path] : [] : scripts.filter((script) => script.startsWith(`${path}/`))))
   ];
 }
 function selectTests(projectPath, asked, given) {
@@ -45240,22 +45343,22 @@ var init_test_selection = __esm(() => {
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   appendFileSync as appendFileSync2,
-  closeSync as closeSync3,
+  closeSync as closeSync5,
   constants,
   copyFileSync,
-  existsSync as existsSync27,
-  fstatSync,
-  mkdirSync as mkdirSync17,
-  openSync as openSync4,
-  readdirSync as readdirSync15,
-  readFileSync as readFileSync29,
-  readSync as readSync2,
+  existsSync as existsSync30,
+  fstatSync as fstatSync2,
+  mkdirSync as mkdirSync20,
+  openSync as openSync6,
+  readdirSync as readdirSync17,
+  readFileSync as readFileSync33,
+  readSync as readSync3,
   rmdirSync as rmdirSync2,
-  statSync as statSync15,
-  writeFileSync as writeFileSync18
+  statSync as statSync18,
+  writeFileSync as writeFileSync19
 } from "node:fs";
-import { basename as basename12, dirname as dirname23, extname as extname4, isAbsolute as isAbsolute5, join as join35, normalize as normalize2, relative as relative6 } from "node:path";
-import { setTimeout as delay5 } from "node:timers/promises";
+import { basename as basename12, dirname as dirname24, extname as extname4, isAbsolute as isAbsolute6, join as join38, normalize as normalize2, relative as relative7 } from "node:path";
+import { setTimeout as delay7 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function editorRestartTimeoutMs() {
   return waitFromEnv("GDHARNESS_EDITOR_RESTART_TIMEOUT_MS", 90000);
@@ -45284,22 +45387,22 @@ function writtenFileRefusal(path, rule) {
   if (/^(res|user):\/\//.test(path)) {
     return `${named} ${path} is a Godot path; ${what} is saved outside the project, at an absolute path on this machine.`;
   }
-  if (!isAbsolute5(path)) {
+  if (!isAbsolute6(path)) {
     return `${named} ${path} is not absolute; name the whole path, so where it is written does not depend on this server's directory.`;
   }
   if (!rule.extensions.includes(extname4(path).toLowerCase())) {
     return `${named} ${path} does not end in ${rule.extensions.join(" or ")}, which is what ${what} is.`;
   }
-  const directory = realAsFarAsItExists(dirname23(path));
-  if (!existsSync27(directory)) {
-    return `${named}'s directory ${dirname23(path)} does not exist; ${what} creates no directories.`;
+  const directory = realAsFarAsItExists(dirname24(path));
+  if (!existsSync30(directory)) {
+    return `${named}'s directory ${dirname24(path)} does not exist; ${what} creates no directories.`;
   }
-  const where = join35(directory, basename12(path));
+  const where = join38(directory, basename12(path));
   const inside = rule.projects.find((project) => project !== "" && isWithinRoot(realAsFarAsItExists(project), where));
   if (inside !== undefined) {
     return `${named} ${path} is inside the project at ${inside}; ${what} is saved outside it, so it never becomes part of the game.`;
   }
-  const taken = rule.writes(where).find((file) => existsSync27(file));
+  const taken = rule.writes(where).find((file) => existsSync30(file));
   if (taken !== undefined) {
     return taken === where ? `${named} ${path} already exists; ${what} is not written over a file. Name a new one.` : `${named} ${path} would write ${taken}, which already exists; ${what} is not written over a file. Name a new one.`;
   }
@@ -45385,7 +45488,7 @@ function keptGameRequest(tool, op, args) {
   }
 }
 function projectSpelling(projectPath, absolutePath) {
-  return `res://${relative6(realAsFarAsItExists(projectPath), realAsFarAsItExists(absolutePath)).replaceAll("\\", "/")}`;
+  return `res://${relative7(realAsFarAsItExists(projectPath), realAsFarAsItExists(absolutePath)).replaceAll("\\", "/")}`;
 }
 function whichGame(args) {
   return { projectPath: args["projectPath"], pid: args["pid"] };
@@ -45473,7 +45576,7 @@ async function untilGone(pids, withinMs = stopWaitMs()) {
   const gone = () => pids.every((pid) => !alive(pid));
   const deadline = Date.now() + withinMs;
   while (!gone() && Date.now() < deadline) {
-    await delay5(50);
+    await delay7(50);
   }
   return gone();
 }
@@ -45684,7 +45787,7 @@ function endedToStartThis(ended) {
   return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.`;
 }
 function lineBeyondScript(absolutePath, relativePath, line) {
-  const text = readFileSync29(absolutePath, "utf8");
+  const text = readFileSync33(absolutePath, "utf8");
   const lines = text === "" ? 0 : text.split(`
 `).length - (text.endsWith(`
 `) ? 1 : 0);
@@ -45884,7 +45987,7 @@ function notRunNote(notRun, failFast) {
 function exportPresetRefusal(projectPath, preset) {
   let text;
   try {
-    text = readFileSync29(join35(projectPath, "export_presets.cfg"), "utf8");
+    text = readFileSync33(join38(projectPath, "export_presets.cfg"), "utf8");
   } catch {
     return `This project has no export_presets.cfg, so it has no preset '${preset}' to export with. project_export add_preset writes one, as the editor's Project > Export does.`;
   }
@@ -45948,9 +46051,9 @@ function writtenBeside(before, after, output, within) {
 function filesIn(folder) {
   const found = new Map;
   try {
-    for (const entry of readdirSync15(folder, { withFileTypes: true })) {
+    for (const entry of readdirSync17(folder, { withFileTypes: true })) {
       if (entry.isFile()) {
-        found.set(entry.name, statSync15(join35(folder, entry.name)).mtimeMs);
+        found.set(entry.name, statSync18(join38(folder, entry.name)).mtimeMs);
       }
     }
   } catch {}
@@ -45982,7 +46085,7 @@ function unsavedInEditorNote(scripts) {
   return `${named} ${one ? "is" : "are"} open in the editor's script ${one ? "tab" : "tabs"} with unsaved edits, and saving ${one ? "that tab" : "them"} there writes ${one ? "its" : "their"} text over what was written here: close ${one ? "it" : "them"} without saving, or save first and edit again.`;
 }
 function editorAddonMissing(projectPath) {
-  if (!existsSync27(join35(projectPath, "project.godot"))) {
+  if (!existsSync30(join38(projectPath, "project.godot"))) {
     return null;
   }
   const report = inspectProject(projectPath);
@@ -46247,7 +46350,7 @@ function profileFrameFunctions(projectPath) {
   let projectGodot = null;
   if (projectPath !== null) {
     try {
-      projectGodot = readFileSync29(join35(projectPath, "project.godot"), "utf8");
+      projectGodot = readFileSync33(join38(projectPath, "project.godot"), "utf8");
     } catch {}
   }
   return frameFunctionsFor(queuedMessagesOf(projectGodot));
@@ -46271,7 +46374,7 @@ function projectSourceOf(projectPath) {
       let source = null;
       if (inside.ok) {
         try {
-          source = readFileSync29(inside.absolutePath, "utf8");
+          source = readFileSync33(inside.absolutePath, "utf8");
         } catch {}
       }
       read.set(script, source);
@@ -46426,7 +46529,7 @@ function foldedEntriesAnswer(log, floor = "warning") {
 }
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync29(join35(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync33(join38(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -46441,13 +46544,13 @@ function uncaughtNote(uncaught) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync27(join35(projectPath, wanted))) {
+  if (wanted === "" || existsSync30(join38(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
   let near = [];
   try {
-    near = readdirSync15(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
+    near = readdirSync17(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
   } catch {
     return "";
   }
@@ -46538,23 +46641,23 @@ function engineChecked(why) {
 }
 function isDirectory(path) {
   try {
-    return statSync15(path).isDirectory();
+    return statSync18(path).isDirectory();
   } catch {
     return false;
   }
 }
 function scriptsUnder(directory, prefix) {
-  if (existsSync27(join35(directory, ".gdignore"))) {
+  if (existsSync30(join38(directory, ".gdignore"))) {
     return [];
   }
   const found = [];
-  for (const entry of readdirSync15(directory, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
+  for (const entry of readdirSync17(directory, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
     if (entry.name.startsWith(".")) {
       continue;
     }
     const path = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
     if (entry.isDirectory()) {
-      found.push(...scriptsUnder(join35(directory, entry.name), path));
+      found.push(...scriptsUnder(join38(directory, entry.name), path));
     } else if (entry.isFile() && entry.name.endsWith(".gd")) {
       found.push(path);
     }
@@ -46562,11 +46665,11 @@ function scriptsUnder(directory, prefix) {
   return found;
 }
 function mainSceneOf(projectFile) {
-  const scene = parseProjectGodot(readFileSync29(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync33(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "" ? scene : null;
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync29(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync33(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function ownArguments(params) {
@@ -46584,7 +46687,8 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   stdio = null;
   locator = new GodotLocator;
-  operationsScript = join35(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join38(__dirname2, "godot", "operations", "godot_operations.gd");
+  listedRunner = shippedListedRunner();
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -46715,7 +46819,7 @@ class GodotServer {
         taken = true;
         this.logDebug(`Took port ${wanted} over from pid ${announced.pid}`);
       } catch {
-        await delay5(HANDOVER_POLL_MS);
+        await delay7(HANDOVER_POLL_MS);
       }
     }
     this.notHandedOverBy = taken ? null : announced.pid;
@@ -46846,14 +46950,14 @@ class GodotServer {
   }
   noteTheStart() {
     const cwd = process.cwd();
-    const mcpJson = join35(cwd, ".mcp.json");
+    const mcpJson = join38(cwd, ".mcp.json");
     const announced = this.ownProject === null ? null : readAnnouncement(announcementPath(this.ownProject));
     const predecessor = announced !== null && announced.pid !== process.pid && alive(announced.pid) ? announced.pid : null;
     writeLifecycle("started", {
       argv: process.argv.slice(1),
       cwd,
       project: this.ownProject,
-      mcpJson: existsSync27(mcpJson) ? mcpJson : null
+      mcpJson: existsSync30(mcpJson) ? mcpJson : null
     });
     if (predecessor !== null) {
       writeLifecycle("replaced", { project: this.ownProject, predecessor });
@@ -46994,7 +47098,7 @@ class GodotServer {
         return checked.response;
       }
       const named = args["projectPath"];
-      if (typeof named === "string" && existsSync27(join35(named, "project.godot"))) {
+      if (typeof named === "string" && existsSync30(join38(named, "project.godot"))) {
         this.lastProjectPath = named;
       }
       this.updates.refresh();
@@ -47030,8 +47134,8 @@ class GodotServer {
     let notSaved;
     try {
       savedAt = answer.content.map((item, index) => {
-        const file = join35(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
-        writeFileSync18(file, item.type === "text" ? item.text : Buffer.from(item.data, "base64"));
+        const file = join38(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
+        writeFileSync19(file, item.type === "text" ? item.text : Buffer.from(item.data, "base64"));
         return file;
       });
     } catch (error) {
@@ -47449,6 +47553,9 @@ class GodotServer {
         if (op === "close") {
           return await this.handleCloseEditor();
         }
+        if (op === "rebind") {
+          return await this.handleRebindEditorServers();
+        }
         return op === "restart" ? await this.handleRestartEditor(args) : await this.handleLaunchEditor(args);
       case "editor_run":
         if (op === "stop") {
@@ -47594,7 +47701,7 @@ class GodotServer {
           return this.createErrorResponse("line is required: the one-based line to stop on.");
         }
         if (op === "set") {
-          if (!existsSync27(located.absolutePath)) {
+          if (!existsSync30(located.absolutePath)) {
             return this.missingScript(project.value.path, located.relativePath);
           }
           const beyond = lineBeyondScript(located.absolutePath, located.relativePath, line);
@@ -47687,8 +47794,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join35(path, "project.godot");
-    if (!existsSync27(file)) {
+    const file = join38(path, "project.godot");
+    if (!existsSync30(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -47708,7 +47815,7 @@ class GodotServer {
   }
   runEnvironment(args) {
     const savesIn = readNonEmptyString(args, "savesIn");
-    if (savesIn !== undefined && !isAbsolute5(savesIn)) {
+    if (savesIn !== undefined && !isAbsolute6(savesIn)) {
       return {
         ok: false,
         response: this.createErrorResponse(`savesIn must be an absolute path, not "${savesIn}".`, [
@@ -48389,7 +48496,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync29(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync33(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -48500,18 +48607,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname23(output.absolutePath);
+    const folder = dirname24(output.absolutePath);
     try {
-      mkdirSync17(folder, { recursive: true });
+      mkdirSync20(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname23(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname24(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
     const exportLogs = scratchDirectory("export");
     const exportArgs = [
       "--headless",
       "--log-file",
-      join35(exportLogs, "engine.log"),
+      join38(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -48519,7 +48626,7 @@ class GodotServer {
       output.absolutePath
     ];
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
-    const writtenAt = () => existsSync27(output.absolutePath) ? statSync15(output.absolutePath).mtimeMs : null;
+    const writtenAt = () => existsSync30(output.absolutePath) ? statSync18(output.absolutePath).mtimeMs : null;
     const caches = editorCacheDirectory(engine.value);
     const exportOnce = async () => {
       const before = writtenAt();
@@ -48548,7 +48655,7 @@ class GodotServer {
     if (ending.exitSignal === null && ending.exitCode === null) {
       return this.createErrorResponse(`Export could not be run: ${ending.failure ?? "the engine gave no exit status"}`);
     }
-    const beside = writtenBeside(listedBefore, filesIn(folder), basename12(output.absolutePath), dirname23(output.relativePath).replaceAll("\\", "/"));
+    const beside = writtenBeside(listedBefore, filesIn(folder), basename12(output.absolutePath), dirname24(output.relativePath).replaceAll("\\", "/"));
     return exportAnswer(ending, { preset, outputPath: output.relativePath, debug }, before, writtenAt(), beside, docCacheNote);
   }
   reportTestProgress(log) {
@@ -48602,13 +48709,12 @@ class GodotServer {
     if (movie !== null) {
       return this.createErrorResponse(movie);
     }
-    const missing = paths.value.filter((path) => !existsSync27(join35(project.value.path, path.slice("res://".length))));
+    const missing = paths.value.filter((path) => !existsSync30(join38(project.value.path, path.slice("res://".length))));
     const asked = paths.value.filter((path) => !missing.includes(path));
-    const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    const noRunner = !existsSync27(join35(project.value.path, runner));
+    const unusable = gdUnit4Unusable(project.value.path);
     if (asked.length === 0) {
       const verdict = `nothing at ${missing.join(" and ")}`;
-      const andNoRunner = noRunner ? `, and gdUnit4 is not installed in this project: no ${runner}` : "";
+      const andNoRunner = unusable === null ? "" : `, and ${unusable.reason}`;
       return {
         content: [
           {
@@ -48621,16 +48727,16 @@ class GodotServer {
               passed: false,
               verdict,
               tests: 0,
-              ...noRunner ? { gdUnit4Installed: false } : {}
+              ...unusable?.missing === true ? { gdUnit4Installed: false } : {}
             })
           }
         ],
         isError: true
       };
     }
-    if (noRunner) {
-      return this.createErrorResponse(`gdUnit4 is not installed in this project: no ${runner}.`, [
-        "Install gdUnit4 under addons/gdUnit4, from https://github.com/godot-gdunit-labs/gdUnit4"
+    if (unusable !== null) {
+      return this.createErrorResponse(`${unusable.reason}.`, [
+        `${unusable.missing ? "Install" : "Update"} gdUnit4 under addons/gdUnit4, from https://github.com/godot-gdunit-labs/gdUnit4`
       ]);
     }
     const selection = selectTests(project.value.path, asked, args["tests"]);
@@ -48658,25 +48764,37 @@ class GodotServer {
     const ours = `gdharness-reports/${randomUUID2()}`;
     const reports = `res://.godot/${ours}`;
     const ignored = readStringArray(args, "ignore") ?? [];
+    const userData = scratchDirectory("tests");
+    const suitesFile = join38(userData, "suites.txt");
+    const skippingFile = join38(userData, "skipping.txt");
+    writeFileSync19(suitesFile, `${(selection.value?.suites ?? asked).join(`
+`)}
+`);
+    writeFileSync19(skippingFile, `${[...ignored, ...selection.value?.ignore ?? []].join(`
+`)}
+`);
     const cmdArgs = [
       "--headless",
       "--path",
       project.value.path,
       ...flags.value,
       "-s",
-      `res://${runner}`,
+      this.listedRunner,
       "--ignoreHeadlessMode",
       ...readBoolean(args, "failFast") === true ? [] : ["-c"],
-      ...(selection.value?.suites ?? asked).flatMap((path) => ["-a", path]),
-      ...[...ignored, ...selection.value?.ignore ?? []].flatMap((entry) => ["-i", entry]),
       "-rd",
       reports,
       "-rc",
-      "1"
+      "1",
+      "--",
+      "--suites-in",
+      suitesFile,
+      "--skipping-in",
+      skippingFile,
+      "--html-report-off"
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = scratchDirectory("tests");
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const console2 = [];
     let lastSaid = Date.now();
@@ -48725,21 +48843,21 @@ class GodotServer {
     await run.settled;
     const tookMs = Date.now() - began;
     const notCompiled = stopped.for ?? run.log.all.map((entry) => autoloadNotCompiled(entry, autoloaded)).find((found) => found !== null) ?? null;
-    const reportsDir = join35(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join38(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync27(reportsDir) && notCompiled === null ? readdirSync15(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync30(reportsDir) && notCompiled === null ? readdirSync17(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync29(join35(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync33(join38(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
       discard(reportsDir, userData);
       try {
-        rmdirSync2(dirname23(reportsDir));
+        rmdirSync2(dirname24(reportsDir));
       } catch {}
     }
     const engineEntries = foldedRepeats(run.log.select({
@@ -48938,7 +49056,7 @@ class GodotServer {
         if (!location.ok) {
           return this.createErrorResponse(location.reason, PATH_SOLUTIONS);
         }
-        if (!existsSync27(location.absolutePath)) {
+        if (!existsSync30(location.absolutePath)) {
           return this.missingScript(project.value.path, location.relativePath);
         }
       }
@@ -49120,11 +49238,11 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const sourceOf = (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync27(contained.absolutePath)) {
+      if (!contained.ok || !existsSync30(contained.absolutePath)) {
         return null;
       }
       try {
-        return readFileSync29(contained.absolutePath, "utf8");
+        return readFileSync33(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -49214,11 +49332,11 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync27(contained.absolutePath)) {
+    if (!contained.ok || !existsSync30(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync29(contained.absolutePath, "utf8");
+      return readFileSync33(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -49375,7 +49493,7 @@ class GodotServer {
       ...Array.isArray(stack) ? {
         stack: stack.map((frame) => ({
           ...frame,
-          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join35(projectPath, frame["script"].slice("res://".length)) } : {}
+          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join38(projectPath, frame["script"].slice("res://".length)) } : {}
         }))
       } : {}
     });
@@ -49499,7 +49617,7 @@ class GodotServer {
     try {
       const askedAt = Date.now();
       const asked = this.godotBridge.invokeTool("playing_status", {}, { counted: false });
-      const answer = await Promise.race([asked, delay5(PLAYING_STATUS_MS).then(() => null)]);
+      const answer = await Promise.race([asked, delay7(PLAYING_STATUS_MS).then(() => null)]);
       if (answer === null) {
         this.logDebug(`playing_status did not answer within ${PLAYING_STATUS_MS}ms`);
         asked.then(() => {
@@ -49524,7 +49642,7 @@ class GodotServer {
     try {
       const answer = await Promise.race([
         this.godotBridge.invokeTool("scan_status", {}, { counted: false }),
-        delay5(PLAYING_STATUS_MS).then(() => null)
+        delay7(PLAYING_STATUS_MS).then(() => null)
       ]);
       if (answer === null) {
         return null;
@@ -49643,18 +49761,63 @@ class GodotServer {
     const deadline = Date.now() + EDITOR_SERVERS_START_MS;
     for (;; ) {
       const answer = await this.editorServersListening();
-      if (answer.serversNote === undefined || Date.now() >= deadline) {
+      const adapterFailed = answer.lspListening === true && answer.dapListening === false;
+      if (answer.serversNote === undefined || adapterFailed || Date.now() >= deadline) {
         return answer;
       }
-      await delay5(500);
+      await delay7(500);
     }
   }
+  async rebindTheDebugAdapter(servers) {
+    if (servers.dapListening !== false && servers.lspListening !== false) {
+      return { servers, report: {} };
+    }
+    const { rebound, said } = await this.editorServersSaid(servers.dapListening === false);
+    const after = rebound ? await this.editorServersListening() : servers;
+    return {
+      servers: after,
+      report: {
+        ...said.length === 0 ? {} : { serversSaid: said },
+        ...rebound ? { debugAdapterRebound: after.dapListening === true } : {}
+      }
+    };
+  }
+  async editorServersSaid(rebind) {
+    let answer = {};
+    try {
+      answer = asParams(await this.godotBridge.invokeTool("editor_servers", { rebind }, { counted: false }));
+    } catch (error) {
+      this.logDebug(`editor_servers did not answer: ${errorMessage(error)}`);
+    }
+    return {
+      rebound: readBoolean(answer, "rebound") === true,
+      said: [...readStringArray(answer, "said") ?? [], ...readStringArray(answer, "saidSince") ?? []]
+    };
+  }
+  async handleRebindEditorServers() {
+    if (!this.godotBridge.getStatus().connected) {
+      return this.createErrorResponse("No editor is connected, so there is no debug adapter to bind.", [
+        "editor_launch opens one on a project",
+        "editor_status says whether the bridge is up and what has reached it"
+      ]);
+    }
+    const { rebound, said } = await this.editorServersSaid(true);
+    if (!rebound) {
+      return this.createErrorResponse("The editor has no debug adapter to bind again: no DebugAdapterServer is in its tree.", ["editor_status says what the editor serves"]);
+    }
+    const servers = await this.editorServersListening();
+    return this.jsonTextResponse({
+      rebound: true,
+      ...servers,
+      ...said.length === 0 ? {} : { serversSaid: said }
+    });
+  }
   settingKeysOf(projectPath) {
     if (projectPath === undefined) {
       return null;
     }
     try {
-      return settingKeys(readFileSync29(join35(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync33(join38(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -49692,7 +49855,7 @@ class GodotServer {
         "editor_status says whether anything has reached the bridge since"
       ]);
     }
-    const servers = await this.editorServersOnceStarted();
+    const { servers, report: rebinding } = await this.rebindTheDebugAdapter(await this.editorServersOnceStarted());
     const now = this.godotBridge.getStatus();
     const after = this.settingKeysOf(before.projectPath);
     return this.jsonTextResponse({
@@ -49704,6 +49867,7 @@ class GodotServer {
       staleNote: this.godotBridge.anotherRelease(),
       ...this.whatTheEditorDropped(settingsBefore, after),
       ...servers,
+      ...rebinding,
       ...mine && this.launchedEditor !== null ? { arguments: this.launchedEditor.arguments } : {},
       tookMs: Date.now() - began
     });
@@ -49837,7 +50001,7 @@ class GodotServer {
       if (Date.now() >= deadline) {
         return false;
       }
-      await delay5(250);
+      await delay7(250);
     }
   }
   async handleLaunchEditor(args) {
@@ -50096,7 +50260,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync27(join35(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync30(join38(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, {
         addon: false,
         budgetMs,
@@ -50184,7 +50348,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync15(endpoint.file).mtimeMs;
+      announcedAt = statSync18(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -50204,7 +50368,7 @@ class GodotServer {
     } catch (error) {
       return this.createErrorResponse(`The editor is connected but its debug adapter is not: ${errorMessage(error)}`, [
         `This asked on port ${this.dap().port}, which is where the connected editor says it serves`,
-        "Godot binds its debug adapter once, as the editor starts, and reports a failure only in the editor's own log panel: editor_launch restart binds it again",
+        "Godot binds its debug adapter once, as the editor starts, and reports a failure only in the editor's own log panel: editor_launch rebind binds it again in place",
         "GDHARNESS_DAP_PORT points this server at another one"
       ]);
     }
@@ -50234,7 +50398,7 @@ class GodotServer {
     }
     const startedAt = Date.now();
     const transcript = openTranscript(startedAt);
-    closeSync3(transcript.fd);
+    closeSync5(transcript.fd);
     const playAnswer = asParams(JSON.parse(answer.content[0]?.text ?? "{}"));
     const which = playOf(playAnswer);
     const played = {
@@ -50324,18 +50488,18 @@ class GodotServer {
     }
     let handle;
     try {
-      handle = openSync4(game.errorReport, "r");
+      handle = openSync6(game.errorReport, "r");
     } catch {
       return;
     }
     try {
       const from = game.errorReportOffset ?? 0;
-      const size = fstatSync(handle).size;
+      const size = fstatSync2(handle).size;
       if (size <= from) {
         return;
       }
       const buffer = Buffer.alloc(size - from);
-      const read = readSync2(handle, buffer, 0, buffer.length, from);
+      const read = readSync3(handle, buffer, 0, buffer.length, from);
       let reported = buffer.subarray(0, read);
       if (game.consoleFromReport !== true) {
         const boundary = consoleBoundaryAt(reported);
@@ -50358,7 +50522,7 @@ class GodotServer {
         game.log.append("stderr", reported);
       }
     } finally {
-      closeSync3(handle);
+      closeSync5(handle);
     }
   }
   announcedPidNamedBy(run, line) {
@@ -50378,7 +50542,7 @@ class GodotServer {
       return 0;
     }
     try {
-      return reportAlreadyInTranscript(readFileSync29(game.transcript), readFileSync29(report));
+      return reportAlreadyInTranscript(readFileSync33(game.transcript), readFileSync33(report));
     } catch (error) {
       this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
       return 0;
@@ -50401,7 +50565,7 @@ class GodotServer {
       if (Date.now() >= deadline) {
         return false;
       }
-      await delay5(100);
+      await delay7(100);
     }
   }
   async endActiveGame(reason, going, graceful) {
@@ -50627,7 +50791,7 @@ class GodotServer {
   async launchKeptGame(godotPath, cmdArgs, projectPath, env, desktop, profiled = false, debugged = true) {
     const startedAt = Date.now();
     const transcript = openTranscript(startedAt);
-    closeSync3(transcript.fd);
+    closeSync5(transcript.fd);
     const gameEnv = profiled ? { ...env ?? process.env, [PROFILE_FROM_START]: "1" } : env;
     const profile = profiled ? profilePath(startedAt) : undefined;
     const launched = await launchOutsideTheTree({
@@ -50675,21 +50839,21 @@ class GodotServer {
     }
     let handle;
     try {
-      handle = openSync4(game.transcript, "r");
+      handle = openSync6(game.transcript, "r");
     } catch {
       return;
     }
     try {
-      const size = fstatSync(handle).size;
+      const size = fstatSync2(handle).size;
       if (size <= game.readOffset) {
         return;
       }
       const buffer = Buffer.alloc(size - game.readOffset);
-      const read = readSync2(handle, buffer, 0, buffer.length, game.readOffset);
+      const read = readSync3(handle, buffer, 0, buffer.length, game.readOffset);
       game.readOffset += read;
       game.log.append("transcript", buffer.subarray(0, read));
     } finally {
-      closeSync3(handle);
+      closeSync5(handle);
     }
   }
   async pickUpWhatTheEditorIsPlaying() {
@@ -51073,7 +51237,7 @@ class GodotServer {
     };
     const going = await this.runStillGoing(run);
     const projectPath = run.projectPath;
-    const projectGone = projectPath !== null && !existsSync27(join35(projectPath, "project.godot"));
+    const projectGone = projectPath !== null && !existsSync30(join38(projectPath, "project.godot"));
     if (projectGone && callersName !== undefined) {
       return this.createErrorResponse(`callersOf reads the project's scripts, and the run's project at ${projectPath} has no project.godot any more.`, ["editor_run profile without callersOf answers with the profile itself"]);
     }
@@ -51231,7 +51395,7 @@ class GodotServer {
           return true;
         }
       }
-      await delay5(100);
+      await delay7(100);
     }
     return false;
   }
@@ -51251,7 +51415,7 @@ class GodotServer {
     while (cancelled?.aborted !== true && await this.runStillGoing(run) && Date.now() < until) {
       this.drainEditorOutput(run);
       this.drainTranscript(run);
-      await delay5(RUN_POLL_MS);
+      await delay7(RUN_POLL_MS);
     }
     return await this.handleGetDebugOutput(args, await this.runStillGoing(run) ? budgetMs : undefined);
   }
@@ -51293,7 +51457,7 @@ class GodotServer {
       if (Date.now() >= until) {
         return false;
       }
-      await delay5(50);
+      await delay7(50);
     }
   }
   async handleEditorConsole(args) {
@@ -51420,7 +51584,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync27(join35(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync30(join38(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -52049,7 +52213,7 @@ class GodotServer {
     if (!scriptPath.ok) {
       return this.createErrorResponse(scriptPath.reason);
     }
-    if (!existsSync27(scriptPath.absolutePath)) {
+    if (!existsSync30(scriptPath.absolutePath)) {
       return this.missingScript(projectPath, scriptPath.relativePath);
     }
     const asked = readNonEmptyString(args, "newScriptPath");
@@ -52463,7 +52627,7 @@ class GodotServer {
     }
     const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const declared = new RegExp(`^\\s*(?:@\\w+(?:\\([^)]*\\))?\\s+)*class_name\\s+${escaped}\\b`, "m");
-    if (declared.test(readFileSync29(scriptPath, "utf8"))) {
+    if (declared.test(readFileSync33(scriptPath, "utf8"))) {
       return null;
     }
     const checked = await this.classesTheEditorCannotSee(args);
@@ -52629,7 +52793,7 @@ class GodotServer {
   async ownRunOnItsWay(projectPath, budgetMs) {
     const run = await this.currentRun();
     const project = projectPath ?? run?.projectPath ?? null;
-    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync27(join35(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync30(join38(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -52638,7 +52802,7 @@ class GodotServer {
         return !run.announcedBefore.has(one.pid);
       }
       try {
-        return statSync15(one.file).mtimeMs >= run.startedAt;
+        return statSync18(one.file).mtimeMs >= run.startedAt;
       } catch {
         return false;
       }
@@ -52723,7 +52887,7 @@ class GodotServer {
       return this.createErrorResponse(staleNote);
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join35(screenshotDir, "capture.png") : null;
+    const screenshotPath = screenshotDir ? join38(screenshotDir, "capture.png") : null;
     const refused = (message) => this.createErrorResponse(message);
     const onGame = {
       pid: choice.endpoint.pid,
@@ -52784,7 +52948,7 @@ class GodotServer {
 
 Ran alongside ${ranWith.join(", ")}. ${ALONGSIDE_NOTE}`}`
           },
-          { type: "image", data: readFileSync29(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync33(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -52963,7 +53127,7 @@ var init_server = __esm(() => {
   init_tool_definitions();
   init_tool_reference();
   init_update_check();
-  __dirname2 = dirname23(fileURLToPath5(import.meta.url));
+  __dirname2 = dirname24(fileURLToPath5(import.meta.url));
   KEEPER_DEBUG_MS = PAUSE_MS + STEP_MS + 2 * READ_MS;
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
@@ -53023,16 +53187,45 @@ var init_server = __esm(() => {
 
 // src/cli.ts
 init_bridge_announce();
+import { existsSync as existsSync31 } from "node:fs";
+import { join as join39, resolve as resolve9 } from "node:path";
+
+// 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/cli.ts
 init_errors();
 init_godot_path();
-import { existsSync as existsSync28 } from "node:fs";
-import { join as join36, resolve as resolve8 } from "node:path";
 
 // src/harnesses.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { basename as basename3, dirname as dirname4, join as join5, relative as relative2, resolve as resolve2 } from "node:path";
-import process4 from "node:process";
+import process5 from "node:process";
 
 // node_modules/yaml/dist/index.js
 var composer = require_composer();
@@ -53601,12 +53794,12 @@ var HARNESSES = [
   }
 ];
 function appDataRoot() {
-  return process4.env["APPDATA"] ?? join5(homedir2(), "AppData", "Roaming");
+  return process5.env["APPDATA"] ?? join5(homedir2(), "AppData", "Roaming");
 }
 function homePath(path) {
   return typeof path === "string" ? join5(homedir2(), path) : join5(appDataRoot(), path.appData);
 }
-function fileFor(harness, platform = process4.platform) {
+function fileFor(harness, platform = process5.platform) {
   if (typeof harness.file === "string") {
     return harness.file;
   }
@@ -53619,7 +53812,7 @@ function configPath(harness, projectPath) {
   }
   return homePath(file);
 }
-function displayPath(harness, platform = process4.platform) {
+function displayPath(harness, platform = process5.platform) {
   const file = fileFor(harness, platform);
   if (typeof file !== "string") {
     return `%APPDATA%/${file.appData.replaceAll("\\", "/")}`;
@@ -53961,10 +54154,10 @@ init_issues();
 init_paths();
 
 // src/prompt.ts
-import process9 from "node:process";
+import process10 from "node:process";
 import { createInterface } from "node:readline/promises";
 function interactive() {
-  return process9.stdin.isTTY && process9.stdout.isTTY;
+  return process10.stdin.isTTY && process10.stdout.isTTY;
 }
 
 class Ask {
@@ -53973,7 +54166,7 @@ class Ask {
     if (!interactive()) {
       return fallback;
     }
-    this.line ??= createInterface({ input: process9.stdin, output: process9.stdout });
+    this.line ??= createInterface({ input: process10.stdin, output: process10.stdout });
     const answer = (await this.line.question(`${question} ${fallback ? "[Y/n]" : "[y/N]"} `)).trim();
     return answer === "" ? fallback : answer.toLowerCase().startsWith("y");
   }
@@ -54287,19 +54480,832 @@ function writeSkill(directories, version) {
   });
 }
 
+// src/suite-run.ts
+init_alive();
+init_desktop();
+import {
+  closeSync as closeSync3,
+  existsSync as existsSync18,
+  fstatSync,
+  mkdirSync as mkdirSync8,
+  openSync as openSync3,
+  readdirSync as readdirSync11,
+  readFileSync as readFileSync17,
+  readSync,
+  rmSync as rmSync10,
+  statSync as statSync11,
+  writeFileSync as writeFileSync10
+} from "node:fs";
+import { availableParallelism, freemem } from "node:os";
+import { isAbsolute as isAbsolute4, join as join21, relative as relative3, resolve as resolve4, sep as sep2 } from "node:path";
+import process12 from "node:process";
+import { setTimeout as delay3 } from "node:timers/promises";
+
+// src/engine-slots.ts
+init_alive();
+init_process_children();
+import { closeSync as closeSync2, mkdirSync as mkdirSync6, openSync as openSync2, readFileSync as readFileSync13, rmSync as rmSync8, statSync as statSync9, writeSync as writeSync2 } from "node:fs";
+import { join as join18 } from "node:path";
+import process11 from "node:process";
+import { setTimeout as delay2 } from "node:timers/promises";
+var START_TOLERANCE_MS = 2000;
+var UNWRITTEN_MS = 1e4;
+var SLOT_WAIT_MS = 50;
+var START_READ_MS = 1e4;
+function holderOf(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const { pid, started } = parsed;
+    return typeof pid === "number" && Number.isInteger(pid) && pid > 0 && typeof started === "number" ? { pid, started } : null;
+  } catch {
+    return null;
+  }
+}
+function lockIsFree(content, writtenAt, now, isAlive, startOf) {
+  const holder = holderOf(content);
+  if (holder === null) {
+    return now - writtenAt > UNWRITTEN_MS;
+  }
+  if (!isAlive(holder.pid)) {
+    return true;
+  }
+  const started = startOf(holder.pid);
+  return started !== undefined && Math.abs(started - holder.started) > START_TOLERANCE_MS;
+}
+async function ownStart() {
+  const said = (await startTimesOf([process11.pid])).get(process11.pid);
+  return said ?? Math.round(Date.now() - process11.uptime() * 1000);
+}
+
+class EngineSlots {
+  starts = new Map;
+  held = new Set;
+  directory;
+  count;
+  holder;
+  constructor(directory, count, holder) {
+    this.directory = directory;
+    this.count = count;
+    this.holder = holder;
+  }
+  async take(signal) {
+    mkdirSync6(this.directory, { recursive: true });
+    for (;; ) {
+      signal?.throwIfAborted();
+      for (let slot = 0;slot < this.count; slot += 1) {
+        const lock = join18(this.directory, `${String(slot)}.lock`);
+        if (this.made(lock) || await this.takenOver(lock)) {
+          this.held.add(lock);
+          return lock;
+        }
+      }
+      await delay2(SLOT_WAIT_MS, undefined, signal === undefined ? {} : { signal });
+    }
+  }
+  releaseAll() {
+    for (const lock of this.held) {
+      this.release(lock);
+    }
+  }
+  release(lock) {
+    this.held.delete(lock);
+    try {
+      if (holderOf(readFileSync13(lock, "utf8"))?.pid === this.holder.pid) {
+        rmSync8(lock, { force: true });
+      }
+    } catch {}
+  }
+  made(path) {
+    let made;
+    try {
+      made = openSync2(path, "wx");
+    } catch {
+      return false;
+    }
+    try {
+      writeSync2(made, JSON.stringify(this.holder));
+    } finally {
+      closeSync2(made);
+    }
+    return true;
+  }
+  async takenOver(lock) {
+    if (!await this.free(lock)) {
+      return false;
+    }
+    const steal = `${lock}.steal`;
+    if (!this.made(steal)) {
+      try {
+        if (Date.now() - statSync9(steal).mtimeMs > UNWRITTEN_MS) {
+          rmSync8(steal, { force: true });
+        }
+      } catch {}
+      return false;
+    }
+    try {
+      if (!await this.free(lock)) {
+        return false;
+      }
+      try {
+        rmSync8(lock, { force: true });
+      } catch {
+        return false;
+      }
+      return this.made(lock);
+    } finally {
+      rmSync8(steal, { force: true });
+    }
+  }
+  async free(lock) {
+    let content;
+    let writtenAt;
+    try {
+      content = readFileSync13(lock, "utf8");
+      writtenAt = statSync9(lock).mtimeMs;
+    } catch {
+      return false;
+    }
+    const pid = holderOf(content)?.pid;
+    if (pid !== undefined && alive(pid)) {
+      await this.readStart(pid);
+    }
+    return lockIsFree(content, writtenAt, Date.now(), alive, (asked) => this.starts.get(asked)?.started);
+  }
+  async readStart(pid) {
+    const known = this.starts.get(pid);
+    if (known !== undefined && Date.now() - known.readAt < START_READ_MS) {
+      return;
+    }
+    const started = (await startTimesOf([pid])).get(pid);
+    this.starts.set(pid, { started, readAt: Date.now() });
+  }
+}
+
+// src/suite-run.ts
+init_errors();
+init_setup();
+init_spawn();
+
+// src/suite-fingerprint.ts
+init_class_cache();
+import { createHash as createHash5 } from "node:crypto";
+import { existsSync as existsSync16, readdirSync as readdirSync10, readFileSync as readFileSync14, statSync as statSync10 } from "node:fs";
+import { join as join19, posix as posix2 } from "node:path";
+var RES_LITERAL = /res:\/\/[^"'\s)\]<>]*/g;
+var RELATIVE_LOAD = /\b(?:pre)?load\(\s*["']((?!res:\/\/|uid:\/\/)[^"']+)["']/g;
+var REACHES_AT_RUN_TIME = [
+  /\bDirAccess\b/,
+  /\blist_directory\b/,
+  /\b(?:load|load_threaded_request)\(\s*(?=[^\s),])/
+];
+var BINARY_RESOURCE = /\.(?:scn|res)$/;
+var ADDON = /^res:\/\/addons\/[^/]+\//;
+var PLACEHOLDER = /[%{}]/;
+
+class SuiteFingerprints {
+  reached = new Map;
+  scripts;
+  everywhere;
+  alwaysDigest;
+  constructor(scripts, always) {
+    this.scripts = scripts;
+    this.everywhere = ["res://project.godot", ...extensionsOf(scripts.projectPath)];
+    this.alwaysDigest = createHash5("sha256").update(always.join(`
+`)).digest("hex");
+  }
+  of(suite) {
+    const seen = new Set;
+    const pending = [suite.path, ...this.everywhere];
+    for (let path = pending.pop();path !== undefined; path = pending.pop()) {
+      if (seen.has(path)) {
+        continue;
+      }
+      seen.add(path);
+      const reached = this.read(path);
+      if (reached.unreadable !== null) {
+        return null;
+      }
+      pending.push(...reached.reaches);
+    }
+    const hash = createHash5("sha256").update(this.alwaysDigest);
+    for (const path of [...seen].sort()) {
+      hash.update(`${path}
+${this.read(path).digest}
+`);
+    }
+    return hash.digest("hex");
+  }
+  read(asked) {
+    const path = ADDON.exec(asked)?.[0] ?? asked;
+    const known = this.reached.get(path);
+    if (known !== undefined) {
+      return known;
+    }
+    const reached = path === asked ? this.readAnew(path) : this.addon(path);
+    this.reached.set(path, reached);
+    return reached;
+  }
+  addon(root) {
+    const hash = createHash5("sha256");
+    const walk = (directory, under) => {
+      for (const entry of readdirSync10(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+        const file = join19(directory, entry.name);
+        if (entry.isDirectory()) {
+          walk(file, `${under}${entry.name}/`);
+        } else if (entry.isFile()) {
+          hash.update(`${under}${entry.name}
+`).update(readFileSync14(file));
+        }
+      }
+    };
+    const directory = join19(this.scripts.projectPath, root.slice("res://".length));
+    if (existsSync16(directory)) {
+      walk(directory, "");
+    }
+    return { digest: hash.digest("hex"), reaches: [], unreadable: null };
+  }
+  readAnew(path) {
+    if (PLACEHOLDER.test(path)) {
+      return { digest: "", reaches: [], unreadable: `${path} is filled in at run time` };
+    }
+    const file = join19(this.scripts.projectPath, path.slice("res://".length));
+    if (!existsSync16(file)) {
+      return { digest: "missing", reaches: [], unreadable: null };
+    }
+    if (statSync10(file).isDirectory()) {
+      const inside = readdirSync10(file, { withFileTypes: true }).filter((entry) => !entry.name.startsWith(".")).map((entry) => `${path.endsWith("/") ? path : `${path}/`}${entry.name}`).sort();
+      return { digest: inside.join(`
+`), reaches: inside, unreadable: null };
+    }
+    if (BINARY_RESOURCE.test(path)) {
+      return { digest: "", reaches: [], unreadable: `${path} is a binary resource` };
+    }
+    const bytes = readFileSync14(file);
+    const digest = createHash5("sha256").update(bytes).digest("hex");
+    const text = bytes.toString("latin1");
+    const reaches = new Set;
+    for (const [literal] of text.matchAll(RES_LITERAL)) {
+      reaches.add(literal);
+    }
+    if (existsSync16(`${file}.import`)) {
+      reaches.add(`${path}.import`);
+    }
+    if (path.endsWith(".gd")) {
+      const script = this.scripts.script(path);
+      const code = script?.code ?? "";
+      const dynamic = REACHES_AT_RUN_TIME.find((pattern) => pattern.test(code));
+      if (dynamic !== undefined) {
+        return { digest, reaches: [], unreadable: `${path} reaches what it names at run time` };
+      }
+      for (const [, relative] of text.matchAll(RELATIVE_LOAD)) {
+        reaches.add(`res://${posix2.join(posix2.dirname(path.slice("res://".length)), relative ?? "")}`);
+      }
+      const base = this.scripts.base(path);
+      if (base !== null && "path" in base) {
+        reaches.add(base.path);
+      }
+      for (const name of classesNamedIn(code, this.scripts.classes)) {
+        reaches.add(this.scripts.classes.get(name) ?? "");
+      }
+      if (text.includes("uid://")) {
+        return { digest, reaches: [], unreadable: `${path} loads by uid` };
+      }
+    }
+    reaches.delete("");
+    reaches.delete(path);
+    return { digest, reaches: [...reaches], unreadable: null };
+  }
+}
+function extensionsOf(projectPath) {
+  const list = join19(projectPath, ".godot", "extension_list.cfg");
+  return existsSync16(list) ? readFileSync14(list, "utf8").split(`
+`).map((line) => line.trim()).filter((line) => line.startsWith("res://")) : [];
+}
+
+// src/suite-judge.ts
+init_junit();
+import { stripVTControlCharacters } from "node:util";
+var SUITE_OPENED = /^Run Test Suite:\s*(res:\/\/.+?\.gd)\s*$/;
+var TIME = String.raw`(?:\d+h )?(?:\d+min )?(?:\d+s )?\d+ms`;
+var CASE_LINE = new RegExp(String.raw`^\s*(res://.+?\.gd) > (.+?) (STARTED|PASSED|FAILED|FLAKY|SKIPPED|WARNING)(?: \((?:retry \d+|\d+ retries)\))?(?: (${TIME}))?\s*$`);
+var STATISTICS = new RegExp(String.raw`^Statistics:.*\|\s*([A-Z]+)(?:\s+\(.*?\))?\s+(${TIME})\s*$`);
+var ERROR_LINE = /^\s*(?:SCRIPT |USER )?ERROR: (.*?)\s*$/;
+var EXECUTED = /^Executed test cases\s*:\s*\((\d+)\//;
+var DRIVER_FALLBACK = /^\s*WARNING: Your video card drivers .*, switching to /;
+var LEAK = /ObjectDB instances (?:were )?leaked at exit|resources? still in use at exit|Pages in use exist at exit/;
+var STARVED = [
+  /Parameter "mem(?:_new)?" is null\.?\s*\n\s*at: \w+ \((?:\.\/)?core\/(?:os\/memory\.cpp|templates\/cowdata\.h):/g,
+  /ERROR: Failed decoding WebP image\.\s*\n\s*at: _webp_unpack/g
+];
+function secondsOf(time) {
+  let ms = 0;
+  for (const [, amount, unit] of time.matchAll(/(\d+)(h|min|ms|s)\b/g)) {
+    ms += Number(amount) * (unit === "h" ? 3600000 : unit === "min" ? 60000 : unit === "s" ? 1000 : 1);
+  }
+  return ms / 1000;
+}
+function funcOf(name) {
+  const colon = name.indexOf(":");
+  return colon < 0 ? name : name.slice(0, colon);
+}
+function readRun(printed) {
+  const lines = stripVTControlCharacters(printed).replaceAll(`\r
+`, `
+`).split(`
+`);
+  const suites = new Map;
+  const errors = [];
+  const leaks = [];
+  let executed = null;
+  let open = null;
+  let during = null;
+  let afterCase = [];
+  let lastCase = null;
+  const settleAfterCase = (owner) => {
+    for (const held of afterCase) {
+      errors.push({ ...held, suite: open?.path ?? null, during: owner });
+    }
+    afterCase = [];
+  };
+  for (const [at, line] of lines.entries()) {
+    const opened = SUITE_OPENED.exec(line);
+    if (opened?.[1] !== undefined) {
+      settleAfterCase("after");
+      open = suites.get(opened[1]) ?? { path: opened[1], cases: [], closed: null };
+      suites.set(open.path, open);
+      during = "before";
+      lastCase = null;
+      continue;
+    }
+    const caseLine = CASE_LINE.exec(line);
+    if (caseLine !== null && open !== null) {
+      const name = caseLine[2] ?? "";
+      if (caseLine[3] === "STARTED") {
+        settleAfterCase(lastCase ?? "before");
+        during = name;
+      } else {
+        open.cases.push({
+          name,
+          func: funcOf(name),
+          verdict: caseLine[3] ?? "",
+          seconds: secondsOf(caseLine[4] ?? ""),
+          at
+        });
+        lastCase = name;
+        during = null;
+      }
+      continue;
+    }
+    const statistics = STATISTICS.exec(line);
+    if (statistics !== null && open !== null) {
+      settleAfterCase("after");
+      open.closed = { verdict: statistics[1] ?? "", seconds: secondsOf(statistics[2] ?? "") };
+      open = null;
+      during = null;
+      lastCase = null;
+      continue;
+    }
+    const counted = EXECUTED.exec(line);
+    if (counted?.[1] !== undefined) {
+      executed = Number(counted[1]);
+      continue;
+    }
+    if (LEAK.test(line)) {
+      leaks.push(line.trim());
+      continue;
+    }
+    if (suites.size === 0 && DRIVER_FALLBACK.test(line)) {
+      errors.length = 0;
+      continue;
+    }
+    const error = ERROR_LINE.exec(line);
+    if (error === null) {
+      continue;
+    }
+    const text = error[1] ?? "";
+    if (open === null) {
+      errors.push({ text, at, suite: null, during: null });
+    } else if (during === null) {
+      afterCase.push({ text, at });
+    } else {
+      errors.push({ text, at, suite: open.path, during });
+    }
+  }
+  const last = open;
+  const stoppedIn = last === null ? null : during === null ? `${last.path}, after ${lastCase ?? "its cases"}` : during === "before" ? `${last.path}, in before` : `${last.path} > ${during}`;
+  settleAfterCase("after");
+  const joined = lines.join(`
+`);
+  const starved = STARVED.flatMap((pattern) => [...joined.matchAll(pattern)].map((found) => found[0]));
+  const unloadable = scriptErrorsPrinted(lines).map((error) => `${error.path}${error.line === null ? "" : `:${String(error.line)}`}: ${error.message}`);
+  return { lines, suites, errors, leaks, starved, executed, unloadable, stoppedIn };
+}
+var WINDOWS_EXITS = new Map([
+  [3221225477, "STATUS_ACCESS_VIOLATION"],
+  [3221225495, "STATUS_NO_MEMORY"],
+  [3221225773, "STATUS_COMMITMENT_LIMIT"],
+  [3221225794, "STATUS_DLL_INIT_FAILED"],
+  [3221226505, "STATUS_STACK_BUFFER_OVERRUN"],
+  [3228369022, "a module that could not be found (VcppException)"],
+  [3228369023, "a procedure that could not be found (VcppException)"]
+]);
+var MEMORY_EXITS = new Set([3221225495, 3221225773]);
+function exitNamed(code) {
+  const unsigned = code >>> 0;
+  const name = WINDOWS_EXITS.get(unsigned);
+  return name === undefined ? String(code) : `0x${unsigned.toString(16).toUpperCase()} (${name})`;
+}
+var TAIL = 60;
+var MOST_NAMED = 8;
+function named(items) {
+  const shown = items.slice(0, MOST_NAMED).join(", ");
+  return items.length > MOST_NAMED ? `${shown} and ${String(items.length - MOST_NAMED)} more` : shown;
+}
+function judgeEngine(printed, handed, end) {
+  const faults = [];
+  const failing = new Set;
+  const shownAt = new Set;
+  if (end.ended !== null) {
+    faults.push(end.ended);
+  } else if (end.code !== 0) {
+    faults.push(end.code === null ? `the engine was ended by ${end.signal ?? "a signal"}` : `the engine exited ${exitNamed(end.code)}`);
+  }
+  if (printed.unloadable.length > 0) {
+    faults.push(`gdUnit4 could not load ${named(printed.unloadable)}, so it ran nothing`);
+  }
+  if (printed.executed === null || printed.executed === 0) {
+    faults.push(printed.executed === null ? "the run never printed its summary" : "the run executed no test case at all, whatever it exited with");
+  }
+  for (const { path, cases } of handed.suites) {
+    const suite = printed.suites.get(path);
+    if (suite === undefined) {
+      faults.push(`${path} never started`);
+      failing.add(path);
+      continue;
+    }
+    if (suite.closed === null) {
+      faults.push(`${path} never finished`);
+      failing.add(path);
+    } else if (suite.closed.verdict !== "PASSED") {
+      if (suite.cases.every((ran) => ran.verdict !== "FAILED")) {
+        faults.push(`${path} reported ${suite.closed.verdict} with every case passing, so a hook failed`);
+      }
+      failing.add(path);
+    }
+    const finished = new Set(suite.cases.map((ran) => ran.func));
+    const missing = cases.filter((func) => !finished.has(func));
+    if (missing.length > 0 && suite.closed !== null) {
+      faults.push(`${path} closed without running ${named(missing)}`);
+      failing.add(path);
+    }
+    const wanted = new Set(cases);
+    const unasked = [...finished].filter((func) => !wanted.has(func));
+    if (unasked.length > 0) {
+      faults.push(`${path} ran ${named(unasked)}, which gdharness did not read as cases of it to run here, so its ` + "plan of the cases was wrong");
+      failing.add(path);
+    }
+    for (const ran of suite.cases) {
+      if (ran.verdict === "FAILED" || ran.verdict === "FLAKY") {
+        faults.push(ran.verdict === "FLAKY" ? `${path} > ${ran.name} failed before it passed on a retry` : `${path} > ${ran.name} failed`);
+        failing.add(path);
+        for (let at = ran.at;at < printed.lines.length && (at === ran.at || printed.lines[at]?.trim()); at += 1) {
+          shownAt.add(at);
+        }
+      }
+    }
+  }
+  const unexpected = unexpectedErrors(printed, handed);
+  for (const error of unexpected.printed) {
+    const where = error.suite === null ? "outside every suite" : `in ${error.suite} > ${error.during ?? ""}`;
+    faults.push(`an engine error ${where}: ${error.text}`);
+    if (error.suite !== null) {
+      failing.add(error.suite);
+    }
+    shownAt.add(error.at);
+    shownAt.add(error.at + 1);
+  }
+  for (const missing of unexpected.neverPrinted) {
+    faults.push(`${missing.suite} > ${missing.during} declares the error "${missing.text}", which it never printed`);
+    failing.add(missing.suite);
+  }
+  for (const leak of printed.leaks) {
+    faults.push(`the engine exited holding what it should have freed: ${leak}`);
+  }
+  const memoryExit = end.code !== null && MEMORY_EXITS.has(end.code >>> 0);
+  const starved = memoryExit || printed.starved.length > 0;
+  if (printed.starved.length > 0) {
+    faults.push("the engine ran out of memory");
+  }
+  printed.lines.forEach((line, at) => {
+    if (/^(?:Overall Summary|Executed test|Total execution time| ?Exit code)/.test(line.trim())) {
+      shownAt.add(at);
+    }
+  });
+  const passed = faults.length === 0;
+  const passedSuites = handed.suites.map((suite) => suite.path).filter((path) => !failing.has(path));
+  const cutShort = end.ended !== null || printed.executed === null || handed.suites.some(({ path }) => printed.suites.get(path)?.closed == null);
+  return {
+    passed,
+    faults,
+    passedSuites,
+    starved,
+    shown: passed ? [] : linesShown(printed.lines, shownAt, cutShort)
+  };
+}
+function linesShown(lines, picked, cutShort) {
+  const summary = [...picked].filter((at) => at < lines.length).sort((a, b) => a - b);
+  const telling = summary.some((at) => !/^(?:Overall Summary|Executed test|Total execution|\s*Exit code)/.test(lines[at]?.trim() ?? ""));
+  if (!telling && !cutShort) {
+    return [];
+  }
+  if (!telling) {
+    return lines.slice(Math.max(0, lines.length - TAIL)).filter((line, at, all) => at < all.length - 1 || line !== "");
+  }
+  const shown = [];
+  let previous = -1;
+  for (const at of summary) {
+    if (previous >= 0 && at > previous + 1) {
+      shown.push("...");
+    }
+    shown.push(lines[at] ?? "");
+    previous = at;
+  }
+  return shown;
+}
+function unexpectedErrors(printed, handed) {
+  const owed = new Map;
+  for (const { path } of handed.suites) {
+    const suite = printed.suites.get(path);
+    const declared = handed.expected[path];
+    if (suite === undefined || declared === undefined) {
+      continue;
+    }
+    const ranHooks = suite.closed === null ? ["before"] : ["before", "after"];
+    for (const during of [...ranHooks, ...suite.cases.map((ran) => ran.name)]) {
+      const texts = declared[funcOf(during)];
+      if (Array.isArray(texts) && texts.length > 0) {
+        owed.set(`${path}
+${during}`, {
+          suite: path,
+          during,
+          texts: texts.map((text) => String(text))
+        });
+      }
+    }
+  }
+  const unexpected = [];
+  for (const error of printed.errors) {
+    const debt = error.suite === null || error.during === null ? undefined : owed.get(`${error.suite}
+${error.during}`);
+    const index = debt?.texts.indexOf(error.text) ?? -1;
+    if (debt === undefined || index < 0) {
+      unexpected.push(error);
+    } else {
+      debt.texts.splice(index, 1);
+    }
+  }
+  const neverPrinted = [...owed.values()].flatMap((debt) => debt.texts.map((text) => ({ suite: debt.suite, during: debt.during, text })));
+  return { printed: unexpected, neverPrinted };
+}
+
+// src/suite-plan.ts
+init_class_cache();
+init_gdscript_source();
+init_whole_file();
+import { existsSync as existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync15 } from "node:fs";
+import { dirname as dirname10, posix as posix3 } from "node:path";
+var SUITE_BASE = "GdUnitTestSuite";
+var CASE_PREFIX = "test_";
+var NEEDS_WINDOW = /^const\s+GDHARNESS_NEEDS_WINDOW\b[^=\n]*=\s*true\b/m;
+var SCENE_RUNNER = /\bscene_runner\s*\(/;
+
+class ProjectScripts {
+  sources = new Map;
+  classes = new Map;
+  read = new Map;
+  projectPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    eachScript(projectPath, (script, source) => {
+      this.sources.set(script, source);
+      const declared = declaredClassOf(source);
+      if (declared !== null) {
+        this.classes.set(declared, script);
+      }
+    });
+  }
+  script(path) {
+    const known = this.read.get(path);
+    if (known !== undefined) {
+      return known;
+    }
+    const source = this.sources.get(path);
+    if (source === undefined) {
+      return;
+    }
+    const shape = shapeOf(source);
+    const read = {
+      source,
+      extendsAs: shape.body.extendsAs,
+      funcs: shape.body.declarations.filter((d) => d.kind === "func").map((d) => d.name),
+      code: codeOf(source)
+    };
+    this.read.set(path, read);
+    return read;
+  }
+  base(path) {
+    const extendsAs = this.script(path)?.extendsAs ?? null;
+    if (extendsAs === null) {
+      return null;
+    }
+    const quote = extendsAs[0];
+    if (quote === '"' || quote === "'") {
+      const target = extendsAs.slice(1, -1);
+      return {
+        path: target.startsWith("res://") ? target : `res://${posix3.join(posix3.dirname(path.slice(6)), target)}`
+      };
+    }
+    const name = extendsAs.split(".")[0] ?? extendsAs;
+    const declaring = this.classes.get(name);
+    return declaring === undefined ? { name } : { path: declaring };
+  }
+  suite(path) {
+    const cases = new Set;
+    let windowed = false;
+    const seen = new Set;
+    let at = path;
+    while (!seen.has(at)) {
+      seen.add(at);
+      const read = this.script(at);
+      if (read === undefined) {
+        return null;
+      }
+      for (const func of read.funcs.filter((name) => name.startsWith(CASE_PREFIX))) {
+        cases.add(func);
+      }
+      windowed ||= NEEDS_WINDOW.test(read.code) || SCENE_RUNNER.test(read.code);
+      const base = this.base(at);
+      if (base === null) {
+        return null;
+      }
+      if ("name" in base ? base.name === SUITE_BASE : base.path === this.classes.get(SUITE_BASE)) {
+        return cases.size > 0 ? { path, cases: [...cases].sort(), windowed } : null;
+      }
+      if ("name" in base) {
+        return null;
+      }
+      at = base.path;
+    }
+    return null;
+  }
+  suitesUnder(roots) {
+    const prefixes = roots.map((root) => root.endsWith("/") ? root : `${root}/`);
+    return [...this.sources.keys()].filter((path) => prefixes.some((prefix) => path.startsWith(prefix))).sort().flatMap((path) => this.suite(path) ?? []);
+  }
+}
+function readTimes(file) {
+  try {
+    const parsed = JSON.parse(readFileSync15(file, "utf8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeJson(file, value) {
+  mkdirSync7(dirname10(file), { recursive: true });
+  writeWhole(file, `${JSON.stringify(value, null, 1)}
+`);
+}
+function timesAfter(times, suites, runs) {
+  const next = { ...times };
+  const declared = new Map(suites.map((suite) => [suite.path, suite]));
+  const measured = new Map;
+  for (const run of runs) {
+    for (const printed of run.suites.values()) {
+      if (printed.closed === null || !declared.has(printed.path)) {
+        continue;
+      }
+      const entry = measured.get(printed.path) ?? { cases: new Map, around: 0 };
+      const own = new Map;
+      for (const ran of printed.cases) {
+        own.set(ran.func, (own.get(ran.func) ?? 0) + ran.seconds);
+      }
+      const inCases = [...own.values()].reduce((sum, seconds) => sum + seconds, 0);
+      entry.around = Math.max(entry.around, printed.closed.seconds - inCases);
+      for (const [func, seconds] of own) {
+        entry.cases.set(func, seconds);
+      }
+      measured.set(printed.path, entry);
+    }
+  }
+  for (const [path, entry] of measured) {
+    const suite = declared.get(path);
+    const cases = {};
+    for (const func of suite?.cases ?? []) {
+      const seconds = entry.cases.get(func) ?? times[path]?.cases[func];
+      if (seconds !== undefined) {
+        cases[func] = round(seconds);
+      }
+    }
+    const inCases = Object.values(cases).reduce((sum, seconds) => sum + seconds, 0);
+    next[path] = { seconds: round(entry.around + inCases), cases };
+  }
+  return next;
+}
+function round(seconds) {
+  return Math.round(seconds * 1000) / 1000;
+}
+var UNTIMED_CASE = 0.02;
+var SPLIT_PAST_SECONDS = 10;
+var ENGINE_START_SECONDS = 5;
+function median(values) {
+  if (values.length === 0) {
+    return;
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 1 ? sorted[middle] : ((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2;
+}
+function unitsOf(suites, times, splitPast = SPLIT_PAST_SECONDS) {
+  const known = Object.values(times);
+  const caseCost = median(known.flatMap((time) => Object.values(time.cases))) ?? UNTIMED_CASE;
+  const aroundCost = median(known.map((time) => time.seconds - Object.values(time.cases).reduce((sum, s) => sum + s, 0))) ?? 0;
+  return suites.flatMap((suite) => {
+    const time = times[suite.path];
+    const costOf = (func) => time?.cases[func] ?? caseCost;
+    const around = time === undefined ? aroundCost : Math.max(0, time.seconds - Object.values(time.cases).reduce((sum, s) => sum + s, 0));
+    const whole = around + suite.cases.reduce((sum, func) => sum + costOf(func), 0);
+    if (suite.windowed || whole <= splitPast || suite.cases.length < 2) {
+      return [{ suite: suite.path, cases: suite.cases, cost: whole, windowed: suite.windowed }];
+    }
+    return suite.cases.map((func) => ({
+      suite: suite.path,
+      cases: [func],
+      cost: around + costOf(func),
+      windowed: false
+    }));
+  });
+}
+function dealt(units, declared, most) {
+  const windowed = units.filter((unit) => unit.windowed);
+  const headless = units.filter((unit) => !unit.windowed).sort((a, b) => b.cost - a.cost || a.suite.localeCompare(b.suite) || (a.cases[0] ?? "").localeCompare(b.cases[0] ?? ""));
+  const total = headless.reduce((sum, unit) => sum + unit.cost, 0);
+  const slowest = headless[0]?.cost ?? 0;
+  const room = Math.max(1, most - (windowed.length > 0 && most > 1 ? 1 : 0));
+  const count = headless.length === 0 ? 0 : Math.max(1, Math.min(room, headless.length, Math.ceil(total / Math.max(slowest, ENGINE_START_SECONDS))));
+  const bins = Array.from({ length: count }, () => []);
+  const loads = Array.from({ length: count }, () => 0);
+  for (const unit of headless) {
+    const lightest = loads.indexOf(Math.min(...loads));
+    bins[lightest]?.push(unit);
+    loads[lightest] = (loads[lightest] ?? 0) + unit.cost;
+  }
+  const plans = bins.map((bin) => planOf(bin, declared, false));
+  return windowed.length > 0 ? [planOf(windowed, declared, true), ...plans] : plans;
+}
+function inOneEngine(units, declared) {
+  return planOf(units, declared, units.some((unit) => unit.windowed));
+}
+function planOf(bin, declared, windowed) {
+  const held = new Map;
+  for (const unit of bin) {
+    held.set(unit.suite, [...held.get(unit.suite) ?? [], ...unit.cases]);
+  }
+  const skipping = [...held].flatMap(([path, cases]) => (declared.get(path) ?? []).filter((func) => !cases.includes(func)).map((func) => `${path}:${func}`));
+  return {
+    suites: [...held].map(([path, cases]) => ({ path, cases: [...cases].sort() })),
+    skipping,
+    cost: bin.reduce((sum, unit) => sum + unit.cost, 0),
+    windowed
+  };
+}
+function viewportOf(projectPath) {
+  const file = `${projectPath}/project.godot`;
+  if (!existsSync17(file)) {
+    return null;
+  }
+  const text = readFileSync15(file, "utf8");
+  const width = /^window\/size\/viewport_width\s*=\s*(\d+)/m.exec(text)?.[1];
+  const height = /^window\/size\/viewport_height\s*=\s*(\d+)/m.exec(text)?.[1];
+  return width === undefined || height === undefined ? null : { width: Number(width), height: Number(height) };
+}
+
 // src/version.ts
-import { readFileSync as readFileSync12 } from "node:fs";
-import { dirname as dirname10, join as join17 } from "node:path";
+import { readFileSync as readFileSync16 } from "node:fs";
+import { dirname as dirname11, join as join20 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getLocalVersion() {
-  const currentDirectory = dirname10(fileURLToPath2(import.meta.url));
+  const currentDirectory = dirname11(fileURLToPath2(import.meta.url));
   const packageCandidates = [
-    join17(currentDirectory, "..", "package.json"),
-    join17(currentDirectory, "..", "..", "package.json")
+    join20(currentDirectory, "..", "package.json"),
+    join20(currentDirectory, "..", "..", "package.json")
   ];
   for (const packagePath of packageCandidates) {
     try {
-      const value = JSON.parse(readFileSync12(packagePath, "utf-8"));
+      const value = JSON.parse(readFileSync16(packagePath, "utf-8"));
       if (typeof value === "object" && value !== null && "name" in value && value.name === "gdharness" && "version" in value && typeof value.version === "string") {
         return value.version;
       }
@@ -54308,6 +55314,513 @@ function getLocalVersion() {
   return "0.0.0";
 }
 
+// src/suite-run.ts
+class TestUsageError extends Refusal {
+}
+var MOST_ENGINES = 4;
+var MEMORY_KEPT = 4 * 1024 ** 3;
+var MEMORY_PER_ENGINE = 1.5 * 1024 ** 3;
+var SILENCE_FLOOR_SECONDS = 300;
+var SILENCE_TIMES_SLOWEST = 4;
+var LOOK_MS = 500;
+var AUTOLOAD_FAILED = "Failed to instantiate an autoload";
+var VALUED = new Set([
+  "--engines",
+  "--slots",
+  "--slot-count",
+  "--silence",
+  "--tests",
+  "--reach-also",
+  "--order"
+]);
+var SWITCHES = new Set(["--changed-only", "--import"]);
+function testOptionsOf(args, cwd) {
+  const valued = new Map;
+  const switches = new Set;
+  const positional = [];
+  for (let at = 0;at < args.length; at += 1) {
+    const arg = args[at] ?? "";
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+    } else if (SWITCHES.has(arg)) {
+      switches.add(arg);
+    } else if (VALUED.has(arg)) {
+      const value = args[at + 1];
+      if (value === undefined || value.startsWith("--")) {
+        throw new TestUsageError(`${arg} needs a value.`);
+      }
+      valued.set(arg, [...valued.get(arg) ?? [], value]);
+      at += 1;
+    } else {
+      throw new TestUsageError(`Unknown option ${arg} for gdharness test. Run gdharness help.`);
+    }
+  }
+  const first = positional[0];
+  const named = first === undefined ? null : resolve4(cwd, first);
+  const projectNamed = named !== null && existsSync18(join21(named, "project.godot"));
+  const projectPath = projectNamed ? named : resolve4(cwd);
+  if (!existsSync18(join21(projectPath, "project.godot"))) {
+    throw new TestUsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
+  }
+  const last = (flag) => valued.get(flag)?.at(-1);
+  const order = last("--order");
+  return {
+    projectPath,
+    selected: positional.slice(projectNamed ? 1 : 0).map((entry) => resPathOf(entry, projectPath, cwd)),
+    engines: whole(last("--engines"), "--engines") ?? MOST_ENGINES,
+    slotsDirectory: last("--slots") === undefined ? null : resolve4(cwd, last("--slots") ?? ""),
+    slotCount: whole(last("--slot-count"), "--slot-count"),
+    silenceSeconds: whole(last("--silence"), "--silence") ?? SILENCE_FLOOR_SECONDS,
+    roots: (valued.get("--tests") ?? []).map((root) => resPathOf(root, projectPath, cwd).replace(/\/$/, "")),
+    changedOnly: switches.has("--changed-only"),
+    reachAlso: (valued.get("--reach-also") ?? []).map((path) => resolve4(projectPath, path)),
+    importFirst: switches.has("--import"),
+    order: order === undefined ? null : order === "reversed" ? "reversed" : seedOf(order)
+  };
+}
+function whole(value, flag) {
+  if (value === undefined) {
+    return null;
+  }
+  const number = Number(value);
+  if (!Number.isInteger(number) || number < 1) {
+    throw new TestUsageError(`${flag} takes a whole number above 0, not ${value}.`);
+  }
+  return number;
+}
+function seedOf(value) {
+  const seed = Number(value);
+  if (!Number.isInteger(seed) || seed < 0) {
+    throw new TestUsageError(`--order takes reversed or a whole number to shuffle by, not ${value}.`);
+  }
+  return seed;
+}
+function resPathOf(entry, projectPath, cwd) {
+  if (entry.startsWith("res://")) {
+    return entry;
+  }
+  const caseAt = /^(.*\.gd):(\w+)$/.exec(entry);
+  const file = caseAt?.[1] ?? entry;
+  const fromProject = resolve4(projectPath, file);
+  const absolute = isAbsolute4(file) || !existsSync18(fromProject) ? resolve4(cwd, file) : fromProject;
+  const inside = relative3(projectPath, absolute);
+  if (inside.startsWith("..") || isAbsolute4(inside)) {
+    throw new TestUsageError(`${entry} is not inside the project at ${projectPath}.`);
+  }
+  const path = `res://${inside.split(sep2).join("/")}`;
+  return caseAt === null ? path : `${path}:${caseAt[2] ?? ""}`;
+}
+function homeOf(projectPath) {
+  return mainCheckoutOf(projectPath) ?? projectPath;
+}
+function selectedSuites(scripts, options) {
+  const roots = options.roots.length > 0 ? options.roots : ["res://tests", "res://test"].filter((root) => existsSync18(join21(options.projectPath, root.slice(6))));
+  if (options.selected.length === 0) {
+    const found = scripts.suitesUnder(roots);
+    if (found.length === 0) {
+      throw new TestUsageError(roots.length === 0 ? "The project has no tests or test directory to look for suites in. Name one with --tests." : `No gdUnit4 suite under ${roots.join(" or ")}: no script there extends GdUnitTestSuite and declares a test_ function.`);
+    }
+    return found;
+  }
+  const chosen = new Map;
+  for (const entry of options.selected) {
+    const caseAt = /^(res:\/\/.*\.gd):(\w+)$/.exec(entry);
+    const path = caseAt?.[1] ?? entry;
+    const directory = join21(options.projectPath, path.slice(6));
+    const suites = existsSync18(directory) && statSync11(directory).isDirectory() ? scripts.suitesUnder([path.replace(/\/$/, "")]) : [scripts.suite(path)].filter((suite) => suite !== null);
+    if (suites.length === 0) {
+      throw new TestUsageError(existsSync18(directory) ? `${path} holds no gdUnit4 suite: nothing there extends GdUnitTestSuite and declares a test_ function.` : `Nothing at ${path}.`);
+    }
+    for (const suite of suites) {
+      const picked = chosen.get(suite.path) ?? { suite, cases: new Set };
+      const asked = caseAt?.[2];
+      if (asked !== undefined && !suite.cases.includes(asked)) {
+        throw new TestUsageError(`${suite.path} declares no case ${asked}. It declares ${suite.cases.join(", ")}.`);
+      }
+      for (const func of asked === undefined ? suite.cases : [asked]) {
+        picked.cases.add(func);
+      }
+      chosen.set(suite.path, picked);
+    }
+  }
+  return [...chosen.values()].map(({ suite, cases }) => ({
+    ...suite,
+    cases: suite.cases.filter((c) => cases.has(c))
+  }));
+}
+function roomFor(most) {
+  const byMemory = Math.floor((freemem() - MEMORY_KEPT) / MEMORY_PER_ENGINE);
+  return Math.max(1, Math.min(most, availableParallelism(), byMemory));
+}
+function ordered(units, order) {
+  const sorted = [...units].sort((a, b) => a.suite.localeCompare(b.suite));
+  if (order === "reversed") {
+    return sorted.reverse();
+  }
+  let state = order >>> 0;
+  const next = () => {
+    state = state + 1831565813 >>> 0;
+    let mixed = Math.imul(state ^ state >>> 15, 1 | state);
+    mixed = mixed + Math.imul(mixed ^ mixed >>> 7, 61 | mixed) ^ mixed;
+    return ((mixed ^ mixed >>> 14) >>> 0) / 4294967296;
+  };
+  for (let at = sorted.length - 1;at > 0; at -= 1) {
+    const other = Math.floor(next() * (at + 1));
+    const here = sorted[at];
+    const there = sorted[other];
+    if (here !== undefined && there !== undefined) {
+      sorted[at] = there;
+      sorted[other] = here;
+    }
+  }
+  return sorted;
+}
+async function runTestCommand(options, godotPath) {
+  const unusable = gdUnit4Unusable(options.projectPath);
+  if (unusable !== null) {
+    throw new TestUsageError(`${unusable.reason}. Install gdUnit4 6.0 or later under addons/gdUnit4.`);
+  }
+  const startedAt = Date.now();
+  const scripts = new ProjectScripts(options.projectPath);
+  const home = homeOf(options.projectPath);
+  const state = join21(home, ".godot", "gdharness");
+  const timesFile = join21(state, "suite-times.json");
+  const passedFile = join21(state, "suite-passed.json");
+  let suites = selectedSuites(scripts, options);
+  const wholeSuites = suites.map((suite) => scripts.suite(suite.path) ?? suite);
+  const declared = new Map(wholeSuites.map((suite) => [suite.path, suite.cases]));
+  const testRuns = join21(options.projectPath, ".godot", "gdharness", "test-runs");
+  sweepRunDirectories(testRuns);
+  const runDirectory = join21(testRuns, `${String(startedAt)}-${String(process12.pid)}`);
+  mkdirSync8(runDirectory, { recursive: true });
+  const slots = new EngineSlots(options.slotsDirectory ?? join21(home, ".godot", "gate", "slots"), options.slotCount ?? Math.min(MOST_ENGINES, availableParallelism()), { pid: process12.pid, started: await ownStart() });
+  const running = new Set;
+  const interrupted = () => {
+    for (const end of running) {
+      end();
+    }
+    slots.releaseAll();
+    process12.exit(130);
+  };
+  process12.once("SIGINT", interrupted);
+  process12.once("SIGTERM", interrupted);
+  const launch = {
+    godotPath,
+    projectPath: options.projectPath,
+    runDirectory,
+    slots,
+    silenceFloorSeconds: options.silenceSeconds,
+    running
+  };
+  try {
+    if (options.importFirst) {
+      const imported = await importProject(launch);
+      if (imported !== null) {
+        console.log(`The import failed, so no suite ran: ${imported}`);
+        return 1;
+      }
+    }
+    const fingerprints = new SuiteFingerprints(scripts, [
+      getLocalVersion(),
+      readFileSync17(shippedListedRunner(), "utf8"),
+      ...options.reachAlso.map((path) => `${path}
+${existsSync18(path) ? readFileSync17(path, "latin1") : "missing"}`)
+    ]);
+    const printsOf = new Map(suites.map((suite) => [suite.path, fingerprints.of(suite)]));
+    if (options.changedOnly) {
+      const passedBefore = readRecord(passedFile);
+      const unchanged = suites.filter((suite) => {
+        const print = printsOf.get(suite.path);
+        return print !== null && print !== undefined && passedBefore[suite.path] === print;
+      });
+      suites = suites.filter((suite) => !unchanged.includes(suite));
+      if (unchanged.length > 0) {
+        console.log(`${plural(unchanged.length, "suite")} passed with everything ${unchanged.length === 1 ? "it reaches" : "they reach"} as it stands now, and ${unchanged.length === 1 ? "is" : "are"} not run.`);
+      }
+      if (suites.length === 0) {
+        console.log("Nothing has changed since every suite last passed.");
+        rmSync10(runDirectory, { recursive: true, force: true });
+        return 0;
+      }
+    }
+    const times = readTimes(timesFile);
+    const units = unitsOf(suites, times);
+    const plans = options.order === null ? dealt(units, declared, roomFor(options.engines)) : [inOneEngine(ordered(units, options.order), declared)];
+    const functions = suites.reduce((sum, suite) => sum + suite.cases.length, 0);
+    console.log(`${plural(functions, "test function")} in ${plural(suites.length, "suite")} over ${plural(plans.length, "engine")}${plans.some((plan) => plan.windowed) ? ", one of them windowed" : ""}.`);
+    let ran = await Promise.all(plans.map((plan, index) => runEngine2(launch, plan, index, units)));
+    if (ran.some((engine) => engine.verdict.starved) && ran.some((engine) => !engine.verdict.passed)) {
+      console.log("An engine ran out of memory, so every engine that failed runs again, one at a time.");
+      const again = [];
+      for (const engine of ran) {
+        again.push(engine.verdict.passed ? engine : await runEngine2(launch, engine.plan, engine.index, units, "again"));
+      }
+      ran = again;
+    }
+    writeJson(timesFile, timesAfter(readTimes(timesFile), wholeSuites, ran.map((engine) => engine.printed)));
+    recordPassed(passedFile, ran, printsOf);
+    return report(ran, startedAt, runDirectory);
+  } finally {
+    process12.off("SIGINT", interrupted);
+    process12.off("SIGTERM", interrupted);
+  }
+}
+function plural(count, noun) {
+  return `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
+}
+function readRecord(file) {
+  try {
+    const parsed = JSON.parse(readFileSync17(file, "utf8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function recordPassed(file, ran, printsOf) {
+  const passed = readRecord(file);
+  const failedSomewhere = new Set;
+  const passedSomewhere = new Set;
+  for (const engine of ran) {
+    const passing = new Set(engine.verdict.passedSuites);
+    for (const { path } of engine.plan.suites) {
+      (passing.has(path) ? passedSomewhere : failedSomewhere).add(path);
+    }
+  }
+  for (const path of new Set([...passedSomewhere, ...failedSomewhere])) {
+    const print = printsOf.get(path);
+    if (!failedSomewhere.has(path) && print !== null && print !== undefined) {
+      passed[path] = print;
+    } else {
+      delete passed[path];
+    }
+  }
+  writeJson(file, passed);
+}
+function sweepRunDirectories(testRuns) {
+  if (!existsSync18(testRuns)) {
+    return;
+  }
+  for (const entry of readdirSync11(testRuns)) {
+    const pid = Number(/^\d+-(\d+)$/.exec(entry)?.[1]);
+    if (!Number.isInteger(pid) || !alive(pid)) {
+      rmSync10(join21(testRuns, entry), { recursive: true, force: true });
+    }
+  }
+}
+async function importProject(launch) {
+  const directory = join21(launch.runDirectory, "import");
+  mkdirSync8(join21(directory, "user"), { recursive: true });
+  const log = join21(directory, "import.log");
+  const lock = await launch.slots.take();
+  try {
+    const ended = await watched(launch, ["--headless", "--audio-driver", "Dummy", "--path", launch.projectPath, "--import"], directory, log, false, launch.silenceFloorSeconds);
+    if (ended.ended !== null || ended.code !== 0) {
+      return `${ended.ended ?? `the engine exited ${String(ended.code)}`}; everything it printed is in ${log}`;
+    }
+    return null;
+  } finally {
+    launch.slots.release(lock);
+  }
+}
+async function runEngine2(launch, plan, index, units, again = "") {
+  const directory = join21(launch.runDirectory, `engine-${String(index)}${again === "" ? "" : `-${again}`}`);
+  mkdirSync8(join21(directory, "user"), { recursive: true });
+  const suitesFile = join21(directory, "suites.txt");
+  const skippingFile = join21(directory, "skipping.txt");
+  const expectedFile = join21(directory, "expected.json");
+  writeFileSync10(suitesFile, `${plan.suites.map((suite) => suite.path).join(`
+`)}
+`);
+  writeFileSync10(skippingFile, `${plan.skipping.join(`
+`)}
+`);
+  const viewport = viewportOf(launch.projectPath);
+  const display = plan.windowed ? viewport === null ? [] : ["--resolution", `${String(viewport.width)}x${String(viewport.height)}`] : ["--headless"];
+  const args = [
+    ...display,
+    "--audio-driver",
+    "Dummy",
+    "--path",
+    launch.projectPath,
+    "-s",
+    shippedListedRunner(),
+    ...plan.windowed ? [] : ["--ignoreHeadlessMode"],
+    "-c",
+    "-rd",
+    `res://${relative3(launch.projectPath, join21(directory, "reports")).split(sep2).join("/")}`,
+    "-rc",
+    "1",
+    "--",
+    "--suites-in",
+    suitesFile,
+    "--skipping-in",
+    skippingFile,
+    "--html-report-off",
+    "--junit-report-off",
+    "--compile-together",
+    "--expected-errors-out",
+    expectedFile
+  ];
+  const held = new Set(plan.suites.map((suite) => suite.path));
+  const slowest = Math.max(0, ...units.filter((unit) => held.has(unit.suite)).map((unit) => unit.cost));
+  const silence = Math.max(launch.silenceFloorSeconds, SILENCE_TIMES_SLOWEST * slowest);
+  const log = join21(directory, "engine.log");
+  const lock = await launch.slots.take();
+  const began = Date.now();
+  let end;
+  try {
+    end = await watched(launch, args, directory, log, plan.windowed, silence);
+  } finally {
+    launch.slots.release(lock);
+  }
+  const printed = readRun(readFileSync17(log, "utf8"));
+  const assignment = { suites: plan.suites, expected: readExpected(expectedFile) };
+  return {
+    index,
+    plan,
+    printed,
+    verdict: judgeEngine(printed, assignment, end),
+    log,
+    seconds: (Date.now() - began) / 1000
+  };
+}
+function readExpected(file) {
+  try {
+    const parsed = JSON.parse(readFileSync17(file, "utf8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+async function watched(launch, args, directory, log, windowed, silenceSeconds) {
+  const user = join21(directory, "user");
+  const env = { ...process12.env, APPDATA: user, XDG_DATA_HOME: user };
+  const output = openSync3(log, "w");
+  let child;
+  let stop;
+  try {
+    if (process12.platform === "win32" && (windowed || !crashesReported())) {
+      const compiled = await ensureHelperCompiled();
+      if (compiled !== null) {
+        const how = windowed ? "on a desktop of its own" : "through the desktop helper";
+        return { code: null, signal: null, ended: `the engine could not be started ${how}: ${compiled}` };
+      }
+      const stopFile = join21(directory, "stop");
+      const how = windowed ? { desktop: HIDDEN_DESKTOP, directory: launch.projectPath } : { directory: launch.projectPath };
+      const wrapper = throughHelper(how, launch.godotPath, args, {
+        spec: join21(directory, "spec.json"),
+        pid: join21(directory, "pid"),
+        error: join21(directory, "error"),
+        stop: stopFile
+      });
+      child = spawnHidden(wrapper.command, wrapper.args, {
+        stdio: ["ignore", output, output],
+        env: windowed ? { ...env, [DESKTOP_VARIABLE]: HIDDEN_DESKTOP } : env,
+        cwd: directory
+      });
+      stop = () => {
+        writeFileSync10(stopFile, "");
+      };
+    } else {
+      child = spawnHidden(launch.godotPath, args, {
+        stdio: ["ignore", output, output],
+        env,
+        cwd: launch.projectPath,
+        detached: process12.platform !== "win32"
+      });
+      stop = () => {
+        endTree(child);
+      };
+    }
+  } finally {
+    closeSync3(output);
+  }
+  launch.running.add(stop);
+  let ended = null;
+  const exited = Promise.race([
+    exitOf(child),
+    new Promise((settle) => {
+      child.once("error", (error) => {
+        ended ??= `the engine did not start: ${error.message}`;
+        settle({ code: null, signal: null });
+      });
+    })
+  ]);
+  const finished = { now: false };
+  exited.then(() => {
+    finished.now = true;
+  });
+  const reading = openSync3(log, "r");
+  try {
+    let size = 0;
+    let lastGrowth = Date.now();
+    let text = "";
+    while (!finished.now) {
+      await delay3(LOOK_MS);
+      const now = fstatSync(reading).size;
+      if (now > size) {
+        const chunk = Buffer.alloc(now - size);
+        readSync(reading, chunk, 0, chunk.length, size);
+        text += chunk.toString("utf8");
+        size = now;
+        lastGrowth = Date.now();
+        if (ended === null && text.includes(AUTOLOAD_FAILED)) {
+          ended = "an autoload did not start, so the suites were ended rather than run without it";
+          stop();
+        }
+      } else if (ended === null && Date.now() - lastGrowth > silenceSeconds * 1000) {
+        const stoppedIn = readRun(text).stoppedIn;
+        ended = `the engine printed nothing for ${String(silenceSeconds)} s${stoppedIn === null ? "" : ` while running ${stoppedIn}`}, so it was ended`;
+        stop();
+      }
+    }
+  } finally {
+    closeSync3(reading);
+    launch.running.delete(stop);
+  }
+  const { code, signal } = await exited;
+  return { code, signal, ended };
+}
+function endTree(child) {
+  if (child.pid === undefined) {
+    return;
+  }
+  if (process12.platform === "win32") {
+    runHidden("taskkill", ["/T", "/F", "/PID", String(child.pid)]).catch(() => {});
+    return;
+  }
+  try {
+    process12.kill(-child.pid, "SIGKILL");
+  } catch {}
+}
+function report(ran, startedAt, runDirectory) {
+  const failed = ran.filter((engine) => !engine.verdict.passed);
+  for (const engine of failed) {
+    console.log("");
+    console.log(`--- engine ${String(engine.index)}: ${plural(engine.plan.suites.length, "suite")}, ${engine.seconds.toFixed(1)} s`);
+    for (const fault of engine.verdict.faults) {
+      console.log(`  ${fault}`);
+    }
+    if (engine.verdict.shown.length > 0) {
+      console.log("");
+      for (const line of engine.verdict.shown) {
+        console.log(line);
+      }
+    }
+    console.log(`everything it printed: ${engine.log}`);
+  }
+  const cases = ran.reduce((sum, engine) => sum + [...engine.printed.suites.values()].reduce((n, s) => n + s.cases.length, 0), 0);
+  const suites = new Set(ran.flatMap((engine) => engine.plan.suites.map((suite) => suite.path))).size;
+  const longest = Math.max(0, ...ran.map((engine) => engine.seconds));
+  const took = (Date.now() - startedAt) / 1000;
+  if (failed.length === 0) {
+    rmSync10(runDirectory, { recursive: true, force: true });
+  }
+  console.log("");
+  console.log(`${failed.length === 0 ? "Passed" : "Failed"}: ${plural(cases, "case")} in ${plural(suites, "suite")} across ${plural(ran.length, "engine")}, ${took.toFixed(1)} s; the longest engine took ${longest.toFixed(1)} s.`);
+  return failed.length === 0 ? 0 : 1;
+}
+
 // src/cli.ts
 var args = process.argv.slice(2);
 var command = args[0];
@@ -54316,8 +55829,8 @@ class UsageError extends Refusal {
 }
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
-  const projectPath = resolve8(named ?? ".");
-  if (!existsSync28(join36(projectPath, "project.godot"))) {
+  const projectPath = resolve9(named ?? ".");
+  if (!existsSync31(join39(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -54362,7 +55875,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync28(join36(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync31(join39(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }
@@ -54494,7 +56007,7 @@ async function setup() {
       console.log("no harness configured; name one yourself, and gdharness harnesses lists them all");
     }
     if (!args.includes("--no-skill")) {
-      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync28);
+      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync31);
       for (const written of writeSkill(directories, getLocalVersion())) {
         console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
       }
@@ -54608,7 +56121,7 @@ async function upgrade() {
       moved.push(took.from);
     }
   }
-  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync28), version)) {
+  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync31), version)) {
     console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
   }
   console.log(`
@@ -54730,6 +56243,17 @@ Usage:
   gdharness runtime on|off [project] Register or remove the runtime autoload, which reaches
                                      an export if it is left on
   gdharness classes [project]        Rebuild .godot/global_script_class_cache.cfg from disk
+  gdharness test [project] [suite ...] [--engines N] [--slots DIR] [--slot-count N]
+                 [--silence S] [--tests DIR] [--changed-only] [--reach-also PATH] [--import]
+                 [--order reversed|SEED] [--runner]
+                                     Run the project's gdUnit4 suites over several engines and
+                                     judge every line they print: exit 1 on a failing case, an
+                                     engine error no case declared, a case that never finished
+                                     or a leak at exit. A suite is a script, a directory, or
+                                     script.gd:test_case for one case. --changed-only leaves out
+                                     suites that passed with everything they reach unchanged; it
+                                     is for iterating, and no gate passes it. --runner prints the
+                                     shipped runner's path. docs/test-runs.md has the rest.
   gdharness version                  Show the installed version
   gdharness help                     Show this help
 
@@ -54745,7 +56269,22 @@ function checkFlags() {
     }
   }
 }
+async function test() {
+  const rest = args.slice(1);
+  if (rest.includes("--runner")) {
+    console.log(shippedListedRunner());
+    return;
+  }
+  const options = testOptionsOf(rest, process.cwd());
+  const { godotPath } = await engine(options.projectPath);
+  process.exitCode = await runTestCommand(options, godotPath);
+}
 async function main() {
+  await letWindowsReportCrashes();
+  if (command === "test") {
+    await test();
+    return;
+  }
   checkFlags();
   switch (command) {
     case undefined: {
@@ -54791,7 +56330,7 @@ async function main() {
 await main().catch((error) => {
   if (error instanceof Refusal) {
     console.error("gdharness:", error.message);
-    process.exit(error instanceof UsageError ? 2 : 1);
+    process.exit(error instanceof UsageError || error instanceof TestUsageError ? 2 : 1);
   }
   console.error(defectReport(`gdharness ${command ?? "server"}`, error));
   process.exit(1);