gdharness 0.10.1 → 0.11.0

package/build/index.js

@@ -10126,9 +10126,21 @@ function defectReport(where, error, godotVersion) {
 
 // src/server.ts
 import { execFile as execFile3, spawn } from "node:child_process";
-import { existsSync as existsSync7, mkdirSync as mkdirSync4, mkdtempSync as mkdtempSync2, readdirSync as readdirSync5, readFileSync as readFileSync9, realpathSync as realpathSync2, rmSync as rmSync4 } from "node:fs";
+import {
+  closeSync,
+  existsSync as existsSync7,
+  fstatSync,
+  mkdirSync as mkdirSync5,
+  mkdtempSync as mkdtempSync2,
+  openSync as openSync2,
+  readdirSync as readdirSync6,
+  readFileSync as readFileSync10,
+  readSync,
+  realpathSync as realpathSync2,
+  rmSync as rmSync5
+} from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename, dirname as dirname4, join as join9, normalize as normalize2 } from "node:path";
+import { basename, dirname as dirname4, join as join10, normalize as normalize2 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { promisify as promisify3 } from "node:util";
@@ -25425,11 +25437,16 @@ function announced(line) {
   }
   return { severity: match[2] === "WARNING" ? "warning" : "error", text: match[3] ?? "" };
 }
