gdharness 1.3.10 → 1.3.12

package/build/cli.js

@@ -10094,7 +10094,15 @@ var init_import_freshness = __esm(() => {
 });
 
 // src/library-copies.ts
-import { existsSync as existsSync9, readdirSync as readdirSync7, readFileSync as readFileSync7, renameSync, unlinkSync } from "node:fs";
+import {
+  existsSync as existsSync9,
+  mkdirSync as mkdirSync3,
+  readdirSync as readdirSync7,
+  readFileSync as readFileSync7,
+  renameSync,
+  unlinkSync,
+  writeFileSync as writeFileSync3
+} from "node:fs";
 import { basename as basename6, dirname as dirname6, isAbsolute as isAbsolute5, join as join10 } from "node:path";
 function freeLibraryCopies(projectPath, platform = process.platform) {
   const setAside = [];
@@ -10129,6 +10137,44 @@ function freeLibraryCopies(projectPath, platform = process.platform) {
   }
   return { setAside, swept };
 }
+function seedExtensionList(projectPath) {
+  const list = join10(projectPath, ".godot", "extension_list.cfg");
+  if (existsSync9(list)) {
+    return null;
+  }
+  const found = [];
+  const visit = (directory, resDirectory) => {
+    if (existsSync9(join10(directory, ".gdignore"))) {
+      return;
+    }
+    let entries;
+    try {
+      entries = readdirSync7(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        visit(join10(directory, entry.name), `${resDirectory}${entry.name}/`);
+      } else if (entry.name.endsWith(".gdextension")) {
+        found.push(`${resDirectory}${entry.name}`);
+      }
+    }
+  };
+  visit(projectPath, "res://");
+  if (found.length === 0) {
+    return [];
+  }
+  found.sort();
+  mkdirSync3(dirname6(list), { recursive: true });
+  writeFileSync3(list, `${found.join(`
+`)}
+`);
+  return found;
+}
 function windowsLibraries(projectPath) {
   const listed = readOrNull(join10(projectPath, ".godot", "extension_list.cfg"));
   if (listed === null) {
@@ -10177,7 +10223,7 @@ var init_library_copies = () => {};
 
 // src/reimport.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync10, readFileSync as readFileSync8, rmSync as rmSync3, statSync as statSync8, utimesSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync8, rmSync as rmSync3, statSync as statSync8, utimesSync, writeFileSync as writeFileSync4 } from "node:fs";
 import { basename as basename7, join as join11 } from "node:path";
 function forceNextImport(projectPath, resourcePath) {
   const relative = resourcePath.replace(/^res:\/\//, "");
@@ -10186,7 +10232,7 @@ function forceNextImport(projectPath, resourcePath) {
     return;
   }
   const { atime, mtimeMs } = statSync8(sidecar);
-  writeFileSync3(sidecar, readFileSync8(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
+  writeFileSync4(sidecar, readFileSync8(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
   utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
   rmSync3(importRecord(projectPath, resourcePath), { force: true });
 }
@@ -10961,7 +11007,7 @@ var init_script_origins = __esm(() => {
 });
 
 // src/headless.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync12, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "node:fs";
 import { dirname as dirname7, join as join14 } from "node:path";
 function snakeCased(params) {
   const result = emptyRecord();
@@ -11156,7 +11202,7 @@ async function operationOutcome(engine, operation, params, projectPath) {
   const paramsDir = scratchDirectory("params");
   const paramsFile = join14(paramsDir, `${operation}.json`);
   const answerFile = join14(paramsDir, "answer.json");
-  writeFileSync4(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
+  writeFileSync5(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     ...engine.editor === true ? ["--editor"] : [],
@@ -11277,7 +11323,7 @@ var init_headless = __esm(() => {
 });
 
 // src/update-check.ts
-import { existsSync as existsSync13, mkdirSync as mkdirSync3, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir4, tmpdir as tmpdir3 } from "node:os";
 import { join as join15 } from "node:path";
 function packageUrl(root) {
@@ -11311,7 +11357,7 @@ function cacheDirectory(environment) {
 function cacheFile(environment = process.env) {
   try {
     const directory = cacheDirectory(environment);
-    mkdirSync3(directory, { recursive: true, mode: 448 });
+    mkdirSync4(directory, { recursive: true, mode: 448 });
     return join15(directory, "update-check.json");
   } catch {
     return join15(tmpdir3(), "gdharness-update-check.json");
@@ -11339,7 +11385,7 @@ function readCache(path) {
 }
 function writeCache(path, entry) {
   try {
-    writeFileSync5(path, JSON.stringify(entry), { encoding: "utf8", mode: 384 });
+    writeFileSync6(path, JSON.stringify(entry), { encoding: "utf8", mode: 384 });
   } catch {}
 }
 function parts(version) {
@@ -12023,13 +12069,13 @@ import { createHash as createHash4 } from "node:crypto";
 import {
   cpSync,
   existsSync as existsSync14,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   readdirSync as readdirSync9,
   readFileSync as readFileSync13,
   rmdirSync,
   rmSync as rmSync5,
   statSync as statSync9,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "node:fs";
 import { dirname as dirname8, join as join16 } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -12118,15 +12164,15 @@ function installAddons(projectPath, from = shippedAddonsDirectory()) {
     const target = join16(projectPath, "addons", name);
     const replaced = existsSync14(target);
     rmSync5(target, { recursive: true, force: true });
-    mkdirSync4(dirname8(target), { recursive: true });
+    mkdirSync5(dirname8(target), { recursive: true });
     cpSync(source, target, { recursive: true });
-    writeFileSync6(join16(target, VERSION_MARKER), `${SERVER_VERSION}
+    writeFileSync7(join16(target, VERSION_MARKER), `${SERVER_VERSION}
 `);
     installed.push({ name, path: target, replaced });
   }
-  writeFileSync6(join16(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
+  writeFileSync7(join16(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
 `);
-  writeFileSync6(join16(projectPath, "addons", RUNTIME_ADDON, DIGEST_MARKER), `${runtimeAddonDigest(from)}
+  writeFileSync7(join16(projectPath, "addons", RUNTIME_ADDON, DIGEST_MARKER), `${runtimeAddonDigest(from)}
 `);
   return installed;
 }
@@ -14767,7 +14813,7 @@ import {
   readFileSync as readFileSync14,
   rmSync as rmSync7,
   statSync as statSync10,
-  writeFileSync as writeFileSync8,
+  writeFileSync as writeFileSync9,
   writeSync
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
@@ -14816,7 +14862,7 @@ async function ensureHelperCompiled(directory = tmpdir4(), budgetMs = HELPER_COM
 async function compileHelper(directory, assembly, budgetMs) {
   const scratch = mkdtempSync2(join18(directory, "gdharness-desktop-source-"));
   const source = join18(scratch, "helper.cs");
-  writeFileSync8(source, SOURCE, "utf8");
+  writeFileSync9(source, SOURCE, "utf8");
   const literal = (path) => `'${path.replaceAll("'", "''")}'`;
   const script = [
     "$ErrorActionPreference = 'Stop'",
@@ -14902,9 +14948,10 @@ function throughHelper(how, command, args, files, assembly = helperAssembly()) {
     how.noActivate === true ? "1" : "0",
     files.stop,
     how.directory,
-    files.step
+    files.step,
+    how.affinity === undefined ? "" : how.affinity.toString()
   ];
-  writeFileSync8(files.spec, fields.map((field) => Buffer.from(field, "utf8").toString("base64")).join(`
+  writeFileSync9(files.spec, fields.map((field) => Buffer.from(field, "utf8").toString("base64")).join(`
 `), "utf8");
   const literal = (path) => `'${path.replaceAll("'", "''")}'`;
   const script = [
@@ -14976,6 +15023,9 @@ public static class GdharnessDesktop {
   [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr handle);
   [DllImport("kernel32.dll")] static extern bool TerminateProcess(IntPtr handle, uint code);
   [DllImport("kernel32.dll")] static extern uint SetErrorMode(uint mode);
+  [DllImport("kernel32.dll", SetLastError = true)] static extern bool SetProcessAffinityMask(IntPtr process, UIntPtr mask);
+  [DllImport("kernel32.dll")] static extern uint ResumeThread(IntPtr thread);
+  const uint CreateSuspended = 0x4;
   const uint FailCriticalErrors = 0x1;
   const uint NoOpenFileErrorBox = 0x8000;
 
@@ -15037,7 +15087,8 @@ public static class GdharnessDesktop {
   public static int RunSpec(string specFile) {
     string[] lines = File.ReadAllLines(specFile);
     Func<int, string> field = delegate(int index) { return Encoding.UTF8.GetString(Convert.FromBase64String(lines[index])); };
-    return Run(field(0), field(1), field(2), field(3) == "1", field(4), field(5), field(6));
+    string affinity = lines.Length > 7 ? field(7) : "";
+    return Run(field(0), field(1), field(2), field(3) == "1", field(4), field(5), field(6), affinity.Length == 0 ? 0UL : ulong.Parse(affinity));
   }
 
   static void Step(string stepFile, string step) {
@@ -15046,7 +15097,9 @@ public static class GdharnessDesktop {
     }
   }
 
-  public static int Run(string desktop, string commandLine, string pidFile, bool noActivate, string stopFile, string directory, string stepFile) {
+  // With an affinity, the process starts suspended and is held to those processors before its
+  // first thread runs, so every thread it starts afterwards is held to them as well.
+  public static int Run(string desktop, string commandLine, string pidFile, bool noActivate, string stopFile, string directory, string stepFile, ulong affinity) {
     StartupInfo startup = new StartupInfo();
     startup.cb = Marshal.SizeOf(typeof(StartupInfo));
     if (desktop.Length > 0) {
@@ -15076,9 +15129,19 @@ public static class GdharnessDesktop {
     }
     try {
     Step(stepFile, "starting the process");
-    if (!CreateProcessW(null, new StringBuilder(commandLine), IntPtr.Zero, IntPtr.Zero, true, DetachedProcess, IntPtr.Zero, directory, ref startup, out started)) {
+    uint creation = DetachedProcess | (affinity == 0 ? 0u : CreateSuspended);
+    if (!CreateProcessW(null, new StringBuilder(commandLine), IntPtr.Zero, IntPtr.Zero, true, creation, IntPtr.Zero, directory, ref startup, out started)) {
       throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateProcessW " + commandLine);
     }
+    if (affinity != 0) {
+      Step(stepFile, "holding the process to its processors");
+      if (!SetProcessAffinityMask(started.process, new UIntPtr(affinity))) {
+        int error = Marshal.GetLastWin32Error();
+        TerminateProcess(started.process, 1);
+        throw new Win32Exception(error, "SetProcessAffinityMask " + affinity);
+      }
+      ResumeThread(started.thread);
+    }
     File.WriteAllText(pidFile, started.processId.ToString());
     if (noActivate) {
       HoldTheForeground(started);
@@ -15127,6 +15190,13 @@ function funcOf(name) {
   const colon = name.indexOf(":");
   return colon < 0 ? name : name.slice(0, colon);
 }
+function rowOf(name) {
+  const row = /^[^:]+:(\d+)(?: |$)/.exec(name)?.[1];
+  return row === undefined ? null : Number(row);
+}
+function rowRuns(share, row) {
+  return "only" in share ? row !== null && share.only.includes(row) : row === null || !share.besides.includes(row);
+}
 function readRun(printed) {
   const lines = stripVTControlCharacters(printed).replaceAll(`\r
 `, `
@@ -15146,7 +15216,21 @@ function readRun(printed) {
     }
     afterCase = [];
   };
+  const leftOut = new Map;
+  let engineVersion = null;
   for (const [at, line] of lines.entries()) {
+    const banner = engineVersion === null ? BANNER.exec(line) : null;
+    if (banner !== null) {
+      engineVersion = banner[1] ?? null;
+      continue;
+    }
+    const left = LEFT_OUT.exec(line);
+    if (left !== null) {
+      const key = `${left[1] ?? ""} > ${left[2] ?? ""}`;
+      const row = Number(left[3]);
+      leftOut.set(key, [...leftOut.get(key) ?? [], row < 0 ? null : row]);
+      continue;
+    }
     const opened = SUITE_OPENED.exec(line);
     if (opened?.[1] !== undefined) {
       settleAfterCase("after");
@@ -15166,6 +15250,7 @@ function readRun(printed) {
         open.cases.push({
           name,
           func: funcOf(name),
+          row: rowOf(name),
           verdict: caseLine[3] ?? "",
           seconds: secondsOf(caseLine[4] ?? ""),
           at
@@ -15225,7 +15310,7 @@ function readRun(printed) {
 `);
   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 };
+  return { lines, suites, errors, leaks, starved, executed, unloadable, stoppedIn, leftOut, engineVersion };
 }
 function withNestedErrors(printed, piped) {
   const nested = piped.flatMap((entry, at) => {
@@ -15234,6 +15319,12 @@ function withNestedErrors(printed, piped) {
   });
   return nested.length === 0 ? printed : { ...printed, errors: [...printed.errors, ...nested] };
 }
+function versionFault(said, wanted) {
+  if (said === null) {
+    return `the engine printed no version as it started, so it cannot be told to be Godot ${wanted}`;
+  }
+  return said === wanted || said.startsWith(`${wanted}.`) ? null : `the engine that ran is Godot ${said}, not the ${wanted} --godot-version asks for`;
+}
 function readExpected(file) {
   const declared = (value) => typeof value === "object" && value !== null ? value : {};
   try {
@@ -15253,6 +15344,56 @@ function exitNamed(code) {
   const gdunit = GDUNIT_EXITS.get(code);
   return gdunit === undefined ? String(code) : `${String(code)} (${gdunit})`;
 }
+function rowsAcross(engines) {
+  const dealtOut = new Map;
+  for (const { handed, printed } of engines) {
+    for (const suite of handed) {
+      for (const func of Object.keys(suite.rows ?? {})) {
+        const key = `${suite.path} > ${func}`;
+        const entry = dealtOut.get(key) ?? { path: suite.path, func, holders: [] };
+        entry.holders.push(printed);
+        dealtOut.set(key, entry);
+      }
+    }
+  }
+  const faults = [];
+  for (const [key, { path, func, holders }] of dealtOut) {
+    const suites = holders.map((printed) => printed.suites.get(path));
+    if (suites.some((suite) => suite?.closed === null || suite?.closed === undefined)) {
+      continue;
+    }
+    const counts = new Map;
+    for (const ran of suites.flatMap((suite) => suite?.cases ?? []).filter((ran) => ran.func === func)) {
+      counts.set(ran.row, (counts.get(ran.row) ?? 0) + 1);
+    }
+    const said = (row) => row === null ? "the case whole" : `row ${String(row)}`;
+    if (counts.size === 0) {
+      faults.push({
+        suite: path,
+        fault: `${key} ran in none of the ${String(holders.length)} engines its rows were dealt to`
+      });
+      continue;
+    }
+    const twice = [...counts].filter(([, times]) => times > 1).map(([row]) => said(row));
+    if (twice.length > 0) {
+      faults.push({ suite: path, fault: `${key} ran ${named(twice)} in more than one engine` });
+    }
+    const rows = [...counts.keys()].filter((row) => row !== null);
+    if (rows.length > 0 && counts.has(null)) {
+      faults.push({ suite: path, fault: `${key} ran both whole and by its rows` });
+    }
+    const left = holders.flatMap((printed) => printed.leftOut.get(key) ?? []).filter((row) => row !== null);
+    const top = Math.max(-1, ...rows, ...left);
+    const gaps = Array.from({ length: top + 1 }, (_, row) => row).filter((row) => !counts.has(row));
+    if (gaps.length > 0) {
+      faults.push({
+        suite: path,
+        fault: `${key} did not run ${named(gaps.map(said))} in any of the ${String(holders.length)} engines its rows were dealt to`
+      });
+    }
+  }
+  return faults;
+}
 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;
@@ -15265,15 +15406,23 @@ function judgeEngine(printed, handed, end) {
   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)}`);
+    const free = end.freeBytes === undefined ? "" : `, with ${(end.freeBytes / 1024 ** 3).toFixed(1)} GB of memory free as it ended`;
+    faults.push(end.code === null ? `the engine was ended by ${end.signal ?? "a signal"}${free}` : `the engine exited ${exitNamed(end.code)}${free}`);
+  }
+  if (printed.lines.every((line) => line.trim() === "")) {
+    faults.push("the engine printed nothing at all");
   }
   if (printed.unloadable.length > 0) {
     faults.push(`gdUnit4 could not load ${named(printed.unloadable)}, so it ran nothing`);
   }
+  const wrongEngine = handed.godotVersion === undefined || handed.godotVersion === null ? null : versionFault(printed.engineVersion, handed.godotVersion);
+  if (wrongEngine !== null) {
+    faults.push(wrongEngine);
+  }
   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) {
+  for (const { path, cases, rows = {} } of handed.suites) {
     const suite = printed.suites.get(path);
     if (suite === undefined) {
       faults.push(`${path} never started`);
@@ -15290,11 +15439,18 @@ function judgeEngine(printed, handed, end) {
       failing.add(path);
     }
     const finished = new Set(suite.cases.map((ran) => ran.func));
-    const missing = cases.filter((func) => !finished.has(func));
+    const missing = cases.filter((func) => !finished.has(func) && rows[func] === undefined);
     if (missing.length > 0 && suite.closed !== null) {
       faults.push(`${path} closed without running ${named(missing)}`);
       failing.add(path);
     }
+    for (const [func, share] of Object.entries(rows)) {
+      const strays = suite.cases.filter((ran) => ran.func === func && !rowRuns(share, ran.row)).map((ran) => ran.row === null ? "the case whole" : `row ${String(ran.row)}`);
+      if (strays.length > 0) {
+        faults.push(`${path} > ${func} ran ${named(strays)}, which ${strays.length === 1 ? "was" : "were"} dealt to another engine`);
+        failing.add(path);
+      }
+    }
     const wanted = new Set(cases);
     const unasked = [...finished].filter((func) => !wanted.has(func));
     if (unasked.length > 0) {
@@ -15416,7 +15572,7 @@ ${String(error.warning)}`);
   const neverPrinted = [...owed.values()].flatMap((debt) => debt.texts.map((text) => ({ suite: debt.suite, during: debt.during, text, warning: debt.warning })));
   return { printed: unexpected, neverPrinted };
 }
-var SUITE_OPENED, TIME, CASE_LINE, STATISTICS, ERROR_LINE, WARNING_LINE, EXECUTED, DRIVER_FALLBACK, ORPHANS_REPORTED, STARVED, NESTED_ERROR = "While attempting to print an error, another error was printed:", WINDOWS_EXITS, MEMORY_EXITS, GDUNIT_FAILED = 100, GDUNIT_EXITS, TAIL = 60, MOST_NAMED = 8;
+var SUITE_OPENED, TIME, CASE_LINE, STATISTICS, ERROR_LINE, WARNING_LINE, EXECUTED, BANNER, LEFT_OUT, DRIVER_FALLBACK, ORPHANS_REPORTED, STARVED, NESTED_ERROR = "While attempting to print an error, another error was printed:", WINDOWS_EXITS, MEMORY_EXITS, GDUNIT_FAILED = 100, GDUNIT_EXITS, TAIL = 60, MOST_NAMED = 8;
 var init_suite_judge = __esm(() => {
   init_engine_leaks();
   init_junit();
@@ -15427,6 +15583,8 @@ var init_suite_judge = __esm(() => {
   ERROR_LINE = /^\s*(?:SCRIPT |USER )?ERROR: (.*?)\s*$/;
   WARNING_LINE = /^\s*(?:SCRIPT |USER )?WARNING: (.*?)\s*$/;
   EXECUTED = /^Executed test cases\s*:\s*\((\d+)\//;
+  BANNER = /^\s*Godot Engine v(\S+?)(?:\s+-\s+\S+)?\s*$/;
+  LEFT_OUT = /^gdharness left out (res:\/\/.+?\.gd) > ([^:\s]+):(-?\d+)\s*$/;
   DRIVER_FALLBACK = /^\s*WARNING: Your video card drivers .*, switching to /;
   ORPHANS_REPORTED = /^\s*WARNING: Detected \d+ (?:possible )?orphan nodes\.\s*$/;
   STARVED = [
@@ -15453,11 +15611,11 @@ var init_suite_judge = __esm(() => {
 });
 
 // src/whole-file.ts
-import { renameSync as renameSync2, rmSync as rmSync9, writeFileSync as writeFileSync9 } from "node:fs";
+import { renameSync as renameSync2, rmSync as rmSync9, writeFileSync as writeFileSync10 } from "node:fs";
 function writeWhole(path, text) {
   const partial = `${path}.${process.pid}.partial`;
   try {
-    writeFileSync9(partial, text, "utf8");
+    writeFileSync10(partial, text, "utf8");
   } catch {
     return false;
   }
@@ -15484,16 +15642,29 @@ var init_whole_file = __esm(() => {
 });
 
 // src/suite-plan.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync7, readFileSync as readFileSync18 } from "node:fs";
-import { dirname as dirname10, posix as posix3 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync8, readFileSync as readFileSync18 } from "node:fs";
+import { dirname as dirname10, join as join21, posix as posix3 } from "node:path";
+function within(path, folder) {
+  return path === folder || path.startsWith(`${folder}/`);
+}
 
 class ProjectScripts {
   sources = new Map;
   classes = new Map;
   read = new Map;
   projectPath;
+  notSearched;
+  guessWindow;
   constructor(projectPath) {
     this.projectPath = projectPath;
+    let settings = {};
+    try {
+      settings = parseProjectGodot(readFileSync18(join21(projectPath, "project.godot"), "utf8"))["gdharness"] ?? {};
+    } catch {}
+    const [section, key] = [NOT_SEARCHED_SETTING, GUESS_WINDOW_SETTING].map((setting) => setting.slice("gdharness/".length));
+    const listed = settings[section ?? ""];
+    this.notSearched = typeof listed === "string" ? [...listed.matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((found) => (found[1] ?? "").replace(/\/+$/, "")) : [];
+    this.guessWindow = settings[key ?? ""] !== false;
     eachScript(projectPath, (script, source) => {
       this.sources.set(script, source);
       const declared = declaredClassOf(source);
@@ -15554,7 +15725,7 @@ class ProjectScripts {
       }
       const declared = NEEDS_WINDOW.exec(read.code)?.[1];
       said ??= declared === undefined ? undefined : declared === "true";
-      guessed ||= SCENE_RUNNER.test(read.code);
+      guessed ||= this.guessWindow && SCENE_RUNNER.test(read.code);
       const base = this.base(at);
       if (base === null) {
         return null;
@@ -15570,8 +15741,16 @@ class ProjectScripts {
     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) ?? []);
+    const searched = roots.map((root) => root.replace(/\/+$/, ""));
+    return [...this.sources.keys()].filter((path) => searched.some((root) => path.startsWith(`${root}/`) && !this.notSearched.some((folder) => within(path, folder) && !within(root, folder)))).sort().flatMap((path) => this.suite(path) ?? []);
+  }
+  searchedAsTold(paths) {
+    return [
+      ...new Set(paths.flatMap((path) => {
+        const root = path.replace(/\/+$/, "");
+        return path.endsWith(".gd") || !this.notSearched.some((folder) => folder.startsWith(`${root}/`) && !within(root, folder)) ? [path] : this.suitesUnder([root]).map((suite) => suite.path);
+      }))
+    ];
   }
 }
 function readTimes(file) {
@@ -15583,11 +15762,11 @@ function readTimes(file) {
   }
 }
 function writeJson(file, value) {
-  mkdirSync7(dirname10(file), { recursive: true });
+  mkdirSync8(dirname10(file), { recursive: true });
   writeWhole(file, `${JSON.stringify(value, null, 1)}
 `);
 }
-function timesAfter(times, suites, runs, now) {
+function timesAfter(times, suites, runs, now, cutShort = new Set) {
   const next = {};
   for (const [path, time] of Object.entries(times)) {
     const suite = now(path);
@@ -15596,7 +15775,12 @@ function timesAfter(times, suites, runs, now) {
     }
     const cases = Object.fromEntries(Object.entries(time.cases).filter(([func]) => suite.cases.includes(func)));
     const dropped = Object.entries(time.cases).filter(([func]) => !(func in cases)).reduce((sum, [, seconds]) => sum + seconds, 0);
-    next[path] = { seconds: round(Math.max(0, time.seconds - dropped)), cases };
+    const rows = Object.fromEntries(Object.entries(time.rows ?? {}).filter(([func]) => suite.cases.includes(func)));
+    next[path] = {
+      seconds: round(Math.max(0, time.seconds - dropped)),
+      cases,
+      ...Object.keys(rows).length > 0 ? { rows } : {}
+    };
   }
   const declared = new Map(suites.map((suite) => [suite.path, suite]));
   const measured = new Map;
@@ -15605,15 +15789,24 @@ function timesAfter(times, suites, runs, now) {
       if (printed.closed === null || !declared.has(printed.path)) {
         continue;
       }
-      const entry = measured.get(printed.path) ?? { cases: new Map, around: 0 };
+      const entry = measured.get(printed.path) ?? {
+        cases: new Map,
+        rows: 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);
+        if (ran.row !== null) {
+          const rows = entry.rows.get(ran.func) ?? new Map;
+          rows.set(ran.row, ran.seconds);
+          entry.rows.set(ran.func, rows);
+        }
       }
       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);
+        entry.cases.set(func, (entry.cases.get(func) ?? 0) + seconds);
       }
       measured.set(printed.path, entry);
     }
@@ -15621,17 +15814,33 @@ function timesAfter(times, suites, runs, now) {
   for (const [path, entry] of measured) {
     const suite = declared.get(path);
     const cases = {};
+    const rows = {};
     for (const func of suite?.cases ?? []) {
-      const seconds = entry.cases.get(func) ?? times[path]?.cases[func];
+      const measuredRows = entry.rows.get(func);
+      const keptRows = measuredRows === undefined ? times[path]?.rows?.[func] : rowsAfter(times[path]?.rows?.[func], measuredRows, cutShort.has(`${path}:${func}`));
+      if (keptRows !== undefined) {
+        rows[func] = keptRows.map(round);
+      }
+      const seconds = measuredRows === undefined || keptRows === undefined ? entry.cases.get(func) ?? times[path]?.cases[func] : keptRows.reduce((sum, row) => sum + row, 0);
       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 };
+    next[path] = {
+      seconds: round(entry.around + inCases),
+      cases,
+      ...Object.keys(rows).length > 0 ? { rows } : {}
+    };
   }
   return next;
 }
+function rowsAfter(before, measured, cutShort) {
+  const count = Math.max(...measured.keys()) + 1;
+  const whole = !cutShort && measured.size === count;
+  const length = whole ? count : Math.max(count, before?.length ?? 0);
+  return Array.from({ length }, (_, row) => measured.get(row) ?? before?.[row] ?? 0);
+}
 function round(seconds) {
   return Math.round(seconds * 1000) / 1000;
 }
@@ -15652,24 +15861,39 @@ function unitsOf(suites, times, splitPast = SPLIT_PAST_SECONDS) {
     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,
-          headless: suite.headless
-        }
-      ];
-    }
-    return suite.cases.map((func) => ({
+    const wholly = {
       suite: suite.path,
-      cases: [func],
-      cost: around + costOf(func),
-      windowed: false,
+      cases: suite.cases,
+      cost: whole,
+      windowed: suite.windowed,
       headless: suite.headless
-    }));
+    };
+    if (suite.windowed || whole <= splitPast) {
+      return [wholly];
+    }
+    const units = suite.cases.flatMap((func) => {
+      const rows = time?.rows?.[func] ?? [];
+      if (rows.length < 2 || around + costOf(func) <= splitPast) {
+        return [
+          {
+            suite: suite.path,
+            cases: [func],
+            cost: around + costOf(func),
+            windowed: false,
+            headless: suite.headless
+          }
+        ];
+      }
+      return rows.map((seconds, index) => ({
+        suite: suite.path,
+        cases: [func],
+        row: { index, rest: index === rows.length - 1 },
+        cost: around + seconds,
+        windowed: false,
+        headless: suite.headless
+      }));
+    });
+    return units.length < 2 ? [wholly] : units;
   });
 }
 function dealt(units, declared, most) {
@@ -15677,7 +15901,7 @@ function dealt(units, declared, most) {
     return [];
   }
   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 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] ?? "") || (a.row?.index ?? 0) - (b.row?.index ?? 0));
   const together = windowed.reduce((sum, unit) => sum + unit.cost, 0);
   const restart = windowed.length > 0 ? ENGINE_START_SECONDS : 0;
   const total = units.reduce((sum, unit) => sum + unit.cost, 0);
@@ -15691,8 +15915,8 @@ function dealt(units, declared, most) {
     loads[lightest] = (loads[lightest] ?? 0) + unit.cost;
   }
   return [
-    ...windowed.length > 0 ? [planOf(windowed, declared, true, 0)] : [],
-    ...bins.flatMap((bin, lane) => bin.length === 0 ? [] : [planOf(bin, declared, false, lane)])
+    ...windowed.length > 0 ? [planOf(windowed, declared, true, 0, units)] : [],
+    ...bins.flatMap((bin, lane) => bin.length === 0 ? [] : [planOf(bin, declared, false, lane, units)])
   ];
 }
 function lanesOf(plans) {
@@ -15713,24 +15937,41 @@ function headlessInAWindow(plans, units) {
   return plans.filter((plan) => plan.windowed).flatMap((plan) => plan.suites.map((suite) => suite.path)).filter((path) => said.has(path));
 }
 function inOneEngine(units, declared) {
-  return planOf(units, declared, units.some((unit) => unit.windowed), 0);
+  return planOf(units, declared, units.some((unit) => unit.windowed), 0, units);
 }
-function planOf(bin, declared, windowed, lane) {
+function planOf(bin, declared, windowed, lane, all) {
   const held = new Map;
   for (const unit of bin) {
-    held.set(unit.suite, [...held.get(unit.suite) ?? [], ...unit.cases]);
+    const cases = held.get(unit.suite) ?? [];
+    held.set(unit.suite, [...cases, ...unit.cases.filter((func) => !cases.includes(func))]);
   }
   const skipping = [...held].flatMap(([path, cases]) => (declared.get(path) ?? []).filter((func) => !cases.includes(func)).map((func) => `${path}:${func}`));
+  const rowsOf = (units, path, func) => units.flatMap((unit) => unit.suite === path && unit.cases[0] === func && unit.row !== undefined ? [unit.row.index] : []);
+  const sharesOf = (path, cases) => {
+    const shares = {};
+    for (const func of cases) {
+      const mine = rowsOf(bin, path, func);
+      const dealtOut = rowsOf(all, path, func);
+      if (mine.length === 0 || mine.length === dealtOut.length) {
+        continue;
+      }
+      const rest = bin.some((unit) => unit.suite === path && unit.cases[0] === func && unit.row?.rest === true);
+      shares[func] = rest ? { besides: dealtOut.filter((row) => !mine.includes(row)) } : { only: mine.sort((a, b) => a - b) };
+    }
+    return shares;
+  };
   return {
-    suites: [...held].map(([path, cases]) => ({ path, cases: [...cases].sort() })),
+    suites: [...held].map(([path, cases]) => {
+      const rows = sharesOf(path, cases);
+      return { path, cases: [...cases].sort(), ...Object.keys(rows).length > 0 ? { rows } : {} };
+    }),
     skipping,
     cost: bin.reduce((sum, unit) => sum + unit.cost, 0),
     windowed,
     lane
   };
 }
-function windowNeedsOf(projectPath, paths) {
-  const scripts = new ProjectScripts(projectPath);
+function windowNeedsOf(scripts, paths) {
   const suites = new Map(paths.flatMap((path) => path.endsWith(".gd") ? scripts.suite(path) ?? [] : scripts.suitesUnder([path])).map((suite) => [suite.path, suite]));
   const sorted = [...suites.values()].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
   return {
@@ -15748,10 +15989,11 @@ function viewportOf(projectPath) {
   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 SUITE_BASE = "GdUnitTestSuite", CASE_PREFIX = "test_", NEEDS_WINDOW, TEST_DIRECTORIES, SCENE_RUNNER, NOT_SEARCHED_SETTING = "gdharness/tests/not_searched", GUESS_WINDOW_SETTING = "gdharness/tests/scene_runner_needs_window", UNTIMED_CASE = 0.02, SPLIT_PAST_SECONDS = 10, ENGINE_START_SECONDS = 5;
 var init_suite_plan = __esm(() => {
   init_class_cache();
   init_gdscript_source();
+  init_resources();
   init_whole_file();
   NEEDS_WINDOW = /^const\s+GDHARNESS_NEEDS_WINDOW\b[^=\n]*=\s*(true|false)\b/m;
   TEST_DIRECTORIES = ["tests", "test"];
@@ -37360,12 +37602,12 @@ var init_stdio = __esm(() => {
 
 // src/autoload-failure.ts
 import { existsSync as existsSync20, readFileSync as readFileSync21 } from "node:fs";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 function scriptsAutoloaded(projectPath) {
   const scripts = new Map;
   let settings;
   try {
-    settings = parseProjectGodot(readFileSync21(join23(projectPath, "project.godot"), "utf8"));
+    settings = parseProjectGodot(readFileSync21(join24(projectPath, "project.godot"), "utf8"));
   } catch {
     return scripts;
   }
@@ -37374,7 +37616,7 @@ function scriptsAutoloaded(projectPath) {
       scripts.set(`res://${path}`, name);
       continue;
     }
-    const scene = join23(projectPath, path);
+    const scene = join24(projectPath, path);
     if (!existsSync20(scene)) {
       continue;
     }
@@ -37401,7 +37643,7 @@ var init_autoload_failure = __esm(() => {
 import { existsSync as existsSync21, readdirSync as readdirSync13, readFileSync as readFileSync22, statSync as statSync14, unlinkSync as unlinkSync2 } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir5 } from "node:os";
-import { dirname as dirname12, join as join24, resolve as resolve6 } from "node:path";
+import { dirname as dirname12, join as join25, resolve as resolve6 } from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
@@ -37409,19 +37651,19 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join24(perUser ?? tmpdir5(), "gdharness");
+  return join25(perUser ?? tmpdir5(), "gdharness");
 }
 function runtimeDirectories(variables = process.env) {
   const candidates = [runtimeDirectory(variables)];
   const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
   for (const base of fallbacks) {
-    candidates.push(join24(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join25(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve6(path)))];
 }
 function errorReportOf(pid, directories = runtimeDirectories()) {
   for (const directory of directories) {
-    const path = join24(directory, `runtime-${pid}.log`);
+    const path = join25(directory, `runtime-${pid}.log`);
     if (existsSync21(path)) {
       return path;
     }
@@ -37577,14 +37819,14 @@ function announcedIn(directory) {
   for (const entry of readdirSync13(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
-      sweepErrorReport(join24(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      sweepErrorReport(join25(directory, entry), Number.parseInt(report[1] ?? "", 10));
       continue;
     }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
     }
-    const file = join24(directory, entry);
+    const file = join25(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const running = alive(pid);
     entries.push({ file, pid, running });
@@ -37612,7 +37854,7 @@ function announcedIn(directory) {
     found.push(announced);
   }
   const held = new Set(entries.map((one) => one.file));
-  const here = join24(directory, ".");
+  const here = join25(directory, ".");
   for (const file of verdicts.keys()) {
     if (dirname12(file) === here && !held.has(file)) {
       verdicts.delete(file);
@@ -37621,7 +37863,7 @@ function announcedIn(directory) {
   return found;
 }
 async function announcementEnded(pid, directories = runtimeDirectories()) {
-  const files = directories.map((directory) => join24(directory, `runtime-${pid}.json`)).filter((file) => existsSync21(file));
+  const files = directories.map((directory) => join25(directory, `runtime-${pid}.json`)).filter((file) => existsSync21(file));
   const first = files[0];
   if (first === undefined) {
     return;
@@ -38040,10 +38282,10 @@ var init_runtime_client = __esm(() => {
 });
 
 // src/boot-note.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync23, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname13, join as join25 } from "node:path";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync23, writeFileSync as writeFileSync12 } from "node:fs";
+import { dirname as dirname13, join as join26 } from "node:path";
 function bootNotePath(projectPath) {
-  return join25(projectPath, ".godot", "gdharness-boot.json");
+  return join26(projectPath, ".godot", "gdharness-boot.json");
 }
 function readScenes(projectPath) {
   try {
@@ -38063,7 +38305,7 @@ function readBootNote(projectPath, scene) {
 function writeBootNote(projectPath, scene, announcedAfterMs) {
   try {
     const path = bootNotePath(projectPath);
-    mkdirSync9(dirname13(path), { recursive: true });
+    mkdirSync10(dirname13(path), { recursive: true });
     const scenes = {
       ...readScenes(projectPath),
       [scene]: {
@@ -38071,7 +38313,7 @@ function writeBootNote(projectPath, scene, announcedAfterMs) {
         at: new Date().toISOString()
       }
     };
-    writeFileSync11(path, JSON.stringify({ scenes }, null, 2), "utf8");
+    writeFileSync12(path, JSON.stringify({ scenes }, null, 2), "utf8");
   } catch {}
 }
 function halfAsLongAgain(lastBootMs) {
@@ -38089,10 +38331,10 @@ var init_boot_note = __esm(() => {
 });
 
 // src/breakpoint-note.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync24, rmSync as rmSync11, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname14, isAbsolute as isAbsolute7, join as join26, relative as relative4 } from "node:path";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync24, rmSync as rmSync11, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname14, isAbsolute as isAbsolute7, join as join27, relative as relative4 } from "node:path";
 function breakpointNotePath(projectPath) {
-  return join26(projectPath, ".godot", "gdharness-breakpoints.json");
+  return join27(projectPath, ".godot", "gdharness-breakpoints.json");
 }
 function writeBreakpointNote(projectPath, held) {
   const path = breakpointNotePath(projectPath);
@@ -38109,8 +38351,8 @@ function writeBreakpointNote(projectPath, held) {
         lines: [...one.lines]
       }))
     };
-    mkdirSync10(dirname14(path), { recursive: true });
-    writeFileSync12(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync11(dirname14(path), { recursive: true });
+    writeFileSync13(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the breakpoints at ${path}: ${errorMessage(error)}`);
@@ -38133,7 +38375,7 @@ function readBreakpointNote(projectPath) {
       }
       const lines = Array.isArray(listed) ? listed.filter((line) => Number.isInteger(line) && line > 0) : [];
       if (lines.length > 0) {
-        held.push({ scriptPath: realAsFarAsItExists(join26(projectPath, script)), lines });
+        held.push({ scriptPath: realAsFarAsItExists(join27(projectPath, script)), lines });
       }
     }
     return held;
@@ -38151,10 +38393,10 @@ var init_breakpoint_note = __esm(() => {
 });
 
 // src/class-note.ts
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync25 } from "node:fs";
-import { dirname as dirname15, join as join27 } from "node:path";
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync25 } from "node:fs";
+import { dirname as dirname15, join as join28 } from "node:path";
 function classNotePath(projectPath) {
-  return join27(projectPath, ".godot", "gdharness-classes.json");
+  return join28(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
@@ -38188,7 +38430,7 @@ function unfinishedScanIn(value) {
 function writeClassNote(projectPath, note) {
   const path = classNotePath(projectPath);
   try {
-    mkdirSync11(dirname15(path), { recursive: true });
+    mkdirSync12(dirname15(path), { recursive: true });
   } catch {
     return;
   }
@@ -38201,9 +38443,9 @@ var init_class_note = __esm(() => {
 
 // src/config-pin.ts
 import { existsSync as existsSync22, readFileSync as readFileSync26 } from "node:fs";
-import { join as join28 } from "node:path";
+import { join as join29 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join28(projectPath, ".mcp.json");
+  const config = join29(projectPath, ".mcp.json");
   if (!existsSync22(config)) {
     return [];
   }
@@ -38230,16 +38472,16 @@ var init_config_pin = __esm(() => {
 });
 
 // src/cut-test-run.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync27, rmSync as rmSync12, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname16, join as join29 } from "node:path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync13, readFileSync as readFileSync27, rmSync as rmSync12, writeFileSync as writeFileSync14 } from "node:fs";
+import { dirname as dirname16, join as join30 } from "node:path";
 function keptAt(projectPath) {
-  return join29(projectPath, ".godot", "gdharness-reports", "cut-run.json");
+  return join30(projectPath, ".godot", "gdharness-reports", "cut-run.json");
 }
 function keepCutTestRun(projectPath, run) {
   const path = keptAt(projectPath);
   try {
-    mkdirSync12(dirname16(path), { recursive: true });
-    writeFileSync13(path, `${JSON.stringify(run, null, 2)}
+    mkdirSync13(dirname16(path), { recursive: true });
+    writeFileSync14(path, `${JSON.stringify(run, null, 2)}
 `, "utf8");
   } catch {}
 }
@@ -39109,20 +39351,20 @@ var init_dap_client = __esm(() => {
 import {
   closeSync as closeSync4,
   existsSync as existsSync24,
-  mkdirSync as mkdirSync13,
+  mkdirSync as mkdirSync14,
   openSync as openSync4,
   readFileSync as readFileSync28,
   readSync as readSync2,
   rmSync as rmSync13,
   statSync as statSync15,
-  writeFileSync as writeFileSync14
+  writeFileSync as writeFileSync15
 } from "node:fs";
-import { dirname as dirname17, join as join30 } from "node:path";
+import { dirname as dirname17, join as join31 } from "node:path";
 function editorLogPath(projectPath) {
-  return join30(projectPath, ".godot", "gdharness-editor.log");
+  return join31(projectPath, ".godot", "gdharness-editor.log");
 }
 function editorLogNotePath(projectPath) {
-  return join30(projectPath, ".godot", "gdharness-editor.json");
+  return join31(projectPath, ".godot", "gdharness-editor.json");
 }
 function readEditorLogNote(projectPath) {
   try {
@@ -39138,7 +39380,7 @@ function readEditorLogNote(projectPath) {
 function clearEditorLog(projectPath) {
   try {
     const path = editorLogPath(projectPath);
-    mkdirSync13(dirname17(path), { recursive: true });
+    mkdirSync14(dirname17(path), { recursive: true });
     rmSync13(path, { force: true });
     rmSync13(editorLogNotePath(projectPath), { force: true });
   } catch {}
@@ -39146,8 +39388,8 @@ function clearEditorLog(projectPath) {
 function writeEditorLogNote(projectPath, pid, processStartedAt) {
   try {
     const path = editorLogNotePath(projectPath);
-    mkdirSync13(dirname17(path), { recursive: true });
-    writeFileSync14(path, JSON.stringify({
+    mkdirSync14(dirname17(path), { recursive: true });
+    writeFileSync15(path, JSON.stringify({
       pid,
       startedAt: new Date().toISOString(),
       ...processStartedAt === undefined ? {} : { processStartedAt }
@@ -39391,7 +39633,7 @@ var init_editor_log = __esm(() => {
 });
 
 // src/rename.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync14, readFileSync as readFileSync29, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync25, mkdirSync as mkdirSync15, readFileSync as readFileSync29, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync16 } from "node:fs";
 import { dirname as dirname18, posix as posix4 } from "node:path";
 
 class Script {
@@ -40107,9 +40349,9 @@ function applyRewrites(rewrites) {
   const done = [];
   try {
     for (const rewrite of rewrites) {
-      mkdirSync14(dirname18(rewrite.writeTo), { recursive: true });
+      mkdirSync15(dirname18(rewrite.writeTo), { recursive: true });
       const staging = `${rewrite.writeTo}.gdharness-rename`;
-      writeFileSync15(staging, rewrite.after, "utf8");
+      writeFileSync16(staging, rewrite.after, "utf8");
       renameSync3(staging, rewrite.writeTo);
       let movedUid = false;
       if (rewrite.writeTo !== rewrite.absolute) {
@@ -40124,7 +40366,7 @@ function applyRewrites(rewrites) {
   } catch (error) {
     for (const { rewrite, movedUid } of done.reverse()) {
       try {
-        writeFileSync15(rewrite.absolute, rewrite.before, "utf8");
+        writeFileSync16(rewrite.absolute, rewrite.before, "utf8");
         if (rewrite.writeTo !== rewrite.absolute) {
           unlinkSync3(rewrite.writeTo);
           if (movedUid) {
@@ -40163,7 +40405,7 @@ var init_rename = __esm(() => {
 import { existsSync as existsSync26, realpathSync as realpathSync3 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname19, join as join31, resolve as resolve7 } from "node:path";
+import { dirname as dirname19, join as join32, resolve as resolve7 } from "node:path";
 import { setTimeout as delay6 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function initializeTimeoutMs() {
@@ -40841,7 +41083,7 @@ async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   } catch {
     throw new ArgumentRefusal(`Project path does not exist: ${requestedProjectPath}`);
   }
-  if (!existsSync26(join31(projectPath, "project.godot"))) {
+  if (!existsSync26(join32(projectPath, "project.godot"))) {
     throw new ArgumentRefusal(`Not a Godot project: ${projectPath}. Point projectPath at the directory holding project.godot.`);
   }
   const contained = resolveWithinProject(projectPath, scriptPathValue);
@@ -41001,8 +41243,8 @@ var init_lsp_client = __esm(() => {
 });
 
 // src/rename-symbol.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync15, readdirSync as readdirSync14, realpathSync as realpathSync4, rmSync as rmSync14, writeFileSync as writeFileSync16 } from "node:fs";
-import { basename as basename9, dirname as dirname20, join as join32, relative as relative5, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync27, mkdirSync as mkdirSync16, readdirSync as readdirSync14, realpathSync as realpathSync4, rmSync as rmSync14, writeFileSync as writeFileSync17 } from "node:fs";
+import { basename as basename9, dirname as dirname20, join as join33, relative as relative5, resolve as resolve8 } from "node:path";
 function resourcePathOf(projectPath, absolute) {
   const inside = relative5(onDiskSpelling(projectPath), onDiskSpelling(absolute));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
@@ -41015,7 +41257,7 @@ function onDiskSpelling(path) {
   let at = resolve8(path);
   for (;; ) {
     try {
-      return join32(realpathSync4.native(at), ...missing.reverse());
+      return join33(realpathSync4.native(at), ...missing.reverse());
     } catch {
       const parent = dirname20(at);
       if (parent === at) {
@@ -41444,15 +41686,15 @@ ${mention.kind}`;
   };
 }
 function writeLeftAloneDetail(projectPath, symbol, detail) {
-  const directory = join32(projectPath, ".godot", "gdharness-renames");
-  mkdirSync15(directory, { recursive: true });
+  const directory = join33(projectPath, ".godot", "gdharness-renames");
+  mkdirSync16(directory, { recursive: true });
   detailWrites += 1;
-  const path = join32(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
-  writeFileSync16(path, `${JSON.stringify(detail, null, 2)}
+  const path = join33(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
+  writeFileSync17(path, `${JSON.stringify(detail, null, 2)}
 `, "utf8");
   const kept = readdirSync14(directory).filter((name) => name.endsWith(".json")).sort().reverse();
   for (const old of kept.slice(10)) {
-    rmSync14(join32(directory, old), { force: true });
+    rmSync14(join33(directory, old), { force: true });
   }
   return path;
 }
@@ -41494,17 +41736,17 @@ var init_rename_symbol = __esm(() => {
 // src/file-move.ts
 import {
   existsSync as existsSync28,
-  mkdirSync as mkdirSync16,
+  mkdirSync as mkdirSync17,
   readdirSync as readdirSync15,
   readFileSync as readFileSync30,
   renameSync as renameSync4,
   statSync as statSync16,
-  writeFileSync as writeFileSync17
+  writeFileSync as writeFileSync18
 } from "node:fs";
-import { basename as basename10, dirname as dirname21, extname as extname3, join as join33, relative as relative6 } from "node:path";
+import { basename as basename10, dirname as dirname21, extname as extname3, join as join34, relative as relative6 } from "node:path";
 function filesUnder(directory) {
   return readdirSync15(directory, { withFileTypes: true }).flatMap((entry) => {
-    const path = join33(directory, entry.name);
+    const path = join34(directory, entry.name);
     return entry.isDirectory() ? filesUnder(path) : [path];
   });
 }
@@ -41525,8 +41767,8 @@ function unseenByTheEngine(projectPath, path) {
       return `${path} is under ${step}, and the engine passes over every directory whose name starts with a dot`;
     }
     if (at < steps.length - 1) {
-      directory = join33(directory, step);
-      if (existsSync28(join33(directory, ".gdignore"))) {
+      directory = join34(directory, step);
+      if (existsSync28(join34(directory, ".gdignore"))) {
         return `${path} is under a directory holding a .gdignore, which the engine does not load`;
       }
     }
@@ -41538,12 +41780,12 @@ function installedAddonOf(projectPath, path) {
   if (steps[0] !== "addons" || steps[1] === undefined) {
     return null;
   }
-  return existsSync28(join33(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
+  return existsSync28(join34(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
 }
 function binaryResources(projectPath) {
   const found = [];
   const visit = (directory, prefix) => {
-    if (existsSync28(join33(directory, ".gdignore"))) {
+    if (existsSync28(join34(directory, ".gdignore"))) {
       return;
     }
     for (const entry of readdirSync15(directory, { withFileTypes: true })) {
@@ -41552,7 +41794,7 @@ function binaryResources(projectPath) {
       }
       const path = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join33(directory, entry.name), `${path}/`);
+        visit(join34(directory, entry.name), `${path}/`);
       } else if (/\.(scn|res)$/i.test(entry.name)) {
         found.push(path);
       }
@@ -41562,7 +41804,7 @@ function binaryResources(projectPath) {
   return found;
 }
 function targetPathOf(projectPath, absolute) {
-  const inside = relative6(onDiskSpelling(projectPath), join33(onDiskSpelling(dirname21(absolute)), basename10(absolute)));
+  const inside = relative6(onDiskSpelling(projectPath), join34(onDiskSpelling(dirname21(absolute)), basename10(absolute)));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
     return null;
   }
@@ -41617,7 +41859,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
     return { ok: false, reason: `${unseen}, so nothing there could load what was moved.` };
   }
   if (!isDirectory) {
-    const owner = SIDECARS.map((sidecar) => from.endsWith(sidecar) ? from.slice(0, -sidecar.length) : null).find((path) => path !== null && existsSync28(join33(projectPath, path.slice("res://".length))));
+    const owner = SIDECARS.map((sidecar) => from.endsWith(sidecar) ? from.slice(0, -sidecar.length) : null).find((path) => path !== null && existsSync28(join34(projectPath, path.slice("res://".length))));
     if (owner !== undefined && owner !== null) {
       return { ok: false, reason: `${from} belongs to ${owner} and moves with it: move ${owner} instead.` };
     }
@@ -41651,12 +41893,12 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
     scripts,
     moves,
     named: [from],
-    exists: (path) => existsSync28(join33(projectPath, path.slice("res://".length)))
+    exists: (path) => existsSync28(join34(projectPath, path.slice("res://".length)))
   }, { edits: [], mentions: [] });
   plan = mentionIgnored(plan, ignoredTexts(projectPath), null, [from]);
   const binaries = [];
   for (const path of binaryResources(projectPath)) {
-    const bytes = readFileSync30(join33(projectPath, path.slice("res://".length)));
+    const bytes = readFileSync30(join34(projectPath, path.slice("res://".length)));
     const names = [...moves.keys()].find((moving) => bytes.includes(moving));
     if (names !== undefined) {
       binaries.push({
@@ -41675,7 +41917,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   }));
   const left = leftAloneReport(mentions);
   const rewrites = rewritesOf(plan, texts, null);
-  const absoluteOf = (path) => join33(projectPath, path.slice("res://".length));
+  const absoluteOf = (path) => join34(projectPath, path.slice("res://".length));
   const rewritten = new Map(rewrites.map((rewrite) => [rewrite.path, rewrite]));
   const moved = [...moves].map(([source, target]) => {
     const rewrite = rewritten.get(source);
@@ -41734,7 +41976,7 @@ function applyFileMove(outcome) {
   }
   const undo = [];
   const rename = (source, target) => {
-    mkdirSync16(dirname21(target), { recursive: true });
+    mkdirSync17(dirname21(target), { recursive: true });
     renameSync4(source, target);
     undo.push(() => {
       renameSync4(target, source);
@@ -41743,10 +41985,10 @@ function applyFileMove(outcome) {
   try {
     for (const rewrite of outcome.inPlace) {
       const staging = `${rewrite.absolute}.gdharness-move`;
-      writeFileSync17(staging, rewrite.after, "utf8");
+      writeFileSync18(staging, rewrite.after, "utf8");
       renameSync4(staging, rewrite.absolute);
       undo.push(() => {
-        writeFileSync17(rewrite.absolute, rewrite.before, "utf8");
+        writeFileSync18(rewrite.absolute, rewrite.before, "utf8");
       });
     }
     if (outcome.directory !== null) {
@@ -41758,9 +42000,9 @@ function applyFileMove(outcome) {
       }
       if (file.text !== null) {
         const { before, after } = file.text;
-        writeFileSync17(file.absoluteTo, after, "utf8");
+        writeFileSync18(file.absoluteTo, after, "utf8");
         undo.push(() => {
-          writeFileSync17(file.absoluteTo, before, "utf8");
+          writeFileSync18(file.absoluteTo, before, "utf8");
         });
       }
     }
@@ -45462,16 +45704,16 @@ var DEBUG_PREFIX = "debug ";
 var init_keeper_channel = () => {};
 
 // src/lifecycle-log.ts
-import { appendFileSync, mkdirSync as mkdirSync17, renameSync as renameSync5, statSync as statSync17 } from "node:fs";
-import { dirname as dirname22, join as join34 } from "node:path";
+import { appendFileSync, mkdirSync as mkdirSync18, renameSync as renameSync5, statSync as statSync17 } from "node:fs";
+import { dirname as dirname22, join as join35 } from "node:path";
 import process14 from "node:process";
 function lifecycleLogPath() {
-  return join34(runtimeDirectory(), "servers.log");
+  return join35(runtimeDirectory(), "servers.log");
 }
 function writeLifecycle(event, fields = {}) {
   const path = lifecycleLogPath();
   try {
-    mkdirSync17(dirname22(path), { recursive: true });
+    mkdirSync18(dirname22(path), { recursive: true });
     if ((statSync17(path, { throwIfNoEntry: false })?.size ?? 0) > LIFECYCLE_LOG_LIMIT) {
       try {
         renameSync5(path, `${path}.1`);
@@ -45830,16 +46072,16 @@ var init_prompts = __esm(() => {
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync18, readFileSync as readFileSync31, rmSync as rmSync15, writeFileSync as writeFileSync18 } from "node:fs";
-import { dirname as dirname23, join as join35 } from "node:path";
+import { mkdirSync as mkdirSync19, readFileSync as readFileSync31, rmSync as rmSync15, writeFileSync as writeFileSync19 } from "node:fs";
+import { dirname as dirname23, join as join36 } from "node:path";
 function restartNotePath(projectPath) {
-  return join35(projectPath, ".godot", "gdharness-restart.json");
+  return join36(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync18(dirname23(path), { recursive: true });
-    writeFileSync18(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync19(dirname23(path), { recursive: true });
+    writeFileSync19(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
@@ -45873,10 +46115,10 @@ 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 readFileSync32, rmSync as rmSync16, statSync as statSync18 } from "node:fs";
-import { basename as basename11, join as join36, resolve as resolve9 } from "node:path";
+import { mkdirSync as mkdirSync20, openSync as openSync5, readdirSync as readdirSync16, readFileSync as readFileSync32, rmSync as rmSync16, statSync as statSync18 } from "node:fs";
+import { basename as basename11, join as join37, resolve as resolve9 } from "node:path";
 function runsDirectory() {
-  return join36(runtimeDirectory(), "runs");
+  return join37(runtimeDirectory(), "runs");
 }
 function projectKey(projectPath) {
   const real = realAsFarAsItExists(resolve9(projectPath)).replace(/[\\/]+$/, "");
@@ -45884,14 +46126,14 @@ function projectKey(projectPath) {
   return createHash7("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join36(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join37(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function latestRunPath(servedBy, directory = runtimeDirectory()) {
-  return join36(directory, "runs", `latest-${projectKey(servedBy)}.json`);
+  return join37(directory, "runs", `latest-${projectKey(servedBy)}.json`);
 }
 function writeLatestRun(servedBy, latest) {
   try {
-    mkdirSync19(runsDirectory(), { recursive: true });
+    mkdirSync20(runsDirectory(), { recursive: true });
     writeWhole(latestRunPath(servedBy), JSON.stringify(latest, null, 2));
   } catch {}
 }
@@ -45911,24 +46153,24 @@ function readLatestRun(servedBy, directory = runtimeDirectory()) {
   }
 }
 function openTranscript(startedAt) {
-  mkdirSync19(runsDirectory(), { recursive: true });
-  const path = join36(runsDirectory(), `run-${startedAt}.log`);
+  mkdirSync20(runsDirectory(), { recursive: true });
+  const path = join37(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync5(path, "a") };
 }
 function profilePath(startedAt) {
-  return join36(runsDirectory(), `run-${startedAt}.profile.json`);
+  return join37(runsDirectory(), `run-${startedAt}.profile.json`);
 }
 function profileMarkPath(startedAt) {
-  return join36(runsDirectory(), `run-${startedAt}.profile-mark.json`);
+  return join37(runsDirectory(), `run-${startedAt}.profile-mark.json`);
 }
 function noteIsAbout(note, playing) {
   return note.play !== undefined && playing !== null && note.play.play === playing.play && note.play.editorPid === playing.editorPid;
 }
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join36(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join37(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
-  mkdirSync19(runsDirectory(), { recursive: true });
+  mkdirSync20(runsDirectory(), { recursive: true });
   const path = editorNotePath(note.projectPath);
   if (!writeWhole(path, JSON.stringify(note, null, 2))) {
     throw new Error(`the editor run note could not be written at ${path}`);
@@ -45978,13 +46220,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync16(join36(directory, "runs"));
+      entries = readdirSync16(join37(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join36(directory, "runs", entry));
+        const record = recordAt(join37(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -46252,7 +46494,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!transcript && !entry.endsWith(".partial")) {
       continue;
     }
-    const path = join36(directory, entry);
+    const path = join37(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -46502,18 +46744,18 @@ var init_server_instructions = __esm(() => {
 
 // src/test-selection.ts
 import { existsSync as existsSync29, readFileSync as readFileSync34 } from "node:fs";
-import { basename as basename12, join as join37 } from "node:path";
+import { basename as basename12, join as join38 } from "node:path";
 function casesIn(projectPath, suite) {
-  const text = readFileSync34(join37(projectPath, suite.slice("res://".length)), "utf8");
+  const text = readFileSync34(join38(projectPath, suite.slice("res://".length)), "utf8");
   return [...text.matchAll(/^func\s+(test_\w*)\s*\(/gm)].map((match) => match[1] ?? "");
 }
 function scriptsWithoutCases(projectPath, asked) {
-  return asked.filter((path) => path.endsWith(".gd") && existsSync29(join37(projectPath, path.slice("res://".length))) && casesIn(projectPath, path).length === 0);
+  return asked.filter((path) => path.endsWith(".gd") && existsSync29(join38(projectPath, path.slice("res://".length))) && casesIn(projectPath, path).length === 0);
 }
 function suitesUnder(projectPath, asked) {
   const scripts = projectFiles(projectPath, [".gd"]).map((path) => `res://${path}`);
   return [
-    ...new Set(asked.flatMap((path) => path.endsWith(".gd") ? existsSync29(join37(projectPath, path.slice("res://".length))) ? [path] : [] : scripts.filter((script) => script.startsWith(`${path}/`))))
+    ...new Set(asked.flatMap((path) => path.endsWith(".gd") ? existsSync29(join38(projectPath, path.slice("res://".length))) ? [path] : [] : scripts.filter((script) => script.startsWith(`${path}/`))))
   ];
 }
 function selectTests(projectPath, asked, given) {
@@ -46576,7 +46818,7 @@ import {
   copyFileSync,
   existsSync as existsSync30,
   fstatSync as fstatSync2,
-  mkdirSync as mkdirSync20,
+  mkdirSync as mkdirSync21,
   openSync as openSync6,
   readdirSync as readdirSync17,
   readFileSync as readFileSync35,
@@ -46584,9 +46826,9 @@ import {
   realpathSync as realpathSync5,
   rmdirSync as rmdirSync2,
   statSync as statSync19,
-  writeFileSync as writeFileSync19
+  writeFileSync as writeFileSync20
 } from "node:fs";
-import { basename as basename13, dirname as dirname24, extname as extname4, isAbsolute as isAbsolute8, join as join38, normalize as normalize2, relative as relative7 } from "node:path";
+import { basename as basename13, dirname as dirname24, extname as extname4, isAbsolute as isAbsolute8, join as join39, normalize as normalize2, relative as relative7 } from "node:path";
 import { setTimeout as delay7 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function editorRestartTimeoutMs() {
@@ -46645,7 +46887,7 @@ function writtenFileRefusal(path, rule) {
   if (!existsSync30(directory)) {
     return `${named}'s directory ${dirname24(path)} does not exist; ${what} creates no directories.`;
   }
-  const where = join38(directory, basename13(path));
+  const where = join39(directory, basename13(path));
   const inside = rule.projects.find((project) => project !== "" && isWithinRoot(realAsFarAsItExists(project), where));
   if (inside !== undefined) {
     return `${named} ${path} is inside the project at ${inside}; ${what} is saved outside it, so it never becomes part of the game.`;
@@ -47292,7 +47534,7 @@ function notRunNote(notRun, failFast) {
 function presetsIn(projectPath) {
   let text;
   try {
-    text = readFileSync35(join38(projectPath, "export_presets.cfg"), "utf8");
+    text = readFileSync35(join39(projectPath, "export_presets.cfg"), "utf8");
   } catch {
     return null;
   }
@@ -47373,7 +47615,7 @@ function filesIn(folder) {
   try {
     for (const entry of readdirSync17(folder, { withFileTypes: true })) {
       if (entry.isFile()) {
-        found.set(entry.name, statSync19(join38(folder, entry.name)).mtimeMs);
+        found.set(entry.name, statSync19(join39(folder, entry.name)).mtimeMs);
       }
     }
   } catch {}
@@ -47413,7 +47655,7 @@ function unsavedInEditorNote(scripts) {
   return `${named} ${one ? "is" : "are"} open in the editor's script ${one ? "tab" : "tabs"} with unsaved edits, and saving ${one ? "that tab" : "them"} there writes ${one ? "its" : "their"} text over what was written here: close ${one ? "it" : "them"} without saving, or save first and edit again.`;
 }
 function editorAddonMissing(projectPath) {
-  if (!existsSync30(join38(projectPath, "project.godot"))) {
+  if (!existsSync30(join39(projectPath, "project.godot"))) {
     return null;
   }
   const report = inspectProject(projectPath);
@@ -47441,7 +47683,7 @@ function rewriteBusNamed(projectPath, from, to) {
   const giving = [`bus = &"${quoted(from)}"`, `bus = "${quoted(from)}"`];
   const rewritten = [];
   for (const file of projectFiles(projectPath, [".tscn", ".tres"])) {
-    const absolute = join38(projectPath, file);
+    const absolute = join39(projectPath, file);
     const lines = readFileSync35(absolute, "utf8").split(`
 `);
     const at = [];
@@ -47454,14 +47696,14 @@ function rewriteBusNamed(projectPath, from, to) {
       return `bus = &"${quoted(to)}"${ending}`;
     });
     if (at.length > 0) {
-      writeFileSync19(absolute, after.join(`
+      writeFileSync20(absolute, after.join(`
 `));
       rewritten.push({ file: `res://${file}`, lines: at });
     }
   }
   const namedInScripts = [];
   for (const file of projectFiles(projectPath, [".gd"])) {
-    readFileSync35(join38(projectPath, file), "utf8").split(`
+    readFileSync35(join39(projectPath, file), "utf8").split(`
 `).forEach((line, index) => {
       if (line.includes(`"${from}"`)) {
         namedInScripts.push({ file: `res://${file}`, line: index + 1, text: line.trim() });
@@ -47736,7 +47978,7 @@ function profileFrameFunctions(projectPath) {
   let projectGodot = null;
   if (projectPath !== null) {
     try {
-      projectGodot = readFileSync35(join38(projectPath, "project.godot"), "utf8");
+      projectGodot = readFileSync35(join39(projectPath, "project.godot"), "utf8");
     } catch {}
   }
   return frameFunctionsFor(queuedMessagesOf(projectGodot));
@@ -47919,7 +48161,7 @@ function foldedEntriesAnswer(log, floor = "warning") {
 }
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync35(join38(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync35(join39(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -47934,7 +48176,7 @@ function uncaughtNote(uncaught) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync30(join38(projectPath, wanted))) {
+  if (wanted === "" || existsSync30(join39(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -47957,7 +48199,7 @@ function windowNoteFor(needing, sharing) {
   return `${named(needing)} ${one ? "needs" : "need"} a window, as gdharness test reads ${one ? "it" : "them"}, so the run had one: the engine ran without --headless, at the size project.godot gives its viewport, with no sound${process.platform === "win32" ? ", on a desktop of its own, where its window neither shows nor takes the keyboard" : ""}. ${why}${shared}`;
 }
 function testPathsIn(projectPath, given) {
-  const defaults = TEST_DIRECTORIES.filter((directory) => existsSync30(join38(projectPath, directory)));
+  const defaults = TEST_DIRECTORIES.filter((directory) => existsSync30(join39(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) {
@@ -48069,7 +48311,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   stdio = null;
   locator = new GodotLocator;
-  operationsScript = join38(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join39(__dirname2, "godot", "operations", "godot_operations.gd");
   exportOptionsRead = new Map;
   heldWhilePending = new Set;
   evaluatedWhilePending = new Set;
@@ -48340,7 +48582,7 @@ class GodotServer {
   }
   noteTheStart() {
     const cwd = process.cwd();
-    const mcpJson = join38(cwd, ".mcp.json");
+    const mcpJson = join39(cwd, ".mcp.json");
     const announced = this.ownProject === null ? null : readAnnouncement(announcementPath(this.ownProject));
     const predecessor = announced !== null && announced.pid !== process.pid && alive(announced.pid) ? announced.pid : null;
     writeLifecycle("started", {
@@ -48488,7 +48730,7 @@ class GodotServer {
         return checked.response;
       }
       const named = args["projectPath"];
-      if (typeof named === "string" && existsSync30(join38(named, "project.godot"))) {
+      if (typeof named === "string" && existsSync30(join39(named, "project.godot"))) {
         this.lastProjectPath = named;
       }
       this.updates.refresh();
@@ -48524,8 +48766,8 @@ class GodotServer {
     let notSaved;
     try {
       savedAt = answer.content.map((item, index) => {
-        const file = join38(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
-        writeFileSync19(file, item.type === "text" ? item.text : Buffer.from(item.data, "base64"));
+        const file = join39(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
+        writeFileSync20(file, item.type === "text" ? item.text : Buffer.from(item.data, "base64"));
         return file;
       });
     } catch (error) {
@@ -49208,7 +49450,7 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join38(path, "project.godot");
+    const file = join39(path, "project.godot");
     if (!existsSync30(file)) {
       return {
         ok: false,
@@ -50077,7 +50319,7 @@ class GodotServer {
       const platform = presetPlatform(project.value.path, preset);
       if (platform !== null) {
         const known = await this.exportOptions(platform, {
-          presetsFile: join38(project.value.path, "export_presets.cfg"),
+          presetsFile: join39(project.value.path, "export_presets.cfg"),
           preset,
           asked: options
         });
@@ -50128,7 +50370,7 @@ ${platform}`;
     }
     const empty = scratchDirectory("export");
     try {
-      writeFileSync19(join38(empty, "project.godot"), `config_version=5
+      writeFileSync20(join39(empty, "project.godot"), `config_version=5
 `);
       const outcome = await runOperation({ godotPath: engine.value, script: this.operationsScript, debug: DEBUG_MODE, editor: true }, "export_options", { platform, ...standing }, empty);
       const options = outcome.ok ? outcome.payload["options"] : undefined;
@@ -50167,7 +50409,7 @@ ${platform}`;
     }
     const folder = dirname24(output.absolutePath);
     try {
-      mkdirSync20(folder, { recursive: true });
+      mkdirSync21(folder, { recursive: true });
     } catch (error) {
       return this.createErrorResponse(`Cannot create ${dirname24(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
@@ -50184,7 +50426,7 @@ ${platform}`;
     const exportArgs = [
       "--headless",
       "--log-file",
-      join38(exportLogs, "engine.log"),
+      join39(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       pack ? "--export-pack" : debug ? "--export-debug" : "--export-release",
@@ -50275,8 +50517,9 @@ ${platform}`;
     if (movie !== null) {
       return this.createErrorResponse(movie);
     }
-    const missing = paths.value.filter((path) => !existsSync30(join38(project.value.path, path.slice("res://".length))));
-    const asked = paths.value.filter((path) => !missing.includes(path));
+    const missing = paths.value.filter((path) => !existsSync30(join39(project.value.path, path.slice("res://".length))));
+    const projectScripts = new ProjectScripts(project.value.path);
+    const asked = projectScripts.searchedAsTold(paths.value.filter((path) => !missing.includes(path)));
     const unusable = gdUnit4Unusable(project.value.path);
     if (asked.length === 0) {
       const verdict = `nothing at ${missing.join(" and ")}`;
@@ -50315,7 +50558,7 @@ ${platform}`;
       return this.createErrorResponse(selection.reason);
     }
     const leftOut = new Set(readStringArray(args, "ignore") ?? []);
-    const needs = windowNeedsOf(project.value.path, selection.value?.suites ?? asked);
+    const needs = windowNeedsOf(projectScripts, selection.value?.suites ?? asked);
     const needing = needs.needing.filter((path) => !leftOut.has(basename13(path, ".gd")));
     const noDisplay = resolveHeadless(undefined, { platform: process.platform, variables: process.env });
     const windowed = needing.length > 0 && !noDisplay;
@@ -50347,14 +50590,14 @@ ${platform}`;
     const reports = `res://.godot/${ours}`;
     const ignored = readStringArray(args, "ignore") ?? [];
     const userData = scratchDirectory("tests");
-    const suitesFile = join38(userData, "suites.txt");
-    const skippingFile = join38(userData, "skipping.txt");
-    const engineLog = join38(userData, "engine.log");
-    const expectedFile = join38(userData, "expected.json");
-    writeFileSync19(suitesFile, `${(selection.value?.suites ?? asked).join(`
+    const suitesFile = join39(userData, "suites.txt");
+    const skippingFile = join39(userData, "skipping.txt");
+    const engineLog = join39(userData, "engine.log");
+    const expectedFile = join39(userData, "expected.json");
+    writeFileSync20(suitesFile, `${(selection.value?.suites ?? asked).join(`
 `)}
 `);
-    writeFileSync19(skippingFile, `${[...ignored, ...selection.value?.ignore ?? []].join(`
+    writeFileSync20(skippingFile, `${[...ignored, ...selection.value?.ignore ?? []].join(`
 `)}
 `);
     const viewport = windowed ? viewportOf(project.value.path) : null;
@@ -50391,11 +50634,11 @@ ${platform}`;
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
     const helperFiles = {
-      spec: join38(userData, "spec"),
-      pid: join38(userData, "pid"),
-      error: join38(userData, "error"),
-      stop: join38(userData, "stop"),
-      step: join38(userData, "step")
+      spec: join39(userData, "spec"),
+      pid: join39(userData, "pid"),
+      error: join39(userData, "error"),
+      stop: join39(userData, "stop"),
+      step: join39(userData, "step")
     };
     const onDesktop = windowed && process.platform === "win32";
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData), onDesktop ? { directory: project.value.path, files: helperFiles } : undefined);
@@ -50446,12 +50689,12 @@ ${platform}`;
     await run.settled;
     const helperFailed = onDesktop ? helperFailure(helperFiles.error) ?? (existsSync30(helperFiles.pid) ? null : `it never started, and ${helperStep(helperFiles.step)}`) : null;
     if (helperFailed !== null) {
-      discard(join38(project.value.path, ".godot", ...ours.split("/")), userData);
+      discard(join39(project.value.path, ".godot", ...ours.split("/")), userData);
       return this.createErrorResponse(`No tests ran: ${named(needing)} ${needing.length === 1 ? "needs" : "need"} a window, and the engine could not be started on a desktop of its own: ${helperFailed}`);
     }
     const tookMs = Date.now() - began;
     const notCompiled = stopped.for ?? run.log.all.map((entry) => autoloadNotCompiled(entry, autoloaded)).find((found) => found !== null) ?? null;
-    const reportsDir = join38(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join39(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     const casePrinted = withNestedErrors(readRun(existsSync30(engineLog) ? readFileSync35(engineLog, "utf8") : ""), run.log.all);
@@ -50460,7 +50703,7 @@ ${platform}`;
       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(readFileSync35(join38(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync35(join39(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -51202,7 +51445,7 @@ ${error.text}`;
       ...Array.isArray(stack) ? {
         stack: stack.map((frame) => ({
           ...frame,
-          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join38(projectPath, frame["script"].slice("res://".length)) } : {}
+          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join39(projectPath, frame["script"].slice("res://".length)) } : {}
         }))
       } : {}
     });
@@ -51531,7 +51774,7 @@ ${error.text}`;
       return null;
     }
     try {
-      return settingKeys(readFileSync35(join38(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync35(join39(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -51983,7 +52226,7 @@ ${error.text}`;
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync30(join38(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync30(join39(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, {
         addon: false,
         budgetMs,
@@ -52455,7 +52698,7 @@ ${error.text}`;
       if (onDesktop === undefined) {
         child.kill();
       } else {
-        writeFileSync19(onDesktop.files.stop, "");
+        writeFileSync20(onDesktop.files.stop, "");
       }
     };
     const cancelled = callSignal();
@@ -52982,7 +53225,7 @@ ${error.text}`;
     };
     const going = await this.runStillGoing(run);
     const projectPath = run.projectPath;
-    const projectGone = projectPath !== null && !existsSync30(join38(projectPath, "project.godot"));
+    const projectGone = projectPath !== null && !existsSync30(join39(projectPath, "project.godot"));
     if (projectGone && callersName !== undefined) {
       return this.createErrorResponse(`callersOf reads the project's scripts, and the run's project at ${projectPath} has no project.godot any more.`, ["editor_run profile without callersOf answers with the profile itself"]);
     }
@@ -53367,7 +53610,7 @@ ${error.text}`;
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync30(join38(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync30(join39(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -54784,7 +55027,7 @@ ${error.text}`;
   async ownRunOnItsWay(projectPath, budgetMs) {
     const run = await this.currentRun();
     const project = projectPath ?? run?.projectPath ?? null;
-    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync30(join38(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync30(join39(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -54894,7 +55137,7 @@ ${error.text}`;
       return this.createErrorResponse(staleNote);
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join38(screenshotDir, "capture.png") : null;
+    const screenshotPath = screenshotDir ? join39(screenshotDir, "capture.png") : null;
     const refused = (message) => this.createErrorResponse(message);
     const onGame = {
       pid: choice.endpoint.pid,
@@ -55229,7 +55472,7 @@ var init_server = __esm(() => {
 // src/cli.ts
 init_bridge_announce();
 import { existsSync as existsSync31 } from "node:fs";
-import { join as join39, resolve as resolve10 } from "node:path";
+import { join as join40, resolve as resolve10 } from "node:path";
 
 // src/error-mode.ts
 import process3 from "node:process";
@@ -55254,9 +55497,6 @@ async function letWindowsReportCrashes() {
     }
   } catch {}
 }
-function crashesReported() {
-  return cleared;
-}
 
 // src/cli.ts
 init_errors();
@@ -56226,7 +56466,7 @@ init_setup();
 init_setup();
 init_tool_definitions();
 init_tool_reference();
-import { existsSync as existsSync15, mkdirSync as mkdirSync5, readdirSync as readdirSync10, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync6, readdirSync as readdirSync10, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
 import { basename as basename8, dirname as dirname9, join as join17 } from "node:path";
 var SKILL_NAME = "gdharness";
 var SHARED_SKILLS = join17(".agents", "skills");
@@ -56521,8 +56761,8 @@ function writeSkill(directories, version) {
     rmSync6(directory, { recursive: true, force: true });
     for (const [name, contents] of files) {
       const path = join17(directory, name);
-      mkdirSync5(dirname9(path), { recursive: true });
-      writeFileSync7(path, contents, "utf8");
+      mkdirSync6(dirname9(path), { recursive: true });
+      writeFileSync8(path, contents, "utf8");
     }
     return { path: directory, replaced };
   });
@@ -56530,30 +56770,31 @@ function writeSkill(directories, version) {
 
 // src/suite-run.ts
 init_alive();
+init_class_cache();
 init_desktop();
 init_engine_leaks();
 import {
   closeSync as closeSync3,
   existsSync as existsSync19,
   fstatSync,
-  mkdirSync as mkdirSync8,
+  mkdirSync as mkdirSync9,
   openSync as openSync3,
   readdirSync as readdirSync12,
   readFileSync as readFileSync20,
   readSync,
   rmSync as rmSync10,
   statSync as statSync13,
-  writeFileSync as writeFileSync10
+  writeFileSync as writeFileSync11
 } from "node:fs";
 import { availableParallelism, freemem, totalmem } from "node:os";
-import { isAbsolute as isAbsolute6, join as join22, relative as relative3, resolve as resolve5, sep as sep2 } from "node:path";
+import { isAbsolute as isAbsolute6, join as join23, relative as relative3, resolve as resolve5, sep as sep2 } from "node:path";
 import process12 from "node:process";
 import { setTimeout as delay3 } from "node:timers/promises";
 
 // src/engine-slots.ts
 init_alive();
 init_process_children();
-import { closeSync as closeSync2, mkdirSync as mkdirSync6, openSync as openSync2, readFileSync as readFileSync15, rmSync as rmSync8, statSync as statSync11, writeSync as writeSync2 } from "node:fs";
+import { closeSync as closeSync2, mkdirSync as mkdirSync7, openSync as openSync2, readFileSync as readFileSync15, rmSync as rmSync8, statSync as statSync11, writeSync as writeSync2 } from "node:fs";
 import { join as join19 } from "node:path";
 import process11 from "node:process";
 import { setTimeout as delay2 } from "node:timers/promises";
@@ -56601,7 +56842,7 @@ class EngineSlots {
     this.holder = holder;
   }
   async take(signal) {
-    mkdirSync6(this.directory, { recursive: true });
+    mkdirSync7(this.directory, { recursive: true });
     for (;; ) {
       signal?.throwIfAborted();
       for (let slot = 0;slot < this.count; slot += 1) {
@@ -56695,6 +56936,8 @@ class EngineSlots {
 
 // src/suite-run.ts
 init_errors();
+init_import_freshness();
+init_library_copies();
 init_setup();
 init_spawn();
 
@@ -56840,13 +57083,13 @@ init_suite_plan();
 
 // src/version.ts
 import { readFileSync as readFileSync19 } from "node:fs";
-import { dirname as dirname11, join as join21 } from "node:path";
+import { dirname as dirname11, join as join22 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getLocalVersion() {
   const currentDirectory = dirname11(fileURLToPath2(import.meta.url));
   const packageCandidates = [
-    join21(currentDirectory, "..", "package.json"),
-    join21(currentDirectory, "..", "..", "package.json")
+    join22(currentDirectory, "..", "package.json"),
+    join22(currentDirectory, "..", "..", "package.json")
   ];
   for (const packagePath of packageCandidates) {
     try {
@@ -56864,6 +57107,8 @@ init_windows_ask();
 
 class TestUsageError extends Refusal {
 }
+var WINDOWS_EXCEPTION = 3221225472;
+var SLOWEST_NAMED = 5;
 var MOST_ENGINES = 4;
 var MEMORY_KEPT = 4 * 1024 ** 3;
 var MEMORY_PER_ENGINE = 1.5 * 1024 ** 3;
@@ -56878,6 +57123,10 @@ var VALUED = new Set([
   "--slots",
   "--slot-count",
   "--silence",
+  "--deadline",
+  "--godot",
+  "--godot-version",
+  "--cores",
   "--tests",
   "--reach-also",
   "--order"
@@ -56906,9 +57155,9 @@ function testOptionsOf(args, cwd) {
   }
   const first = positional[0];
   const named = first === undefined ? null : resolve5(cwd, first);
-  const projectNamed = named !== null && existsSync19(join22(named, "project.godot"));
+  const projectNamed = named !== null && existsSync19(join23(named, "project.godot"));
   const projectPath = projectNamed ? named : resolve5(cwd);
-  if (!existsSync19(join22(projectPath, "project.godot"))) {
+  if (!existsSync19(join23(projectPath, "project.godot"))) {
     throw new TestUsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   const last = (flag) => valued.get(flag)?.at(-1);
@@ -56920,6 +57169,10 @@ function testOptionsOf(args, cwd) {
     slotsDirectory: last("--slots") === undefined ? null : resolve5(cwd, last("--slots") ?? ""),
     slotCount: whole(last("--slot-count"), "--slot-count"),
     silenceSeconds: whole(last("--silence"), "--silence") ?? SILENCE_FLOOR_SECONDS,
+    deadlineSeconds: whole(last("--deadline"), "--deadline"),
+    godotPath: godotNamed(last("--godot"), cwd),
+    godotVersion: versionNamed(last("--godot-version")),
+    cores: coresNamed(last("--cores")),
     roots: (valued.get("--tests") ?? []).map((root) => resPathOf(root, projectPath, cwd).replace(/\/$/, "")),
     changedOnly: switches.has("--changed-only"),
     reachAlso: (valued.get("--reach-also") ?? []).map((path) => resolve5(projectPath, path)),
@@ -56938,6 +57191,34 @@ function whole(value, flag) {
   }
   return number;
 }
+function godotNamed(value, cwd) {
+  if (value === undefined) {
+    return null;
+  }
+  const path = resolve5(cwd, value);
+  if (!existsSync19(path) || statSync13(path).isDirectory()) {
+    throw new TestUsageError(`--godot names ${path}, which is not an engine executable.`);
+  }
+  return path;
+}
+function coresNamed(value) {
+  const cores = whole(value, "--cores");
+  const most = Math.min(availableParallelism(), 64);
+  if (cores !== null && cores > most) {
+    throw new TestUsageError(`--cores ${String(cores)} is more than the ${String(most)} processors a run can be held to here.`);
+  }
+  return cores;
+}
+function versionNamed(value) {
+  if (value === undefined) {
+    return null;
+  }
+  const version = value.replace(/^v/, "");
+  if (!/^\d+\.\d+(?:\.\d+)?(?:\.[\w-]+)*$/.test(version)) {
+    throw new TestUsageError(`--godot-version takes a version such as 4.7.2 or 4.7.2.stable, not ${value}.`);
+  }
+  return version;
+}
 function seedOf(value) {
   const seed = Number(value);
   if (!Number.isInteger(seed) || seed < 0) {
@@ -56965,7 +57246,7 @@ function homeOf(projectPath) {
   return mainCheckoutOf(projectPath) ?? projectPath;
 }
 function selectedSuites(scripts, options) {
-  const roots = options.roots.length > 0 ? options.roots : TEST_DIRECTORIES.filter((root) => existsSync19(join22(options.projectPath, root))).map((root) => `res://${root}`);
+  const roots = options.roots.length > 0 ? options.roots : TEST_DIRECTORIES.filter((root) => existsSync19(join23(options.projectPath, root))).map((root) => `res://${root}`);
   if (options.selected.length === 0) {
     const found = scripts.suitesUnder(roots);
     if (found.length === 0) {
@@ -56977,7 +57258,7 @@ function selectedSuites(scripts, options) {
   for (const entry of options.selected) {
     const caseAt = /^(res:\/\/.*\.gd):(\w+)$/.exec(entry);
     const path = caseAt?.[1] ?? entry;
-    const directory = join22(options.projectPath, path.slice(6));
+    const directory = join23(options.projectPath, path.slice(6));
     const suites = existsSync19(directory) && statSync13(directory).isDirectory() ? scripts.suitesUnder([path.replace(/\/$/, "")]) : [scripts.suite(path)].filter((suite) => suite !== null);
     if (suites.length === 0) {
       throw new TestUsageError(existsSync19(directory) ? `${path} holds no gdUnit4 suite: nothing there extends GdUnitTestSuite and declares a test_ function.` : `Nothing at ${path} in the project at ${options.projectPath}.`);
@@ -56999,7 +57280,7 @@ function selectedSuites(scripts, options) {
     cases: suite.cases.filter((c) => cases.has(c))
   }));
 }
-function roomFor(most, processors, available, said = "of memory free") {
+function roomFor(most, processors, available, said = "of memory free", processorsSaid = `the machine has ${plural(processors, "processor")}`) {
   const byMemory = Math.floor((available - MEMORY_KEPT) / MEMORY_PER_ENGINE);
   const engines = Math.max(1, Math.min(most, processors, byMemory));
   if (engines >= most) {
@@ -57008,7 +57289,7 @@ function roomFor(most, processors, available, said = "of memory free") {
   const gigabytes = (bytes) => `${(bytes / 1024 ** 3).toFixed(1)} GB`;
   return {
     engines,
-    held: byMemory < processors ? `the machine has ${gigabytes(Math.max(0, available))} ${said}, ${gigabytes(MEMORY_KEPT)} of it kept for everything else and ${gigabytes(MEMORY_PER_ENGINE)} taken for each engine` : `the machine has ${plural(processors, "processor")}`
+    held: byMemory < processors ? `the machine has ${gigabytes(Math.max(0, available))} ${said}, ${gigabytes(MEMORY_KEPT)} of it kept for everything else and ${gigabytes(MEMORY_PER_ENGINE)} taken for each engine` : processorsSaid
   };
 }
 async function memoryAvailable() {
@@ -57070,6 +57351,9 @@ function ordered(units, order) {
   }
   return sorted;
 }
+function heldToCores(cores, command, args, platform = process12.platform) {
+  return cores === null || platform !== "linux" ? { command, args: [...args] } : { command: "taskset", args: ["-c", `0-${String(cores - 1)}`, command, ...args] };
+}
 async function runTestCommand(options, godotPath) {
   const unusable = gdUnit4Unusable(options.projectPath);
   if (unusable !== null) {
@@ -57078,17 +57362,17 @@ async function runTestCommand(options, godotPath) {
   const startedAt = Date.now();
   const scripts = new ProjectScripts(options.projectPath);
   const home = homeOf(options.projectPath);
-  const state = join22(home, ".godot", "gdharness");
-  const timesFile = join22(state, "suite-times.json");
-  const passedFile = join22(state, "suite-passed.json");
+  const state = join23(home, ".godot", "gdharness");
+  const timesFile = join23(state, "suite-times.json");
+  const passedFile = join23(state, "suite-passed.json");
   let suites = selectedSuites(scripts, options);
   const wholeSuites = suites.map((suite) => scripts.suite(suite.path) ?? suite);
   const declared = new Map(wholeSuites.map((suite) => [suite.path, suite.cases]));
-  const testRuns = join22(options.projectPath, ".godot", "gdharness", "test-runs");
+  const testRuns = join23(options.projectPath, ".godot", "gdharness", "test-runs");
   sweepRunDirectories(testRuns);
-  const runDirectory = join22(testRuns, `${String(startedAt)}-${String(process12.pid)}`);
-  mkdirSync8(runDirectory, { recursive: true });
-  const slots = new EngineSlots(options.slotsDirectory ?? join22(home, ".godot", "gate", "slots"), options.slotCount ?? Math.min(MOST_ENGINES, availableParallelism()), { pid: process12.pid, started: await ownStart() });
+  const runDirectory = join23(testRuns, `${String(startedAt)}-${String(process12.pid)}`);
+  mkdirSync9(runDirectory, { recursive: true });
+  const slots = new EngineSlots(options.slotsDirectory ?? join23(home, ".godot", "gate", "slots"), options.slotCount ?? Math.min(MOST_ENGINES, availableParallelism()), { pid: process12.pid, started: await ownStart() });
   const running = new Set;
   const interrupted = () => {
     for (const end of running) {
@@ -57105,8 +57389,11 @@ async function runTestCommand(options, godotPath) {
     runDirectory,
     slots,
     silenceFloorSeconds: options.silenceSeconds,
+    deadlineSeconds: options.deadlineSeconds,
     running,
-    selfTyped: selfTypedExports(scripts.sources)
+    selfTyped: selfTypedExports(scripts.sources),
+    godotVersion: options.godotVersion,
+    cores: options.cores
   };
   try {
     if (options.importFirst) {
@@ -57145,7 +57432,10 @@ ${existsSync19(path) ? readFileSync20(path, "latin1") : "missing"}`)
     if (memory.unread !== undefined) {
       console.log(`Windows did not say how much memory it can still commit (${memory.unread}), so engines are sized by the physical memory free.`);
     }
-    const room = roomFor(options.engines, availableParallelism(), memory.bytes, memory.said);
+    const room = options.cores === null ? roomFor(options.engines, availableParallelism(), memory.bytes, memory.said) : roomFor(options.engines, options.cores, memory.bytes, memory.said, `--cores holds it to ${plural(options.cores, "processor")}`);
+    if (options.cores !== null && process12.platform === "darwin") {
+      console.log("macOS offers no way to hold a process to some processors, so --cores holds only the number of engines here.");
+    }
     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);
     const how = options.order === null ? `${windowedSaid(plans)}${roomSaid(plans.length, lanesOf(plans), lanesOf(dealt(units, declared, options.engines)), room.held, options.engines)}` : options.order === "reversed" ? ", in reverse order of path" : `, shuffled by ${String(options.order)}`;
@@ -57155,10 +57445,16 @@ ${existsSync19(path) ? readFileSync20(path, "latin1") : "missing"}`)
       const one = windowedAnyway.length === 1;
       console.log(`${named(windowedAnyway)} ${one ? "says it runs" : "say they run"} headless and ${one ? "runs" : "run"} with a window here, since an ordered run is one engine and a suite in it needs a window. Run ${one ? "it" : "them"} without the windowed suites to run ${one ? "it" : "them"} headless.`);
     }
-    const split = [...new Set(units.map((unit) => unit.suite))].filter((path) => units.filter((unit) => unit.suite === path).length > 1);
+    const split = [...new Set(units.map((unit) => unit.suite))].filter((path) => units.filter((unit) => unit.suite === path && unit.row === undefined).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)}.`);
     }
+    const byRows = [
+      ...new Set(units.flatMap((unit) => unit.row === undefined ? [] : [`${unit.suite} > ${unit.cases[0] ?? ""}`]))
+    ];
+    if (plans.length > 1 && byRows.length > 0) {
+      console.log(`Dealt out row by row, since ${byRows.length === 1 ? "it" : "each"} took more than ${String(SPLIT_PAST_SECONDS)} s last time: ${named(byRows)}.`);
+    }
     const lanes = [...new Set(plans.map((plan) => plan.lane))].map((lane) => plans.flatMap((plan, index) => plan.lane === lane ? [{ plan, index }] : []));
     let ran = (await inTurns(lanes, room.engines, (lane) => runLane(launch, lane, units))).flat().sort((a, b) => a.index - b.index);
     if (ran.some((engine) => engine.verdict.starved) && ran.some((engine) => !engine.verdict.passed)) {
@@ -57169,9 +57465,10 @@ ${existsSync19(path) ? readFileSync20(path, "latin1") : "missing"}`)
       }
       ran = again;
     }
-    writeJson(timesFile, timesAfter(readTimes(timesFile), wholeSuites, ran.map((engine) => engine.printed), (path) => scripts.suite(path)));
-    recordPassed(passedFile, ran, printsOf);
-    return report(ran, startedAt, runDirectory, options.printOutput);
+    writeJson(timesFile, timesAfter(readTimes(timesFile), wholeSuites, ran.map((engine) => engine.printed), (path) => scripts.suite(path), new Set(ran.flatMap((engine) => engine.plan.suites.filter((suite) => (engine.printed.suites.get(suite.path)?.closed ?? null) === null).flatMap((suite) => suite.cases.map((func) => `${suite.path}:${func}`))))));
+    const across = rowsAcross(ran.map((engine) => ({ handed: engine.plan.suites, printed: engine.printed })));
+    recordPassed(passedFile, ran, printsOf, new Set(across.map((fault) => fault.suite)));
+    return report(ran, across.map((fault) => fault.fault), startedAt, runDirectory, options.printOutput);
   } finally {
     process12.off("SIGINT", interrupted);
     process12.off("SIGTERM", interrupted);
@@ -57207,9 +57504,9 @@ function readRecord(file) {
     return {};
   }
 }
-function recordPassed(file, ran, printsOf) {
+function recordPassed(file, ran, printsOf, failedAcross) {
   const passed = readRecord(file);
-  const failedSomewhere = new Set;
+  const failedSomewhere = new Set(failedAcross);
   const passedSomewhere = new Set;
   for (const engine of ran) {
     const passing = new Set(engine.verdict.passedSuites);
@@ -57234,19 +57531,38 @@ function sweepRunDirectories(testRuns) {
   for (const entry of readdirSync12(testRuns)) {
     const pid = Number(/^\d+-(\d+)$/.exec(entry)?.[1]);
     if (!Number.isInteger(pid) || !alive(pid)) {
-      rmSync10(join22(testRuns, entry), { recursive: true, force: true });
+      rmSync10(join23(testRuns, entry), { recursive: true, force: true });
     }
   }
 }
 async function importProject(launch) {
-  const directory = join22(launch.runDirectory, "import");
-  mkdirSync8(join22(directory, "user"), { recursive: true });
-  const log = join22(directory, "import.log");
+  const seeded = seedExtensionList(launch.projectPath);
+  if (seeded !== null && seeded.length > 0) {
+    console.log(`Wrote .godot/extension_list.cfg naming ${named(seeded)}, so the import loads them.`);
+  }
+  const cached = cachedClasses(launch.projectPath);
+  if ((seeded === null || seeded.length === 0) && cached !== null && staleAgainst(cached, launch.projectPath).length === 0 && staleImports(launch.projectPath).length === 0) {
+    console.log("The import was skipped: every imported file and the class cache are current.");
+    return null;
+  }
+  const directory = join23(launch.runDirectory, "import");
+  mkdirSync9(join23(directory, "user"), { recursive: true });
+  const log = join23(directory, "import.log");
   const lock = await launch.slots.take();
   try {
-    const ended = await watched(launch, ["--headless", "--audio-driver", "Dummy", "--path", launch.projectPath, "--import"], directory, log, false, launch.silenceFloorSeconds);
+    freeLibraryCopies(launch.projectPath);
+    const ended = await watched(launch, ["--headless", "--audio-driver", "Dummy", "--path", launch.projectPath, "--import"], directory, log, launch.silenceFloorSeconds);
     if (ended.ended !== null || ended.code !== 0) {
-      return `${ended.ended ?? `the engine exited ${String(ended.code)}`}; everything it printed is in ${log}`;
+      return `${ended.ended ?? `the engine exited ${exitNamed(ended.code ?? 0)}`}; everything it printed is in ${log}`;
+    }
+    const printed = readRun(readFileSync20(log, "utf8"));
+    const wrongEngine = launch.godotVersion === null ? null : versionFault(printed.engineVersion, launch.godotVersion);
+    if (wrongEngine !== null) {
+      return `${wrongEngine}; everything it printed is in ${log}`;
+    }
+    const errors = printed.errors.filter((error) => !error.warning);
+    if (errors.length > 0) {
+      return `it printed ${errors.length === 1 ? "an engine error" : `${String(errors.length)} engine errors`}, the first ${JSON.stringify(errors[0]?.text ?? "")}; everything it printed is in ${log}`;
     }
     return null;
   } finally {
@@ -57266,15 +57582,22 @@ async function runLane(launch, lane, units) {
   }
 }
 async function runEngine2(launch, plan, index, units, again = "", slot = null) {
-  const directory = join22(launch.runDirectory, `engine-${String(index)}${again === "" ? "" : `-${again}`}`);
-  mkdirSync8(join22(directory, "user"), { recursive: true });
-  const suitesFile = join22(directory, "suites.txt");
-  const skippingFile = join22(directory, "skipping.txt");
-  const expectedFile = join22(directory, "expected.json");
-  writeFileSync10(suitesFile, `${plan.suites.map((suite) => suite.path).join(`
+  const directory = join23(launch.runDirectory, `engine-${String(index)}${again === "" ? "" : `-${again}`}`);
+  mkdirSync9(join23(directory, "user"), { recursive: true });
+  const suitesFile = join23(directory, "suites.txt");
+  const skippingFile = join23(directory, "skipping.txt");
+  const rowsFile = join23(directory, "rows.txt");
+  const expectedFile = join23(directory, "expected.json");
+  writeFileSync11(suitesFile, `${plan.suites.map((suite) => suite.path).join(`
+`)}
+`);
+  writeFileSync11(skippingFile, `${plan.skipping.join(`
 `)}
 `);
-  writeFileSync10(skippingFile, `${plan.skipping.join(`
+  writeFileSync11(rowsFile, `${plan.suites.flatMap((suite) => Object.entries(suite.rows ?? {}).map(([func, share]) => [
+    `${suite.path}:${func}`,
+    ..."only" in share ? ["only", ...share.only] : ["besides", ...share.besides]
+  ].join("\t"))).join(`
 `)}
 `);
   const viewport = viewportOf(launch.projectPath);
@@ -57290,7 +57613,7 @@ async function runEngine2(launch, plan, index, units, again = "", slot = null) {
     ...plan.windowed ? [] : ["--ignoreHeadlessMode"],
     "-c",
     "-rd",
-    `res://${relative3(launch.projectPath, join22(directory, "reports")).split(sep2).join("/")}`,
+    `res://${relative3(launch.projectPath, join23(directory, "reports")).split(sep2).join("/")}`,
     "-rc",
     "1",
     "--",
@@ -57298,6 +57621,8 @@ async function runEngine2(launch, plan, index, units, again = "", slot = null) {
     suitesFile,
     "--skipping-in",
     skippingFile,
+    "--rows-in",
+    rowsFile,
     "--html-report-off",
     "--junit-report-off",
     "--compile-together",
@@ -57307,12 +57632,12 @@ async function runEngine2(launch, plan, index, units, again = "", slot = null) {
   const held = new Set(plan.suites.map((suite) => suite.path));
   const slowest = Math.max(0, ...units.filter((unit) => held.has(unit.suite)).map((unit) => unit.cost));
   const silence = Math.max(launch.silenceFloorSeconds, SILENCE_TIMES_SLOWEST * slowest);
-  const log = join22(directory, "engine.log");
+  const log = join23(directory, "engine.log");
   const lock = slot ?? await launch.slots.take();
   const began = Date.now();
   let end;
   try {
-    end = await watched(launch, args, directory, log, plan.windowed, silence);
+    end = await watched(launch, args, directory, log, silence);
   } finally {
     if (slot === null) {
       launch.slots.release(lock);
@@ -57322,7 +57647,8 @@ async function runEngine2(launch, plan, index, units, again = "", slot = null) {
   const assignment = {
     suites: plan.suites,
     expected: readExpected(expectedFile),
-    selfTyped: launch.selfTyped
+    selfTyped: launch.selfTyped,
+    godotVersion: launch.godotVersion
   };
   return {
     index,
@@ -57330,29 +57656,34 @@ async function runEngine2(launch, plan, index, units, again = "", slot = null) {
     printed,
     verdict: judgeEngine(printed, assignment, end),
     log,
-    seconds: (Date.now() - began) / 1000
+    seconds: (Date.now() - began) / 1000,
+    again: again !== ""
   };
 }
-async function watched(launch, args, directory, log, windowed, silenceSeconds) {
-  const user = join22(directory, "user");
+async function watched(launch, args, directory, log, silenceSeconds) {
+  const user = join23(directory, "user");
   const env = { ...process12.env, APPDATA: user, XDG_DATA_HOME: user };
   const output = openSync3(log, "w");
   let child;
   let stop;
   let helper = null;
   try {
-    if (process12.platform === "win32" && (windowed || !crashesReported())) {
-      const where = windowed ? "on a desktop of its own" : "through the desktop helper";
+    if (process12.platform === "win32") {
+      const where = "on a desktop of its own";
       const compiled = await ensureHelperCompiled();
       if (compiled !== null) {
         return { code: null, signal: null, ended: `the engine could not be started ${where}: ${compiled}` };
       }
-      const stopFile = join22(directory, "stop");
-      const error = join22(directory, "error");
-      helper = { error, how: where, pid: join22(directory, "pid"), step: join22(directory, "step") };
-      const how = windowed ? { desktop: HIDDEN_DESKTOP, directory: launch.projectPath } : { directory: launch.projectPath };
+      const stopFile = join23(directory, "stop");
+      const error = join23(directory, "error");
+      helper = { error, how: where, pid: join23(directory, "pid"), step: join23(directory, "step") };
+      const how = {
+        desktop: HIDDEN_DESKTOP,
+        directory: launch.projectPath,
+        ...launch.cores === null ? {} : { affinity: (1n << BigInt(launch.cores)) - 1n }
+      };
       const wrapper = throughHelper(how, launch.godotPath, args, {
-        spec: join22(directory, "spec"),
+        spec: join23(directory, "spec"),
         pid: helper.pid,
         error,
         stop: stopFile,
@@ -57360,18 +57691,19 @@ async function watched(launch, args, directory, log, windowed, silenceSeconds) {
       });
       child = spawnHidden(wrapper.command, wrapper.args, {
         stdio: ["ignore", output, output],
-        env: windowed ? { ...env, [DESKTOP_VARIABLE]: HIDDEN_DESKTOP } : env,
+        env: { ...env, [DESKTOP_VARIABLE]: HIDDEN_DESKTOP },
         cwd: directory
       });
       stop = () => {
-        writeFileSync10(stopFile, "");
+        writeFileSync11(stopFile, "");
       };
     } else {
-      child = spawnHidden(launch.godotPath, args, {
+      const held = heldToCores(launch.cores, launch.godotPath, args);
+      child = spawnHidden(held.command, held.args, {
         stdio: ["ignore", output, output],
         env,
         cwd: launch.projectPath,
-        detached: process12.platform !== "win32"
+        detached: true
       });
       stop = () => {
         endTree(child);
@@ -57398,10 +57730,17 @@ async function watched(launch, args, directory, log, windowed, silenceSeconds) {
   const reading = openSync3(log, "r");
   try {
     let size = 0;
-    let lastGrowth = Date.now();
+    const started = Date.now();
+    let lastGrowth = started;
     let text = "";
     while (!finished.now) {
       await delay3(LOOK_MS);
+      const deadline = launch.deadlineSeconds;
+      if (ended === null && deadline !== null && Date.now() - started > deadline * 1000) {
+        const stoppedIn = readRun(text).stoppedIn;
+        ended = `the engine ran past the ${String(deadline)} s deadline${stoppedIn === null ? "" : ` while running ${stoppedIn}`}, so it was ended`;
+        stop();
+      }
       const now = fstatSync(reading).size;
       if (now > size) {
         const chunk = Buffer.alloc(now - size);
@@ -57425,11 +57764,12 @@ async function watched(launch, args, directory, log, windowed, silenceSeconds) {
     launch.running.delete(stop);
   }
   const { code, signal } = await exited;
+  const freeBytes = code !== null && code >>> 0 >= WINDOWS_EXCEPTION ? freemem() : undefined;
   const failed = helper === null ? null : helperFailure(helper.error);
   if (failed !== null && helper !== null) {
     ended ??= `the engine could not be started ${helper.how}: ${failed}`;
   }
-  return { code, signal, ended };
+  return { code, signal, ended, ...freeBytes === undefined ? {} : { freeBytes } };
 }
 function endTree(child) {
   if (child.pid === undefined) {
@@ -57443,7 +57783,7 @@ function endTree(child) {
     process12.kill(-child.pid, "SIGKILL");
   } catch {}
 }
-function report(ran, startedAt, runDirectory, printOutput) {
+function report(ran, across, startedAt, runDirectory, printOutput) {
   if (printOutput) {
     for (const engine of ran) {
       console.log("");
@@ -57453,11 +57793,22 @@ function report(ran, startedAt, runDirectory, printOutput) {
   }
   const failed = ran.filter((engine) => !engine.verdict.passed);
   for (const engine of failed) {
+    const heading = `--- engine ${String(engine.index)}: ${plural(engine.plan.suites.length, "suite")}, ${engine.seconds.toFixed(1)} s${engine.again ? ", run again alone after an engine ran out of memory, and failed again" : ""}`;
     console.log("");
-    console.log(`--- engine ${String(engine.index)}: ${plural(engine.plan.suites.length, "suite")}, ${engine.seconds.toFixed(1)} s`);
+    console.log(heading);
     for (const fault of engine.verdict.faults) {
       console.log(`  ${fault}`);
     }
+    if (existsSync19(engine.log)) {
+      const verdict = [
+        `gdharness: ${heading.slice(4)}`,
+        ...engine.verdict.faults.map((fault) => `  ${fault}`)
+      ];
+      writeFileSync11(engine.log, `${verdict.join(`
+`)}
+---
+${readFileSync20(engine.log, "utf8")}`);
+    }
     if (engine.verdict.shown.length > 0) {
       console.log("");
       for (const line of engine.verdict.shown) {
@@ -57466,18 +57817,33 @@ function report(ran, startedAt, runDirectory, printOutput) {
     }
     console.log(`everything it printed: ${engine.log}`);
   }
+  if (across.length > 0) {
+    console.log("");
+    console.log("--- the cases dealt by their rows, over every engine holding them:");
+    for (const fault of across) {
+      console.log(`  ${fault}`);
+    }
+  }
   const cases = ran.reduce((sum, engine) => sum + [...engine.printed.suites.values()].reduce((n, s) => n + s.cases.length, 0), 0);
   const suites = new Set(ran.flatMap((engine) => engine.plan.suites.map((suite) => suite.path))).size;
   const longest = Math.max(0, ...ran.map((engine) => engine.seconds));
   const took = (Date.now() - startedAt) / 1000;
+  if (ran.length > 1) {
+    console.log("");
+    console.log(`The engines took ${ran.map((engine) => `${engine.seconds.toFixed(1)} s`).join(", ")}, dealt ${ran.map((engine) => `${engine.plan.cost.toFixed(1)} s`).join(", ")}.`);
+  }
+  const slowest = ran.flatMap((engine) => [...engine.printed.suites.values()].flatMap((suite) => suite.closed === null ? [] : [{ path: suite.path, seconds: suite.closed.seconds }])).sort((a, b) => b.seconds - a.seconds).slice(0, SLOWEST_NAMED);
+  if (slowest.length > 1) {
+    console.log(`The slowest suites: ${slowest.map((suite) => `${suite.path} ${suite.seconds.toFixed(1)} s`).join(", ")}.`);
+  }
   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) {
+  if (failed.length === 0 && across.length === 0) {
     rmSync10(runDirectory, { recursive: true, force: true });
     console.log(`Passed: ${totals}`);
     return 0;
   }
-  const problems = failed.reduce((sum, engine) => sum + engine.verdict.faults.length, 0);
+  const problems = failed.reduce((sum, engine) => sum + engine.verdict.faults.length, across.length);
   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;
@@ -57492,7 +57858,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve10(named ?? ".");
-  if (!existsSync31(join39(projectPath, "project.godot"))) {
+  if (!existsSync31(join40(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -57537,7 +57903,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync31(join39(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync31(join40(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }
@@ -57909,7 +58275,8 @@ Usage:
                                      an export if it is left on
   gdharness classes [project]        Rebuild .godot/global_script_class_cache.cfg from disk
   gdharness test [project] [suite ...] [--engines N] [--slots DIR] [--slot-count N]
-                 [--silence S] [--tests DIR] [--changed-only] [--reach-also PATH] [--import]
+                 [--silence S] [--deadline S] [--tests DIR] [--changed-only] [--reach-also PATH]
+                 [--import] [--godot PATH] [--godot-version V] [--cores N]
                  [--order reversed|SEED] [--print-output] [--runner]
                                      Run the project's gdUnit4 suites over several engines and
                                      judge every line they print: exit 1 on a failing case, an
@@ -57943,7 +58310,7 @@ async function test() {
     return;
   }
   const options = testOptionsOf(rest, process.cwd());
-  const { godotPath } = await engine(options.projectPath);
+  const godotPath = options.godotPath ?? (await engine(options.projectPath)).godotPath;
   process.exitCode = await runTestCommand(options, godotPath);
 }
 async function main() {