gdharness 1.3.11 → 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);
@@ -15154,7 +15217,13 @@ 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] ?? ""}`;
@@ -15241,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, leftOut };
+  return { lines, suites, errors, leaks, starved, executed, unloadable, stoppedIn, leftOut, engineVersion };
 }
 function withNestedErrors(printed, piped) {
   const nested = piped.flatMap((entry, at) => {
@@ -15250,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 {
@@ -15331,11 +15406,19 @@ 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");
   }
@@ -15489,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, 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 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();
@@ -15500,6 +15583,7 @@ 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*$/;
@@ -15527,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;
   }
@@ -15558,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);
@@ -15628,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;
@@ -15644,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) {
@@ -15657,7 +15762,7 @@ function readTimes(file) {
   }
 }
 function writeJson(file, value) {
-  mkdirSync7(dirname10(file), { recursive: true });
+  mkdirSync8(dirname10(file), { recursive: true });
   writeWhole(file, `${JSON.stringify(value, null, 1)}
 `);
 }
@@ -15866,8 +15971,7 @@ function planOf(bin, declared, windowed, lane, all) {
     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 {
@@ -15885,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"];
@@ -37497,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;
   }
@@ -37511,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;
     }
@@ -37538,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);
@@ -37546,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;
     }
@@ -37714,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 });
@@ -37749,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);
@@ -37758,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;
@@ -38177,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 {
@@ -38200,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]: {
@@ -38208,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) {
@@ -38226,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);
@@ -38246,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)}`);
@@ -38270,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;
@@ -38288,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 {
@@ -38325,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;
   }
@@ -38338,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 [];
   }
@@ -38367,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 {}
 }
@@ -39246,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 {
@@ -39275,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 {}
@@ -39283,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 }
@@ -39528,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 {
@@ -40244,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) {
@@ -40261,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) {
@@ -40300,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() {
@@ -40978,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);
@@ -41138,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)) {
@@ -41152,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) {
@@ -41581,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;
 }
@@ -41631,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];
   });
 }
@@ -41662,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`;
       }
     }
@@ -41675,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 })) {
@@ -41689,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);
       }
@@ -41699,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;
   }
@@ -41754,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.` };
     }
@@ -41788,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({
@@ -41812,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);
@@ -41871,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);
@@ -41880,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) {
@@ -41895,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");
         });
       }
     }
@@ -45599,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`);
@@ -45967,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)}`);
@@ -46010,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(/[\\/]+$/, "");
@@ -46021,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 {}
 }
@@ -46048,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}`);
@@ -46115,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);
         }
@@ -46389,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;
     }
@@ -46639,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) {
@@ -46713,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,
@@ -46721,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() {
@@ -46782,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.`;
@@ -47429,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;
   }
@@ -47510,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 {}
@@ -47550,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);
@@ -47578,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 = [];
@@ -47591,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() });
@@ -47873,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));
@@ -48056,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;
   }
@@ -48071,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();
@@ -48094,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) {
@@ -48206,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;
@@ -48477,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", {
@@ -48625,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();
@@ -48661,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) {
@@ -49345,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,
@@ -50214,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
         });
@@ -50265,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;
@@ -50304,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)}`);
     }
@@ -50321,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",
@@ -50412,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 ")}`;
@@ -50452,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;
@@ -50484,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;
@@ -50528,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);
@@ -50583,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);
@@ -50597,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);
@@ -51339,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)) } : {}
         }))
       } : {}
     });
@@ -51668,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;
     }
@@ -52120,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,
@@ -52592,7 +52698,7 @@ ${error.text}`;
       if (onDesktop === undefined) {
         child.kill();
       } else {
-        writeFileSync19(onDesktop.files.stop, "");
+        writeFileSync20(onDesktop.files.stop, "");
       }
     };
     const cancelled = callSignal();
@@ -53119,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"]);
     }
@@ -53504,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
       }));
@@ -54921,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;
@@ -55031,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,
@@ -55366,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";
@@ -55391,9 +55497,6 @@ async function letWindowsReportCrashes() {
     }
   } catch {}
 }
-function crashesReported() {
-  return cleared;
-}
 
 // src/cli.ts
 init_errors();
@@ -56363,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");
@@ -56658,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 };
   });
@@ -56667,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";
@@ -56738,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) {
@@ -56832,6 +56936,8 @@ class EngineSlots {
 
 // src/suite-run.ts
 init_errors();
+init_import_freshness();
+init_library_copies();
 init_setup();
 init_spawn();
 
@@ -56977,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 {
@@ -57001,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;
@@ -57015,6 +57123,10 @@ var VALUED = new Set([
   "--slots",
   "--slot-count",
   "--silence",
+  "--deadline",
+  "--godot",
+  "--godot-version",
+  "--cores",
   "--tests",
   "--reach-also",
   "--order"
@@ -57043,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);
@@ -57057,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)),
@@ -57075,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) {
@@ -57102,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) {
@@ -57114,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}.`);
@@ -57136,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) {
@@ -57145,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() {
@@ -57207,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) {
@@ -57215,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) {
@@ -57242,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) {
@@ -57282,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)}`;
@@ -57378,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 {
@@ -57410,19 +57582,19 @@ 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 rowsFile = join22(directory, "rows.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(`
 `)}
 `);
-  writeFileSync10(skippingFile, `${plan.skipping.join(`
+  writeFileSync11(skippingFile, `${plan.skipping.join(`
 `)}
 `);
-  writeFileSync10(rowsFile, `${plan.suites.flatMap((suite) => Object.entries(suite.rows ?? {}).map(([func, share]) => [
+  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(`
@@ -57441,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",
     "--",
@@ -57460,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);
@@ -57475,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,
@@ -57483,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,
@@ -57513,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);
@@ -57551,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);
@@ -57578,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) {
@@ -57606,11 +57793,22 @@ function report(ran, across, 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) {
@@ -57630,6 +57828,14 @@ function report(ran, across, startedAt, runDirectory, printOutput) {
   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 && across.length === 0) {
@@ -57652,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;
@@ -57697,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}`);
   }
 }
@@ -58069,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
@@ -58103,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() {