+var STREAMS = ["stdout", "stderr", "transcript"];
 
 class GameLog {
   entries = [];
-  decoders = { stdout: new StringDecoder("utf8"), stderr: new StringDecoder("utf8") };
-  partial = { stdout: "", stderr: "" };
+  decoders = {
+    stdout: new StringDecoder("utf8"),
+    stderr: new StringDecoder("utf8"),
+    transcript: new StringDecoder("utf8")
+  };
+  partial = { stdout: "", stderr: "", transcript: "" };
   lastHeadline = null;
   cursor = 0;
   append(source, chunk) {
@@ -25442,7 +25459,7 @@ class GameLog {
     }
   }
   finish() {
-    for (const source of ["stdout", "stderr"]) {
+    for (const source of STREAMS) {
       const tail = this.partial[source] + this.decoders[source].end();
       this.partial[source] = "";
       if (tail !== "") {
@@ -26154,6 +26171,9 @@ function runArguments(options) {
   if (options.scene !== null) {
     args.push(`res://${options.scene}`);
   }
+  if (options.userArgs !== undefined && options.userArgs.length > 0) {
+    args.push("--", ...options.userArgs);
+  }
   return args;
 }
 function editorArguments(projectPath, ports) {
@@ -26601,6 +26621,39 @@ function whyNoReport(printed, asked) {
   }
   return printed.some((line) => NOTHING_RAN.test(line)) ? `no test cases found at ${asked}` : null;
 }
+var RUNNING_SUITE = /Run Test Suite:\s*(\S+)/;
+var ORPHANS = /(\d+)\s+orphans/;
+var OVERALL = "Overall Summary";
+function orphansPrinted(printed) {
+  const suites = [];
+  let total = null;
+  let running = null;
+  for (const line of printed) {
+    const started = RUNNING_SUITE.exec(line);
+    if (started?.[1] !== undefined) {
+      running = started[1];
+      continue;
+    }
+    const counted = ORPHANS.exec(line);
+    if (counted?.[1] === undefined) {
+      continue;
+    }
+    const orphans = Number(counted[1]);
+    if (line.includes(OVERALL)) {
+      total = orphans;
+      running = null;
+      continue;
+    }
+    if (running !== null && orphans > 0) {
+      suites.push({ path: running, orphans });
+    }
+    running = null;
+  }
+  return {
+    total: total ?? suites.reduce((sum, suite) => sum + suite.orphans, 0),
+    suites
+  };
+}
 
 // src/lsp_client.ts
 import { realpathSync } from "node:fs";
@@ -26905,6 +26958,14 @@ class GodotLSPClient {
     }
     return uri;
   }
+  closeDocument(uri) {
+    if (!this.documentVersions.delete(uri)) {
+      return;
+    }
+    try {
+      this.sendNotification("textDocument/didClose", { textDocument: { uri } });
+    } catch {}
+  }
   async initialize(rootPath) {
     await this.ensureConnected();
     const resolvedRootPath = resolve2(rootPath);
@@ -26958,8 +27019,9 @@ class GodotLSPClient {
         timer
       });
     });
+    let opened = null;
     try {
-      this.syncDocument(filePath, content);
+      opened = this.syncDocument(filePath, content);
       return await diagnosticsPromise;
     } catch (error) {
       const waiter = this.diagnosticsWaiters.get(key);
@@ -26968,16 +27030,25 @@ class GodotLSPClient {
         this.diagnosticsWaiters.delete(key);
       }
       throw error;
+    } finally {
+      if (opened !== null) {
+        this.closeDocument(opened);
+      }
     }
   }
   async getCompletions(filePath, content, line, character) {
     await this.ensureConnected();
     await this.ensureInitializedForFile(filePath);
     const uri = this.syncDocument(filePath, content);
-    const result = await this.sendRequest("textDocument/completion", {
-      textDocument: { uri },
-      position: { line, character }
-    });
+    let result;
+    try {
+      result = await this.sendRequest("textDocument/completion", {
+        textDocument: { uri },
+        position: { line, character }
+      });
+    } finally {
+      this.closeDocument(uri);
+    }
     if (Array.isArray(result)) {
       return result;
     }
@@ -26993,18 +27064,27 @@ class GodotLSPClient {
     await this.ensureConnected();
     await this.ensureInitializedForFile(filePath);
     const uri = this.syncDocument(filePath, content);
-    return this.sendRequest("textDocument/hover", {
-      textDocument: { uri },
-      position: { line, character }
-    });
+    try {
+      return await this.sendRequest("textDocument/hover", {
+        textDocument: { uri },
+        position: { line, character }
+      });
+    } finally {
+      this.closeDocument(uri);
+    }
   }
   async getDocumentSymbols(filePath, content) {
     await this.ensureConnected();
     await this.ensureInitializedForFile(filePath);
     const uri = this.syncDocument(filePath, content);
-    const result = await this.sendRequest("textDocument/documentSymbol", {
-      textDocument: { uri }
-    });
+    let result;
+    try {
+      result = await this.sendRequest("textDocument/documentSymbol", {
+        textDocument: { uri }
+      });
+    } finally {
+      this.closeDocument(uri);
+    }
     return Array.isArray(result) ? result : [];
   }
   isConnected() {
@@ -27412,6 +27492,10 @@ function setupResourceHandlers(mcp, getProjectPath) {
   });
 }
 
+// src/run-record.ts
+import { mkdirSync as mkdirSync3, openSync, readdirSync as readdirSync5, readFileSync as readFileSync8, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join8 } from "node:path";
+
 // src/runtime-client.ts
 import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync7, unlinkSync } from "node:fs";
 import { createConnection as createConnection3 } from "node:net";
@@ -27707,9 +27791,86 @@ function runtimeRequest(endpoint, command, params, timeoutMs) {
   });
 }
 
