gdharness 1.3.6 → 1.3.7

package/build/cli.js

@@ -8776,6 +8776,7 @@ function parseJUnit(xml) {
     throw new MalformedReportError("No <testsuites> or <testsuite> in the report");
   }
   const suiteElements = top.name === "testsuite" ? [top] : top.children.filter((child) => child.name === "testsuite");
+  const where = (suite) => suite.path ?? suite.name;
   const suites = suiteElements.map((suite) => {
     const cases = suite.children.filter((child) => child.name === "testcase").map((element) => caseOf(suite, element));
     const failures = cases.filter(failedAnAssertion).length;
@@ -8795,6 +8796,7 @@ function parseJUnit(xml) {
       cases
     };
   });
+  suites.sort((a, b) => where(a) < where(b) ? -1 : where(a) > where(b) ? 1 : 0);
   const all = suites.flatMap((suite) => suite.cases);
   return {
     tests: all.length,
@@ -11856,7 +11858,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, GDUNIT4_CI_RUNNER = "addons/gdUnit4/src/core/runners/GdUnitTestCIRunner.gd";
+var ADDONS, EDITOR_PLUGINS, RUNTIME_AUTOLOAD, SCRIPT_RUNS_SETTING = "gdharness/runtime/serve_script_runs", QUIET_SCENES_SETTING = "gdharness/runtime/quiet_scenes_under", 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();
@@ -12448,14 +12450,14 @@ var init_tool_definitions = __esm(() => {
       name: "project_test",
       title: "Run tests",
       effect: "additive",
-      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. Each entry under failed carries its first report as message and detail, and, when it has more than one, its reports under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. Identical reports fold into one with times, at most twenty different ones are kept (reportsLeftOut counts the rest), and past about a megabyte the largest cases keep only their first message (failedWithoutDetail). failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted, not listed, and an engine message keeps the frames above gdUnit4, not the twenty inside it; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. What changed on disk since it was imported is then imported before any suite runs, and named under importedFirst. On Windows and Linux the run gets a user:// of its own, away from a player's saves; on macOS the engine reads user:// off HOME, so it writes where the player keeps theirs, and savesNote says so. A run that found nothing to run is never called a pass, and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. An autoload that does not compile stops the run at once, its errors listed the same way. A client sending a progress token is told as each suite finishes, and at least every twenty seconds. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. 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. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
-      answer: "time is gdUnit4's own sum of the seconds its cases took, from its report. tookMs is the whole call in milliseconds, from the class rebuild to the engine's exit, which is what a caller waits for. " + IMPORTED_FIRST,
+      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. Each entry under failed carries its first report as message and detail, and, when it has more than one, its reports under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. Identical reports fold into one with times, at most twenty different ones are kept (reportsLeftOut counts the rest), and past about a megabyte the largest cases keep only their first message (failedWithoutDetail). failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted, not listed, and an engine message keeps the frames above gdUnit4, not the twenty inside it; identical engine messages come back once under engineEntries, with times saying how often they were printed. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. What changed on disk since it was imported is then imported before any suite runs, and named under importedFirst. On Windows and Linux the run gets a user:// of its own, away from a player's saves; on macOS the engine reads user:// off HOME, so it writes where the player keeps theirs, and savesNote says so. A run that found nothing to run is never called a pass, and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. An autoload that does not compile stops the run at once, its errors listed the same way. A client sending a progress token is told as each suite finishes, and at least every twenty seconds. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. 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. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and is not listed there, and none are when the project turns off gdUnit4's report/godot/script_error setting; a suite declares them all the same. Needs gdUnit4 under addons/gdUnit4.",
+      answer: "time is gdUnit4's own sum of the seconds its cases took, from its report. tookMs is the whole call in milliseconds, from the class rebuild to the engine's exit, which is what a caller waits for. The run is judged as gdharness test judges it: undeclaredErrors names each engine error that no suite declared in its GDHARNESS_EXPECTED_ERRORS constant, with the suite and the case that printed it, and declaredNotPrinted each declared error its case did not print. Either fails the run, and each suite holding one is listed with its count. engineErrors counts every engine error the run printed but those a suite declared. " + IMPORTED_FIRST,
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
           type: ["string", "array"],
           items: { type: "string" },
-          description: "A test directory or suite file inside the project, or a list of them, all run on one engine: a named set of suites boots once rather than once per suite. An entry given twice, or a suite inside a directory also listed, runs once. An entry that is not there is left out and named under missing, the rest run, and such a run is never called passed; when no entry is there the run is refused before the engine starts, naming each one. Default test."
+          description: "A test directory or suite file inside the project, or a list of them, all run on one engine: a named set of suites boots once rather than once per suite. An entry given twice, or a suite inside a directory also listed, runs once. An entry that is not there is left out and named under missing, the rest run, and such a run is never called passed; when no entry is there the run is refused before the engine starts, naming each one. Default tests and test, those the project has, which is where gdharness test looks."
         },
         ignore: {
           type: "array",
@@ -12696,7 +12698,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "scene_animation",
       title: "Animations",
-      description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. read answers with every track of an animation in the shape add_track takes, so a track read off one animation can be added to another. add_track on a path the animation already has a track of that type for adds the keys to that track, as the editor keys a property it already animates, answering existingTrack true and keysAdded beside keys, the track's count; a key at a time that track already has a key at is refused. A key past the animation's end, where it never plays, is written and named under pastLength. remove clears the player's autoplay when it named the animation and names under statesPlayingNothing the states that played it. read and read_states need no editor: one serving the project answers and says whether it holds unsaved changes to the scene, and with none a headless engine reads the file without running the scene's scripts. The ops that write go through the editor when one serves the project; with none, a headless engine runs the editor's own tool and the answer says so under writtenBy. That engine runs every script of the file, where the editor runs only tool scripts, so what a script changes as the file loads is put back before anything is saved, and a file where that cannot be done, such as a scene whose script does not compile, is refused and nothing is written. An editor of the project that is running and has not reached this server is waited for rather than written around.",
+      description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. The player and the tree are nodes, so scene_node add puts one in the scene first. read answers with every track of an animation in the shape add_track takes, so a track read off one animation can be added to another. add_track on a path the animation already has a track of that type for adds the keys to that track, as the editor keys a property it already animates, answering existingTrack true and keysAdded beside keys, the track's count; a key at a time that track already has a key at is refused. A key past the animation's end, where it never plays, is written and named under pastLength. remove clears the player's autoplay when it named the animation and names under statesPlayingNothing the states that played it. read and read_states need no editor: one serving the project answers and says whether it holds unsaved changes to the scene, and with none a headless engine reads the file without running the scene's scripts. The ops that write go through the editor when one serves the project; with none, a headless engine runs the editor's own tool and the answer says so under writtenBy. That engine runs every script of the file, where the editor runs only tool scripts, so what a script changes as the file loads is put back before anything is saved, and a file where that cannot be done, such as a scene whose script does not compile, is refused and nothing is written. An editor of the project that is running and has not reached this server is waited for rather than written around.",
       parameters: {
         projectPath: PROJECT_PATH,
         scenePath: SCENE_PATH,
@@ -13042,7 +13044,7 @@ var init_tool_definitions = __esm(() => {
       name: "editor_launch",
       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.",
+      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. close and restart name under savedScenes the open scenes that had unsaved changes and were saved on the way out, an empty list when none had; a scene that would not save refuses the close or restart and leaves the editor running. Both answer tookMs, how long the editor took to go or to come back. 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. When either came back without its port, serversSaid gives the lines the editor's log panel has about its servers, the one place Godot says why a port would not bind, and when it was the debug adapter, which is bound again in the editor that came back, debugAdapterRebound says whether that took; neither is there when both came up. 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, the lines that rebind made the panel print. 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: {
@@ -13595,7 +13597,11 @@ var init_tool_definitions = __esm(() => {
         },
         outputPath: {
           type: "string",
-          description: "Also save the picture as a PNG at this absolute path, for somebody to open later; the answer says where. Refused unless it ends in .png, its directory exists, it is outside the project, and no file is there already."
+          description: "Also save the picture as a lossless PNG at this absolute path, for somebody to open later or a script to compare; the answer says where. Refused unless it ends in .png, its directory exists, it is outside the project, and no file is there already."
+        },
+        inline: {
+          type: "boolean",
+          description: "Send the picture back in the answer. Default true, as a JPEG when that is smaller than the PNG and the picture has no transparency (the text says so, with both sizes), since every picture an answer carries stays in the session for as long as it lasts. false sends none and needs outputPath, for a capture a script compares rather than one somebody looks at."
         }
       },
       requires: [],
@@ -13897,7 +13903,7 @@ var init_tool_definitions = __esm(() => {
       operations: {
         pause: {
           effect: "additive",
-          summary: "stop a game this server started where it is, answering with the stack. The game takes it between frames, and in a script every 2048 lines it runs, so a loop that sleeps between few lines can take seconds; the call waits thirty, and past that answers paused false with the request still standing. Stopped between frames, where no script runs, the game is stepped on to the next line of script it runs",
+          summary: "stop a game this server started where it is, answering with the stack. The game takes it between frames, and in a script every 2048 lines it runs, so a loop that sleeps between few lines can take seconds; the call waits thirty, and past that answers paused false with the request still standing. Stopped between frames, where no script runs, the game is stepped on to the next line of script it runs, and stopped in gdharness's runtime addon, an autoload whose _process runs first in every frame, on to the next line of the game's own script, for up to five seconds; one whose stack is still the addon's after them says so in a note",
           requires: []
         },
         continue: { effect: "additive", summary: "resume after a breakpoint", requires: [] },
@@ -14428,6 +14434,316 @@ var init_desktop = __esm(() => {
   DIGEST = createHash4("sha256").update(SOURCE).digest("hex").slice(0, 16);
 });
 
+// src/suite-judge.ts
+import { readFileSync as readFileSync15 } from "node:fs";
+import { stripVTControlCharacters } from "node:util";
+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 };
+}
+function readExpected(file) {
+  try {
+    const parsed = JSON.parse(readFileSync15(file, "utf8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function exitNamed(code) {
+  const unsigned = code >>> 0;
+  const status = WINDOWS_EXITS.get(unsigned);
+  if (status !== undefined) {
+    return `0x${unsigned.toString(16).toUpperCase()} (${status})`;
+  }
+  const gdunit = GDUNIT_EXITS.get(code);
+  return gdunit === undefined ? String(code) : `${String(code)} (${gdunit})`;
+}
+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;
+  const explained = end.code === GDUNIT_FAILED && [...printed.suites.values()].some((suite) => suite.cases.some((ran) => ran.verdict === "FAILED"));
+  if (end.ended !== null) {
+    faults.push(end.ended);
+  } else if (end.code !== 0 && !explained) {
+    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.expected, handed.suites.map((suite) => suite.path));
+  for (const error of unexpected.printed) {
+    faults.push(error.suite === null ? `an engine error outside every suite: ${error.text}` : `an engine error in ${error.suite} > ${error.during ?? ""}: ${error.text}; ${declaringAdvice(error.during ?? "")}`);
+    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 declaringAdvice(during) {
+  return `if the suite prints it on purpose, list its text under "${funcOf(during)}" in the suite's GDHARNESS_EXPECTED_ERRORS`;
+}
+function unexpectedErrors(printed, expected, paths) {
+  const owed = new Map;
+  for (const path of paths) {
+    const suite = printed.suites.get(path);
+    const declared = 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 };
+}
+var SUITE_OPENED, TIME, CASE_LINE, STATISTICS, ERROR_LINE, EXECUTED, DRIVER_FALLBACK, LEAK, STARVED, WINDOWS_EXITS, MEMORY_EXITS, GDUNIT_FAILED = 100, GDUNIT_EXITS, TAIL = 60, MOST_NAMED = 8;
+var init_suite_judge = __esm(() => {
+  init_junit();
+  SUITE_OPENED = /^Run Test Suite:\s*(res:\/\/.+?\.gd)\s*$/;
+  TIME = String.raw`(?:\d+h )?(?:\d+min )?(?:\d+s )?\d+ms`;
+  CASE_LINE = new RegExp(String.raw`^\s*(res://.+?\.gd) > (.+?) (STARTED|PASSED|FAILED|FLAKY|SKIPPED|WARNING)(?: \((?:retry \d+|\d+ retries)\))?(?: (${TIME}))?\s*$`);
+  STATISTICS = new RegExp(String.raw`^Statistics:.*\|\s*([A-Z]+)(?:\s+\(.*?\))?\s+(${TIME})\s*$`);
+  ERROR_LINE = /^\s*(?:SCRIPT |USER )?ERROR: (.*?)\s*$/;
+  EXECUTED = /^Executed test cases\s*:\s*\((\d+)\//;
+  DRIVER_FALLBACK = /^\s*WARNING: Your video card drivers .*, switching to /;
+  LEAK = /ObjectDB instances (?:were )?leaked at exit|resources? still in use at exit|Pages in use exist at exit/;
+  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
+  ];
+  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)"]
+  ]);
+  MEMORY_EXITS = new Set([3221225495, 3221225773]);
+  GDUNIT_EXITS = new Map([
+    [GDUNIT_FAILED, "gdUnit4's code for a case that failed or errored"],
+    [101, "gdUnit4's code for orphan nodes left behind"],
+    [103, "gdUnit4's code for a suite that cannot run headless"],
+    [104, "gdUnit4's code for a Godot version it does not support"],
+    [105, "gdUnit4's code for scripts that did not compile"]
+  ]);
+});
+
 // src/whole-file.ts
 import { renameSync as renameSync2, rmSync as rmSync9, writeFileSync as writeFileSync9 } from "node:fs";
 function writeWhole(path, text) {
@@ -14459,6 +14775,227 @@ var init_whole_file = __esm(() => {
   HELD_BY_A_READER = new Set(["EPERM", "EACCES", "EBUSY"]);
 });
 
+// src/suite-plan.ts
+import { existsSync as existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync16 } from "node:fs";
+import { dirname as dirname10, posix as posix3 } from "node:path";
+
+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(readFileSync16(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;
+}
+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 = readFileSync16(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) };
+}
+var SUITE_BASE = "GdUnitTestSuite", CASE_PREFIX = "test_", NEEDS_WINDOW, TEST_DIRECTORIES, SCENE_RUNNER, UNTIMED_CASE = 0.02, SPLIT_PAST_SECONDS = 10, ENGINE_START_SECONDS = 5;
+var init_suite_plan = __esm(() => {
+  init_class_cache();
+  init_gdscript_source();
+  init_whole_file();
+  NEEDS_WINDOW = /^const\s+GDHARNESS_NEEDS_WINDOW\b[^=\n]*=\s*true\b/m;
+  TEST_DIRECTORIES = ["tests", "test"];
+  SCENE_RUNNER = /\bscene_runner\s*\(/;
+});
+
 // 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 = {};
@@ -36060,13 +36597,13 @@ var init_stdio = __esm(() => {
 });
 
 // src/autoload-failure.ts
-import { existsSync as existsSync19, readFileSync as readFileSync18 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync19 } from "node:fs";
 import { join as join22 } from "node:path";
 function scriptsAutoloaded(projectPath) {
   const scripts = new Map;
   let settings;
   try {
-    settings = parseProjectGodot(readFileSync18(join22(projectPath, "project.godot"), "utf8"));
+    settings = parseProjectGodot(readFileSync19(join22(projectPath, "project.godot"), "utf8"));
   } catch {
     return scripts;
   }
@@ -36080,7 +36617,7 @@ function scriptsAutoloaded(projectPath) {
       continue;
     }
     try {
-      for (const named of readFileSync18(scene, "utf8").matchAll(/^\[ext_resource\b[^\]]*\btype="Script"[^\]]*\bpath="(res:\/\/[^"]+)"/gm)) {
+      for (const named of readFileSync19(scene, "utf8").matchAll(/^\[ext_resource\b[^\]]*\btype="Script"[^\]]*\bpath="(res:\/\/[^"]+)"/gm)) {
         scripts.set(named[1] ?? "", name);
       }
     } catch {}
@@ -36099,7 +36636,7 @@ var init_autoload_failure = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync20, readdirSync as readdirSync12, readFileSync as readFileSync19, statSync as statSync12, unlinkSync as unlinkSync2 } from "node:fs";
+import { existsSync as existsSync20, readdirSync as readdirSync12, readFileSync as readFileSync20, statSync as statSync12, unlinkSync as unlinkSync2 } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir5 } from "node:os";
 import { dirname as dirname12, join as join23, resolve as resolve5 } from "node:path";
@@ -36154,7 +36691,7 @@ function reportAlreadyInTranscript(transcript, report) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync19(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync20(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -36224,7 +36761,7 @@ function discoverRuntimes(directories = runtimeDirectories()) {
 function wentAway(file, pid) {
   let project = "";
   try {
-    const fields = asParams(JSON.parse(readFileSync19(file, "utf8")));
+    const fields = asParams(JSON.parse(readFileSync20(file, "utf8")));
     project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
   } catch {
     return;
@@ -36739,14 +37276,14 @@ var init_runtime_client = __esm(() => {
 });
 
 // src/boot-note.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "node:fs";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync21, writeFileSync as writeFileSync11 } from "node:fs";
 import { dirname as dirname13, join as join24 } from "node:path";
 function bootNotePath(projectPath) {
   return join24(projectPath, ".godot", "gdharness-boot.json");
 }
 function readScenes(projectPath) {
   try {
-    return asParams(asParams(JSON.parse(readFileSync20(bootNotePath(projectPath), "utf8")))["scenes"]);
+    return asParams(asParams(JSON.parse(readFileSync21(bootNotePath(projectPath), "utf8")))["scenes"]);
   } catch {
     return {};
   }
@@ -36788,7 +37325,7 @@ var init_boot_note = __esm(() => {
 });
 
 // src/breakpoint-note.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync21, rmSync as rmSync11, writeFileSync as writeFileSync12 } from "node:fs";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync22, 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 join25(projectPath, ".godot", "gdharness-breakpoints.json");
@@ -36817,7 +37354,7 @@ function writeBreakpointNote(projectPath, held) {
 }
 function readBreakpointNote(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync21(breakpointNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync22(breakpointNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.breakpoints)) {
       return [];
     }
@@ -36850,14 +37387,14 @@ var init_breakpoint_note = __esm(() => {
 });
 
 // src/class-note.ts
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync22 } from "node:fs";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync23 } from "node:fs";
 import { dirname as dirname15, join as join26 } from "node:path";
 function classNotePath(projectPath) {
   return join26(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync22(classNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync23(classNotePath(projectPath), "utf8")));
     const rebuiltWith = readArray(fields, "rebuiltWith");
     if (rebuiltWith === undefined || !rebuiltWith.every((name) => typeof name === "string")) {
       return null;
@@ -36899,7 +37436,7 @@ var init_class_note = __esm(() => {
 });
 
 // src/config-pin.ts
-import { existsSync as existsSync21, readFileSync as readFileSync23 } from "node:fs";
+import { existsSync as existsSync21, readFileSync as readFileSync24 } from "node:fs";
 import { join as join27 } from "node:path";
 function versionsNamedInConfig(projectPath) {
   const config = join27(projectPath, ".mcp.json");
@@ -36908,7 +37445,7 @@ function versionsNamedInConfig(projectPath) {
   }
   let text;
   try {
-    text = readFileSync23(config, "utf8");
+    text = readFileSync24(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -36929,7 +37466,7 @@ var init_config_pin = __esm(() => {
 });
 
 // src/cut-test-run.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync24, rmSync as rmSync12, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync25, rmSync as rmSync12, writeFileSync as writeFileSync13 } from "node:fs";
 import { dirname as dirname16, join as join28 } from "node:path";
 function keptAt(projectPath) {
   return join28(projectPath, ".godot", "gdharness-reports", "cut-run.json");
@@ -36948,7 +37485,7 @@ function takeCutTestRun(projectPath) {
     return null;
   }
   try {
-    const run = JSON.parse(readFileSync24(path, "utf8"));
+    const run = JSON.parse(readFileSync25(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 {
@@ -37764,7 +38301,7 @@ import {
   existsSync as existsSync23,
   mkdirSync as mkdirSync13,
   openSync as openSync4,
-  readFileSync as readFileSync25,
+  readFileSync as readFileSync26,
   readSync as readSync2,
   rmSync as rmSync13,
   statSync as statSync13,
@@ -37779,7 +38316,7 @@ function editorLogNotePath(projectPath) {
 }
 function readEditorLogNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync25(editorLogNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync26(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;
@@ -37878,7 +38415,7 @@ function foldProgress(text) {
 function theFirstOf(path) {
   const whole = statSync13(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
-    return { text: readFileSync25(path, "utf8") };
+    return { text: readFileSync26(path, "utf8") };
   }
   const handle = openSync4(path, "r");
   try {
@@ -38039,7 +38576,7 @@ var init_editor_log = __esm(() => {
 });
 
 // src/rename.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync14, readFileSync as readFileSync26, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync24, mkdirSync as mkdirSync14, readFileSync as readFileSync27, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync15 } from "node:fs";
 import { dirname as dirname18, posix as posix4 } from "node:path";
 
 class Script {
@@ -38744,7 +39281,7 @@ function rewritesOf(plan, texts, move) {
 }
 function applyRewrites(rewrites) {
   for (const rewrite of rewrites) {
-    const now = readFileSync26(rewrite.absolute, "utf8");
+    const now = readFileSync27(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`);
     }
@@ -40144,7 +40681,7 @@ import {
   existsSync as existsSync27,
   mkdirSync as mkdirSync16,
   readdirSync as readdirSync14,
-  readFileSync as readFileSync27,
+  readFileSync as readFileSync28,
   renameSync as renameSync4,
   statSync as statSync14,
   writeFileSync as writeFileSync17
@@ -40304,7 +40841,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   plan = mentionIgnored(plan, ignoredTexts(projectPath), null, [from]);
   const binaries = [];
   for (const path of binaryResources(projectPath)) {
-    const bytes = readFileSync27(join32(projectPath, path.slice("res://".length)));
+    const bytes = readFileSync28(join32(projectPath, path.slice("res://".length)));
     const names = [...moves.keys()].find((moving) => bytes.includes(moving));
     if (names !== undefined) {
       binaries.push({
@@ -40365,7 +40902,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
 }
 function applyFileMove(outcome) {
   for (const rewrite of outcome.inPlace) {
-    if (readFileSync27(rewrite.absolute, "utf8") !== rewrite.before) {
+    if (readFileSync28(rewrite.absolute, "utf8") !== rewrite.before) {
       throw new Error(`${rewrite.path} changed on disk while the move was being worked out; nothing was written`);
     }
   }
@@ -40373,7 +40910,7 @@ function applyFileMove(outcome) {
     if (!existsSync27(file.absoluteFrom)) {
       throw new Error(`${file.from} is gone from disk; nothing was written`);
     }
-    if (file.text !== null && readFileSync27(file.absoluteFrom, "utf8") !== file.text.before) {
+    if (file.text !== null && readFileSync28(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 (existsSync27(file.absoluteTo) && !sameFile(file.absoluteFrom, file.absoluteTo)) {
@@ -40437,7 +40974,7 @@ var init_godot_variant = __esm(() => {
 });
 
 // src/game-debugger.ts
-var PAUSE_MS = 30000, STEP_MS = 1e4, READ_MS = 5000, REPLIES;
+var PAUSE_MS = 30000, STEP_MS = 1e4, RUNTIME_ADDON2 = "res://addons/gdharness_runtime/", READ_MS = 5000, REPLIES;
 var init_game_debugger = __esm(() => {
   init_godot_variant();
   REPLIES = new Set([
@@ -44045,7 +44582,7 @@ var init_godot_bridge = __esm(() => {
 
 // src/import-freshness.ts
 import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync28, readdirSync as readdirSync15, readFileSync as readFileSync28, statSync as statSync15 } from "node:fs";
+import { existsSync as existsSync28, readdirSync as readdirSync15, readFileSync as readFileSync29, statSync as statSync15 } from "node:fs";
 import { join as join33 } from "node:path";
 function md5Of(file) {
   let stats;
@@ -44060,7 +44597,7 @@ function md5Of(file) {
   }
   let md5;
   try {
-    md5 = createHash6("md5").update(readFileSync28(file)).digest("hex");
+    md5 = createHash6("md5").update(readFileSync29(file)).digest("hex");
   } catch {
     return null;
   }
@@ -44106,7 +44643,7 @@ function behind(projectPath, resPath, sidecar) {
   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(readFileSync28(record, "utf8"))?.[1] ?? "";
+    recorded = /^source_md5="([0-9a-f]*)"/m.exec(readFileSync29(record, "utf8"))?.[1] ?? "";
   } catch {
     recorded = "";
   }
@@ -44148,7 +44685,7 @@ function staleImports(projectPath) {
         }
         let sidecar;
         try {
-          sidecar = readFileSync28(join33(directory, entry.name), "utf8");
+          sidecar = readFileSync29(join33(directory, entry.name), "utf8");
         } catch {
           continue;
         }
@@ -44636,7 +45173,7 @@ var init_prompts = __esm(() => {
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync18, readFileSync as readFileSync29, rmSync as rmSync15, writeFileSync as writeFileSync18 } from "node:fs";
+import { mkdirSync as mkdirSync18, readFileSync as readFileSync30, rmSync as rmSync15, writeFileSync as writeFileSync18 } from "node:fs";
 import { dirname as dirname23, join as join35 } from "node:path";
 function restartNotePath(projectPath) {
   return join35(projectPath, ".godot", "gdharness-restart.json");
@@ -44653,7 +45190,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync29(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync30(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -44679,7 +45216,7 @@ var init_restart_note = __esm(() => {
 
 // src/run-record.ts
 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 { mkdirSync as mkdirSync19, openSync as openSync5, readdirSync as readdirSync16, readFileSync as readFileSync31, 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 join36(runtimeDirectory(), "runs");
@@ -44703,7 +45240,7 @@ function writeLatestRun(servedBy, latest) {
 }
 function readLatestRun(servedBy, directory = runtimeDirectory()) {
   try {
-    const fields = JSON.parse(readFileSync30(latestRunPath(servedBy, directory), "utf8"));
+    const fields = JSON.parse(readFileSync31(latestRunPath(servedBy, directory), "utf8"));
     if (typeof fields !== "object" || fields === null) {
       return null;
     }
@@ -44752,7 +45289,7 @@ function readEditorRunNote(projectPath) {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync30(path, "utf8"));
+    parsed = JSON.parse(readFileSync31(path, "utf8"));
   } catch {
     return null;
   }
@@ -44802,7 +45339,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync30(path, "utf8"));
+    parsed = JSON.parse(readFileSync31(path, "utf8"));
   } catch {
     return null;
   }
@@ -44861,7 +45398,7 @@ async function runningAs(pid) {
     const began = await startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync30(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync31(`/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();
@@ -45049,10 +45586,10 @@ var init_run_record = __esm(() => {
 });
 
 // src/script-profile.ts
-import { readFileSync as readFileSync31 } from "node:fs";
+import { readFileSync as readFileSync32 } from "node:fs";
 function readProfileFile(path) {
   try {
-    const parsed = JSON.parse(readFileSync31(path, "utf8"));
+    const parsed = JSON.parse(readFileSync32(path, "utf8"));
     return typeof parsed === "object" && typeof parsed.connected === "boolean" ? parsed : null;
   } catch {
     return null;
@@ -45109,7 +45646,7 @@ function writeProfileMark(path, mark) {
 }
 function readProfileMark(path) {
   try {
-    const parsed = JSON.parse(readFileSync31(path, "utf8"));
+    const parsed = JSON.parse(readFileSync32(path, "utf8"));
     return typeof parsed === "object" && typeof parsed.totals === "object" ? parsed : null;
   } catch {
     return null;
@@ -45251,8 +45788,9 @@ function callersOf(totals, name, scripts) {
     property
   };
 }
-var QUEUE_SETTING = "limits/debugger/max_queued_messages", QUEUE_DEFAULT = 2048, QUEUE_HEADROOM = 512, UNNAMED_PREFIX = "#", PROFILE_FROM_START = "GDHARNESS_PROFILE_FROM_START", ms = (seconds) => Math.round(seconds * 1e6) / 1000, RUNTIME_SCRIPT = "gdharness_runtime/runtime_autoload.gd", PROFILER_PROBE = "_profiler_probe", PROFILER_CALIBRATOR = "_calibrate_the_profiler", RUNTIME_ADDON2 = "res://addons/gdharness_runtime/", CALL_SITES = 40;
+var QUEUE_SETTING = "limits/debugger/max_queued_messages", QUEUE_DEFAULT = 2048, QUEUE_HEADROOM = 512, UNNAMED_PREFIX = "#", PROFILE_FROM_START = "GDHARNESS_PROFILE_FROM_START", ms = (seconds) => Math.round(seconds * 1e6) / 1000, RUNTIME_SCRIPT = "gdharness_runtime/runtime_autoload.gd", PROFILER_PROBE = "_profiler_probe", PROFILER_CALIBRATOR = "_calibrate_the_profiler", CALL_SITES = 40;
 var init_script_profile = __esm(() => {
+  init_game_debugger();
   init_gdscript_source();
   init_godot_variant();
   init_resources();
@@ -45276,10 +45814,10 @@ var init_server_instructions = __esm(() => {
 });
 
 // src/test-selection.ts
-import { existsSync as existsSync29, readFileSync as readFileSync32 } from "node:fs";
+import { existsSync as existsSync29, readFileSync as readFileSync33 } from "node:fs";
 import { basename as basename11, join as join37 } from "node:path";
 function casesIn(projectPath, suite) {
-  const text = readFileSync32(join37(projectPath, suite.slice("res://".length)), "utf8");
+  const text = readFileSync33(join37(projectPath, suite.slice("res://".length)), "utf8");
   return [...text.matchAll(/^func\s+(test_\w*)\s*\(/gm)].map((match) => match[1] ?? "");
 }
 function suitesUnder(projectPath, asked) {
@@ -45351,7 +45889,7 @@ import {
   mkdirSync as mkdirSync20,
   openSync as openSync6,
   readdirSync as readdirSync17,
-  readFileSync as readFileSync33,
+  readFileSync as readFileSync34,
   readSync as readSync3,
   rmdirSync as rmdirSync2,
   statSync as statSync18,
@@ -45370,6 +45908,25 @@ function waitFromEnv(variable, fallback) {
 function greetingWaitMs() {
   return waitFromEnv("GDHARNESS_GREETING_WAIT_MS", 1e4);
 }
+function pictureToSend(pngPath, jpegPath) {
+  const png = readFileSync34(pngPath);
+  const beside = pngPath.replace(/\.png$/, ".jpg");
+  const jpeg = jpegPath !== undefined && normalize2(jpegPath) === normalize2(beside) && existsSync30(beside) ? readFileSync34(beside) : null;
+  const sent = jpeg !== null && jpeg.length < png.length ? jpeg : png;
+  return {
+    data: sent.toString("base64"),
+    mimeType: sent === png ? "image/png" : "image/jpeg",
+    bytes: sent.length,
+    pngBytes: png.length
+  };
+}
+function kilobytes(bytes) {
+  return `${String(Math.max(1, Math.round(bytes / 1024)))} KB`;
+}
+function savedScenesOf(asked, as = "savedScenes") {
+  const saved = readStringArray(asParams(JSON.parse(asked.content[0]?.text ?? "{}")), "saved");
+  return saved === undefined ? {} : { [as]: saved };
+}
 function restartUnderway(note, now = Date.now()) {
   return alive(note.byPid) && now - Date.parse(note.quitAt) < editorRestartTimeoutMs() + 30000;
 }
@@ -45787,7 +46344,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 = readFileSync33(absolutePath, "utf8");
+  const text = readFileSync34(absolutePath, "utf8");
   const lines = text === "" ? 0 : text.split(`
 `).length - (text.endsWith(`
 `) ? 1 : 0);
@@ -45987,7 +46544,7 @@ function notRunNote(notRun, failFast) {
 function exportPresetRefusal(projectPath, preset) {
   let text;
   try {
-    text = readFileSync33(join38(projectPath, "export_presets.cfg"), "utf8");
+    text = readFileSync34(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.`;
   }
@@ -46350,7 +46907,7 @@ function profileFrameFunctions(projectPath) {
   let projectGodot = null;
   if (projectPath !== null) {
     try {
-      projectGodot = readFileSync33(join38(projectPath, "project.godot"), "utf8");
+      projectGodot = readFileSync34(join38(projectPath, "project.godot"), "utf8");
     } catch {}
   }
   return frameFunctionsFor(queuedMessagesOf(projectGodot));
@@ -46374,7 +46931,7 @@ function projectSourceOf(projectPath) {
       let source = null;
       if (inside.ok) {
         try {
-          source = readFileSync33(inside.absolutePath, "utf8");
+          source = readFileSync34(inside.absolutePath, "utf8");
         } catch {}
       }
       read.set(script, source);
@@ -46529,7 +47086,7 @@ function foldedEntriesAnswer(log, floor = "warning") {
 }
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync33(join38(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync34(join38(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -46558,12 +47115,13 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function testPathsIn(projectPath, given) {
-  const entries = given === undefined || given === null || given === "" ? ["test"] : given;
+  const defaults = TEST_DIRECTORIES.filter((directory) => existsSync30(join38(projectPath, directory)));
+  const entries = given === undefined || given === null || given === "" ? defaults.length > 0 ? defaults : TEST_DIRECTORIES : given;
   const listed = Array.isArray(entries) ? entries : [entries];
   if (listed.length === 0) {
     return {
       ok: false,
-      reason: "path is an empty list: name a suite file or a directory, or leave path out for test."
+      reason: "path is an empty list: name a suite file or a directory, or leave path out for tests and test."
     };
   }
   const resolved = [];
@@ -46665,11 +47223,11 @@ function scriptsUnder(directory, prefix) {
   return found;
 }
 function mainSceneOf(projectFile) {
-  const scene = parseProjectGodot(readFileSync33(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync34(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "" ? scene : null;
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync33(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync34(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function ownArguments(params) {
@@ -48496,7 +49054,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync33(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync34(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -48767,6 +49325,8 @@ class GodotServer {
     const userData = scratchDirectory("tests");
     const suitesFile = join38(userData, "suites.txt");
     const skippingFile = join38(userData, "skipping.txt");
+    const engineLog = join38(userData, "engine.log");
+    const expectedFile = join38(userData, "expected.json");
     writeFileSync19(suitesFile, `${(selection.value?.suites ?? asked).join(`
 `)}
 `);
@@ -48778,6 +49338,8 @@ class GodotServer {
       "--path",
       project.value.path,
       ...flags.value,
+      "--log-file",
+      engineLog,
       "-s",
       this.listedRunner,
       "--ignoreHeadlessMode",
@@ -48791,7 +49353,9 @@ class GodotServer {
       suitesFile,
       "--skipping-in",
       skippingFile,
-      "--html-report-off"
+      "--html-report-off",
+      "--expected-errors-out",
+      expectedFile
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
@@ -48846,11 +49410,13 @@ class GodotServer {
     const reportsDir = join38(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
+    const casePrinted = readRun(existsSync30(engineLog) ? readFileSync34(engineLog, "utf8") : "");
+    const declaredErrors = readExpected(expectedFile);
     try {
       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(readFileSync33(join38(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync34(join38(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -48961,7 +49527,44 @@ class GodotServer {
       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.hookFailures > 0 || suite.hookErrors > 0 || suite.skipped > 0 || orphansIn(suite.path) > 0);
+    const judgedErrors = unexpectedErrors(casePrinted, declaredErrors, [...casePrinted.suites.keys()]);
+    const uncaughtTexts = new Set(uncaught.map((entry) => entry.text));
+    const undeclaredPrinted = judgedErrors.printed.filter((error) => !uncaughtTexts.has(error.text));
+    const undeclaredFolded = new Map;
+    for (const error of undeclaredPrinted) {
+      const key = `${error.suite ?? ""}
+${error.during ?? ""}
+${error.text}`;
+      const seen = undeclaredFolded.get(key);
+      if (seen === undefined) {
+        undeclaredFolded.set(key, {
+          suite: error.suite ?? undefined,
+          case: error.during ?? undefined,
+          text: error.text,
+          times: 1
+        });
+      } else {
+        seen.times += 1;
+      }
+    }
+    const undeclaredAll = [...undeclaredFolded.values()].map((error) => ({
+      ...error,
+      times: error.times > 1 ? error.times : undefined
+    }));
+    const undeclaredErrors = undeclaredAll.slice(0, MOST_UNDECLARED_ERRORS);
+    const declaredNotPrinted = judgedErrors.neverPrinted.map((missing) => ({
+      suite: missing.suite,
+      case: missing.during,
+      text: missing.text
+    }));
+    const erring = (path) => ({
+      undeclared: undeclaredPrinted.filter((error) => error.suite === path).length,
+      notPrinted: judgedErrors.neverPrinted.filter((missing) => missing.suite === path).length
+    });
+    const declaredAndPrinted = casePrinted.errors.length - judgedErrors.printed.length;
+    const ranIn = (suite) => suite.path === null ? suite.tests : casePrinted.suites.get(suite.path)?.cases.length ?? suite.tests;
+    const notRunIn = (suite) => Math.max(0, suite.discovered - ranIn(suite));
+    const unclean = report.suites.filter((suite) => suite.failures > 0 || suite.errors > 0 || suite.hookFailures > 0 || suite.hookErrors > 0 || suite.skipped > 0 || orphansIn(suite.path) > 0 || erring(suite.path).undeclared + erring(suite.path).notPrinted > 0);
     const hooksPrinted = hookFailuresPrinted(said);
     const hookFailures = report.suites.filter((suite) => suite.hookFailures + suite.hookErrors > 0).flatMap((suite) => {
       const printedHere = hooksPrinted.filter((hook) => hook.path === suite.path);
@@ -48973,7 +49576,7 @@ class GodotServer {
         }
       ];
     });
-    const notRun = report.suites.reduce((sum, suite) => sum + Math.max(0, suite.discovered - suite.tests), 0);
+    const notRun = report.suites.reduce((sum, suite) => sum + notRunIn(suite), 0);
     const uncaughtFolded = foldedRepeats(uncaught.map(aboveTheRunner));
     const listedAsUncaught = new Set(uncaughtFolded.map((entry) => entry.index));
     const notApplied = ignoredYetRan(report, ignored);
@@ -48981,8 +49584,13 @@ class GodotServer {
       ...new Set((selection.value?.selected ?? []).filter((one) => !report.suites.some((suite) => (suite.path === one.suite || suite.name === basename12(one.suite, ".gd")) && suite.cases.some((ran) => ran.name === one.test || new RegExp(`^${one.test}\\W`).test(ran.name)))).map((one) => `${basename12(one.suite, ".gd")}:${one.test}`))
     ];
     return this.jsonTextResponse({
-      passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0 && uncaught.length === 0 && missing.length === 0 && testsNotRun.length === 0,
-      verdict: testsNotRun.length === 0 ? verdict : `${verdict}; not run: ${testsNotRun.join(", ")}`,
+      passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0 && uncaught.length === 0 && undeclaredPrinted.length === 0 && declaredNotPrinted.length === 0 && missing.length === 0 && testsNotRun.length === 0,
+      verdict: [
+        verdict === "passed" && undeclaredPrinted.length + declaredNotPrinted.length > 0 ? undefined : verdict,
+        undeclaredPrinted.length > 0 ? `${undeclaredPrinted.length === 1 ? "one engine error" : `${String(undeclaredPrinted.length)} engine errors`} no suite declared` : undefined,
+        declaredNotPrinted.length > 0 ? `${declaredNotPrinted.length === 1 ? "one declared error" : `${String(declaredNotPrinted.length)} declared errors`} never printed` : undefined,
+        testsNotRun.length > 0 ? `not run: ${testsNotRun.join(", ")}` : undefined
+      ].filter((part) => part !== undefined).join("; "),
       ...missing.length > 0 ? { missing } : {},
       ...testsNotRun.length > 0 ? { testsNotRun } : {},
       ...timedOut ? { timedOut, hung, silentForMs } : {},
@@ -48998,6 +49606,9 @@ class GodotServer {
       failedWithoutDetail: briefed > 0 ? briefed : undefined,
       hookFailures: hookFailures.length > 0 ? hookFailures : undefined,
       uncaughtScriptErrors: uncaughtFolded.length > 0 ? uncaughtFolded : undefined,
+      undeclaredErrors: undeclaredErrors.length > 0 ? undeclaredErrors : undefined,
+      undeclaredErrorsOmitted: undeclaredAll.length > undeclaredErrors.length ? undeclaredAll.length - undeclaredErrors.length : undefined,
+      declaredNotPrinted: declaredNotPrinted.length > 0 ? declaredNotPrinted : undefined,
       warnings: warnings.length > 0 ? warnings : undefined,
       orphans: orphans.total > 0 ? orphans.total : undefined,
       notRun: notRun > 0 ? notRun : undefined,
@@ -49011,13 +49622,17 @@ class GodotServer {
         briefed > 0 ? `${briefed} of the ${failed.length} failing cases, those with the largest reports, are named with their first message only, since their reports would have made the answer too large to deliver; pass one case's suite path to see its reports.` : undefined,
         notApplied.length > 0 ? "An ignore entry named a case that ran all the same: gdUnit4 leaves a case out only as suite_name:test_name, and reads an entry with no colon as a suite name or a piece of a suite path. ignoreNotApplied gives the form for each case that ran." : undefined,
         uncaughtNote(uncaught),
+        undeclaredErrors.length > 0 ? `An engine error a suite does not declare fails the run, as gdharness test judges it; ${declaringAdvice(undeclaredErrors[0]?.case ?? "test_name")}, once for each time it prints it.` : undefined,
+        declaredNotPrinted.length > 0 ? "A declared error the case did not print fails the run too, since the case no longer reaches what it was written to test." : undefined,
         ranAs.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." : notRunNote(notRun, readBoolean(args, "failFast") === true)
       ].filter((part) => part !== undefined).join(" ") || undefined,
       suites: unclean.map((suite) => ({
         name: suite.name,
         path: suite.path,
-        tests: suite.tests,
-        notRun: suite.discovered > suite.tests ? suite.discovered - suite.tests : undefined,
+        tests: ranIn(suite),
+        notRun: notRunIn(suite) > 0 ? notRunIn(suite) : undefined,
+        undeclaredErrors: erring(suite.path).undeclared > 0 ? erring(suite.path).undeclared : undefined,
+        declaredNotPrinted: erring(suite.path).notPrinted > 0 ? erring(suite.path).notPrinted : undefined,
         failures: suite.failures,
         errors: suite.errors,
         hookFailures: suite.hookFailures + suite.hookErrors > 0 ? suite.hookFailures + suite.hookErrors : undefined,
@@ -49026,7 +49641,7 @@ class GodotServer {
         time: suite.time
       })),
       suitesPassed: report.suites.length - unclean.length,
-      engineErrors: run.log.count("error"),
+      engineErrors: Math.max(0, run.log.count("error") - declaredAndPrinted),
       engineWarnings: run.log.count("warning"),
       engineEntries: engineEntriesShown.map((entry) => listedAsUncaught.has(entry.index) ? { ...entry, detail: undefined, detailUnder: "uncaughtScriptErrors" } : entry),
       engineEntriesOmitted: engineEntries.length > engineEntriesShown.length ? engineEntries.length - engineEntriesShown.length : undefined,
@@ -49242,7 +49857,7 @@ class GodotServer {
         return null;
       }
       try {
-        return readFileSync33(contained.absolutePath, "utf8");
+        return readFileSync34(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -49336,7 +49951,7 @@ class GodotServer {
       return null;
     }
     try {
-      return readFileSync33(contained.absolutePath, "utf8");
+      return readFileSync34(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -49772,8 +50387,9 @@ class GodotServer {
     if (servers.dapListening !== false && servers.lspListening !== false) {
       return { servers, report: {} };
     }
-    const { rebound, said } = await this.editorServersSaid(servers.dapListening === false);
+    const { rebound, before, since } = await this.editorServersSaid(servers.dapListening === false);
     const after = rebound ? await this.editorServersListening() : servers;
+    const said = [...before, ...since];
     return {
       servers: after,
       report: {
@@ -49791,17 +50407,18 @@ class GodotServer {
     }
     return {
       rebound: readBoolean(answer, "rebound") === true,
-      said: [...readStringArray(answer, "said") ?? [], ...readStringArray(answer, "saidSince") ?? []]
+      before: readStringArray(answer, "said") ?? [],
+      since: 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 refused = await this.noEditorYet({}, []);
+      if (refused !== null) {
+        return refused;
+      }
     }
-    const { rebound, said } = await this.editorServersSaid(true);
+    const { rebound, since: 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"]);
     }
@@ -49817,7 +50434,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync33(join38(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync34(join38(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -49865,6 +50482,7 @@ class GodotServer {
       serverVersion: SERVER_VERSION,
       addonIsStale: this.godotBridge.anotherRelease() !== undefined,
       staleNote: this.godotBridge.anotherRelease(),
+      ...savedScenesOf(asked),
       ...this.whatTheEditorDropped(settingsBefore, after),
       ...servers,
       ...rebinding,
@@ -49908,6 +50526,7 @@ class GodotServer {
       closed: true,
       editorPid: pid,
       projectPath: before.projectPath,
+      ...savedScenesOf(asked),
       ...this.whatTheEditorDropped(settingsBefore, this.settingKeysOf(before.projectPath)),
       tookMs: Date.now() - began
     });
@@ -49991,7 +50610,7 @@ class GodotServer {
     if (opened.error !== null) {
       return this.createErrorResponse(`The editor was asked to go and could not be started again: ${opened.error}`, [`editor_launch opens one on ${projectPath}`]);
     }
-    return this.jsonTextResponse({ restarting: true, pid: opened.pid });
+    return this.jsonTextResponse({ restarting: true, pid: opened.pid, ...savedScenesOf(asked, "saved") });
   }
   async waitForBridge(reached, deadline) {
     for (;; ) {
@@ -50050,7 +50669,7 @@ class GodotServer {
       dapPort: ports.dap,
       arguments: opened.arguments,
       finishesRestart: unfinished === null ? undefined : `This is the launch half of a restart begun at ${unfinished.quitAt} by server pid ${unfinished.byPid}, which quit editor pid ${unfinished.editorPid ?? "unknown"} and was ended before it could start one.`,
-      settingsNote: before === null ? "project.godot could not be read before this editor was opened, so nothing here will be able to say what the import saved away. Opening a project rewrites the file and drops any key sitting at its own default." : before.size === 0 ? undefined : "Opening a project imports it and saves project.godot, and Godot drops any key sitting at its own default. editor_status names anything lost under settingsDropped once this editor has connected."
+      settingsNote: before === null ? "project.godot could not be read before this editor was opened, so nothing here will be able to say what the import saved away. Opening a project rewrites the file and drops any key sitting at its own default." : before.size === 0 ? undefined : "Opening a project imports it and saves project.godot, and Godot drops any key sitting at its own default. editor_status names anything lost under settingsDropped once this editor has connected, and leaves settingsDropped out when nothing was."
     });
   }
   async editorsNotYetConnected(projectPath) {
@@ -50542,7 +51161,7 @@ class GodotServer {
       return 0;
     }
     try {
-      return reportAlreadyInTranscript(readFileSync33(game.transcript), readFileSync33(report));
+      return reportAlreadyInTranscript(readFileSync34(game.transcript), readFileSync34(report));
     } catch (error) {
       this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
       return 0;
@@ -52627,7 +53246,7 @@ class GodotServer {
     }
     const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const declared = new RegExp(`^\\s*(?:@\\w+(?:\\([^)]*\\))?\\s+)*class_name\\s+${escaped}\\b`, "m");
-    if (declared.test(readFileSync33(scriptPath, "utf8"))) {
+    if (declared.test(readFileSync34(scriptPath, "utf8"))) {
       return null;
     }
     const checked = await this.classesTheEditorCannotSee(args);
@@ -52692,6 +53311,10 @@ class GodotServer {
         "editor_launch open starts another"
       ]);
     }
+    const closed = this.closedHere;
+    if (closed !== null && (project === null || (await this.editorsNotYetConnected(project) ?? []).length === 0)) {
+      return this.createErrorResponse(`Editor not connected: this server closed the editor, pid ${closed.editorPid}, on request at ${closed.at}, so nothing is coming until one is opened.`, [...instead, "editor_launch open starts one on the project"]);
+    }
     return this.createErrorResponse("Editor not connected: no Godot editor with the gdharness editor addon has reached this server.", [
       ...instead,
       "Open the project in the editor with editor_launch, or by hand",
@@ -52840,7 +53463,8 @@ class GodotServer {
   }
   async handleRuntimeCommand(command, args, asked) {
     const timeoutMs = asked.patience ?? this.runtimeTimeoutMs();
-    const { op: _op, projectPath, pid, outputPath, ...params } = asParams(args);
+    const callArgs = asParams(args);
+    const { op: _op, projectPath, pid, outputPath, inline: _inline, ...params } = callArgs;
     const waited = typeof pid === "number" ? null : await this.ownRunOnItsWay(typeof projectPath === "string" ? projectPath : this.ownProject, timeoutMs);
     if (waited !== null) {
       return this.createErrorResponse(waited, [
@@ -52873,6 +53497,13 @@ class GodotServer {
     }
     const expectsScreenshot = command === "capture_screenshot" || command === "capture_viewport";
     const saveTo = expectsScreenshot && typeof outputPath === "string" ? outputPath : null;
+    const sendsThePicture = readBoolean(callArgs, "inline") !== false;
+    if (expectsScreenshot && !sendsThePicture && saveTo === null) {
+      return this.createErrorResponse("inline: false sends no picture back, so it needs outputPath to save one to; without it the capture would answer nothing to look at.", [
+        "Pass outputPath, an absolute path ending in .png outside the project",
+        "Or leave inline out to have the picture sent"
+      ]);
+    }
     if (saveTo !== null) {
       const refusal = captureDestinationRefusal(saveTo, [
         choice.endpoint.project.path,
@@ -52940,15 +53571,17 @@ class GodotServer {
         }
       }
       const ranWith = [...onGame.alongside];
+      const sent = sendsThePicture ? pictureToSend(screenshotPath, readString(payload, "jpegPath")) : null;
+      const how = sent === null ? ". Not sent, as inline: false asked" : sent.mimeType === "image/jpeg" ? `. Sent as JPEG, ${kilobytes(sent.bytes)} against the PNG's ${kilobytes(sent.pngBytes)}${saveTo === null ? "" : "; the saved PNG is lossless"}` : "";
       return {
         content: [
           {
             type: "text",
-            text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${captureDetail(payload)}${saveTo === null ? "" : `. Saved to ${saveTo}`}${ranWith.length === 0 ? "" : `
+            text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${captureDetail(payload)}${saveTo === null ? "" : `. Saved to ${saveTo}`}${how}${ranWith.length === 0 ? "" : `
 
 Ran alongside ${ranWith.join(", ")}. ${ALONGSIDE_NOTE}`}`
           },
-          { type: "image", data: readFileSync33(screenshotPath).toString("base64"), mimeType: "image/png" }
+          ...sent === null ? [] : [{ type: "image", data: sent.data, mimeType: sent.mimeType }]
         ]
       };
     } finally {
@@ -53065,7 +53698,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, FAILED_BUDGET = 1e6, ANSWER_BUDGET = 4000000, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, ALONGSIDE_NOTE = "Another call on this game was running while this one was: calls sent together run together and are answered as each finishes, so this answer is not from after the other. Send a call meant to come after another once that one has answered.", OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, CLOSE_ASK_MS = 3000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", LOOPING_AFTER = 100, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, OUTPUT_PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, FAILED_BUDGET = 1e6, ANSWER_BUDGET = 4000000, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, ALONGSIDE_NOTE = "Another call on this game was running while this one was: calls sent together run together and are answered as each finishes, so this answer is not from after the other. Send a call meant to come after another once that one has answered.", OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, CLOSE_ASK_MS = 3000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", LOOPING_AFTER = 100, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, OUTPUT_PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, MOST_UNDECLARED_ERRORS = 20, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
 var init_server = __esm(() => {
   init_dist();
   init_stdio();
@@ -53123,6 +53756,8 @@ var init_server = __esm(() => {
   init_server_version();
   init_setup();
   init_spawn();
+  init_suite_judge();
+  init_suite_plan();
   init_test_selection();
   init_tool_definitions();
   init_tool_reference();
@@ -54298,6 +54933,11 @@ engines would otherwise announce sixteen games that are not games. Set \`${SCRIP
 true in \`project.godot\` to serve one anyway, which is for driving a \`-s\` script on purpose. Read
 that setting rather than assuming the quiet: it is a default and not a property of script runs.
 
+A scene that is not the game, such as a bench, is run as a scene and is served like the game unless
+the project lists its folder in \`${QUIET_SCENES_SETTING}\`, a \`PackedStringArray\` of \`res://\`
+prefixes, empty by default. A run started on a scene under one of them neither serves nor
+announces, nor do the engines it starts, unless it was started to be profiled from its start.
+
 The autoload reaches an export. \`gdharness runtime off\` in the project before shipping.
 
 ## At a breakpoint
@@ -54490,13 +55130,13 @@ import {
   mkdirSync as mkdirSync8,
   openSync as openSync3,
   readdirSync as readdirSync11,
-  readFileSync as readFileSync17,
+  readFileSync as readFileSync18,
   readSync,
   rmSync as rmSync10,
   statSync as statSync11,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { availableParallelism, freemem } from "node:os";
+import { availableParallelism, freemem, totalmem } 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";
@@ -54785,516 +55425,12 @@ function extensionsOf(projectPath) {
 `).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/suite-run.ts
+init_suite_judge();
+init_suite_plan();
 
 // src/version.ts
-import { readFileSync as readFileSync16 } from "node:fs";
+import { readFileSync as readFileSync17 } from "node:fs";
 import { dirname as dirname11, join as join20 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getLocalVersion() {
@@ -55305,7 +55441,7 @@ function getLocalVersion() {
   ];
   for (const packagePath of packageCandidates) {
     try {
-      const value = JSON.parse(readFileSync16(packagePath, "utf-8"));
+      const value = JSON.parse(readFileSync17(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;
       }
@@ -55402,7 +55538,8 @@ function resPathOf(entry, projectPath, cwd) {
   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 fromHere = resolve4(cwd, file);
+  const absolute = isAbsolute4(file) || !existsSync18(fromProject) && existsSync18(fromHere) ? fromHere : fromProject;
   const inside = relative3(projectPath, absolute);
   if (inside.startsWith("..") || isAbsolute4(inside)) {
     throw new TestUsageError(`${entry} is not inside the project at ${projectPath}.`);
@@ -55414,7 +55551,7 @@ 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))));
+  const roots = options.roots.length > 0 ? options.roots : TEST_DIRECTORIES.filter((root) => existsSync18(join21(options.projectPath, root))).map((root) => `res://${root}`);
   if (options.selected.length === 0) {
     const found = scripts.suitesUnder(roots);
     if (found.length === 0) {
@@ -55429,7 +55566,7 @@ function selectedSuites(scripts, options) {
     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}.`);
+      throw new TestUsageError(existsSync18(directory) ? `${path} holds no gdUnit4 suite: nothing there extends GdUnitTestSuite and declares a test_ function.` : `Nothing at ${path} in the project at ${options.projectPath}.`);
     }
     for (const suite of suites) {
       const picked = chosen.get(suite.path) ?? { suite, cases: new Set };
@@ -55448,9 +55585,32 @@ function selectedSuites(scripts, options) {
     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 roomFor(most, processors, available) {
+  const byMemory = Math.floor((available - MEMORY_KEPT) / MEMORY_PER_ENGINE);
+  const engines = Math.max(1, Math.min(most, processors, byMemory));
+  if (engines >= most) {
+    return { engines, held: undefined };
+  }
+  const gigabytes = (bytes) => `${(bytes / 1024 ** 3).toFixed(1)} GB`;
+  return {
+    engines,
+    held: byMemory < processors ? `the machine has ${gigabytes(Math.max(0, available))} of memory free, ${gigabytes(MEMORY_KEPT)} of it kept for everything else and ${gigabytes(MEMORY_PER_ENGINE)} taken for each engine` : `the machine has ${plural(processors, "processor")}`
+  };
+}
+async function memoryAvailable() {
+  const level = await macMemoryLevel();
+  return level === null ? freemem() : totalmem() * level / 100;
+}
+async function macMemoryLevel() {
+  if (process12.platform !== "darwin") {
+    return null;
+  }
+  try {
+    const level = Number((await runHidden("sysctl", ["-n", "kern.memorystatus_level"])).stdout.trim());
+    return Number.isFinite(level) && level > 0 && level <= 100 ? level : null;
+  } catch {
+    return null;
+  }
 }
 function ordered(units, order) {
   const sorted = [...units].sort((a, b) => a.suite.localeCompare(b.suite));
@@ -55522,9 +55682,9 @@ async function runTestCommand(options, godotPath) {
     }
     const fingerprints = new SuiteFingerprints(scripts, [
       getLocalVersion(),
-      readFileSync17(shippedListedRunner(), "utf8"),
+      readFileSync18(shippedListedRunner(), "utf8"),
       ...options.reachAlso.map((path) => `${path}
-${existsSync18(path) ? readFileSync17(path, "latin1") : "missing"}`)
+${existsSync18(path) ? readFileSync18(path, "latin1") : "missing"}`)
     ]);
     const printsOf = new Map(suites.map((suite) => [suite.path, fingerprints.of(suite)]));
     if (options.changedOnly) {
@@ -55535,7 +55695,7 @@ ${existsSync18(path) ? readFileSync17(path, "latin1") : "missing"}`)
       });
       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.`);
+        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: ${named(unchanged.map((suite) => suite.path))}.`);
       }
       if (suites.length === 0) {
         console.log("Nothing has changed since every suite last passed.");
@@ -55545,9 +55705,16 @@ ${existsSync18(path) ? readFileSync17(path, "latin1") : "missing"}`)
     }
     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 room = roomFor(options.engines, availableParallelism(), await memoryAvailable());
+    const plans = options.order === null ? dealt(units, declared, room.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" : ""}.`);
+    const held = options.order === null && room.held !== undefined && plans.length === room.engines ? `, of the ${String(options.engines)} asked for, since ${room.held}` : "";
+    const how = options.order === null ? `${plans.some((plan) => plan.windowed) ? ", one of them windowed" : ""}${held}` : options.order === "reversed" ? ", in reverse order of path" : `, shuffled by ${String(options.order)}`;
+    console.log(`${plural(functions, "test function")} in ${plural(suites.length, "suite")} over ${plural(plans.length, "engine")}${how}.`);
+    const split = [...new Set(units.map((unit) => unit.suite))].filter((path) => units.filter((unit) => unit.suite === path).length > 1);
+    if (plans.length > 1 && split.length > 0) {
+      console.log(`Dealt out case by case, since ${split.length === 1 ? "it" : "each"} took more than ${String(SPLIT_PAST_SECONDS)} s last time: ${named(split)}.`);
+    }
     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.");
@@ -55570,7 +55737,7 @@ function plural(count, noun) {
 }
 function readRecord(file) {
   try {
-    const parsed = JSON.parse(readFileSync17(file, "utf8"));
+    const parsed = JSON.parse(readFileSync18(file, "utf8"));
     return typeof parsed === "object" && parsed !== null ? parsed : {};
   } catch {
     return {};
@@ -55673,7 +55840,7 @@ async function runEngine2(launch, plan, index, units, again = "") {
   } finally {
     launch.slots.release(lock);
   }
-  const printed = readRun(readFileSync17(log, "utf8"));
+  const printed = readRun(readFileSync18(log, "utf8"));
   const assignment = { suites: plan.suites, expected: readExpected(expectedFile) };
   return {
     index,
@@ -55684,14 +55851,6 @@ async function runEngine2(launch, plan, index, units, again = "") {
     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 };
@@ -55813,12 +55972,17 @@ function report(ran, startedAt, runDirectory) {
   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;
+  const totals = `${plural(cases, "case")} in ${plural(suites, "suite")} across ${plural(ran.length, "engine")}, ${took.toFixed(1)} s; the longest engine took ${longest.toFixed(1)} s.`;
+  console.log("");
   if (failed.length === 0) {
     rmSync10(runDirectory, { recursive: true, force: true });
+    console.log(`Passed: ${totals}`);
+    return 0;
   }
-  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;
+  const problems = failed.reduce((sum, engine) => sum + engine.verdict.faults.length, 0);
+  console.log(`Failed: ${plural(problems, "problem")}, listed above. Ran ${totals}`);
+  console.log(`Every engine's output is kept under ${runDirectory} until the next run.`);
+  return 1;
 }
 
 // src/cli.ts