+// src/run-record.ts
+function runsDirectory() {
+  return join8(runtimeDirectory(), "runs");
+}
+function recordPath() {
+  return join8(runsDirectory(), "run.json");
+}
+function openTranscript(startedAt) {
+  mkdirSync3(runsDirectory(), { recursive: true });
+  const path = join8(runsDirectory(), `run-${startedAt}.log`);
+  return { path, fd: openSync(path, "a") };
+}
+function writeRunRecord(record) {
+  mkdirSync3(runsDirectory(), { recursive: true });
+  writeFileSync4(recordPath(), JSON.stringify(record, null, 2), "utf8");
+}
+function readRunRecord() {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync8(recordPath(), "utf8"));
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  const fields = parsed;
+  const pid = fields["pid"];
+  const transcript = fields["transcript"];
+  const startedAt = fields["startedAt"];
+  if (typeof pid !== "number" || typeof transcript !== "string" || typeof startedAt !== "number") {
+    return null;
+  }
+  const args = fields["arguments"];
+  return {
+    pid,
+    transcript,
+    startedAt,
+    projectPath: typeof fields["projectPath"] === "string" ? fields["projectPath"] : "",
+    arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : []
+  };
+}
+function clearRunRecord() {
+  try {
+    rmSync3(recordPath());
+  } catch {}
+}
+function ageMs(path, now) {
+  try {
+    return now - statSync2(path).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
+  const directory = runsDirectory();
+  const keep = readRunRecord()?.transcript;
+  let entries;
+  try {
+    entries = readdirSync5(directory);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
+      continue;
+    }
+    const path = join8(directory, entry);
+    if (path === keep || ageMs(path, now) < keepMs) {
+      continue;
+    }
+    try {
+      rmSync3(path);
+    } catch {}
+  }
+}
+
 // src/setup.ts
-import { cpSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync8, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname3, join as join8 } from "node:path";
+import { cpSync, existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync9, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname3, join as join9 } from "node:path";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
 var RUNTIME_AUTOLOAD = {
   name: "GdharnessRuntime",
@@ -27717,11 +27878,11 @@ var RUNTIME_AUTOLOAD = {
 };
 var VERSION_MARKER = ".gdharness-version";
 function installedAddonVersion(projectPath) {
-  const marker = join8(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  const marker = join9(projectPath, "addons", ADDONS[0], VERSION_MARKER);
   if (!existsSync6(marker)) {
     return null;
   }
-  const said = readFileSync8(marker, "utf8").trim();
+  const said = readFileSync9(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 
@@ -28038,7 +28199,7 @@ var TOOL_SPECS = [
   },
   {
     name: "project_test",
-    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. Needs gdUnit4 under addons/gdUnit4.",
+    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
     parameters: {
       projectPath: PROJECT_PATH,
       path: {
@@ -28313,10 +28474,15 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_run",
-    description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice.",
+    description: "The run: starting the project, stopping it, or booting it once to see whether it comes up clean. start keeps it running and collecting output until it quits or is stopped, windowed where there is a display and headless where there is not, unless headless says otherwise; only runtime_capture needs the window. A run that quits on its own is kept, so a scene that prints an answer and quits is start, then editor_output until running is false. What runs is a scene: a SceneTree script is not an entry point here, so put the script on the root of a scene of its own and name that in scene. args hands the game its own flags, the ones it reads with OS.get_cmdline_user_args(), and a run carrying any is started by this server rather than by the editor. check boots it headless for a few frames, waits for it to quit, and answers with the verdict: whether it came up, and every error and warning it printed on the way. A start waits for the game to become something the runtime_* tools can talk to and says which it is under runtime: listening with the port it took, or why not, so the first call after a start does not have to be made twice.",
     parameters: {
       projectPath: PROJECT_PATH,
       scene: { type: "string", description: "A scene to run instead of the main scene." },
+      args: {
+        type: "array",
+        items: { type: "string" },
+        description: `The game's own arguments, what OS.get_cmdline_user_args() answers, such as ["--level=2"]. The separator is added here. A run with any is started by this server rather than by the editor, which fixes the game's command line when it opens the project, so the debug_* tools do not answer for it.`
+      },
       headless: { type: "boolean", description: "start: force a window or no window." },
       frames: { type: "number", description: "check: frames to run before quitting. Default 3." },
       timeoutMs: {
@@ -28445,8 +28611,8 @@ var TOOL_SPECS = [
       },
       includeHidden: {
         type: "boolean",
-        ops: ["text"],
-        description: "text: read hidden nodes as well, for checking that something is not showing. Default false."
+        ops: ["text", "find"],
+        description: "text: read hidden nodes as well, for checking that something is not showing. Default false. find: default true, since a find means the node whether or not it is drawn; false answers with what the player can actually see, which is how a panel that keeps a label for every line and hides the ones that do not is read. A node counts as hidden when anything above it is, and how many matches were left out comes back under hidden."
       },
       metrics: {
         type: "array",
@@ -28463,7 +28629,7 @@ var TOOL_SPECS = [
         requires: []
       },
       find: {
-        summary: "the paths of every node matching className, script, namePattern, group or says, with property read off each",
+        summary: "the paths of every node matching className, script, namePattern, group or says, with property read off each, hidden ones included unless includeHidden says otherwise",
         requires: []
       },
       rect: {
@@ -28771,15 +28937,24 @@ var SLOWEST_FRAME_RATE = 20;
 function patienceForFrames(frames, atLeast) {
   return Math.max(atLeast, frames / SLOWEST_FRAME_RATE * 1000 + atLeast);
 }
+function stillRunning(run) {
+  if (run?.exitCode !== null || run.endedUnwatched === true) {
+    return false;
+  }
+  if (!run.throughEditor && run.process === null && run.pid !== null) {
+    return alive(run.pid);
+  }
+  return true;
+}
 function alive(pid) {
-  if (pid === undefined) {
+  if (pid === undefined || pid === null) {
     return false;
   }
   try {
     process.kill(pid, 0);
     return true;
-  } catch {
-    return false;
+  } catch (error) {
+    return error.code === "EPERM";
   }
 }
 function isOfType(value, kind) {
@@ -28921,13 +29096,13 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync7(join9(projectPath, wanted))) {
+  if (wanted === "" || existsSync7(join10(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
   let near = [];
   try {
-    near = readdirSync5(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 = readdirSync6(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 "";
   }
@@ -28935,11 +29110,11 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync9(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync10(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync9(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync10(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -28955,7 +29130,7 @@ function camelCased(params) {
 class GodotServer {
   mcp;
   locator = new GodotLocator;
-  operationsScript = join9(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join10(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -29112,10 +29287,7 @@ class GodotServer {
     this.stopWatchingForASuccessor();
     withdrawBridge(this.announcedAt);
     this.announcedAt = null;
-    if (this.activeProcess) {
-      this.activeProcess.process?.kill();
-      this.activeProcess = null;
-    }
+    this.activeProcess = null;
     if (this.lspClient) {
       try {
         await this.lspClient.disconnect();
@@ -29180,14 +29352,7 @@ class GodotServer {
       return;
     }
     this.shutdownInitiated = true;
-    if (this.activeProcess) {
-      try {
-        this.activeProcess.process?.kill();
-      } catch (error) {
-        console.error("[SERVER] Failed to kill the Godot process on exit:", errorMessage(error));
-      }
-      this.activeProcess = null;
-    }
+    this.activeProcess = null;
   }
   setupToolHandlers() {
     this.mcp.server.setRequestHandler(ListToolsRequestSchema, () => ({ tools: this.tools }));
@@ -29547,7 +29712,7 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join9(path, "project.godot");
+    const file = join10(path, "project.godot");
     if (!existsSync7(file)) {
       return {
         ok: false,
@@ -29558,6 +29723,21 @@ class GodotServer {
     }
     return { ok: true, value: { path, file } };
   }
+  gameArguments(args) {
+    if (args["args"] === undefined) {
+      return { ok: true, value: [] };
+    }
+    const given = readStringArray(args, "args");
+    if (given === undefined) {
+      return {
+        ok: false,
+        response: this.createErrorResponse("args must be a list of strings.", [
+          `Pass the game's own flags, such as ["--level=2"]`
+        ])
+      };
+    }
+    return { ok: true, value: given };
+  }
   async debuggedGame() {
     const game = this.activeProcess;
     if (game !== null && game.exitCode !== null) {
@@ -29702,7 +29882,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync9(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync10(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -29765,7 +29945,7 @@ class GodotServer {
     }
     const folder = dirname4(output.absolutePath);
     try {
-      mkdirSync4(folder, { recursive: true });
+      mkdirSync5(folder, { recursive: true });
     } catch (error) {
       return this.createErrorResponse(`Cannot create ${dirname4(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
@@ -29827,7 +30007,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync7(join9(project.value.path, runner))) {
+    if (!existsSync7(join10(project.value.path, runner))) {
       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"
       ]);
@@ -29861,7 +30041,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync2(join9(tmpdir4(), "gdharness-tests-"));
+    const userData = mkdtempSync2(join10(tmpdir4(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -29877,26 +30057,26 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join9(project.value.path, ".godot", "gdharness-reports");
+    const reportsDir = join10(project.value.path, ".godot", "gdharness-reports");
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync7(reportsDir) ? readdirSync5(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync7(reportsDir) ? readdirSync6(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(readFileSync9(join9(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync10(join10(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
-      rmSync4(reportsDir, { recursive: true, force: true });
-      rmSync4(userData, { recursive: true, force: true });
+      rmSync5(reportsDir, { recursive: true, force: true });
+      rmSync5(userData, { recursive: true, force: true });
     }
     const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries.map(aboveTheRunner);
     const verdicts = {
       0: "passed",
       100: "failures",
-      101: "warnings",
+      101: "warnings: orphan nodes",
       103: "headless not supported by this gdUnit4",
       104: "Godot version not supported by this gdUnit4",
       105: "script errors"
@@ -29928,7 +30108,17 @@ class GodotServer {
       };
     }
     const failed = report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ ...entry, path: suite.path })));
-    const unclean = report.suites.filter((suite) => suite.failures > 0 || suite.errors > 0 || suite.skipped > 0);
+    const orphans = orphansPrinted(said);
+    const leftBehind = new Map(orphans.suites.map((suite) => [suite.path, suite.orphans]));
+    const orphansIn = (path) => path === null ? 0 : leftBehind.get(path) ?? 0;
+    const warnings = orphans.suites.map((suite) => ({
+      kind: "orphans",
+      path: suite.path,
+      name: report.suites.find((entry) => entry.path === suite.path)?.name ?? suite.path,
+      orphans: suite.orphans,
+      message: `${suite.orphans} node${suite.orphans === 1 ? "" : "s"} were still in the tree when this suite finished. A node built in a test and neither freed nor added to the tree is the usual cause; free it, or add it with auto_free().`
+    }));
+    const unclean = report.suites.filter((suite) => suite.failures > 0 || suite.errors > 0 || suite.skipped > 0 || orphansIn(suite.path) > 0);
     return this.jsonTextResponse({
       passed: !hung && exitCode === 0 && report.failures === 0 && report.errors === 0,
       verdict,
@@ -29939,6 +30129,9 @@ class GodotServer {
       skipped: report.skipped,
       time: report.time,
       failed,
+      warnings: warnings.length > 0 ? warnings : undefined,
+      orphans: orphans.total > 0 ? orphans.total : undefined,
+      note: verdict.startsWith("warnings") && warnings.length === 0 ? "gdUnit4 exits 101 for orphan nodes when nothing failed, and this run printed no count of them: orphan reporting may be off in the project settings." : undefined,
       suites: unclean.map((suite) => ({
         name: suite.name,
         path: suite.path,
@@ -29946,6 +30139,7 @@ class GodotServer {
         failures: suite.failures,
         errors: suite.errors,
         skipped: suite.skipped,
+        orphans: orphansIn(suite.path) > 0 ? orphansIn(suite.path) : undefined,
         time: suite.time
       })),
       suitesPassed: report.suites.length - unclean.length,
@@ -30072,7 +30266,7 @@ class GodotServer {
         version: godotPath === null ? null : await this.godotVersion(godotPath)
       },
       game: {
-        processActive: this.activeProcess?.exitCode === null,
+        processActive: stillRunning(this.currentRun()),
         playingInEditor: playing,
         runtimeConnected: games.some((game) => game.reachable),
         runtimes: games
@@ -30218,6 +30412,10 @@ class GodotServer {
     if (sceneToRun && !sceneToRun.ok) {
       return this.createErrorResponse(sceneToRun.reason, PATH_SOLUTIONS);
     }
+    const given = this.gameArguments(args);
+    if (!given.ok) {
+      return given.response;
+    }
     if (!sceneToRun && !hasMainScene(project.value.file)) {
       return this.createErrorResponse("The project sets no main scene, so there is nothing to run.", [
         "Pass scene to run one scene",
@@ -30234,9 +30432,9 @@ class GodotServer {
     }
     const sceneArgument = sceneToRun?.ok ? sceneToRun.relativePath : null;
     if (op === "check") {
-      return await this.checkBoot(engine.value, project.value.path, sceneArgument, args);
+      return await this.checkBoot(engine.value, project.value.path, sceneArgument, args, given.value);
     }
-    if (this.activeProcess?.exitCode === null) {
+    if (stillRunning(this.currentRun())) {
       this.logDebug("Ending the running game before starting another");
       await this.endActiveGame();
     }
@@ -30245,17 +30443,20 @@ class GodotServer {
       platform: process.platform,
       variables: process.env
     });
-    if (this.godotBridge.isConnected() && (!headless || editorPlaysHeadless(project.value.file))) {
+    const editorWouldPlay = !headless || editorPlaysHeadless(project.value.file);
+    if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0) {
       return await this.playThroughEditor(sceneArgument, refreshed.value, project.value.path, alreadyPlaying);
     }
     const cmdArgs = runArguments({
       projectPath: project.value.path,
       headless,
-      scene: sceneArgument
+      scene: sceneArgument,
+      userArgs: given.value
     });
     this.logDebug(`Running Godot project: ${engine.value} ${cmdArgs.join(" ")}`);
-    const started = this.spawnGame(engine.value, cmdArgs);
+    const started = this.spawnKeptGame(engine.value, cmdArgs, project.value.path);
     this.activeProcess = started;
+    const spawnedInstead = this.godotBridge.isConnected() && editorWouldPlay && given.value.length > 0 ? " The editor cannot be handed arguments for a game it plays, so this one was started " + "here: the debug_* tools answer only for a game the editor is playing." : "";
     return this.jsonTextResponse({
       started: true,
       through: "gdharness",
@@ -30263,11 +30464,11 @@ class GodotServer {
       arguments: cmdArgs,
       refreshedClasses: refreshed.value,
       runtime: await this.runtimeUp(project.value.path, alreadyPlaying),
-      message: "Use editor_output for what it prints and editor_run stop to end it."
+      message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}`
     });
   }
   async runtimeUp(projectPath, before) {
-    if (!existsSync7(join9(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync7(join10(projectPath, RUNTIME_AUTOLOAD.path))) {
       return {
         listening: false,
         note: "this project has no gdharness_runtime addon, so the runtime_* tools have nothing to talk to"
@@ -30302,7 +30503,11 @@ class GodotServer {
     }
     const played = {
       process: null,
+      pid: null,
       log,
+      transcript: null,
+      readOffset: 0,
+      projectPath,
       startedAt: Date.now(),
       exitCode: null,
       throughEditor: true,
@@ -30341,6 +30546,7 @@ class GodotServer {
   async endActiveGame() {
     const running = this.activeProcess;
     this.activeProcess = null;
+    clearRunRecord();
     if (!running) {
       return;
     }
@@ -30348,14 +30554,26 @@ class GodotServer {
       await this.handleViaBridge("stop_playing", {});
       return;
     }
-    running.process?.kill();
+    if (running.process !== null) {
+      running.process.kill();
+      return;
+    }
+    if (running.pid !== null) {
+      try {
+        process.kill(running.pid);
+      } catch {}
+    }
   }
   spawnGame(godotPath, cmdArgs, env) {
     const child = spawn(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
     const log = new GameLog;
     const started = {
       process: child,
+      pid: child.pid ?? null,
       log,
+      transcript: null,
+      readOffset: 0,
+      projectPath: null,
       startedAt: Date.now(),
       exitCode: null,
       throughEditor: false,
@@ -30380,10 +30598,121 @@ class GodotServer {
     });
     return started;
   }
-  async checkBoot(godotPath, projectPath, scene, args) {
+  spawnKeptGame(godotPath, cmdArgs, projectPath, env) {
+    const startedAt = Date.now();
+    const transcript = openTranscript(startedAt);
+    let child;
+    try {
+      child = spawn(godotPath, cmdArgs, {
+        stdio: ["ignore", transcript.fd, transcript.fd],
+        detached: true,
+        ...env ? { env } : {}
+      });
+    } finally {
+      closeSync(transcript.fd);
+    }
+    child.unref();
+    const log = new GameLog;
+    const started = {
+      process: child,
+      pid: child.pid ?? null,
+      log,
+      transcript: transcript.path,
+      readOffset: 0,
+      projectPath,
+      startedAt,
+      exitCode: null,
+      throughEditor: false,
+      brokeOn: null
+    };
+    child.on("exit", (code) => {
+      this.logDebug(`Godot process exited with code ${code ?? "none"}`);
+      this.drainTranscript(started);
+      log.finish();
+      started.exitCode = code ?? -1;
+    });
+    child.on("error", (err) => {
+      console.error("Failed to start Godot process:", err);
+      log.append("stderr", `${err.message}
+`);
+      started.exitCode = -1;
+    });
+    if (started.pid !== null) {
+      writeRunRecord({
+        pid: started.pid,
+        transcript: transcript.path,
+        startedAt,
+        projectPath,
+        arguments: cmdArgs
+      });
+    }
+    sweepTranscripts();
+    return started;
+  }
+  drainTranscript(game) {
+    if (game.transcript === null) {
+      return;
+    }
+    let handle;
+    try {
+      handle = openSync2(game.transcript, "r");
+    } catch {
+      return;
+    }
+    try {
+      const size = fstatSync(handle).size;
+      if (size <= game.readOffset) {
+        return;
+      }
+      const buffer = Buffer.alloc(size - game.readOffset);
+      const read = readSync(handle, buffer, 0, buffer.length, game.readOffset);
+      game.readOffset += read;
+      game.log.append("transcript", buffer.subarray(0, read));
+    } finally {
+      closeSync(handle);
+    }
+  }
+  adoptRecordedRun() {
+    const record = readRunRecord();
+    if (record === null || !this.couldBeOurs(record.projectPath)) {
+      return null;
+    }
+    const adopted = {
+      process: null,
+      pid: record.pid,
+      log: new GameLog,
+      transcript: record.transcript,
+      readOffset: 0,
+      projectPath: record.projectPath === "" ? null : record.projectPath,
+      startedAt: record.startedAt,
+      exitCode: null,
+      throughEditor: false,
+      brokeOn: null
+    };
+    this.drainTranscript(adopted);
+    if (!alive(record.pid)) {
+      adopted.log.finish();
+      adopted.exitCode = null;
+      adopted.endedUnwatched = true;
+    }
+    this.activeProcess = adopted;
+    return adopted;
+  }
+  couldBeOurs(project) {
+    if (project === "") {
+      return true;
+    }
+    const status = this.godotBridge.getStatus();
+    const mine = this.ownProject ?? (status.connected ? status.projectPath ?? null : null);
+    return mine === null || samePath(mine, project);
+  }
+  currentRun() {
+    return this.activeProcess ?? this.adoptRecordedRun();
+  }
+  async checkBoot(godotPath, projectPath, scene, args, userArgs) {
     const frames = readPositiveNumber(args, "frames") ?? 3;
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 60000;
-    const cmdArgs = runArguments({ projectPath, headless: true, scene, quitAfter: frames });
+    const cmdArgs = runArguments({ projectPath, headless: true, scene, quitAfter: frames, userArgs });
     const boot = this.spawnGame(godotPath, cmdArgs);
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -30413,37 +30742,47 @@ class GodotServer {
     });
   }
   handleGetDebugOutput(args) {
-    if (!this.activeProcess) {
+    const run = this.currentRun();
+    if (!run) {
       return this.createErrorResponse("No game is running. Start one with editor_run.");
     }
-    this.drainEditorOutput(this.activeProcess);
+    this.drainEditorOutput(run);
+    this.drainTranscript(run);
+    if (run.endedUnwatched !== true && !stillRunning(run)) {
+      run.log.finish();
+      run.endedUnwatched = run.exitCode === null;
+    }
     const severity = readString(args, "severity");
-    const selected = this.activeProcess.log.select({
+    const selected = run.log.select({
       severity: severity === "error" || severity === "warning" ? severity : "info",
       sinceLastCall: readBoolean(args, "sinceLastCall") ?? false,
       contains: readNonEmptyString(args, "contains"),
       limit: readPositiveNumber(args, "limit") ?? 200
     });
-    const halt = this.activeProcess.throughEditor ? this.dapClient?.whereItStopped() ?? null : null;
+    const halt = run.throughEditor ? this.dapClient?.whereItStopped() ?? null : null;
     return this.jsonTextResponse({
-      running: this.activeProcess.exitCode === null,
-      exitCode: this.activeProcess.exitCode,
-      through: this.activeProcess.throughEditor ? "editor" : "gdharness",
-      pid: this.activeProcess.process?.pid ?? null,
-      errors: this.activeProcess.log.count("error"),
-      warnings: this.activeProcess.log.count("warning"),
-      clean: this.activeProcess.log.count("error") === 0,
+      running: stillRunning(run),
+      exitCode: run.exitCode,
+      through: run.throughEditor ? "editor" : "gdharness",
+      pid: run.pid,
+      errors: run.log.count("error"),
+      warnings: run.log.count("warning"),
+      clean: run.log.count("error") === 0,
       heldAt: halt,
+      endedUnwatched: run.endedUnwatched === true ? true : undefined,
+      project: !run.throughEditor && run.process === null ? run.projectPath ?? undefined : undefined,
+      note: run.endedUnwatched === true ? "This run outlived the server that started it and is over now, so its exit code was never collected. Everything it printed is below, read back from its transcript." : undefined,
       omitted: selected.omitted,
       entries: selected.entries
     });
   }
   async handleStopProject() {
-    if (!this.activeProcess) {
+    const stopped = this.currentRun();
+    if (!stopped) {
       return this.createErrorResponse("No game is running. Start one with editor_run.");
     }
-    const stopped = this.activeProcess;
     this.drainEditorOutput(stopped);
+    this.drainTranscript(stopped);
     this.logDebug("Stopping the running game");
     await this.endActiveGame();
     return this.jsonTextResponse({
@@ -30549,8 +30888,8 @@ class GodotServer {
       return this.createErrorResponse(choice.problem);
     }
     const expectsScreenshot = command === "capture_screenshot" || command === "capture_viewport";
-    const screenshotDir = expectsScreenshot ? mkdtempSync2(join9(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join9(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync2(join10(tmpdir4(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join10(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs);
       if (!reply.ok) {
@@ -30571,12 +30910,12 @@ class GodotServer {
       return {
         content: [
           { type: "text", text: `Screenshot captured: ${dimensions}` },
-          { type: "image", data: readFileSync9(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync10(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
       if (screenshotDir) {
-        rmSync4(screenshotDir, { recursive: true, force: true });
+        rmSync5(screenshotDir, { recursive: true, force: true });
       }
     }
   }
@@ -30601,12 +30940,14 @@ class GodotServer {
       return this.createErrorResponse("runtime_inspect find needs at least one of className, script, namePattern, group, says.");
     }
     const property = readNonEmptyString(args, "property");
+    const includeHidden = readBoolean(args, "includeHidden");
     return await this.handleRuntimeCommand("find_nodes", {
       ...filters,
       projectPath: args["projectPath"],
       root: readNonEmptyString(args, "nodePath") ?? "/root",
       limit: readPositiveNumber(args, "limit") ?? 100,
-      ...property === undefined ? {} : { property }
+      ...property === undefined ? {} : { property },
+      ...includeHidden === undefined ? {} : { include_hidden: includeHidden }
     });
   }
   async handleRuntimeWait(op, args) {