gdharness 1.3.6 → 1.3.8

package/build/cli.js

@@ -8367,9 +8367,487 @@ var init_doc_cache = __esm(() => {
   CACHE_FILE = /^editor_doc_cache-\d+\.\d+\.res$/;
 });
 
+// src/project-scan.ts
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync3 } from "node:fs";
+import { extname, join as join7 } from "node:path";
+function skipped(name) {
+  return name.startsWith(".") || SKIPPED.has(name);
+}
+function steppedOver(directory) {
+  return gdignored(directory) || installedByUs(directory);
+}
+function gdignored(directory) {
+  return existsSync6(join7(directory, ".gdignore"));
+}
+function installedByUs(directory) {
+  return existsSync6(join7(directory, VERSION_MARKER));
+}
+function projectStructure(projectPath) {
+  const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
+  const visit = (directory) => {
+    if (steppedOver(directory)) {
+      return;
+    }
+    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+      if (skipped(entry.name)) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        visit(join7(directory, entry.name));
+      } else if (entry.isFile()) {
+        const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
+        if (SIDECAR_EXTENSIONS.has(extension)) {
+          continue;
+        }
+        if (SCENE_EXTENSIONS.has(extension)) {
+          structure.scenes += 1;
+        } else if (extension === "gd" || extension === "cs") {
+          structure.scripts += 1;
+        } else if (ASSET_EXTENSIONS.has(extension)) {
+          structure.assets += 1;
+        } else {
+          structure.other += 1;
+        }
+      }
+    }
+  };
+  visit(projectPath);
+  return structure;
+}
+function projectFiles(projectPath, extensions) {
+  const found = [];
+  const visit = (directory, prefix) => {
+    if (steppedOver(directory)) {
+      return;
+    }
+    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+      if (skipped(entry.name)) {
+        continue;
+      }
+      const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+      if (entry.isDirectory()) {
+        visit(join7(directory, entry.name), spelled);
+      } else if (entry.isFile() && extensions.includes(extname(entry.name).toLowerCase())) {
+        found.push(spelled);
+      }
+    }
+  };
+  visit(projectPath, "");
+  return found.sort();
+}
+function scriptsWithoutUid(projectPath) {
+  const found = [];
+  const visit = (directory, prefix) => {
+    if (steppedOver(directory)) {
+      return;
+    }
+    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+      if (skipped(entry.name)) {
+        continue;
+      }
+      const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
+      if (entry.isDirectory()) {
+        visit(join7(directory, entry.name), spelled);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
+      if (CARRIES_A_UID.has(extension) && !existsSync6(join7(directory, `${entry.name}.uid`))) {
+        found.push(spelled);
+      }
+    }
+  };
+  visit(projectPath, "");
+  return found.sort();
+}
+function pathsInUidCache(projectPath) {
+  let data;
+  try {
+    data = readFileSync3(join7(projectPath, ".godot", "uid_cache.bin"));
+  } catch {
+    return null;
+  }
+  if (data.length < 4) {
+    return null;
+  }
+  const count = data.readUInt32LE(0);
+  const paths = new Map;
+  let at = 4;
+  for (let entry = 0;entry < count; entry++) {
+    if (at + 12 > data.length) {
+      return null;
+    }
+    const id = data.readBigUInt64LE(at);
+    const length = data.readUInt32LE(at + 8);
+    at += 12;
+    if (at + length > data.length) {
+      return null;
+    }
+    paths.set(id, data.toString("utf8", at, at + length));
+    at += length;
+  }
+  return new Set(paths.values());
+}
+function isBinary(bytes) {
+  return bytes.subarray(0, 8000).includes(0);
+}
+function projectTexts(projectPath) {
+  const found = [];
+  const visit = (directory, prefix) => {
+    if (steppedOver(directory)) {
+      return;
+    }
+    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+      if (skipped(entry.name)) {
+        continue;
+      }
+      const absolute = join7(directory, entry.name);
+      const spelled = `${prefix}${entry.name}`;
+      if (entry.isDirectory()) {
+        visit(absolute, `${spelled}/`);
+        continue;
+      }
+      const extension = entry.name.includes(".") ? entry.name.split(".").pop()?.toLowerCase() ?? "" : "";
+      if (!entry.isFile() || BINARY_EXTENSIONS.has(extension)) {
+        continue;
+      }
+      const bytes = readFileSync3(absolute);
+      if (!isBinary(bytes)) {
+        found.push({ path: `res://${spelled}`, absolute, text: bytes.toString("utf8") });
+      }
+    }
+  };
+  visit(projectPath, "");
+  return found;
+}
+function ignoredTexts(projectPath) {
+  const found = [];
+  const visit = (directory, prefix, ignored) => {
+    if (installedByUs(directory)) {
+      return;
+    }
+    const under = ignored || gdignored(directory);
+    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+      if (skipped(entry.name)) {
+        continue;
+      }
+      const absolute = join7(directory, entry.name);
+      const spelled = `${prefix}${entry.name}`;
+      if (entry.isDirectory()) {
+        visit(absolute, `${spelled}/`, under);
+        continue;
+      }
+      const extension = entry.name.includes(".") ? entry.name.split(".").pop()?.toLowerCase() ?? "" : "";
+      if (!under || !entry.isFile() || BINARY_EXTENSIONS.has(extension) || entry.name === ".gdignore") {
+        continue;
+      }
+      const bytes = readFileSync3(absolute);
+      if (!isBinary(bytes)) {
+        found.push({ path: `res://${spelled}`, absolute, text: bytes.toString("utf8") });
+      }
+    }
+  };
+  visit(projectPath, "", false);
+  return found;
+}
+function plainMatch(line, needle, caseSensitive) {
+  if (caseSensitive) {
+    return line.includes(needle) ? [needle] : null;
+  }
+  const lowered = line.toLowerCase();
+  const at = lowered.indexOf(needle);
+  if (at < 0) {
+    return null;
+  }
+  return [lowered.length === line.length ? line.slice(at, at + needle.length) : needle];
+}
+function compiledQuery(query, caseSensitive) {
+  try {
+    return new RegExp(query, caseSensitive ? "" : "i");
+  } catch (error) {
+    const why = errorMessage(error).split(": ").at(-1) ?? "";
+    throw new Error(`'${query}' is not a regular expression: ${why.charAt(0).toLowerCase()}${why.slice(1)}. With regex true, a character such as ( ) [ ] { } . * + ? | ^ $ or \\ stands for itself only after a backslash, as in \\(; or leave regex out to search for the text as written.`);
+  }
+}
+function searchProject(projectPath, options) {
+  const extensions = options.fileTypes === undefined ? null : new Set(options.fileTypes.map((ext) => ext.replace(/^\./, "").toLowerCase()).filter(Boolean));
+  const result = {
+    query: options.query,
+    results: [],
+    summary: { files_searched: 0, files_with_matches: 0, total_matches: 0, truncated: false }
+  };
+  const regex = options.regex ? compiledQuery(options.query, options.caseSensitive) : null;
+  const needle = options.caseSensitive ? options.query : options.query.toLowerCase();
+  const full = () => result.summary.truncated;
+  const notSearched = [];
+  const visit = (directory) => {
+    if (steppedOver(directory)) {
+      if (gdignored(directory)) {
+        notSearched.push(`res://${directory.slice(projectPath.length + 1).replace(/\\/g, "/")}/`);
+      }
+      return;
+    }
+    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+      if (full()) {
+        return;
+      }
+      if (skipped(entry.name)) {
+        continue;
+      }
+      const entryPath = join7(directory, entry.name);
+      if (entry.isDirectory()) {
+        visit(entryPath);
+        continue;
+      }
+      const extension = entry.name.includes(".") ? entry.name.split(".").pop()?.toLowerCase() ?? "" : "";
+      if (!entry.isFile() || extensions !== null && !extensions.has(extension)) {
+        continue;
+      }
+      const bytes = readFileSync3(entryPath);
+      if (extensions === null && isBinary(bytes)) {
+        continue;
+      }
+      result.summary.files_searched += 1;
+      const matches = [];
+      for (const [index, line] of bytes.toString("utf8").split(/\r?\n/).entries()) {
+        const found = regex ? regex.exec(line) : plainMatch(line, needle, options.caseSensitive);
+        if (found === null) {
+          continue;
+        }
+        if (result.summary.total_matches >= options.maxResults) {
+          result.summary.truncated = true;
+          break;
+        }
+        matches.push({ line: index + 1, content: line.trim(), match: found[0] });
+        result.summary.total_matches += 1;
+      }
+      if (matches.length > 0) {
+        const relativePath = entryPath.slice(projectPath.length + 1).replace(/\\/g, "/");
+        result.results.push({ file: `res://${relativePath}`, matches });
+        result.summary.files_with_matches += 1;
+      }
+    }
+  };
+  visit(projectPath);
+  return notSearched.length === 0 ? result : { ...result, not_searched: notSearched };
+}
+var SKIPPED, VERSION_MARKER = ".gdharness-version", SCENE_EXTENSIONS, SIDECAR_EXTENSIONS, ASSET_EXTENSIONS, CARRIES_A_UID, BINARY_EXTENSIONS;
+var init_project_scan = __esm(() => {
+  init_errors();
+  SKIPPED = new Set(["node_modules"]);
+  SCENE_EXTENSIONS = new Set(["tscn", "scn"]);
+  SIDECAR_EXTENSIONS = new Set(["import", "uid"]);
+  ASSET_EXTENSIONS = new Set([
+    "png",
+    "jpg",
+    "jpeg",
+    "webp",
+    "svg",
+    "bmp",
+    "tga",
+    "exr",
+    "hdr",
+    "ktx",
+    "dds",
+    "ttf",
+    "otf",
+    "woff",
+    "woff2",
+    "fnt",
+    "wav",
+    "mp3",
+    "ogg",
+    "glb",
+    "gltf",
+    "obj",
+    "fbx",
+    "blend",
+    "dae",
+    "ogv",
+    "gdshader",
+    "shader"
+  ]);
+  CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
+  BINARY_EXTENSIONS = new Set([
+    ...[...ASSET_EXTENSIONS].filter((extension) => !["svg", "gltf", "gdshader", "shader", "fnt"].includes(extension)),
+    "scn",
+    "res",
+    "zip",
+    "pck",
+    "exe",
+    "dll",
+    "so",
+    "dylib"
+  ]);
+});
+
+// src/import-freshness.ts
+import { createHash } from "node:crypto";
+import { existsSync as existsSync7, readdirSync as readdirSync5, readFileSync as readFileSync4, statSync as statSync5 } from "node:fs";
+import { join as join8 } from "node:path";
+function md5Of(file) {
+  let stats;
+  try {
+    stats = statSync5(file);
+  } catch {
+    return null;
+  }
+  const known = hashes.get(file);
+  if (known !== undefined && known.size === stats.size && known.mtimeMs === stats.mtimeMs) {
+    return known.md5;
+  }
+  let md5;
+  try {
+    md5 = createHash("md5").update(readFileSync4(file)).digest("hex");
+  } catch {
+    return null;
+  }
+  hashes.set(file, { size: stats.size, mtimeMs: stats.mtimeMs, md5 });
+  return md5;
+}
+function sectionOf(text, section) {
+  const keys = new Map;
+  let inside = false;
+  for (const line of text.split(/\r?\n/)) {
+    const header = /^\[([^\]]+)\]\s*$/.exec(line);
+    if (header !== null) {
+      inside = header[1] === section;
+      continue;
+    }
+    const pair = inside ? /^([A-Za-z0-9_./]+)=(.*)$/.exec(line) : null;
+    if (pair?.[1] !== undefined && pair[2] !== undefined) {
+      keys.set(pair[1], pair[2]);
+    }
+  }
+  return keys;
+}
+function unquoted(value) {
+  return value === undefined ? "" : value.replace(/^"(.*)"$/, "$1");
+}
+function listed(value) {
+  return [...(value ?? "").matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((match) => match[1] ?? "");
+}
+function onDisk(projectPath, resPath) {
+  return join8(projectPath, resPath.slice("res://".length));
+}
+function behind(projectPath, resPath, sidecar) {
+  const remap = sectionOf(sidecar, "remap");
+  const importer = unquoted(remap.get("importer"));
+  if (importer === "keep" || importer === "skip") {
+    return null;
+  }
+  const outputs = listed(sectionOf(sidecar, "deps").get("dest_files"));
+  if (outputs.some((output) => !existsSync7(onDisk(projectPath, output)))) {
+    return "its imported output is not on disk";
+  }
+  const name = resPath.slice(resPath.lastIndexOf("/") + 1);
+  const record = join8(projectPath, ".godot", "imported", `${name}-${createHash("md5").update(resPath, "utf8").digest("hex")}.md5`);
+  let recorded = "";
+  try {
+    recorded = /^source_md5="([0-9a-f]*)"/m.exec(readFileSync4(record, "utf8"))?.[1] ?? "";
+  } catch {
+    recorded = "";
+  }
+  if (recorded === "") {
+    return "its import recorded no hash of its source";
+  }
+  const current = md5Of(onDisk(projectPath, resPath));
+  return current === null || current === recorded ? null : "the source changed after it was imported";
+}
+function staleImports(projectPath) {
+  const stale = [];
+  const visit = (directory, resDirectory) => {
+    if (existsSync7(join8(directory, ".gdignore")) || existsSync7(join8(directory, VERSION_MARKER))) {
+      return;
+    }
+    let entries;
+    try {
+      entries = readdirSync5(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    const names = new Set(entries.map((entry) => entry.name));
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) {
+        continue;
+      }
+      const resPath = `${resDirectory}${entry.name}`;
+      if (entry.isDirectory()) {
+        visit(join8(directory, entry.name), `${resPath}/`);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      if (entry.name.endsWith(".import")) {
+        const source = resPath.slice(0, -".import".length);
+        if (!names.has(entry.name.slice(0, -".import".length))) {
+          continue;
+        }
+        let sidecar;
+        try {
+          sidecar = readFileSync4(join8(directory, entry.name), "utf8");
+        } catch {
+          continue;
+        }
+        const reason = behind(projectPath, source, sidecar);
+        if (reason !== null) {
+          stale.push({ path: source, reason });
+        }
+        continue;
+      }
+      const extension = entry.name.slice(entry.name.lastIndexOf(".") + 1).toLowerCase();
+      if (IMPORTABLE.has(extension) && !names.has(`${entry.name}.import`)) {
+        stale.push({ path: resPath, reason: "it has not been imported" });
+      }
+    }
+  };
+  visit(projectPath, "res://");
+  return stale.sort((one, other) => one.path.localeCompare(other.path));
+}
+var IMPORTABLE_EXTENSIONS, IMPORTABLE, hashes;
+var init_import_freshness = __esm(() => {
+  init_project_scan();
+  IMPORTABLE_EXTENSIONS = [
+    "png",
+    "jpg",
+    "jpeg",
+    "webp",
+    "svg",
+    "bmp",
+    "tga",
+    "exr",
+    "hdr",
+    "dds",
+    "ktx",
+    "wav",
+    "mp3",
+    "ogg",
+    "ttf",
+    "otf",
+    "ttc",
+    "otc",
+    "woff",
+    "woff2",
+    "pfb",
+    "pfm",
+    "fnt",
+    "font",
+    "glb",
+    "gltf",
+    "fbx",
+    "obj",
+    "dae"
+  ];
+  IMPORTABLE = new Set(IMPORTABLE_EXTENSIONS);
+  hashes = new Map;
+});
+
 // src/library-copies.ts
-import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync3, renameSync, unlinkSync } from "node:fs";
-import { basename as basename5, dirname as dirname6, isAbsolute as isAbsolute3, join as join7 } from "node:path";
+import { existsSync as existsSync8, readdirSync as readdirSync6, readFileSync as readFileSync5, renameSync, unlinkSync } from "node:fs";
+import { basename as basename5, dirname as dirname6, isAbsolute as isAbsolute3, join as join9 } from "node:path";
 function freeLibraryCopies(projectPath, platform = process.platform) {
   const setAside = [];
   const swept = [];
@@ -8379,24 +8857,24 @@ function freeLibraryCopies(projectPath, platform = process.platform) {
   for (const library of windowsLibraries(projectPath)) {
     const folder = dirname6(library);
     const copy = `~${basename5(library)}`;
-    if (existsSync6(join7(folder, copy))) {
-      const aside = join7(folder, `${copy}.aside-${process.pid}-${Date.now()}`);
+    if (existsSync8(join9(folder, copy))) {
+      const aside = join9(folder, `${copy}.aside-${process.pid}-${Date.now()}`);
       try {
-        renameSync(join7(folder, copy), aside);
+        renameSync(join9(folder, copy), aside);
         setAside.push(aside);
       } catch {}
     }
     let names;
     try {
-      names = readdirSync4(folder);
+      names = readdirSync6(folder);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.length > copy.length && name.toLowerCase().startsWith(copy.toLowerCase())) {
         try {
-          unlinkSync(join7(folder, name));
-          swept.push(join7(folder, name));
+          unlinkSync(join9(folder, name));
+          swept.push(join9(folder, name));
         } catch {}
       }
     }
@@ -8404,7 +8882,7 @@ function freeLibraryCopies(projectPath, platform = process.platform) {
   return { setAside, swept };
 }
 function windowsLibraries(projectPath) {
-  const listed = readOrNull(join7(projectPath, ".godot", "extension_list.cfg"));
+  const listed = readOrNull(join9(projectPath, ".godot", "extension_list.cfg"));
   if (listed === null) {
     return [];
   }
@@ -8436,13 +8914,13 @@ function resolveResource(projectPath, relativeTo, path) {
     return null;
   }
   if (path.startsWith("res://")) {
-    return join7(projectPath, path.slice("res://".length));
+    return join9(projectPath, path.slice("res://".length));
   }
-  return isAbsolute3(path) ? path : join7(relativeTo, path);
+  return isAbsolute3(path) ? path : join9(relativeTo, path);
 }
 function readOrNull(path) {
   try {
-    return readFileSync3(path, "utf8");
+    return readFileSync5(path, "utf8");
   } catch {
     return null;
   }
@@ -8450,23 +8928,23 @@ function readOrNull(path) {
 var init_library_copies = () => {};
 
 // src/reimport.ts
-import { createHash } from "node:crypto";
-import { existsSync as existsSync7, readFileSync as readFileSync4, rmSync as rmSync3, statSync as statSync5, utimesSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { basename as basename6, join as join8 } from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+import { existsSync as existsSync9, readFileSync as readFileSync6, rmSync as rmSync3, statSync as statSync6, utimesSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename6, join as join10 } from "node:path";
 function forceNextImport(projectPath, resourcePath) {
   const relative = resourcePath.replace(/^res:\/\//, "");
-  const sidecar = join8(projectPath, `${relative}.import`);
-  if (!existsSync7(sidecar)) {
+  const sidecar = join10(projectPath, `${relative}.import`);
+  if (!existsSync9(sidecar)) {
     return;
   }
-  const { atime, mtimeMs } = statSync5(sidecar);
-  writeFileSync3(sidecar, readFileSync4(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
+  const { atime, mtimeMs } = statSync6(sidecar);
+  writeFileSync3(sidecar, readFileSync6(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
   utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
   rmSync3(importRecord(projectPath, resourcePath), { force: true });
 }
 function importRecord(projectPath, resourcePath) {
-  const digest = createHash("md5").update(resourcePath).digest("hex");
-  return join8(projectPath, ".godot", "imported", `${basename6(resourcePath)}-${digest}.md5`);
+  const digest = createHash2("md5").update(resourcePath).digest("hex");
+  return join10(projectPath, ".godot", "imported", `${basename6(resourcePath)}-${digest}.md5`);
 }
 var init_reimport = () => {};
 
@@ -8496,17 +8974,17 @@ function alive(pid) {
 var init_alive = () => {};
 
 // src/scratch.ts
-import { existsSync as existsSync8, mkdtempSync, readdirSync as readdirSync5, rmSync as rmSync4 } from "node:fs";
+import { existsSync as existsSync10, mkdtempSync, readdirSync as readdirSync7, rmSync as rmSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join11 } from "node:path";
 import process8 from "node:process";
 function scratchDirectory(kind) {
-  return mkdtempSync(join9(tmpdir2(), `gdharness-${kind}-${process8.pid}-`));
+  return mkdtempSync(join11(tmpdir2(), `gdharness-${kind}-${process8.pid}-`));
 }
 function sweepAbandonedScratch(directory = tmpdir2()) {
   let entries;
   try {
-    entries = readdirSync5(directory);
+    entries = readdirSync7(directory);
   } catch {
     return;
   }
@@ -8517,7 +8995,7 @@ function sweepAbandonedScratch(directory = tmpdir2()) {
       continue;
     }
     try {
-      remove(join9(directory, entry));
+      remove(join11(directory, entry));
     } catch {}
   }
 }
@@ -8555,7 +9033,7 @@ function tryAgain(path, attempt) {
     lastTryOnExit();
   }
   const after = AGAIN_AFTER_MS[attempt];
-  if (after === undefined || !existsSync8(path)) {
+  if (after === undefined || !existsSync10(path)) {
     waiting.delete(path);
     if (after === undefined) {
       atExit.add(path);
@@ -8744,6 +9222,29 @@ function ignoredYetRan(report, ignored) {
   }
   return found;
 }
+function ignoredLeftOut(report, ignored, declared) {
+  const nameOf = (path) => (path.split("/").at(-1) ?? path).replace(/\.gd$/, "");
+  const leftOut = new Set;
+  const unmatched = [];
+  for (const entry of ignored) {
+    const bare = entry.replace("res://", "");
+    const at = bare.lastIndexOf(":");
+    const suiteNamed = at === -1 ? bare : bare.slice(0, at);
+    const testNamed = at === -1 ? null : bare.slice(at + 1);
+    const named = declared.filter((suite) => nameOf(suite.path) === suiteNamed || suite.path.includes(suiteNamed)).flatMap((suite) => suite.cases.filter((one) => testNamed === null || one === testNamed).map((test) => ({ suite, test })));
+    if (named.length === 0) {
+      unmatched.push(entry);
+      continue;
+    }
+    for (const { suite, test } of named) {
+      const reported = report.suites.filter((ran) => ran.path === suite.path || ran.path === null && ran.name === nameOf(suite.path)).some((ran) => ran.cases.some((one) => one.name === test || new RegExp(`^${test}\\W`).test(one.name)));
+      if (!reported) {
+        leftOut.add(`${nameOf(suite.path)}:${test}`);
+      }
+    }
+  }
+  return { leftOut: [...leftOut].sort(), unmatched };
+}
 function caseOf(suite, element) {
   const of = (kind) => element.children.filter((child) => child.name === kind).map((child) => {
     const detail = child.text.trim();
@@ -8776,6 +9277,7 @@ function parseJUnit(xml) {
     throw new MalformedReportError("No <testsuites> or <testsuite> in the report");
   }
   const suiteElements = top.name === "testsuite" ? [top] : top.children.filter((child) => child.name === "testsuite");
+  const where = (suite) => suite.path ?? suite.name;
   const suites = suiteElements.map((suite) => {
     const cases = suite.children.filter((child) => child.name === "testcase").map((element) => caseOf(suite, element));
     const failures = cases.filter(failedAnAssertion).length;
@@ -8795,6 +9297,7 @@ function parseJUnit(xml) {
       cases
     };
   });
+  suites.sort((a, b) => where(a) < where(b) ? -1 : where(a) > where(b) ? 1 : 0);
   const all = suites.flatMap((suite) => suite.cases);
   return {
     tests: all.length,
@@ -9102,7 +9605,7 @@ var init_junit = __esm(() => {
 });
 
 // src/script-origins.ts
-import { join as join10 } from "node:path";
+import { join as join12 } from "node:path";
 function unresolvedClassIn(message) {
   return UNRESOLVED.exec(message)?.[1] ?? null;
 }
@@ -9164,7 +9667,7 @@ function checkWithEngine(godotPath, projectPath) {
       const ran = await runEngine(godotPath, [
         "--headless",
         "--log-file",
-        join10(logDir, "engine.log"),
+        join12(logDir, "engine.log"),
         "--path",
         projectPath,
         "--check-only",
@@ -9210,8 +9713,8 @@ var init_script_origins = __esm(() => {
 });
 
 // src/headless.ts
-import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname7, join as join11 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname7, join as join13 } from "node:path";
 function snakeCased(params) {
   const result = emptyRecord();
   for (const [key, value] of Object.entries(params)) {
@@ -9223,8 +9726,10 @@ function snakeCased(params) {
 function engineExtras(outcome) {
   const after = outcome.afterAnswerMessages ?? [];
   const before = outcome.beforeOperationMessages ?? [];
+  const notImported = notImportedNote(outcome.messages);
   return {
     ...outcome.messages.length > 0 ? { engine_messages: outcome.messages } : {},
+    ...notImported === undefined ? {} : { engine_messages_note: notImported },
     ...before.length > 0 ? {
       engine_messages_before_operation: before,
       engine_messages_before_operation_note: withNotCompiled(BEFORE_OPERATION_NOTE, before)
@@ -9243,6 +9748,20 @@ function withNotCompiled(note, entries) {
   const path = entries.map(notCompiledIn).find((found) => found !== undefined);
   return path === undefined ? note : `${note} ${path} did not compile, so every run of this project starts its autoloads without it until it is fixed; its errors are among these.`;
 }
+function notImportedNote(entries) {
+  const paths = [
+    ...new Set(entries.flatMap((entry) => {
+      const path = /^No loader found for resource: (res:\/\/\S+)/.exec(entry.text)?.[1];
+      const extension = path?.split(".").pop()?.toLowerCase() ?? "";
+      return path !== undefined && IMPORTABLE_EXTENSIONS.includes(extension) ? [path] : [];
+    }))
+  ];
+  if (paths.length === 0) {
+    return;
+  }
+  const one = paths.length === 1;
+  return `${paths.join(", ")} ${one ? "has" : "have"} no import the engine can load, which is how a file it imports stands before it is first imported, so what uses ${one ? "it" : "them"} reads ${one ? "it" : "them"} as missing although ${one ? "it is" : "they are"} on disk: project_import reimport imports ${one ? "it" : "them"}.`;
+}
 function withoutAsides(entries) {
   const kept = [];
   let aside = false;
@@ -9349,7 +9868,7 @@ async function importOnce(godotPath, projectPath) {
     ran = await runEngine(godotPath, [
       "--headless",
       "--log-file",
-      join11(logDir, "engine.log"),
+      join13(logDir, "engine.log"),
       "--path",
       projectPath,
       "--import"
@@ -9371,13 +9890,13 @@ async function importOnce(godotPath, projectPath) {
 }
 async function runOperation(engine, operation, params, projectPath) {
   const paramsDir = scratchDirectory("params");
-  const paramsFile = join11(paramsDir, `${operation}.json`);
-  const answerFile = join11(paramsDir, "answer.json");
+  const paramsFile = join13(paramsDir, `${operation}.json`);
+  const answerFile = join13(paramsDir, "answer.json");
   writeFileSync4(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join11(paramsDir, "engine.log"),
+    join13(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -9465,10 +9984,10 @@ async function runOperation(engine, operation, params, projectPath) {
   };
 }
 function answerIn(file) {
-  if (!existsSync9(file)) {
+  if (!existsSync11(file)) {
     return { kind: "none" };
   }
-  const text = readFileSync5(file, "utf8");
+  const text = readFileSync7(file, "utf8");
   try {
     const parsed = JSON.parse(text);
     return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? { kind: "answer", payload: parsed } : { kind: "unreadable", why: `it is JSON but not an object: ${text.slice(0, 200)}` };
@@ -9483,6 +10002,7 @@ var AFTER_ANSWER_NOTE = "Printed after this operation had written its answer, wh
 var init_headless = __esm(() => {
   init_doc_cache();
   init_engine_run();
+  init_import_freshness();
   init_library_copies();
   init_paths();
   init_reimport();
@@ -9491,9 +10011,9 @@ var init_headless = __esm(() => {
 });
 
 // src/update-check.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir4, tmpdir as tmpdir3 } from "node:os";
-import { join as join12 } from "node:path";
+import { join as join14 } from "node:path";
 function packageUrl(root) {
   return `${root.replace(/\/+$/, "")}/gdharness/latest`;
 }
@@ -9515,28 +10035,28 @@ function cacheDirectory(environment) {
   };
   const home = set("HOME") ?? homedir4();
   if (process.platform === "win32") {
-    return join12(set("LOCALAPPDATA") ?? home, "gdharness");
+    return join14(set("LOCALAPPDATA") ?? home, "gdharness");
   }
   if (process.platform === "darwin") {
-    return join12(home, "Library", "Caches", "gdharness");
+    return join14(home, "Library", "Caches", "gdharness");
   }
-  return join12(set("XDG_CACHE_HOME") ?? join12(home, ".cache"), "gdharness");
+  return join14(set("XDG_CACHE_HOME") ?? join14(home, ".cache"), "gdharness");
 }
 function cacheFile(environment = process.env) {
   try {
     const directory = cacheDirectory(environment);
     mkdirSync3(directory, { recursive: true, mode: 448 });
-    return join12(directory, "update-check.json");
+    return join14(directory, "update-check.json");
   } catch {
-    return join12(tmpdir3(), "gdharness-update-check.json");
+    return join14(tmpdir3(), "gdharness-update-check.json");
   }
 }
 function readCache(path) {
   try {
-    if (!existsSync10(path)) {
+    if (!existsSync12(path)) {
       return null;
     }
-    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    const parsed = JSON.parse(readFileSync8(path, "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -9684,7 +10204,7 @@ var init_update_check = __esm(() => {
 });
 
 // src/server-version.ts
-import { readFileSync as readFileSync7 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
 function staleAddon(addonDigest, shippedDigest) {
   return addonDigest !== shippedDigest;
 }
@@ -9743,7 +10263,7 @@ var init_server_version = __esm(() => {
   DEBUG_MODE = process.env["GDHARNESS_DEBUG"] === "1";
   SERVER_VERSION = (() => {
     try {
-      const pkg = JSON.parse(readFileSync7(new URL("../package.json", import.meta.url), "utf8"));
+      const pkg = JSON.parse(readFileSync9(new URL("../package.json", import.meta.url), "utf8"));
       return typeof pkg.version === "string" ? pkg.version : "0.0.0";
     } catch {
       return "0.0.0";
@@ -9752,7 +10272,7 @@ var init_server_version = __esm(() => {
 });
 
 // src/issues.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import process9 from "node:process";
 function feedbackNotice(every) {
   return JSON.stringify({
@@ -9771,7 +10291,7 @@ function runtime() {
 function defectSignature(where, message) {
   const normalised = `${where}
 ${message}`.toLowerCase().replaceAll("\\", "/").replaceAll(/(?:[a-z]:)?(?:\/+[\w.-]+){2,}/gu, "<path>").replaceAll(/\d+/gu, "0");
-  return createHash2("sha256").update(normalised).digest("hex").slice(0, 8);
+  return createHash3("sha256").update(normalised).digest("hex").slice(0, 8);
 }
 function facts(where, message, godotVersion) {
   return [
@@ -10528,8 +11048,8 @@ var init_gdscript_source = __esm(() => {
 });
 
 // src/class-cache.ts
-import { existsSync as existsSync11, readdirSync as readdirSync6, readFileSync as readFileSync8, statSync as statSync6 } from "node:fs";
-import { join as join13, posix } from "node:path";
+import { existsSync as existsSync13, readdirSync as readdirSync8, readFileSync as readFileSync10, statSync as statSync7 } from "node:fs";
+import { join as join15, posix } from "node:path";
 function isToolScript(source) {
   return TOOL.test(codeOf(source));
 }
@@ -10548,18 +11068,18 @@ function declaredClassOf(source) {
 }
 function eachScript(projectPath, each) {
   const visit = (directory, prefix) => {
-    if (existsSync11(join13(directory, ".gdignore"))) {
+    if (existsSync13(join15(directory, ".gdignore"))) {
       return;
     }
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync8(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const path = join13(directory, entry.name);
+      const path = join15(directory, entry.name);
       if (entry.isDirectory()) {
         visit(path, `${prefix}${entry.name}/`);
       } else if (entry.isFile() && entry.name.endsWith(".gd")) {
-        each(`res://${prefix}${entry.name}`, readFileSync8(path, "utf8"));
+        each(`res://${prefix}${entry.name}`, readFileSync10(path, "utf8"));
       }
     }
   };
@@ -10581,12 +11101,12 @@ function scriptsNaming(projectPath, classes) {
   return naming.sort((a, b) => a.script.localeCompare(b.script));
 }
 function cachedClasses(projectPath) {
-  const cache = join13(projectPath, ".godot", "global_script_class_cache.cfg");
-  if (!existsSync11(cache)) {
+  const cache = join15(projectPath, ".godot", "global_script_class_cache.cfg");
+  if (!existsSync13(cache)) {
     return null;
   }
   const listed = new Map;
-  const text = readFileSync8(cache, "utf8");
+  const text = readFileSync10(cache, "utf8");
   for (const entry of text.matchAll(/"class":\s*&"([^"]+)"[\s\S]*?"path":\s*"([^"]+)"/g)) {
     listed.set(entry[1] ?? "", entry[2] ?? "");
   }
@@ -10879,14 +11399,14 @@ function uncachedForTheEngineNote(projectPath, types) {
   }
   const one = types.length === 1;
   const named = types.map((type) => `${type.type} (${type.declaredIn})`).join(", ");
-  const cacheExists = existsSync11(join13(projectPath, ".godot", "global_script_class_cache.cfg"));
+  const cacheExists = existsSync13(join15(projectPath, ".godot", "global_script_class_cache.cfg"));
   const state = cacheExists ? `missing from .godot/global_script_class_cache.cfg, which is where the engine that compiled these scripts resolves a class name from, so the error is the cache being behind the files rather than the script.` : `the engine that compiled these scripts resolves a class name from .godot/global_script_class_cache.cfg, which has not been written yet, as in a project no editor has opened, so the error is the missing cache rather than the script.`;
   return `${named} ${one ? "is" : "are"} declared in this project${cacheExists ? " and" : ", but"} ${state} ` + "project_import refresh_classes writes the cache from the declarations on disk; editor_run start " + "writes it before a game, and an editor opening the project writes it when it scans.";
 }
 function cacheWrittenAt(projectPath) {
-  const cache = join13(projectPath, ".godot", "global_script_class_cache.cfg");
+  const cache = join15(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
-    return statSync6(cache).mtimeMs;
+    return statSync7(cache).mtimeMs;
   } catch {
     return null;
   }
@@ -10898,14 +11418,14 @@ function declaredSince(projectPath, paths, names, since) {
       return false;
     }
     try {
-      return statSync6(join13(projectPath, path.slice("res://".length))).mtimeMs > since;
+      return statSync7(join15(projectPath, path.slice("res://".length))).mtimeMs > since;
     } catch {
       return false;
     }
   });
 }
 function cachedAtMissingPaths(cached, projectPath) {
-  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync11(join13(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
+  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync13(join15(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
 }
 function staleAgainst(cached, projectPath) {
   return [...declaredClasses(projectPath)].filter(([name, path]) => cached.get(name) !== path).map(([name]) => name);
@@ -10929,314 +11449,6 @@ var init_class_cache = __esm(() => {
   TOOL = /^[ \t]*(?:@[a-z_]+(?:\([^)\n]*\))?[ \t]+)*@tool\b/m;
 });
 
-// src/project-scan.ts
-import { existsSync as existsSync12, readdirSync as readdirSync7, readFileSync as readFileSync9 } from "node:fs";
-import { extname, join as join14 } from "node:path";
-function skipped(name) {
-  return name.startsWith(".") || SKIPPED.has(name);
-}
-function steppedOver(directory) {
-  return gdignored(directory) || installedByUs(directory);
-}
-function gdignored(directory) {
-  return existsSync12(join14(directory, ".gdignore"));
-}
-function installedByUs(directory) {
-  return existsSync12(join14(directory, VERSION_MARKER));
-}
-function projectStructure(projectPath) {
-  const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
-  const visit = (directory) => {
-    if (steppedOver(directory)) {
-      return;
-    }
-    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
-      if (skipped(entry.name)) {
-        continue;
-      }
-      if (entry.isDirectory()) {
-        visit(join14(directory, entry.name));
-      } else if (entry.isFile()) {
-        const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-        if (SCENE_EXTENSIONS.has(extension)) {
-          structure.scenes += 1;
-        } else if (extension === "gd" || extension === "cs") {
-          structure.scripts += 1;
-        } else if (ASSET_EXTENSIONS.has(extension)) {
-          structure.assets += 1;
-        } else {
-          structure.other += 1;
-        }
-      }
-    }
-  };
-  visit(projectPath);
-  return structure;
-}
-function projectFiles(projectPath, extensions) {
-  const found = [];
-  const visit = (directory, prefix) => {
-    if (steppedOver(directory)) {
-      return;
-    }
-    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
-      if (skipped(entry.name)) {
-        continue;
-      }
-      const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
-      if (entry.isDirectory()) {
-        visit(join14(directory, entry.name), spelled);
-      } else if (entry.isFile() && extensions.includes(extname(entry.name).toLowerCase())) {
-        found.push(spelled);
-      }
-    }
-  };
-  visit(projectPath, "");
-  return found.sort();
-}
-function scriptsWithoutUid(projectPath) {
-  const found = [];
-  const visit = (directory, prefix) => {
-    if (steppedOver(directory)) {
-      return;
-    }
-    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
-      if (skipped(entry.name)) {
-        continue;
-      }
-      const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
-      if (entry.isDirectory()) {
-        visit(join14(directory, entry.name), spelled);
-        continue;
-      }
-      if (!entry.isFile()) {
-        continue;
-      }
-      const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync12(join14(directory, `${entry.name}.uid`))) {
-        found.push(spelled);
-      }
-    }
-  };
-  visit(projectPath, "");
-  return found.sort();
-}
-function pathsInUidCache(projectPath) {
-  let data;
-  try {
-    data = readFileSync9(join14(projectPath, ".godot", "uid_cache.bin"));
-  } catch {
-    return null;
-  }
-  if (data.length < 4) {
-    return null;
-  }
-  const count = data.readUInt32LE(0);
-  const paths = new Map;
-  let at = 4;
-  for (let entry = 0;entry < count; entry++) {
-    if (at + 12 > data.length) {
-      return null;
-    }
-    const id = data.readBigUInt64LE(at);
-    const length = data.readUInt32LE(at + 8);
-    at += 12;
-    if (at + length > data.length) {
-      return null;
-    }
-    paths.set(id, data.toString("utf8", at, at + length));
-    at += length;
-  }
-  return new Set(paths.values());
-}
-function isBinary(bytes) {
-  return bytes.subarray(0, 8000).includes(0);
-}
-function projectTexts(projectPath) {
-  const found = [];
-  const visit = (directory, prefix) => {
-    if (steppedOver(directory)) {
-      return;
-    }
-    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
-      if (skipped(entry.name)) {
-        continue;
-      }
-      const absolute = join14(directory, entry.name);
-      const spelled = `${prefix}${entry.name}`;
-      if (entry.isDirectory()) {
-        visit(absolute, `${spelled}/`);
-        continue;
-      }
-      const extension = entry.name.includes(".") ? entry.name.split(".").pop()?.toLowerCase() ?? "" : "";
-      if (!entry.isFile() || BINARY_EXTENSIONS.has(extension)) {
-        continue;
-      }
-      const bytes = readFileSync9(absolute);
-      if (!isBinary(bytes)) {
-        found.push({ path: `res://${spelled}`, absolute, text: bytes.toString("utf8") });
-      }
-    }
-  };
-  visit(projectPath, "");
-  return found;
-}
-function ignoredTexts(projectPath) {
-  const found = [];
-  const visit = (directory, prefix, ignored) => {
-    if (installedByUs(directory)) {
-      return;
-    }
-    const under = ignored || gdignored(directory);
-    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
-      if (skipped(entry.name)) {
-        continue;
-      }
-      const absolute = join14(directory, entry.name);
-      const spelled = `${prefix}${entry.name}`;
-      if (entry.isDirectory()) {
-        visit(absolute, `${spelled}/`, under);
-        continue;
-      }
-      const extension = entry.name.includes(".") ? entry.name.split(".").pop()?.toLowerCase() ?? "" : "";
-      if (!under || !entry.isFile() || BINARY_EXTENSIONS.has(extension) || entry.name === ".gdignore") {
-        continue;
-      }
-      const bytes = readFileSync9(absolute);
-      if (!isBinary(bytes)) {
-        found.push({ path: `res://${spelled}`, absolute, text: bytes.toString("utf8") });
-      }
-    }
-  };
-  visit(projectPath, "", false);
-  return found;
-}
-function plainMatch(line, needle, caseSensitive) {
-  if (caseSensitive) {
-    return line.includes(needle) ? [needle] : null;
-  }
-  const lowered = line.toLowerCase();
-  const at = lowered.indexOf(needle);
-  if (at < 0) {
-    return null;
-  }
-  return [lowered.length === line.length ? line.slice(at, at + needle.length) : needle];
-}
-function compiledQuery(query, caseSensitive) {
-  try {
-    return new RegExp(query, caseSensitive ? "" : "i");
-  } catch (error) {
-    const why = errorMessage(error).split(": ").at(-1) ?? "";
-    throw new Error(`'${query}' is not a regular expression: ${why.charAt(0).toLowerCase()}${why.slice(1)}. With regex true, a character such as ( ) [ ] { } . * + ? | ^ $ or \\ stands for itself only after a backslash, as in \\(; or leave regex out to search for the text as written.`);
-  }
-}
-function searchProject(projectPath, options) {
-  const extensions = options.fileTypes === undefined ? null : new Set(options.fileTypes.map((ext) => ext.replace(/^\./, "").toLowerCase()).filter(Boolean));
-  const result = {
-    query: options.query,
-    results: [],
-    summary: { files_searched: 0, files_with_matches: 0, total_matches: 0, truncated: false }
-  };
-  const regex = options.regex ? compiledQuery(options.query, options.caseSensitive) : null;
-  const needle = options.caseSensitive ? options.query : options.query.toLowerCase();
-  const full = () => result.summary.truncated;
-  const visit = (directory) => {
-    if (steppedOver(directory)) {
-      return;
-    }
-    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
-      if (full()) {
-        return;
-      }
-      if (skipped(entry.name)) {
-        continue;
-      }
-      const entryPath = join14(directory, entry.name);
-      if (entry.isDirectory()) {
-        visit(entryPath);
-        continue;
-      }
-      const extension = entry.name.includes(".") ? entry.name.split(".").pop()?.toLowerCase() ?? "" : "";
-      if (!entry.isFile() || extensions !== null && !extensions.has(extension)) {
-        continue;
-      }
-      const bytes = readFileSync9(entryPath);
-      if (extensions === null && isBinary(bytes)) {
-        continue;
-      }
-      result.summary.files_searched += 1;
-      const matches = [];
-      for (const [index, line] of bytes.toString("utf8").split(/\r?\n/).entries()) {
-        const found = regex ? regex.exec(line) : plainMatch(line, needle, options.caseSensitive);
-        if (found === null) {
-          continue;
-        }
-        if (result.summary.total_matches >= options.maxResults) {
-          result.summary.truncated = true;
-          break;
-        }
-        matches.push({ line: index + 1, content: line.trim(), match: found[0] });
-        result.summary.total_matches += 1;
-      }
-      if (matches.length > 0) {
-        const relativePath = entryPath.slice(projectPath.length + 1).replace(/\\/g, "/");
-        result.results.push({ file: `res://${relativePath}`, matches });
-        result.summary.files_with_matches += 1;
-      }
-    }
-  };
-  visit(projectPath);
-  return result;
-}
-var SKIPPED, VERSION_MARKER = ".gdharness-version", SCENE_EXTENSIONS, ASSET_EXTENSIONS, CARRIES_A_UID, BINARY_EXTENSIONS;
-var init_project_scan = __esm(() => {
-  init_errors();
-  SKIPPED = new Set(["node_modules"]);
-  SCENE_EXTENSIONS = new Set(["tscn", "scn"]);
-  ASSET_EXTENSIONS = new Set([
-    "png",
-    "jpg",
-    "jpeg",
-    "webp",
-    "svg",
-    "bmp",
-    "tga",
-    "exr",
-    "hdr",
-    "ktx",
-    "dds",
-    "ttf",
-    "otf",
-    "woff",
-    "woff2",
-    "fnt",
-    "wav",
-    "mp3",
-    "ogg",
-    "glb",
-    "gltf",
-    "obj",
-    "fbx",
-    "blend",
-    "dae",
-    "ogv",
-    "gdshader",
-    "shader"
-  ]);
-  CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
-  BINARY_EXTENSIONS = new Set([
-    ...[...ASSET_EXTENSIONS].filter((extension) => !["svg", "gltf", "gdshader", "shader", "fnt"].includes(extension)),
-    "scn",
-    "res",
-    "zip",
-    "pck",
-    "exe",
-    "dll",
-    "so",
-    "dylib"
-  ]);
-});
-
 // src/answer-json.ts
 function answerJson(value) {
   return JSON.stringify(value, null, 2).replace(SCALAR_ARRAY, (_whole, items) => `[${items.split(/,\n\s+/).join(", ")}]`);
@@ -11248,7 +11460,7 @@ var init_answer_json = __esm(() => {
 });
 
 // src/resources.ts
-import { readFileSync as readFileSync10, realpathSync as realpathSync2 } from "node:fs";
+import { readFileSync as readFileSync11, realpathSync as realpathSync2 } from "node:fs";
 import { extname as extname2, resolve as resolve3 } from "node:path";
 function ensureProjectPath(getProjectPath) {
   const projectPath = getProjectPath();
@@ -11444,7 +11656,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync10(projectFilePath, "utf-8");
+    const rawProject = readFileSync11(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -11453,7 +11665,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync10(filePath, "utf-8");
+  const text = readFileSync11(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -11594,19 +11806,19 @@ function readParams(params, key) {
 }
 
 // src/setup.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import {
   cpSync,
-  existsSync as existsSync13,
+  existsSync as existsSync14,
   mkdirSync as mkdirSync4,
-  readdirSync as readdirSync8,
-  readFileSync as readFileSync11,
+  readdirSync as readdirSync9,
+  readFileSync as readFileSync12,
   rmdirSync,
   rmSync as rmSync5,
-  statSync as statSync7,
+  statSync as statSync8,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname8, join as join15 } from "node:path";
+import { dirname as dirname8, join as join16 } from "node:path";
 import { fileURLToPath } from "node:url";
 function editorAddonDigest(from = shippedAddonsDirectory()) {
   return addonsDigest(EDITOR_PLUGINS, from);
@@ -11615,27 +11827,27 @@ function runtimeAddonDigest(from = shippedAddonsDirectory()) {
   return addonsDigest([RUNTIME_ADDON], from);
 }
 function addonsDigest(names, from) {
-  const hash = createHash3("sha256");
+  const hash = createHash4("sha256");
   const walk = (directory, relative) => {
-    for (const name of readdirSync8(directory).sort()) {
+    for (const name of readdirSync9(directory).sort()) {
       if (name === VERSION_MARKER || name === DIGEST_MARKER) {
         continue;
       }
-      const path = join15(directory, name);
+      const path = join16(directory, name);
       const inside = `${relative}/${name}`;
-      if (statSync7(path).isDirectory()) {
+      if (statSync8(path).isDirectory()) {
         walk(path, inside);
       } else {
         hash.update(`${inside}
 `);
-        hash.update(readFileSync11(path));
+        hash.update(readFileSync12(path));
         hash.update(`
 `);
       }
     }
   };
   for (const name of names) {
-    walk(join15(from, name), name);
+    walk(join16(from, name), name);
   }
   return hash.digest("hex");
 }
@@ -11654,28 +11866,28 @@ function installedRuntimeDigest(projectPath) {
   return digestMarker(projectPath, RUNTIME_ADDON);
 }
 function digestMarker(projectPath, addon) {
-  const marker = join15(projectPath, "addons", addon, DIGEST_MARKER);
-  if (!existsSync13(marker)) {
+  const marker = join16(projectPath, "addons", addon, DIGEST_MARKER);
+  if (!existsSync14(marker)) {
     return null;
   }
-  const said = readFileSync11(marker, "utf8").trim();
+  const said = readFileSync12(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function shippedAddonsDirectory() {
-  return join15(dirname8(fileURLToPath(import.meta.url)), "godot", "addons");
+  return join16(dirname8(fileURLToPath(import.meta.url)), "godot", "addons");
 }
 function shippedOperationsScript() {
-  return join15(dirname8(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
+  return join16(dirname8(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
 }
 function shippedListedRunner() {
-  return join15(dirname8(fileURLToPath(import.meta.url)), "godot", "tests", "listed.gd");
+  return join16(dirname8(fileURLToPath(import.meta.url)), "godot", "tests", "listed.gd");
 }
 function gdUnit4Unusable(projectPath) {
   const marker = "addons/gdUnit4/plugin.cfg";
-  if (!existsSync13(join15(projectPath, ...marker.split("/")))) {
+  if (!existsSync14(join16(projectPath, ...marker.split("/")))) {
     return { missing: true, reason: `gdUnit4 is not installed in this project: no ${marker}` };
   }
-  if (!existsSync13(join15(projectPath, ...GDUNIT4_CI_RUNNER.split("/")))) {
+  if (!existsSync14(join16(projectPath, ...GDUNIT4_CI_RUNNER.split("/")))) {
     return {
       missing: false,
       reason: `gdUnit4 in this project is older than 6.0, which the shipped runner needs: no ${GDUNIT4_CI_RUNNER}`
@@ -11686,44 +11898,44 @@ function gdUnit4Unusable(projectPath) {
 function installAddons(projectPath, from = shippedAddonsDirectory()) {
   const installed = [];
   for (const name of ADDONS) {
-    const source = join15(from, name);
-    if (!existsSync13(join15(source, name === RUNTIME_ADDON ? "runtime_autoload.gd" : "plugin.cfg"))) {
+    const source = join16(from, name);
+    if (!existsSync14(join16(source, name === RUNTIME_ADDON ? "runtime_autoload.gd" : "plugin.cfg"))) {
       throw new Error(`The package holds no ${name} addon at ${source}.`);
     }
-    const target = join15(projectPath, "addons", name);
-    const replaced = existsSync13(target);
+    const target = join16(projectPath, "addons", name);
+    const replaced = existsSync14(target);
     rmSync5(target, { recursive: true, force: true });
     mkdirSync4(dirname8(target), { recursive: true });
     cpSync(source, target, { recursive: true });
-    writeFileSync6(join15(target, VERSION_MARKER), `${SERVER_VERSION}
+    writeFileSync6(join16(target, VERSION_MARKER), `${SERVER_VERSION}
 `);
     installed.push({ name, path: target, replaced });
   }
-  writeFileSync6(join15(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
+  writeFileSync6(join16(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
 `);
-  writeFileSync6(join15(projectPath, "addons", RUNTIME_ADDON, DIGEST_MARKER), `${runtimeAddonDigest(from)}
+  writeFileSync6(join16(projectPath, "addons", RUNTIME_ADDON, DIGEST_MARKER), `${runtimeAddonDigest(from)}
 `);
   return installed;
 }
 function installedAddonVersion(projectPath) {
-  const marker = join15(projectPath, "addons", ADDONS[0], VERSION_MARKER);
-  if (!existsSync13(marker)) {
+  const marker = join16(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  if (!existsSync14(marker)) {
     return null;
   }
-  const said = readFileSync11(marker, "utf8").trim();
+  const said = readFileSync12(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function removeAddons(projectPath) {
   const removed = [];
   for (const name of ADDONS) {
-    const target = join15(projectPath, "addons", name);
-    if (existsSync13(target)) {
+    const target = join16(projectPath, "addons", name);
+    if (existsSync14(target)) {
       rmSync5(target, { recursive: true, force: true });
       removed.push(target);
     }
   }
-  const addons = join15(projectPath, "addons");
-  if (removed.length > 0 && existsSync13(addons) && readdirSync8(addons).length === 0) {
+  const addons = join16(projectPath, "addons");
+  if (removed.length > 0 && existsSync14(addons) && readdirSync9(addons).length === 0) {
     rmdirSync(addons);
     removed.push(addons);
   }
@@ -11757,7 +11969,7 @@ function loaderAmong(projectPath, named) {
     }
     let source = null;
     try {
-      source = readFileSync11(join15(projectPath, path), "utf8");
+      source = readFileSync12(join16(projectPath, path), "utf8");
     } catch {}
     if (source?.includes(RUNTIME_AUTOLOAD.path)) {
       return { name: entry, path, exists: true };
@@ -11799,10 +12011,10 @@ function enabledPlugins(settings) {
 function inspectProject(projectPath) {
   const problems = [];
   const addons = ADDONS.map((name) => {
-    const directory = join15(projectPath, "addons", name);
-    const marker = join15(directory, VERSION_MARKER);
-    const installed = existsSync13(directory);
-    const version = existsSync13(marker) ? readFileSync11(marker, "utf8").trim() : null;
+    const directory = join16(projectPath, "addons", name);
+    const marker = join16(directory, VERSION_MARKER);
+    const installed = existsSync14(directory);
+    const version = existsSync14(marker) ? readFileSync12(marker, "utf8").trim() : null;
     const current = version === SERVER_VERSION;
     if (!installed) {
       problems.push(`addons/${name} is not installed; run gdharness setup`);
@@ -11811,7 +12023,7 @@ function inspectProject(projectPath) {
     }
     return { name, installed, version, current };
   });
-  const settings = parseProjectGodot(readFileSync11(join15(projectPath, "project.godot"), "utf8"));
+  const settings = parseProjectGodot(readFileSync12(join16(projectPath, "project.godot"), "utf8"));
   const pluginsEnabled = enabledPlugins(settings);
   for (const name of EDITOR_PLUGINS) {
     if (!pluginsEnabled.includes(name)) {
@@ -11827,7 +12039,7 @@ function inspectProject(projectPath) {
   const tracked = trackedByGit(projectPath, [...named.values()]);
   const addonMissing = (path) => addons.some((addon) => !addon.installed && path.startsWith(`addons/${addon.name}/`));
   for (const [name, path] of named) {
-    if (!existsSync13(join15(projectPath, path))) {
+    if (!existsSync14(join16(projectPath, path))) {
       if (!addonMissing(path)) {
         problems.push(`the ${name} autoload names res://${path}, which is not in this project, so it boots with a missing script; restore that file, or point the autoload at one that is here`);
       }
@@ -11856,7 +12068,7 @@ function inspectProject(projectPath) {
     problems
   };
 }
-var ADDONS, EDITOR_PLUGINS, RUNTIME_AUTOLOAD, SCRIPT_RUNS_SETTING = "gdharness/runtime/serve_script_runs", BIND_ADDRESS_SETTING = "gdharness/runtime/bind_address", PORT_SETTING = "gdharness/runtime/port", DIGEST_MARKER = ".gdharness-digest", RUNTIME_ADDON = "gdharness_runtime", shippedDigest, shippedRuntime, GDUNIT4_CI_RUNNER = "addons/gdUnit4/src/core/runners/GdUnitTestCIRunner.gd";
+var ADDONS, EDITOR_PLUGINS, RUNTIME_AUTOLOAD, SCRIPT_RUNS_SETTING = "gdharness/runtime/serve_script_runs", QUIET_SCENES_SETTING = "gdharness/runtime/quiet_scenes_under", BIND_ADDRESS_SETTING = "gdharness/runtime/bind_address", PORT_SETTING = "gdharness/runtime/port", DIGEST_MARKER = ".gdharness-digest", RUNTIME_ADDON = "gdharness_runtime", shippedDigest, shippedRuntime, GDUNIT4_CI_RUNNER = "addons/gdUnit4/src/core/runners/GdUnitTestCIRunner.gd";
 var init_setup = __esm(() => {
   init_class_cache();
   init_headless();
@@ -11980,6 +12192,7 @@ var init_tool_definitions = __esm(() => {
   init_launch();
   PROJECT_INFO_SECTIONS = [
     "autoloads",
+    "classes",
     "input_actions",
     "plugins",
     "export_presets",
@@ -12147,13 +12360,13 @@ var init_tool_definitions = __esm(() => {
       name: "project_info",
       title: "Project info",
       effect: "read",
-      description: "What a project is: its name and main scene from project.godot, the Godot that answers, and how many scenes, scripts and assets it holds, other counting every remaining file, leaving out the addons gdharness installed and any folder holding a .gdignore, with optional sections on top.",
+      description: "What a project is: its name and main scene from project.godot, the Godot that answers, and how many scenes, scripts and assets it holds, other counting every remaining file, leaving out the .import and .uid files the engine writes beside others, the addons gdharness installed and any folder holding a .gdignore, with optional sections on top.",
       parameters: {
         projectPath: PROJECT_PATH,
         include: {
           type: "array",
           items: { type: "string", enum: [...PROJECT_INFO_SECTIONS] },
-          description: "Extra sections: registered autoloads, the input actions project.godot holds with their events (an engine ui_ action only when the project rebinds it, as engineAction), addons and whether each is enabled, export presets, the audio bus layout, a health report, or export validation. health and validation compile every script of the project in headless engines and name each that fails with its first error, and each file a scene, resource or script refers to that does not exist."
+          description: "Extra sections: registered autoloads, the classes the project's scripts declare with class_name, each with its script, read from the files, the input actions project.godot holds with their events (an engine ui_ action only when the project rebinds it, as engineAction), addons and whether each is enabled, export presets, the audio bus layout, a health report, or export validation. health and validation compile every script of the project in headless engines and name each that fails with its first error, and each file a scene, resource or script refers to that does not exist."
         },
         preset: { type: "string", description: "For validation: the export preset to validate against." },
         detail: {
@@ -12298,7 +12511,7 @@ var init_tool_definitions = __esm(() => {
       name: "project_search",
       title: "Search the project",
       effect: "read",
-      description: "Searches text or a regular expression across project files and returns file paths with line numbers. What the engine steps over is not searched: directories spelled with a dot, node_modules, and any directory holding a .gdignore. A vendored engine or an export directory is therefore absent from the results rather than matching the code you are looking for in a copy nobody runs. The addons gdharness installed are not searched either, since nobody on the project wrote them.",
+      description: "Searches text or a regular expression across project files and returns file paths with line numbers. What the engine steps over is not searched: directories spelled with a dot, node_modules, and any directory holding a .gdignore, which not_searched names when the search passed one. A vendored engine or an export directory is therefore absent from the results rather than matching the code you are looking for in a copy nobody runs. The addons gdharness installed are not searched either, since nobody on the project wrote them.",
       parameters: {
         projectPath: PROJECT_PATH,
         query: { type: "string", description: "The text or pattern to find." },
@@ -12324,7 +12537,7 @@ var init_tool_definitions = __esm(() => {
         direction: {
           type: "string",
           enum: ["forward", "reverse"],
-          description: "forward: what this resource loads, with cycles reported, a script's dependencies including every script whose class_name it uses, marked by_class with the name. summary.total_resources is the file asked about, so 1; total_dependencies counts each file reached, directly or through another, once however many places load it; total_references counts the entries in the tree, and missing names every file referenced that does not exist, with the files referring to it. reverse: every file that refers to it and how, for a file that is gone as well while anything still refers to it, answered with exists: false (a missing file nothing refers to is refused, naming the nearest files), a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name. Each reference carries a kind: ext_resource, extends, preload, load or path for a reference by path; setting, plugin, export_preset and import for one in project.godot, a plugin.cfg, export_presets.cfg or an import sidecar; class_name for a use of the declared name, the declaration itself being the script asked about. Two kinds are mentions rather than uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs, and comment is one in ordinary prose, which it would only make stale. summary.in_code is the count with both of those left out, which is the number to read when the question is whether anything still uses this. Default forward."
+          description: "forward: what this resource loads, with cycles reported, a script's dependencies including every script whose class_name it uses, marked by_class with the name, and the script of every autoload it names, marked by_autoload with the autoload's name. summary.total_resources is the file asked about, so 1; total_dependencies counts each file reached, directly or through another, once however many places load it; total_references counts the entries in the tree, and missing names every file referenced that does not exist, with the files referring to it. reverse: every file that refers to it and how, for a file that is gone as well while anything still refers to it, answered with exists: false (a missing file nothing refers to is refused, naming the nearest files), a scene instancing it, a script extending, preloading or loading it, and for a script with a class_name every use of that name, and for an autoload's script every use of the autoload's name, with autoload naming it. Each reference carries a kind: ext_resource, extends, preload, load or path for a reference by path; setting, plugin, export_preset and import for one in project.godot, a plugin.cfg, export_presets.cfg or an import sidecar; class_name for a use of the declared name, the declaration itself being the script asked about; autoload for code naming the autoload. Two kinds are mentions rather than uses: doc is a name inside a ## documentation comment, which renaming would break in the generated docs, and comment is one in ordinary prose, which it would only make stale. summary.in_code is the count with both of those left out, which is the number to read when the question is whether anything still uses this. Default forward."
         },
         depth: { type: "number", description: "forward: how many levels to follow. Default unlimited." },
         includeBuiltin: {
@@ -12354,7 +12567,7 @@ var init_tool_definitions = __esm(() => {
         options: {
           type: "object",
           ops: ["set_options"],
-          description: `set_options: import options keyed as the .import file spells them, {"compress/mode": 1}. A dictionary option whose keys are numbers, a font's opentype_features or any option already holding number keys, takes them written as strings of digits, and opentype_features also takes an OpenType tag by its four-letter name: {"opentype_features": {"liga": 0}} turns ligatures off. Both are written as the numbers the engine reads. One already holding the value given is answered under unchanged_options rather than updated_options, and when none changed nothing is written or reimported.`,
+          description: `set_options: import options keyed as the .import file spells them, {"compress/mode": 1}. A dictionary option whose keys are numbers, a font's opentype_features or any option already holding number keys, takes them written as strings of digits, and opentype_features also takes an OpenType tag by its four-letter name: {"opentype_features": {"liga": 0}} turns ligatures off. Both are written as the numbers the engine reads. One already holding the value given is answered under unchanged_options rather than updated_options, and when none changed nothing is written or reimported. changed gives each option written as {was, now}, was null for one the import file did not hold.`,
           additionalProperties: true
         },
         reimport: {
@@ -12412,7 +12625,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "project_export",
       title: "Export",
-      description: "Export presets and exports. add_preset writes a preset to export_presets.cfg with the keys the editor's Project > Export writes for a new one, every platform option left at its default, and makes it the platform's runnable preset when the platform has none. It answers where this engine's export templates belong and whether the preset's platform has them, since an export needs them; list says the same for every preset. An editor open on the project does not see a preset added this way until it restarts. run names, as alsoWritten, what else the export wrote beside its output, such as the .pck a Windows or Linux build cannot start without.",
+      description: "Export presets and exports. add_preset writes a preset to export_presets.cfg with the keys the editor's Project > Export writes for a new one, every platform option left at its default, and makes it the platform's runnable preset when the platform has none. It answers where this engine's export templates belong and whether the preset's platform has them, since an export needs them; list says the same for every preset. An editor open on the project does not see a preset added this way until it restarts. run names, as alsoWritten, what else the export wrote beside its output, such as the .pck a Windows or Linux build cannot start without. Its entries are the errors and warnings the export printed, the newest two hundred distinct ones, one printed more than once carrying times, and errors and warnings count them; exported is true only when this run wrote the output and printed no error.",
       parameters: {
         projectPath: PROJECT_PATH,
         preset: {
@@ -12448,19 +12661,19 @@ var init_tool_definitions = __esm(() => {
       name: "project_test",
       title: "Run tests",
       effect: "additive",
-      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Each entry under failed carries its first report as message and detail, and, when it has more than one, its reports under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. Identical reports fold into one with times, at most twenty different ones are kept (reportsLeftOut counts the rest), and past about a megabyte the largest cases keep only their first message (failedWithoutDetail). failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted, not listed, and an engine message keeps the frames above gdUnit4, not the twenty inside it; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. What changed on disk since it was imported is then imported before any suite runs, and named under importedFirst. On Windows and Linux the run gets a user:// of its own, away from a player's saves; on macOS the engine reads user:// off HOME, so it writes where the player keeps theirs, and savesNote says so. A run that found nothing to run is never called a pass, and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. An autoload that does not compile stops the run at once, its errors listed the same way. A client sending a progress token is told as each suite finishes, and at least every twenty seconds. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
-      answer: "time is gdUnit4's own sum of the seconds its cases took, from its report. tookMs is the whole call in milliseconds, from the class rebuild to the engine's exit, which is what a caller waits for. " + IMPORTED_FIRST,
+      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Each entry under failed carries its first report as message and detail, and, when it has more than one, its reports under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. Identical reports fold into one with times, at most twenty different ones are kept (reportsLeftOut counts the rest), and past about a megabyte the largest cases keep only their first message (failedWithoutDetail). failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted, not listed, and an engine message keeps the frames above gdUnit4, not the twenty inside it; identical engine messages come back once under engineEntries, with times saying how often they were printed. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. What changed on disk since it was imported is then imported before any suite runs, and named under importedFirst. On Windows and Linux the run gets a user:// of its own, away from a player's saves; on macOS the engine reads user:// off HOME, so it writes where the player keeps theirs, and savesNote says so. A run that found nothing to run is never called a pass, and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. An autoload that does not compile stops the run at once, its errors listed the same way. A client sending a progress token is told as each suite finishes, and at least every twenty seconds. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and is not listed there, and none are when the project turns off gdUnit4's report/godot/script_error setting; a suite declares them all the same. Needs gdUnit4 under addons/gdUnit4.",
+      answer: "passed is the verdict to read. exitCode is the engine's own exit, gdUnit4's code for what it saw, and is 0 beside passed false when the run is failed for something gdUnit4 does not judge, such as an engine error no suite declared. time is gdUnit4's own sum of the seconds its cases took, from its report. tookMs is the whole call in milliseconds, from the class rebuild to the engine's exit, which is what a caller waits for. The run is judged as gdharness test judges it: undeclaredErrors names each engine error that no suite declared in its GDHARNESS_EXPECTED_ERRORS constant, with the suite and the case that printed it, and declaredNotPrinted each declared error its case did not print. Either fails the run, and each suite holding one is listed with its count. engineErrors counts every engine error the run printed but those a suite declared. " + IMPORTED_FIRST,
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
           type: ["string", "array"],
           items: { type: "string" },
-          description: "A test directory or suite file inside the project, or a list of them, all run on one engine: a named set of suites boots once rather than once per suite. An entry given twice, or a suite inside a directory also listed, runs once. An entry that is not there is left out and named under missing, the rest run, and such a run is never called passed; when no entry is there the run is refused before the engine starts, naming each one. Default test."
+          description: "A test directory or suite file inside the project, or a list of them, all run on one engine: a named set of suites boots once rather than once per suite. An entry given twice, or a suite inside a directory also listed, runs once. An entry that is not there is left out and named under missing, the rest run, and such a run is never called passed; when no entry is there the run is refused before the engine starts, naming each one. Default tests and test, those the project has, which is where gdharness test looks."
         },
         ignore: {
           type: "array",
           items: { type: "string" },
-          description: 'Suites or cases to leave out, as "suite_name" or "suite_name:test_name". A bare test name is read as a suite name and leaves out nothing; an entry that named a case which ran all the same comes back under ignoreNotApplied with the form that would have left it out.'
+          description: 'Suites or cases to leave out, as "suite_name" or "suite_name:test_name". A bare test name is read as a suite name and leaves out nothing; an entry that named a case which ran all the same comes back under ignoreNotApplied with the form that would have left it out. Every case the list left out comes back under ignored as suite_name:test_name, so a run called passed says what it did not run, and an entry naming no suite or case under path comes back under ignoreUnmatched.'
         },
         tests: {
           type: "array",
@@ -12696,7 +12909,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "scene_animation",
       title: "Animations",
-      description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. read answers with every track of an animation in the shape add_track takes, so a track read off one animation can be added to another. add_track on a path the animation already has a track of that type for adds the keys to that track, as the editor keys a property it already animates, answering existingTrack true and keysAdded beside keys, the track's count; a key at a time that track already has a key at is refused. A key past the animation's end, where it never plays, is written and named under pastLength. remove clears the player's autoplay when it named the animation and names under statesPlayingNothing the states that played it. read and read_states need no editor: one serving the project answers and says whether it holds unsaved changes to the scene, and with none a headless engine reads the file without running the scene's scripts. The ops that write go through the editor when one serves the project; with none, a headless engine runs the editor's own tool and the answer says so under writtenBy. That engine runs every script of the file, where the editor runs only tool scripts, so what a script changes as the file loads is put back before anything is saved, and a file where that cannot be done, such as a scene whose script does not compile, is refused and nothing is written. An editor of the project that is running and has not reached this server is waited for rather than written around.",
+      description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. The player and the tree are nodes, so scene_node add puts one in the scene first. read answers with every track of an animation in the shape add_track takes, so a track read off one animation can be added to another. add_track on a path the animation already has a track of that type for adds the keys to that track, as the editor keys a property it already animates, answering existingTrack true and keysAdded beside keys, the track's count; a key at a time that track already has a key at is refused. A key past the animation's end, where it never plays, is written and named under pastLength. remove clears the player's autoplay when it named the animation and names under statesPlayingNothing the states that played it. read and read_states need no editor: one serving the project answers and says whether it holds unsaved changes to the scene, and with none a headless engine reads the file without running the scene's scripts. The ops that write go through the editor when one serves the project; with none, a headless engine runs the editor's own tool and the answer says so under writtenBy. That engine runs every script of the file, where the editor runs only tool scripts, so what a script changes as the file loads is put back before anything is saved, and a file where that cannot be done, such as a scene whose script does not compile, is refused and nothing is written. An editor of the project that is running and has not reached this server is waited for rather than written around.",
       parameters: {
         projectPath: PROJECT_PATH,
         scenePath: SCENE_PATH,
@@ -12904,7 +13117,7 @@ var init_tool_definitions = __esm(() => {
       operations: {
         structure: {
           effect: "read",
-          summary: "functions, variables (static ones marked is_static; one written with := has the type of a literal or built-in constructor it is given, marked inferred, as a constant always does), signals, constants, enums, inner_classes (each with its name, line and extends, and its own members in these same fields), class_name, extends and line_count, read from the file, and dependencies: the paths it loads or preloads as written, then the scripts declaring each project class_name its code uses, which classes_used names with the class; autoloads_used names each autoload the code uses by its global name, with the autoload's script, which the project loads rather than this script, so it is not under dependencies",
+          summary: "functions, variables (static ones marked is_static; one written with := has the type of a literal or built-in constructor it is given, marked inferred, as a constant always does), signals, constants, enums, inner_classes (each with its name, line and extends, and its own members in these same fields), class_name, extends and line_count, read from the file, and dependencies: the paths it loads or preloads as written, then the scripts declaring each project class_name its code uses, which classes_used names with the class; autoloads_used names each autoload the code uses by its global name, with the autoload's script, which the project loads rather than this script, so it is not under dependencies. A member or inner class with a ## documentation comment directly above it carries the comment's text as doc, and the script's own, the ## block above class_name or extends or one followed by a blank line before any member, comes back as class_doc",
           requires: []
         },
         symbols: {
@@ -13042,7 +13255,7 @@ var init_tool_definitions = __esm(() => {
       name: "editor_launch",
       title: "Open, restart or close the editor, or bind its debug adapter again",
       description: "Opens the Godot editor on a project, or restarts or closes the one already connected, or binds its debug adapter again. close saves open scenes, quits the editor and waits for its process to go, which is the only way to end a hidden one short of killing it; an editor this server opened that has not connected yet has nothing of this server's to save, so close stops its process instead. open answers once the process has started, and the editor dials in after its import; a call needing the editor made before then waits for the one this server opened, for as long as a restart waits, and is refused naming it if it has not arrived. open refuses while an editor of the project is already running and has not reached this server, naming its pid, rather than putting a second on the project. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too; a hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one; it saves open scenes on the way out. An editor a server opened is started again by the server, visible unless hidden: true is passed again, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. Godot tries each server port once, as the editor starts, so a restart binds a debug adapter that came back without its port again, in the editor that came back. rebind does the same for the connected editor without restarting it, whoever opened it; a debug session open on the adapter ends with it and is opened again by the next debug call. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so in editor_status rather than waiting for an editor that is not coming, and open finishes it. An open is refused when the editor it would start could never reach this server: a project other than the one this server serves, whose editor dials that project's own server; a project without the gdharness editor addon installed and enabled; and a project whose editor a restart is already bringing back.",
-      answer: "close answers settingsDropped, naming what its save took out of project.godot and left out when it took nothing, and settingsNote when the file could not be read to tell; an editor stopped before it connected is answered with beforeConnecting. restart answers with the version that came back, and says under settingsDropped which keys its save dropped, because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart answers lspListening and dapListening once the editor's servers are up, and debugAdapterRebound says whether binding the debug adapter again took. serversSaid gives the lines the editor's log panel has about its servers, the one place Godot says why a port would not bind. Godot clears that panel whenever a game is played, unless its run/output/always_clear_output_on_play setting is off, so after a play the lines from the editor's own start are gone. rebind answers rebound, with lspListening, dapListening and serversSaid. A restart that a server's end interrupted shows as restartInterrupted in editor_status, and the open that finishes it says so under finishesRestart.",
+      answer: "close answers settingsDropped, naming what its save took out of project.godot and left out when it took nothing, and settingsNote when the file could not be read to tell; an editor stopped before it connected is answered with beforeConnecting. close and restart name under savedScenes the open scenes that had unsaved changes and were saved on the way out, an empty list when none had; a scene that would not save refuses the close or restart and leaves the editor running. Both answer tookMs, how long the editor took to go or to come back. restart answers with the version that came back, and says under settingsDropped which keys its save dropped, because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart answers lspListening and dapListening once the editor's servers are up. When either came back without its port, serversSaid gives the lines the editor's log panel has about its servers, the one place Godot says why a port would not bind, and when it was the debug adapter, which is bound again in the editor that came back, debugAdapterRebound says whether that took; neither is there when both came up. Godot clears that panel whenever a game is played, unless its run/output/always_clear_output_on_play setting is off, so after a play the lines from the editor's own start are gone. rebind answers rebound, with lspListening, dapListening and serversSaid, the lines that rebind made the panel print. A restart that a server's end interrupted shows as restartInterrupted in editor_status, and the open that finishes it says so under finishesRestart.",
       parameters: {
         projectPath: { ...PROJECT_PATH, ops: ["open"] },
         hidden: {
@@ -13595,7 +13808,11 @@ var init_tool_definitions = __esm(() => {
         },
         outputPath: {
           type: "string",
-          description: "Also save the picture as a PNG at this absolute path, for somebody to open later; the answer says where. Refused unless it ends in .png, its directory exists, it is outside the project, and no file is there already."
+          description: "Also save the picture as a lossless PNG at this absolute path, for somebody to open later or a script to compare; the answer says where. Refused unless it ends in .png, its directory exists, it is outside the project, and no file is there already."
+        },
+        inline: {
+          type: "boolean",
+          description: "Send the picture back in the answer. Default true, as a JPEG when that is smaller than the PNG and the picture has no transparency (the text says so, with both sizes), since every picture an answer carries stays in the session for as long as it lasts. false sends none and needs outputPath, for a capture a script compares rather than one somebody looks at."
         }
       },
       requires: [],
@@ -13609,7 +13826,7 @@ var init_tool_definitions = __esm(() => {
       name: "runtime_input",
       title: "Send input to the game",
       description: "Input to the running game: a whole click on a Control or a 3D node named by path or on a control named by the words on it, an item chosen out of a menu, typing into whatever has the focus, or a raw action, key, mouse button, mouse motion or drag. All of it works headless, where the viewport is the project's window size and the GUI only takes what is inside it. On gdharness's own desktop, where a windowed run goes, Windows refuses to say where the pointer is: every pointer answer there carries pointer_on_hidden_desktop, and the first of the run pointer_note saying why it matters: get_mouse_position() on the root window, and the mouse positions derived from it, read a meaningless position, while what reads the event itself (the control under it, hover, tooltips, input handlers) gets the injected position. A native window no real pointer has entered gets no hover from Godot, so the runtime supplies it there and the answers say hover_supplied.",
-      answer: `click: what was under the pointer, and what became of the control: in_tree, removed or freed. Named by says, found says which match it was, its index being the index argument that presses the same match again, found.item names the tab, list entry, tree row or menu bar title pressed (kind; index, the item's own number in its control, which is not found.index; says; and for a row the column of the cell saying the words), and found.pressedOn says "the words" for words in a RichTextLabel pressed where they are drawn, or "the middle of the label" with a note saying why they could not be placed; on a rich label link_pressed says whether the press reached a link, with link_meta giving the meta the label reports clicked, an empty one included. A control scrolled into view first is scrolled each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A button in toggle mode, a CheckBox or CheckButton included, answers pressed with before and after, its button_pressed either side of the click: the same value twice is a click the game undid, and after is null when the click freed it. A refusal for a pointer turned off names where mouse_behavior_recursive was set. On a 3D node landed says the interface did not swallow the press: no control under the pointer stopped it, a control letting the pointer pass included, and every viewport on the way out from the room had the pointer over what shows the room. choose: what was chosen, read before the press, which is heard rather than assumed; what became of the control named (in_tree, removed or freed, since a game can rebuild its screen on the pick); and what the button in front of the menu shows now when it is still there. A menu is opened rather than clicked because its items are drawn rather than built, and the item is looked for as the menu stands once open, since a game can fill a menu as it opens. action, key, mouse_click and joypad_button: the event as it was sent, with whole saying whether the press was let go of again and pressed whether it is left held down (true only after pressed true), for a key the keycode, physical_keycode and unicode it carried, and for a controller button its number, its name and the device. mouse_motion: the position and the relative movement sent. mouse_drag: from, to, motions sent and relative_total. joypad_motion: the axis by number and name, the value and the device. None of these is aimed at anything, so none says what the event reached: click on a nodePath or says answers what was under the pointer. A mouse_click, mouse_motion or mouse_drag with a point outside the window's viewport says so under outside_viewport, with the viewport's rectangle, since no control there receives it.`,
+      answer: `click: what was under the pointer, and what became of the control: in_tree, removed or freed. Named by says, found says which match it was, its index being the index argument that presses the same match again, found.item names the tab, list entry, tree row or menu bar title pressed (kind; index, the item's own number in its control, which is not found.index; says; and for a row the column of the cell saying the words), and found.pressedOn says "the words" for words in a RichTextLabel pressed where they are drawn, or "the middle of the label" with a note saying why they could not be placed; on a rich label link_pressed says whether the press reached a link, with link_meta giving the meta the label reports clicked, an empty one included. A control scrolled into view first is scrolled each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A button in toggle mode, a CheckBox or CheckButton included, answers pressed with before and after, its button_pressed either side of the click: the same value twice is a click the game undid, and after is null when the click freed it. A refusal for a pointer turned off names where mouse_behavior_recursive was set. On a 3D node landed says the interface did not swallow the press: no control under the pointer stopped it, a control letting the pointer pass included, and every viewport on the way out from the room had the pointer over what shows the room. choose: what was chosen, read before the press, which is heard rather than assumed; what became of the control named (in_tree, removed or freed, since a game can rebuild its screen on the pick); and what the button in front of the menu shows now when it is still there. A menu is opened rather than clicked because its items are drawn rather than built, and the item is looked for as the menu stands once open, since a game can fill a menu as it opens. action, key, mouse_click and joypad_button: the event as it was sent, with whole saying whether the press was let go of again and pressed whether it is left held down (true only after pressed true), for a key the keycode, physical_keycode and unicode it carried, and for a controller button its number, its name and the device. mouse_motion: the position and the relative movement sent. mouse_drag: from, to, motions sent and relative_total. joypad_motion: the axis by number and name, the value and the device. None of these is aimed at anything, so none says what the event reached: click on a nodePath or says answers what was under the pointer. An action or a key answers focused with the path of the Control holding the keyboard focus when it went in, since that Control gets it before the game's _unhandled_input: Space or Enter on a focused button presses the button. A mouse_click, mouse_motion or mouse_drag with a point outside the window's viewport says so under outside_viewport, with the viewport's rectangle, since no control there receives it.`,
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
@@ -13897,7 +14114,7 @@ var init_tool_definitions = __esm(() => {
       operations: {
         pause: {
           effect: "additive",
-          summary: "stop a game this server started where it is, answering with the stack. The game takes it between frames, and in a script every 2048 lines it runs, so a loop that sleeps between few lines can take seconds; the call waits thirty, and past that answers paused false with the request still standing. Stopped between frames, where no script runs, the game is stepped on to the next line of script it runs",
+          summary: "stop a game this server started where it is, answering with the stack. The game takes it between frames, and in a script every 2048 lines it runs, so a loop that sleeps between few lines can take seconds; the call waits thirty, and past that answers paused false with the request still standing. Stopped between frames, where no script runs, the game is stepped on to the next line of script it runs, and stopped in gdharness's runtime addon, an autoload whose _process runs first in every frame, on to the next line of the game's own script, for up to five seconds; one whose stack is still the addon's after them says so in a note",
           requires: []
         },
         continue: { effect: "additive", summary: "resume after a breakpoint", requires: [] },
@@ -14045,9 +14262,9 @@ function whatItCanChange(tool) {
   if (destroying.length === 0) {
     return "Adds or starts things, and overwrites and removes nothing itself.";
   }
-  return `Can overwrite, remove or end what is there, through ${listed(destroying)}.`;
+  return `Can overwrite, remove or end what is there, through ${listed2(destroying)}.`;
 }
-function listed(items) {
+function listed2(items) {
   const last = items.at(-1) ?? "";
   return items.length === 1 ? last : `${items.slice(0, -1).join(", ")} and ${last}`;
 }
@@ -14105,30 +14322,30 @@ var init_tool_reference = __esm(() => {
 });
 
 // src/desktop.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import {
   closeSync,
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   mkdtempSync as mkdtempSync2,
   openSync,
-  readFileSync as readFileSync12,
+  readFileSync as readFileSync13,
   rmSync as rmSync7,
-  statSync as statSync8,
+  statSync as statSync9,
   writeFileSync as writeFileSync8,
   writeSync
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 function helperAssembly(directory = tmpdir4()) {
-  return join17(directory, `gdharness-desktop-${DIGEST}.dll`);
+  return join18(directory, `gdharness-desktop-${DIGEST}.dll`);
 }
 async function ensureHelperCompiled(directory = tmpdir4(), budgetMs = HELPER_COMPILE_MS, wait = true) {
   const assembly = helperAssembly(directory);
   const lock = `${assembly}.compiling`;
   const until = Date.now() + budgetMs;
   while (Date.now() < until) {
-    if (existsSync15(assembly)) {
+    if (existsSync16(assembly)) {
       return null;
     }
     let mine = false;
@@ -14146,8 +14363,8 @@ async function ensureHelperCompiled(directory = tmpdir4(), budgetMs = HELPER_COM
       }
     }
     try {
-      const holder = Number(readFileSync12(lock, "utf8").trim());
-      const old = Date.now() - statSync8(lock).mtimeMs > budgetMs;
+      const holder = Number(readFileSync13(lock, "utf8").trim());
+      const old = Date.now() - statSync9(lock).mtimeMs > budgetMs;
       if (old || Number.isInteger(holder) && holder > 0 && !alive(holder)) {
         rmSync7(lock, { force: true });
         continue;
@@ -14161,8 +14378,8 @@ async function ensureHelperCompiled(directory = tmpdir4(), budgetMs = HELPER_COM
   return `the desktop helper was not compiled within ${String(budgetMs)} ms`;
 }
 async function compileHelper(directory, assembly, budgetMs) {
-  const scratch = mkdtempSync2(join17(directory, "gdharness-desktop-source-"));
-  const source = join17(scratch, "helper.cs");
+  const scratch = mkdtempSync2(join18(directory, "gdharness-desktop-source-"));
+  const source = join18(scratch, "helper.cs");
   writeFileSync8(source, SOURCE, "utf8");
   const literal = (path) => `'${path.replaceAll("'", "''")}'`;
   const script = [
@@ -14200,7 +14417,7 @@ async function compileHelper(directory, assembly, budgetMs) {
       });
       compiler.once("close", (code) => {
         clearTimeout(timer);
-        resolve(existsSync15(assembly) ? null : `Windows PowerShell could not compile it${code === null ? " in time" : ""}: ${complained.trim() || `exit code ${String(code)}`}`);
+        resolve(existsSync16(assembly) ? null : `Windows PowerShell could not compile it${code === null ? " in time" : ""}: ${complained.trim() || `exit code ${String(code)}`}`);
       });
     });
   } finally {
@@ -14425,7 +14642,317 @@ public static class GdharnessDesktop {
 var init_desktop = __esm(() => {
   init_alive();
   init_spawn();
-  DIGEST = createHash4("sha256").update(SOURCE).digest("hex").slice(0, 16);
+  DIGEST = createHash5("sha256").update(SOURCE).digest("hex").slice(0, 16);
+});
+
+// src/suite-judge.ts
+import { readFileSync as readFileSync16 } from "node:fs";
+import { stripVTControlCharacters } from "node:util";
+function secondsOf(time) {
+  let ms = 0;
+  for (const [, amount, unit] of time.matchAll(/(\d+)(h|min|ms|s)\b/g)) {
+    ms += Number(amount) * (unit === "h" ? 3600000 : unit === "min" ? 60000 : unit === "s" ? 1000 : 1);
+  }
+  return ms / 1000;
+}
+function funcOf(name) {
+  const colon = name.indexOf(":");
+  return colon < 0 ? name : name.slice(0, colon);
+}
+function readRun(printed) {
+  const lines = stripVTControlCharacters(printed).replaceAll(`\r
+`, `
+`).split(`
+`);
+  const suites = new Map;
+  const errors = [];
+  const leaks = [];
+  let executed = null;
+  let open = null;
+  let during = null;
+  let afterCase = [];
+  let lastCase = null;
+  const settleAfterCase = (owner) => {
+    for (const held of afterCase) {
+      errors.push({ ...held, suite: open?.path ?? null, during: owner });
+    }
+    afterCase = [];
+  };
+  for (const [at, line] of lines.entries()) {
+    const opened = SUITE_OPENED.exec(line);
+    if (opened?.[1] !== undefined) {
+      settleAfterCase("after");
+      open = suites.get(opened[1]) ?? { path: opened[1], cases: [], closed: null };
+      suites.set(open.path, open);
+      during = "before";
+      lastCase = null;
+      continue;
+    }
+    const caseLine = CASE_LINE.exec(line);
+    if (caseLine !== null && open !== null) {
+      const name = caseLine[2] ?? "";
+      if (caseLine[3] === "STARTED") {
+        settleAfterCase(lastCase ?? "before");
+        during = name;
+      } else {
+        open.cases.push({
+          name,
+          func: funcOf(name),
+          verdict: caseLine[3] ?? "",
+          seconds: secondsOf(caseLine[4] ?? ""),
+          at
+        });
+        lastCase = name;
+        during = null;
+      }
+      continue;
+    }
+    const statistics = STATISTICS.exec(line);
+    if (statistics !== null && open !== null) {
+      settleAfterCase("after");
+      open.closed = { verdict: statistics[1] ?? "", seconds: secondsOf(statistics[2] ?? "") };
+      open = null;
+      during = null;
+      lastCase = null;
+      continue;
+    }
+    const counted = EXECUTED.exec(line);
+    if (counted?.[1] !== undefined) {
+      executed = Number(counted[1]);
+      continue;
+    }
+    if (LEAK.test(line)) {
+      leaks.push(line.trim());
+      continue;
+    }
+    if (suites.size === 0 && DRIVER_FALLBACK.test(line)) {
+      errors.length = 0;
+      continue;
+    }
+    const error = ERROR_LINE.exec(line);
+    if (error === null) {
+      continue;
+    }
+    const text = error[1] ?? "";
+    if (open === null) {
+      errors.push({ text, at, suite: null, during: null });
+    } else if (during === null) {
+      afterCase.push({ text, at });
+    } else {
+      errors.push({ text, at, suite: open.path, during });
+    }
+  }
+  const last = open;
+  const stoppedIn = last === null ? null : during === null ? `${last.path}, after ${lastCase ?? "its cases"}` : during === "before" ? `${last.path}, in before` : `${last.path} > ${during}`;
+  settleAfterCase("after");
+  const joined = lines.join(`
+`);
+  const starved = STARVED.flatMap((pattern) => [...joined.matchAll(pattern)].map((found) => found[0]));
+  const unloadable = scriptErrorsPrinted(lines).map((error) => `${error.path}${error.line === null ? "" : `:${String(error.line)}`}: ${error.message}`);
+  return { lines, suites, errors, leaks, starved, executed, unloadable, stoppedIn };
+}
+function readExpected(file) {
+  try {
+    const parsed = JSON.parse(readFileSync16(file, "utf8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function exitNamed(code) {
+  const unsigned = code >>> 0;
+  const status = WINDOWS_EXITS.get(unsigned);
+  if (status !== undefined) {
+    return `0x${unsigned.toString(16).toUpperCase()} (${status})`;
+  }
+  const gdunit = GDUNIT_EXITS.get(code);
+  return gdunit === undefined ? String(code) : `${String(code)} (${gdunit})`;
+}
+function named(items) {
+  const shown = items.slice(0, MOST_NAMED).join(", ");
+  return items.length > MOST_NAMED ? `${shown} and ${String(items.length - MOST_NAMED)} more` : shown;
+}
+function judgeEngine(printed, handed, end) {
+  const faults = [];
+  const failing = new Set;
+  const shownAt = new Set;
+  const explained = end.code === GDUNIT_FAILED && [...printed.suites.values()].some((suite) => suite.cases.some((ran) => ran.verdict === "FAILED"));
+  if (end.ended !== null) {
+    faults.push(end.ended);
+  } else if (end.code !== 0 && !explained) {
+    faults.push(end.code === null ? `the engine was ended by ${end.signal ?? "a signal"}` : `the engine exited ${exitNamed(end.code)}`);
+  }
+  if (printed.unloadable.length > 0) {
+    faults.push(`gdUnit4 could not load ${named(printed.unloadable)}, so it ran nothing`);
+  }
+  if (printed.executed === null || printed.executed === 0) {
+    faults.push(printed.executed === null ? "the run never printed its summary" : "the run executed no test case at all, whatever it exited with");
+  }
+  for (const { path, cases } of handed.suites) {
+    const suite = printed.suites.get(path);
+    if (suite === undefined) {
+      faults.push(`${path} never started`);
+      failing.add(path);
+      continue;
+    }
+    if (suite.closed === null) {
+      faults.push(`${path} never finished`);
+      failing.add(path);
+    } else if (suite.closed.verdict !== "PASSED") {
+      if (suite.cases.every((ran) => ran.verdict !== "FAILED")) {
+        faults.push(`${path} reported ${suite.closed.verdict} with every case passing, so a hook failed`);
+      }
+      failing.add(path);
+    }
+    const finished = new Set(suite.cases.map((ran) => ran.func));
+    const missing = cases.filter((func) => !finished.has(func));
+    if (missing.length > 0 && suite.closed !== null) {
+      faults.push(`${path} closed without running ${named(missing)}`);
+      failing.add(path);
+    }
+    const wanted = new Set(cases);
+    const unasked = [...finished].filter((func) => !wanted.has(func));
+    if (unasked.length > 0) {
+      faults.push(`${path} ran ${named(unasked)}, which gdharness did not read as cases of it to run here, so its ` + "plan of the cases was wrong");
+      failing.add(path);
+    }
+    for (const ran of suite.cases) {
+      if (ran.verdict === "FAILED" || ran.verdict === "FLAKY") {
+        faults.push(ran.verdict === "FLAKY" ? `${path} > ${ran.name} failed before it passed on a retry` : `${path} > ${ran.name} failed`);
+        failing.add(path);
+        for (let at = ran.at;at < printed.lines.length && (at === ran.at || printed.lines[at]?.trim()); at += 1) {
+          shownAt.add(at);
+        }
+      }
+    }
+  }
+  const unexpected = unexpectedErrors(printed, handed.expected, handed.suites.map((suite) => suite.path));
+  for (const error of unexpected.printed) {
+    faults.push(error.suite === null ? `an engine error outside every suite: ${error.text}` : `an engine error in ${error.suite} > ${error.during ?? ""}: ${error.text}; ${declaringAdvice(error.during ?? "")}`);
+    if (error.suite !== null) {
+      failing.add(error.suite);
+    }
+    shownAt.add(error.at);
+    shownAt.add(error.at + 1);
+  }
+  for (const missing of unexpected.neverPrinted) {
+    faults.push(`${missing.suite} > ${missing.during} declares the error "${missing.text}", which it never printed`);
+    failing.add(missing.suite);
+  }
+  for (const leak of printed.leaks) {
+    faults.push(`the engine exited holding what it should have freed: ${leak}`);
+  }
+  const memoryExit = end.code !== null && MEMORY_EXITS.has(end.code >>> 0);
+  const starved = memoryExit || printed.starved.length > 0;
+  if (printed.starved.length > 0) {
+    faults.push("the engine ran out of memory");
+  }
+  printed.lines.forEach((line, at) => {
+    if (/^(?:Overall Summary|Executed test|Total execution time| ?Exit code)/.test(line.trim())) {
+      shownAt.add(at);
+    }
+  });
+  const passed = faults.length === 0;
+  const passedSuites = handed.suites.map((suite) => suite.path).filter((path) => !failing.has(path));
+  const cutShort = end.ended !== null || printed.executed === null || handed.suites.some(({ path }) => printed.suites.get(path)?.closed == null);
+  return {
+    passed,
+    faults,
+    passedSuites,
+    starved,
+    shown: passed ? [] : linesShown(printed.lines, shownAt, cutShort)
+  };
+}
+function linesShown(lines, picked, cutShort) {
+  const summary = [...picked].filter((at) => at < lines.length).sort((a, b) => a - b);
+  const telling = summary.some((at) => !/^(?:Overall Summary|Executed test|Total execution|\s*Exit code)/.test(lines[at]?.trim() ?? ""));
+  if (!telling && !cutShort) {
+    return [];
+  }
+  if (!telling) {
+    return lines.slice(Math.max(0, lines.length - TAIL)).filter((line, at, all) => at < all.length - 1 || line !== "");
+  }
+  const shown = [];
+  let previous = -1;
+  for (const at of summary) {
+    if (previous >= 0 && at > previous + 1) {
+      shown.push("...");
+    }
+    shown.push(lines[at] ?? "");
+    previous = at;
+  }
+  return shown;
+}
+function declaringAdvice(during) {
+  return `if the suite prints it on purpose, list its text under "${funcOf(during)}" in the suite's GDHARNESS_EXPECTED_ERRORS`;
+}
+function unexpectedErrors(printed, expected, paths) {
+  const owed = new Map;
+  for (const path of paths) {
+    const suite = printed.suites.get(path);
+    const declared = expected[path];
+    if (suite === undefined || declared === undefined) {
+      continue;
+    }
+    const ranHooks = suite.closed === null ? ["before"] : ["before", "after"];
+    for (const during of [...ranHooks, ...suite.cases.map((ran) => ran.name)]) {
+      const texts = declared[funcOf(during)];
+      if (Array.isArray(texts) && texts.length > 0) {
+        owed.set(`${path}
+${during}`, {
+          suite: path,
+          during,
+          texts: texts.map((text) => String(text))
+        });
+      }
+    }
+  }
+  const unexpected = [];
+  for (const error of printed.errors) {
+    const debt = error.suite === null || error.during === null ? undefined : owed.get(`${error.suite}
+${error.during}`);
+    const index = debt?.texts.indexOf(error.text) ?? -1;
+    if (debt === undefined || index < 0) {
+      unexpected.push(error);
+    } else {
+      debt.texts.splice(index, 1);
+    }
+  }
+  const neverPrinted = [...owed.values()].flatMap((debt) => debt.texts.map((text) => ({ suite: debt.suite, during: debt.during, text })));
+  return { printed: unexpected, neverPrinted };
+}
+var SUITE_OPENED, TIME, CASE_LINE, STATISTICS, ERROR_LINE, EXECUTED, DRIVER_FALLBACK, LEAK, STARVED, WINDOWS_EXITS, MEMORY_EXITS, GDUNIT_FAILED = 100, GDUNIT_EXITS, TAIL = 60, MOST_NAMED = 8;
+var init_suite_judge = __esm(() => {
+  init_junit();
+  SUITE_OPENED = /^Run Test Suite:\s*(res:\/\/.+?\.gd)\s*$/;
+  TIME = String.raw`(?:\d+h )?(?:\d+min )?(?:\d+s )?\d+ms`;
+  CASE_LINE = new RegExp(String.raw`^\s*(res://.+?\.gd) > (.+?) (STARTED|PASSED|FAILED|FLAKY|SKIPPED|WARNING)(?: \((?:retry \d+|\d+ retries)\))?(?: (${TIME}))?\s*$`);
+  STATISTICS = new RegExp(String.raw`^Statistics:.*\|\s*([A-Z]+)(?:\s+\(.*?\))?\s+(${TIME})\s*$`);
+  ERROR_LINE = /^\s*(?:SCRIPT |USER )?ERROR: (.*?)\s*$/;
+  EXECUTED = /^Executed test cases\s*:\s*\((\d+)\//;
+  DRIVER_FALLBACK = /^\s*WARNING: Your video card drivers .*, switching to /;
+  LEAK = /ObjectDB instances (?:were )?leaked at exit|resources? still in use at exit|Pages in use exist at exit/;
+  STARVED = [
+    /Parameter "mem(?:_new)?" is null\.?\s*\n\s*at: \w+ \((?:\.\/)?core\/(?:os\/memory\.cpp|templates\/cowdata\.h):/g,
+    /ERROR: Failed decoding WebP image\.\s*\n\s*at: _webp_unpack/g
+  ];
+  WINDOWS_EXITS = new Map([
+    [3221225477, "STATUS_ACCESS_VIOLATION"],
+    [3221225495, "STATUS_NO_MEMORY"],
+    [3221225773, "STATUS_COMMITMENT_LIMIT"],
+    [3221225794, "STATUS_DLL_INIT_FAILED"],
+    [3221226505, "STATUS_STACK_BUFFER_OVERRUN"],
+    [3228369022, "a module that could not be found (VcppException)"],
+    [3228369023, "a procedure that could not be found (VcppException)"]
+  ]);
+  MEMORY_EXITS = new Set([3221225495, 3221225773]);
+  GDUNIT_EXITS = new Map([
+    [GDUNIT_FAILED, "gdUnit4's code for a case that failed or errored"],
+    [101, "gdUnit4's code for orphan nodes left behind"],
+    [103, "gdUnit4's code for a suite that cannot run headless"],
+    [104, "gdUnit4's code for a Godot version it does not support"],
+    [105, "gdUnit4's code for scripts that did not compile"]
+  ]);
 });
 
 // src/whole-file.ts
@@ -14459,6 +14986,235 @@ var init_whole_file = __esm(() => {
   HELD_BY_A_READER = new Set(["EPERM", "EACCES", "EBUSY"]);
 });
 
+// src/suite-plan.ts
+import { existsSync as existsSync18, mkdirSync as mkdirSync7, readFileSync as readFileSync17 } from "node:fs";
+import { dirname as dirname10, posix as posix3 } from "node:path";
+
+class ProjectScripts {
+  sources = new Map;
+  classes = new Map;
+  read = new Map;
+  projectPath;
+  constructor(projectPath) {
+    this.projectPath = projectPath;
+    eachScript(projectPath, (script, source) => {
+      this.sources.set(script, source);
+      const declared = declaredClassOf(source);
+      if (declared !== null) {
+        this.classes.set(declared, script);
+      }
+    });
+  }
+  script(path) {
+    const known = this.read.get(path);
+    if (known !== undefined) {
+      return known;
+    }
+    const source = this.sources.get(path);
+    if (source === undefined) {
+      return;
+    }
+    const shape = shapeOf(source);
+    const read = {
+      source,
+      extendsAs: shape.body.extendsAs,
+      funcs: shape.body.declarations.filter((d) => d.kind === "func").map((d) => d.name),
+      code: codeOf(source)
+    };
+    this.read.set(path, read);
+    return read;
+  }
+  base(path) {
+    const extendsAs = this.script(path)?.extendsAs ?? null;
+    if (extendsAs === null) {
+      return null;
+    }
+    const quote = extendsAs[0];
+    if (quote === '"' || quote === "'") {
+      const target = extendsAs.slice(1, -1);
+      return {
+        path: target.startsWith("res://") ? target : `res://${posix3.join(posix3.dirname(path.slice(6)), target)}`
+      };
+    }
+    const name = extendsAs.split(".")[0] ?? extendsAs;
+    const declaring = this.classes.get(name);
+    return declaring === undefined ? { name } : { path: declaring };
+  }
+  suite(path) {
+    const cases = new Set;
+    let windowed = false;
+    const seen = new Set;
+    let at = path;
+    while (!seen.has(at)) {
+      seen.add(at);
+      const read = this.script(at);
+      if (read === undefined) {
+        return null;
+      }
+      for (const func of read.funcs.filter((name) => name.startsWith(CASE_PREFIX))) {
+        cases.add(func);
+      }
+      windowed ||= NEEDS_WINDOW.test(read.code) || SCENE_RUNNER.test(read.code);
+      const base = this.base(at);
+      if (base === null) {
+        return null;
+      }
+      if ("name" in base ? base.name === SUITE_BASE : base.path === this.classes.get(SUITE_BASE)) {
+        return cases.size > 0 ? { path, cases: [...cases].sort(), windowed } : null;
+      }
+      if ("name" in base) {
+        return null;
+      }
+      at = base.path;
+    }
+    return null;
+  }
+  suitesUnder(roots) {
+    const prefixes = roots.map((root) => root.endsWith("/") ? root : `${root}/`);
+    return [...this.sources.keys()].filter((path) => prefixes.some((prefix) => path.startsWith(prefix))).sort().flatMap((path) => this.suite(path) ?? []);
+  }
+}
+function readTimes(file) {
+  try {
+    const parsed = JSON.parse(readFileSync17(file, "utf8"));
+    return typeof parsed === "object" && parsed !== null ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeJson(file, value) {
+  mkdirSync7(dirname10(file), { recursive: true });
+  writeWhole(file, `${JSON.stringify(value, null, 1)}
+`);
+}
+function timesAfter(times, suites, runs) {
+  const next = { ...times };
+  const declared = new Map(suites.map((suite) => [suite.path, suite]));
+  const measured = new Map;
+  for (const run of runs) {
+    for (const printed of run.suites.values()) {
+      if (printed.closed === null || !declared.has(printed.path)) {
+        continue;
+      }
+      const entry = measured.get(printed.path) ?? { cases: new Map, around: 0 };
+      const own = new Map;
+      for (const ran of printed.cases) {
+        own.set(ran.func, (own.get(ran.func) ?? 0) + ran.seconds);
+      }
+      const inCases = [...own.values()].reduce((sum, seconds) => sum + seconds, 0);
+      entry.around = Math.max(entry.around, printed.closed.seconds - inCases);
+      for (const [func, seconds] of own) {
+        entry.cases.set(func, seconds);
+      }
+      measured.set(printed.path, entry);
+    }
+  }
+  for (const [path, entry] of measured) {
+    const suite = declared.get(path);
+    const cases = {};
+    for (const func of suite?.cases ?? []) {
+      const seconds = entry.cases.get(func) ?? times[path]?.cases[func];
+      if (seconds !== undefined) {
+        cases[func] = round(seconds);
+      }
+    }
+    const inCases = Object.values(cases).reduce((sum, seconds) => sum + seconds, 0);
+    next[path] = { seconds: round(entry.around + inCases), cases };
+  }
+  return next;
+}
+function round(seconds) {
+  return Math.round(seconds * 1000) / 1000;
+}
+function median(values) {
+  if (values.length === 0) {
+    return;
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 1 ? sorted[middle] : ((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2;
+}
+function unitsOf(suites, times, splitPast = SPLIT_PAST_SECONDS) {
+  const known = Object.values(times);
+  const caseCost = median(known.flatMap((time) => Object.values(time.cases))) ?? UNTIMED_CASE;
+  const aroundCost = median(known.map((time) => time.seconds - Object.values(time.cases).reduce((sum, s) => sum + s, 0))) ?? 0;
+  return suites.flatMap((suite) => {
+    const time = times[suite.path];
+    const costOf = (func) => time?.cases[func] ?? caseCost;
+    const around = time === undefined ? aroundCost : Math.max(0, time.seconds - Object.values(time.cases).reduce((sum, s) => sum + s, 0));
+    const whole = around + suite.cases.reduce((sum, func) => sum + costOf(func), 0);
+    if (suite.windowed || whole <= splitPast || suite.cases.length < 2) {
+      return [{ suite: suite.path, cases: suite.cases, cost: whole, windowed: suite.windowed }];
+    }
+    return suite.cases.map((func) => ({
+      suite: suite.path,
+      cases: [func],
+      cost: around + costOf(func),
+      windowed: false
+    }));
+  });
+}
+function dealt(units, declared, most) {
+  const windowed = units.filter((unit) => unit.windowed);
+  const headless = units.filter((unit) => !unit.windowed).sort((a, b) => b.cost - a.cost || a.suite.localeCompare(b.suite) || (a.cases[0] ?? "").localeCompare(b.cases[0] ?? ""));
+  if (units.length === 0) {
+    return [];
+  }
+  const together = windowed.reduce((sum, unit) => sum + unit.cost, 0);
+  const total = units.reduce((sum, unit) => sum + unit.cost, 0);
+  const slowest = Math.max(together, headless[0]?.cost ?? 0);
+  const count = Math.max(1, Math.min(most, headless.length + (windowed.length > 0 ? 1 : 0), Math.ceil(total / Math.max(slowest, ENGINE_START_SECONDS))));
+  const bins = Array.from({ length: count }, (_, index) => index === 0 ? [...windowed] : []);
+  const loads = Array.from({ length: count }, (_, index) => index === 0 ? together : 0);
+  for (const unit of headless) {
+    const lightest = loads.indexOf(Math.min(...loads));
+    bins[lightest]?.push(unit);
+    loads[lightest] = (loads[lightest] ?? 0) + unit.cost;
+  }
+  return bins.map((bin, index) => planOf(bin, declared, index === 0 && windowed.length > 0));
+}
+function windowedSaid(plans) {
+  if (!plans.some((plan) => plan.windowed)) {
+    return "";
+  }
+  return plans.length === 1 ? ", with a window" : ", one of them windowed";
+}
+function inOneEngine(units, declared) {
+  return planOf(units, declared, units.some((unit) => unit.windowed));
+}
+function planOf(bin, declared, windowed) {
+  const held = new Map;
+  for (const unit of bin) {
+    held.set(unit.suite, [...held.get(unit.suite) ?? [], ...unit.cases]);
+  }
+  const skipping = [...held].flatMap(([path, cases]) => (declared.get(path) ?? []).filter((func) => !cases.includes(func)).map((func) => `${path}:${func}`));
+  return {
+    suites: [...held].map(([path, cases]) => ({ path, cases: [...cases].sort() })),
+    skipping,
+    cost: bin.reduce((sum, unit) => sum + unit.cost, 0),
+    windowed
+  };
+}
+function viewportOf(projectPath) {
+  const file = `${projectPath}/project.godot`;
+  if (!existsSync18(file)) {
+    return null;
+  }
+  const text = readFileSync17(file, "utf8");
+  const width = /^window\/size\/viewport_width\s*=\s*(\d+)/m.exec(text)?.[1];
+  const height = /^window\/size\/viewport_height\s*=\s*(\d+)/m.exec(text)?.[1];
+  return width === undefined || height === undefined ? null : { width: Number(width), height: Number(height) };
+}
+var SUITE_BASE = "GdUnitTestSuite", CASE_PREFIX = "test_", NEEDS_WINDOW, TEST_DIRECTORIES, SCENE_RUNNER, UNTIMED_CASE = 0.02, SPLIT_PAST_SECONDS = 10, ENGINE_START_SECONDS = 5;
+var init_suite_plan = __esm(() => {
+  init_class_cache();
+  init_gdscript_source();
+  init_whole_file();
+  NEEDS_WINDOW = /^const\s+GDHARNESS_NEEDS_WINDOW\b[^=\n]*=\s*true\b/m;
+  TEST_DIRECTORIES = ["tests", "test"];
+  SCENE_RUNNER = /\bscene_runner\s*\(/;
+});
+
 // node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
 var __create2, __defProp2, __getOwnPropDesc, __getOwnPropNames2, __getProtoOf2, __hasOwnProp2, __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports), __exportAll = (all, symbols) => {
   let target = {};
@@ -36060,13 +36816,13 @@ var init_stdio = __esm(() => {
 });
 
 // src/autoload-failure.ts
-import { existsSync as existsSync19, readFileSync as readFileSync18 } from "node:fs";
-import { join as join22 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync20 } from "node:fs";
+import { join as join23 } from "node:path";
 function scriptsAutoloaded(projectPath) {
   const scripts = new Map;
   let settings;
   try {
-    settings = parseProjectGodot(readFileSync18(join22(projectPath, "project.godot"), "utf8"));
+    settings = parseProjectGodot(readFileSync20(join23(projectPath, "project.godot"), "utf8"));
   } catch {
     return scripts;
   }
@@ -36075,12 +36831,12 @@ function scriptsAutoloaded(projectPath) {
       scripts.set(`res://${path}`, name);
       continue;
     }
-    const scene = join22(projectPath, path);
-    if (!existsSync19(scene)) {
+    const scene = join23(projectPath, path);
+    if (!existsSync20(scene)) {
       continue;
     }
     try {
-      for (const named of readFileSync18(scene, "utf8").matchAll(/^\[ext_resource\b[^\]]*\btype="Script"[^\]]*\bpath="(res:\/\/[^"]+)"/gm)) {
+      for (const named of readFileSync20(scene, "utf8").matchAll(/^\[ext_resource\b[^\]]*\btype="Script"[^\]]*\bpath="(res:\/\/[^"]+)"/gm)) {
         scripts.set(named[1] ?? "", name);
       }
     } catch {}
@@ -36099,10 +36855,10 @@ var init_autoload_failure = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync20, readdirSync as readdirSync12, readFileSync as readFileSync19, statSync as statSync12, unlinkSync as unlinkSync2 } from "node:fs";
+import { existsSync as existsSync21, readdirSync as readdirSync13, readFileSync as readFileSync21, statSync as statSync13, unlinkSync as unlinkSync2 } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir5 } from "node:os";
-import { dirname as dirname12, join as join23, resolve as resolve5 } from "node:path";
+import { dirname as dirname12, join as join24, resolve as resolve5 } from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
@@ -36110,20 +36866,20 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join23(perUser ?? tmpdir5(), "gdharness");
+  return join24(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(join23(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join24(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve5(path)))];
 }
 function errorReportOf(pid, directories = runtimeDirectories()) {
   for (const directory of directories) {
-    const path = join23(directory, `runtime-${pid}.log`);
-    if (existsSync20(path)) {
+    const path = join24(directory, `runtime-${pid}.log`);
+    if (existsSync21(path)) {
       return path;
     }
   }
@@ -36154,7 +36910,7 @@ function reportAlreadyInTranscript(transcript, report) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync19(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync21(file, "utf8")));
   } catch {
     return { kind: "rubbish" };
   }
@@ -36171,7 +36927,7 @@ function parseAnnouncement(file, pid) {
   };
   let announcedAt;
   try {
-    announcedAt = statSync12(file).mtimeMs;
+    announcedAt = statSync13(file).mtimeMs;
   } catch {}
   const when = announcedAt === undefined ? {} : { announcedAt };
   if (protocol !== RUNTIME_PROTOCOL) {
@@ -36224,7 +36980,7 @@ function discoverRuntimes(directories = runtimeDirectories()) {
 function wentAway(file, pid) {
   let project = "";
   try {
-    const fields = asParams(JSON.parse(readFileSync19(file, "utf8")));
+    const fields = asParams(JSON.parse(readFileSync21(file, "utf8")));
     project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
   } catch {
     return;
@@ -36267,29 +37023,29 @@ function strangersAmong(candidates, now, startTimes = startTimesOf) {
   }).map((one) => one.file));
 }
 function announcedIn(directory) {
-  if (!existsSync20(directory)) {
+  if (!existsSync21(directory)) {
     return [];
   }
   const found = [];
   const candidates = [];
   const entries = [];
-  for (const entry of readdirSync12(directory)) {
+  for (const entry of readdirSync13(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
-      sweepErrorReport(join23(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      sweepErrorReport(join24(directory, entry), Number.parseInt(report[1] ?? "", 10));
       continue;
     }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
     }
-    const file = join23(directory, entry);
+    const file = join24(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const running = alive(pid);
     entries.push({ file, pid, running });
     if (running) {
       try {
-        candidates.push({ file, pid, writtenAt: statSync12(file).mtimeMs });
+        candidates.push({ file, pid, writtenAt: statSync13(file).mtimeMs });
       } catch {}
     }
   }
@@ -36311,7 +37067,7 @@ function announcedIn(directory) {
     found.push(announced);
   }
   const held = new Set(entries.map((one) => one.file));
-  const here = join23(directory, ".");
+  const here = join24(directory, ".");
   for (const file of verdicts.keys()) {
     if (dirname12(file) === here && !held.has(file)) {
       verdicts.delete(file);
@@ -36320,7 +37076,7 @@ function announcedIn(directory) {
   return found;
 }
 async function announcementEnded(pid, directories = runtimeDirectories()) {
-  const files = directories.map((directory) => join23(directory, `runtime-${pid}.json`)).filter((file) => existsSync20(file));
+  const files = directories.map((directory) => join24(directory, `runtime-${pid}.json`)).filter((file) => existsSync21(file));
   const first = files[0];
   if (first === undefined) {
     return;
@@ -36346,7 +37102,7 @@ function sweepErrorReport(path, pid, now = Date.now()) {
     return;
   }
   try {
-    if (now - statSync12(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
+    if (now - statSync13(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
       unlinkSync2(path);
     }
   } catch {}
@@ -36739,14 +37495,14 @@ var init_runtime_client = __esm(() => {
 });
 
 // src/boot-note.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync20, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname13, join as join24 } from "node:path";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync22, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname13, join as join25 } from "node:path";
 function bootNotePath(projectPath) {
-  return join24(projectPath, ".godot", "gdharness-boot.json");
+  return join25(projectPath, ".godot", "gdharness-boot.json");
 }
 function readScenes(projectPath) {
   try {
-    return asParams(asParams(JSON.parse(readFileSync20(bootNotePath(projectPath), "utf8")))["scenes"]);
+    return asParams(asParams(JSON.parse(readFileSync22(bootNotePath(projectPath), "utf8")))["scenes"]);
   } catch {
     return {};
   }
@@ -36788,10 +37544,10 @@ var init_boot_note = __esm(() => {
 });
 
 // src/breakpoint-note.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync21, rmSync as rmSync11, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname14, isAbsolute as isAbsolute5, join as join25, relative as relative4 } from "node:path";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync23, rmSync as rmSync11, writeFileSync as writeFileSync12 } from "node:fs";
+import { dirname as dirname14, isAbsolute as isAbsolute5, join as join26, relative as relative4 } from "node:path";
 function breakpointNotePath(projectPath) {
-  return join25(projectPath, ".godot", "gdharness-breakpoints.json");
+  return join26(projectPath, ".godot", "gdharness-breakpoints.json");
 }
 function writeBreakpointNote(projectPath, held) {
   const path = breakpointNotePath(projectPath);
@@ -36817,7 +37573,7 @@ function writeBreakpointNote(projectPath, held) {
 }
 function readBreakpointNote(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync21(breakpointNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync23(breakpointNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.breakpoints)) {
       return [];
     }
@@ -36832,7 +37588,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(join25(projectPath, script)), lines });
+        held.push({ scriptPath: realAsFarAsItExists(join26(projectPath, script)), lines });
       }
     }
     return held;
@@ -36850,14 +37606,14 @@ var init_breakpoint_note = __esm(() => {
 });
 
 // src/class-note.ts
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync22 } from "node:fs";
-import { dirname as dirname15, join as join26 } from "node:path";
+import { mkdirSync as mkdirSync11, readFileSync as readFileSync24 } from "node:fs";
+import { dirname as dirname15, join as join27 } from "node:path";
 function classNotePath(projectPath) {
-  return join26(projectPath, ".godot", "gdharness-classes.json");
+  return join27(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync22(classNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync24(classNotePath(projectPath), "utf8")));
     const rebuiltWith = readArray(fields, "rebuiltWith");
     if (rebuiltWith === undefined || !rebuiltWith.every((name) => typeof name === "string")) {
       return null;
@@ -36899,16 +37655,16 @@ var init_class_note = __esm(() => {
 });
 
 // src/config-pin.ts
-import { existsSync as existsSync21, readFileSync as readFileSync23 } from "node:fs";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync25 } from "node:fs";
+import { join as join28 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join27(projectPath, ".mcp.json");
-  if (!existsSync21(config)) {
+  const config = join28(projectPath, ".mcp.json");
+  if (!existsSync22(config)) {
     return [];
   }
   let text;
   try {
-    text = readFileSync23(config, "utf8");
+    text = readFileSync25(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -36929,10 +37685,10 @@ var init_config_pin = __esm(() => {
 });
 
 // src/cut-test-run.ts
-import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync24, rmSync as rmSync12, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname16, join as join28 } from "node:path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync26, rmSync as rmSync12, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname16, join as join29 } from "node:path";
 function keptAt(projectPath) {
-  return join28(projectPath, ".godot", "gdharness-reports", "cut-run.json");
+  return join29(projectPath, ".godot", "gdharness-reports", "cut-run.json");
 }
 function keepCutTestRun(projectPath, run) {
   const path = keptAt(projectPath);
@@ -36944,11 +37700,11 @@ function keepCutTestRun(projectPath, run) {
 }
 function takeCutTestRun(projectPath) {
   const path = keptAt(projectPath);
-  if (!existsSync22(path)) {
+  if (!existsSync23(path)) {
     return null;
   }
   try {
-    const run = JSON.parse(readFileSync24(path, "utf8"));
+    const run = JSON.parse(readFileSync26(path, "utf8"));
     rmSync12(path, { force: true });
     return typeof run.cutAt === "string" && Array.isArray(run.paths) && run.paths.every((path) => typeof path === "string") ? run : null;
   } catch {
@@ -37761,25 +38517,25 @@ var init_dap_client = __esm(() => {
 // src/editor-log.ts
 import {
   closeSync as closeSync4,
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   mkdirSync as mkdirSync13,
   openSync as openSync4,
-  readFileSync as readFileSync25,
+  readFileSync as readFileSync27,
   readSync as readSync2,
   rmSync as rmSync13,
-  statSync as statSync13,
+  statSync as statSync14,
   writeFileSync as writeFileSync14
 } from "node:fs";
-import { dirname as dirname17, join as join29 } from "node:path";
+import { dirname as dirname17, join as join30 } from "node:path";
 function editorLogPath(projectPath) {
-  return join29(projectPath, ".godot", "gdharness-editor.log");
+  return join30(projectPath, ".godot", "gdharness-editor.log");
 }
 function editorLogNotePath(projectPath) {
-  return join29(projectPath, ".godot", "gdharness-editor.json");
+  return join30(projectPath, ".godot", "gdharness-editor.json");
 }
 function readEditorLogNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync25(editorLogNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync27(editorLogNotePath(projectPath), "utf8")));
     const pid = readNumber(fields, "pid");
     const startedAt = readString(fields, "startedAt");
     return pid !== undefined && Number.isInteger(pid) && pid > 0 && startedAt !== undefined ? { pid, startedAt } : null;
@@ -37820,7 +38576,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
     return { kind: "another editor", notedPid: noted?.pid ?? null };
   }
   const path = editorLogPath(projectPath);
-  if (!existsSync23(path)) {
+  if (!existsSync24(path)) {
     return { kind: "not written" };
   }
   const log = new GameLog;
@@ -37876,9 +38632,9 @@ function foldProgress(text) {
 `);
 }
 function theFirstOf(path) {
-  const whole = statSync13(path).size;
+  const whole = statSync14(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
-    return { text: readFileSync25(path, "utf8") };
+    return { text: readFileSync27(path, "utf8") };
   }
   const handle = openSync4(path, "r");
   try {
@@ -38039,7 +38795,7 @@ var init_editor_log = __esm(() => {
 });
 
 // src/rename.ts
-import { existsSync as existsSync24, mkdirSync as mkdirSync14, readFileSync as readFileSync26, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync25, mkdirSync as mkdirSync14, readFileSync as readFileSync28, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync15 } from "node:fs";
 import { dirname as dirname18, posix as posix4 } from "node:path";
 
 class Script {
@@ -38744,11 +39500,11 @@ function rewritesOf(plan, texts, move) {
 }
 function applyRewrites(rewrites) {
   for (const rewrite of rewrites) {
-    const now = readFileSync26(rewrite.absolute, "utf8");
+    const now = readFileSync28(rewrite.absolute, "utf8");
     if (now !== rewrite.before) {
       throw new Error(`${rewrite.path} changed on disk while the rename was being worked out; nothing was written`);
     }
-    if (rewrite.writeTo !== rewrite.absolute && existsSync24(rewrite.writeTo)) {
+    if (rewrite.writeTo !== rewrite.absolute && existsSync25(rewrite.writeTo)) {
       throw new Error(`${rewrite.writeTo} already exists; nothing was written`);
     }
   }
@@ -38762,7 +39518,7 @@ function applyRewrites(rewrites) {
       let movedUid = false;
       if (rewrite.writeTo !== rewrite.absolute) {
         unlinkSync3(rewrite.absolute);
-        if (existsSync24(`${rewrite.absolute}.uid`)) {
+        if (existsSync25(`${rewrite.absolute}.uid`)) {
           renameSync3(`${rewrite.absolute}.uid`, `${rewrite.writeTo}.uid`);
           movedUid = true;
         }
@@ -38808,10 +39564,10 @@ var init_rename = __esm(() => {
 });
 
 // src/lsp_client.ts
-import { existsSync as existsSync25, realpathSync as realpathSync3 } from "node:fs";
+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 join30, resolve as resolve6 } from "node:path";
+import { dirname as dirname19, join as join31, resolve as resolve6 } from "node:path";
 import { setTimeout as delay6 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function initializeTimeoutMs() {
@@ -39489,7 +40245,7 @@ async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   } catch {
     throw new ArgumentRefusal(`Project path does not exist: ${requestedProjectPath}`);
   }
-  if (!existsSync25(join30(projectPath, "project.godot"))) {
+  if (!existsSync26(join31(projectPath, "project.godot"))) {
     throw new ArgumentRefusal(`Not a Godot project: ${projectPath}. Point projectPath at the directory holding project.godot.`);
   }
   const contained = resolveWithinProject(projectPath, scriptPathValue);
@@ -39649,8 +40405,8 @@ var init_lsp_client = __esm(() => {
 });
 
 // src/rename-symbol.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync15, readdirSync as readdirSync13, realpathSync as realpathSync4, rmSync as rmSync14, writeFileSync as writeFileSync16 } from "node:fs";
-import { basename as basename8, dirname as dirname20, join as join31, relative as relative5, resolve as resolve7 } from "node:path";
+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 basename8, dirname as dirname20, join as join32, relative as relative5, resolve as resolve7 } from "node:path";
 function resourcePathOf(projectPath, absolute) {
   const inside = relative5(onDiskSpelling(projectPath), onDiskSpelling(absolute));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
@@ -39663,7 +40419,7 @@ function onDiskSpelling(path) {
   let at = resolve7(path);
   for (;; ) {
     try {
-      return join31(realpathSync4.native(at), ...missing.reverse());
+      return join32(realpathSync4.native(at), ...missing.reverse());
     } catch {
       const parent = dirname20(at);
       if (parent === at) {
@@ -39717,7 +40473,7 @@ async function renameSymbol(request, services) {
         reason: `newScriptPath must be a .gd path inside the project, and ${request.newScriptPath} is not.`
       };
     }
-    if (existsSync26(request.newScriptPath)) {
+    if (existsSync27(request.newScriptPath)) {
       return { ok: false, reason: `${moveTo} already exists, so the script cannot be moved there.` };
     }
   }
@@ -39893,7 +40649,7 @@ async function renameSymbol(request, services) {
       scripts,
       moves: new Map([[declaringPath, moveTo]]),
       named: [declaringPath],
-      exists: (path) => existsSync26(`${projectPath}/${path.slice("res://".length)}`)
+      exists: (path) => existsSync27(`${projectPath}/${path.slice("res://".length)}`)
     }, plan);
   }
   plan = mentionIgnored(plan, ignoredTexts(projectPath), symbol, moveTo === null ? [] : [declaringPath]);
@@ -40092,15 +40848,15 @@ ${mention.kind}`;
   };
 }
 function writeLeftAloneDetail(projectPath, symbol, detail) {
-  const directory = join31(projectPath, ".godot", "gdharness-renames");
+  const directory = join32(projectPath, ".godot", "gdharness-renames");
   mkdirSync15(directory, { recursive: true });
   detailWrites += 1;
-  const path = join31(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
+  const path = join32(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
   writeFileSync16(path, `${JSON.stringify(detail, null, 2)}
 `, "utf8");
-  const kept = readdirSync13(directory).filter((name) => name.endsWith(".json")).sort().reverse();
+  const kept = readdirSync14(directory).filter((name) => name.endsWith(".json")).sort().reverse();
   for (const old of kept.slice(10)) {
-    rmSync14(join31(directory, old), { force: true });
+    rmSync14(join32(directory, old), { force: true });
   }
   return path;
 }
@@ -40141,25 +40897,25 @@ var init_rename_symbol = __esm(() => {
 
 // src/file-move.ts
 import {
-  existsSync as existsSync27,
+  existsSync as existsSync28,
   mkdirSync as mkdirSync16,
-  readdirSync as readdirSync14,
-  readFileSync as readFileSync27,
+  readdirSync as readdirSync15,
+  readFileSync as readFileSync29,
   renameSync as renameSync4,
-  statSync as statSync14,
+  statSync as statSync15,
   writeFileSync as writeFileSync17
 } from "node:fs";
-import { basename as basename9, dirname as dirname21, extname as extname3, join as join32, relative as relative6 } from "node:path";
+import { basename as basename9, dirname as dirname21, extname as extname3, join as join33, relative as relative6 } from "node:path";
 function filesUnder(directory) {
-  return readdirSync14(directory, { withFileTypes: true }).flatMap((entry) => {
-    const path = join32(directory, entry.name);
+  return readdirSync15(directory, { withFileTypes: true }).flatMap((entry) => {
+    const path = join33(directory, entry.name);
     return entry.isDirectory() ? filesUnder(path) : [path];
   });
 }
 function sameFile(one, other) {
   try {
-    const a = statSync14(one);
-    const b = statSync14(other);
+    const a = statSync15(one);
+    const b = statSync15(other);
     return a.ino === b.ino && a.dev === b.dev;
   } catch {
     return false;
@@ -40173,8 +40929,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 = join32(directory, step);
-      if (existsSync27(join32(directory, ".gdignore"))) {
+      directory = join33(directory, step);
+      if (existsSync28(join33(directory, ".gdignore"))) {
         return `${path} is under a directory holding a .gdignore, which the engine does not load`;
       }
     }
@@ -40186,21 +40942,21 @@ function installedAddonOf(projectPath, path) {
   if (steps[0] !== "addons" || steps[1] === undefined) {
     return null;
   }
-  return existsSync27(join32(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
+  return existsSync28(join33(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
 }
 function binaryResources(projectPath) {
   const found = [];
   const visit = (directory, prefix) => {
-    if (existsSync27(join32(directory, ".gdignore"))) {
+    if (existsSync28(join33(directory, ".gdignore"))) {
       return;
     }
-    for (const entry of readdirSync14(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync15(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
       }
       const path = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join32(directory, entry.name), `${path}/`);
+        visit(join33(directory, entry.name), `${path}/`);
       } else if (/\.(scn|res)$/i.test(entry.name)) {
         found.push(path);
       }
@@ -40210,7 +40966,7 @@ function binaryResources(projectPath) {
   return found;
 }
 function targetPathOf(projectPath, absolute) {
-  const inside = relative6(onDiskSpelling(projectPath), join32(onDiskSpelling(dirname21(absolute)), basename9(absolute)));
+  const inside = relative6(onDiskSpelling(projectPath), join33(onDiskSpelling(dirname21(absolute)), basename9(absolute)));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
     return null;
   }
@@ -40228,13 +40984,13 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   if (to === null) {
     return { ok: false, reason: `newPath must be a path inside the project, and ${absoluteTo} is not.` };
   }
-  if (!existsSync27(absoluteFrom)) {
+  if (!existsSync28(absoluteFrom)) {
     return { ok: false, reason: `There is nothing at ${from} to move.` };
   }
   if (from === to) {
     return { ok: false, reason: `${from} is already there; nothing to move.` };
   }
-  const isDirectory = statSync14(absoluteFrom).isDirectory();
+  const isDirectory = statSync15(absoluteFrom).isDirectory();
   if (from === "res://project.godot") {
     return {
       ok: false,
@@ -40257,7 +41013,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   if (isDirectory && to.startsWith(`${from}/`)) {
     return { ok: false, reason: `${from} cannot be moved into itself.` };
   }
-  if (existsSync27(absoluteTo) && !sameFile(absoluteFrom, absoluteTo)) {
+  if (existsSync28(absoluteTo) && !sameFile(absoluteFrom, absoluteTo)) {
     return { ok: false, reason: `${to} already exists, so nothing was moved there.` };
   }
   const unseen = unseenByTheEngine(projectPath, to);
@@ -40265,7 +41021,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 && existsSync27(join32(projectPath, path.slice("res://".length))));
+    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))));
     if (owner !== undefined && owner !== null) {
       return { ok: false, reason: `${from} belongs to ${owner} and moves with it: move ${owner} instead.` };
     }
@@ -40287,7 +41043,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   } else {
     moves.set(from, to);
     for (const sidecar of SIDECARS) {
-      if (existsSync27(`${absoluteFrom}${sidecar}`)) {
+      if (existsSync28(`${absoluteFrom}${sidecar}`)) {
         moves.set(`${from}${sidecar}`, `${to}${sidecar}`);
       }
     }
@@ -40299,12 +41055,12 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
     scripts,
     moves,
     named: [from],
-    exists: (path) => existsSync27(join32(projectPath, path.slice("res://".length)))
+    exists: (path) => existsSync28(join33(projectPath, path.slice("res://".length)))
   }, { edits: [], mentions: [] });
   plan = mentionIgnored(plan, ignoredTexts(projectPath), null, [from]);
   const binaries = [];
   for (const path of binaryResources(projectPath)) {
-    const bytes = readFileSync27(join32(projectPath, path.slice("res://".length)));
+    const bytes = readFileSync29(join33(projectPath, path.slice("res://".length)));
     const names = [...moves.keys()].find((moving) => bytes.includes(moving));
     if (names !== undefined) {
       binaries.push({
@@ -40323,7 +41079,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   }));
   const left = leftAloneReport(mentions);
   const rewrites = rewritesOf(plan, texts, null);
-  const absoluteOf = (path) => join32(projectPath, path.slice("res://".length));
+  const absoluteOf = (path) => join33(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);
@@ -40365,18 +41121,18 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
 }
 function applyFileMove(outcome) {
   for (const rewrite of outcome.inPlace) {
-    if (readFileSync27(rewrite.absolute, "utf8") !== rewrite.before) {
+    if (readFileSync29(rewrite.absolute, "utf8") !== rewrite.before) {
       throw new Error(`${rewrite.path} changed on disk while the move was being worked out; nothing was written`);
     }
   }
   for (const file of outcome.moved) {
-    if (!existsSync27(file.absoluteFrom)) {
+    if (!existsSync28(file.absoluteFrom)) {
       throw new Error(`${file.from} is gone from disk; nothing was written`);
     }
-    if (file.text !== null && readFileSync27(file.absoluteFrom, "utf8") !== file.text.before) {
+    if (file.text !== null && readFileSync29(file.absoluteFrom, "utf8") !== file.text.before) {
       throw new Error(`${file.from} changed on disk while the move was being worked out; nothing was written`);
     }
-    if (existsSync27(file.absoluteTo) && !sameFile(file.absoluteFrom, file.absoluteTo)) {
+    if (existsSync28(file.absoluteTo) && !sameFile(file.absoluteFrom, file.absoluteTo)) {
       throw new Error(`${file.to} already exists; nothing was written`);
     }
   }
@@ -40437,7 +41193,7 @@ var init_godot_variant = __esm(() => {
 });
 
 // src/game-debugger.ts
-var PAUSE_MS = 30000, STEP_MS = 1e4, READ_MS = 5000, REPLIES;
+var PAUSE_MS = 30000, STEP_MS = 1e4, RUNTIME_ADDON2 = "res://addons/gdharness_runtime/", READ_MS = 5000, REPLIES;
 var init_game_debugger = __esm(() => {
   init_godot_variant();
   REPLIES = new Set([
@@ -44043,168 +44799,6 @@ var init_godot_bridge = __esm(() => {
   };
 });
 
-// src/import-freshness.ts
-import { createHash as createHash6 } from "node:crypto";
-import { existsSync as existsSync28, readdirSync as readdirSync15, readFileSync as readFileSync28, statSync as statSync15 } from "node:fs";
-import { join as join33 } from "node:path";
-function md5Of(file) {
-  let stats;
-  try {
-    stats = statSync15(file);
-  } catch {
-    return null;
-  }
-  const known = hashes.get(file);
-  if (known !== undefined && known.size === stats.size && known.mtimeMs === stats.mtimeMs) {
-    return known.md5;
-  }
-  let md5;
-  try {
-    md5 = createHash6("md5").update(readFileSync28(file)).digest("hex");
-  } catch {
-    return null;
-  }
-  hashes.set(file, { size: stats.size, mtimeMs: stats.mtimeMs, md5 });
-  return md5;
-}
-function sectionOf(text, section) {
-  const keys = new Map;
-  let inside = false;
-  for (const line of text.split(/\r?\n/)) {
-    const header = /^\[([^\]]+)\]\s*$/.exec(line);
-    if (header !== null) {
-      inside = header[1] === section;
-      continue;
-    }
-    const pair = inside ? /^([A-Za-z0-9_./]+)=(.*)$/.exec(line) : null;
-    if (pair?.[1] !== undefined && pair[2] !== undefined) {
-      keys.set(pair[1], pair[2]);
-    }
-  }
-  return keys;
-}
-function unquoted(value) {
-  return value === undefined ? "" : value.replace(/^"(.*)"$/, "$1");
-}
-function listed2(value) {
-  return [...(value ?? "").matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((match) => match[1] ?? "");
-}
-function onDisk(projectPath, resPath) {
-  return join33(projectPath, resPath.slice("res://".length));
-}
-function behind(projectPath, resPath, sidecar) {
-  const remap = sectionOf(sidecar, "remap");
-  const importer = unquoted(remap.get("importer"));
-  if (importer === "keep" || importer === "skip") {
-    return null;
-  }
-  const outputs = listed2(sectionOf(sidecar, "deps").get("dest_files"));
-  if (outputs.some((output) => !existsSync28(onDisk(projectPath, output)))) {
-    return "its imported output is not on disk";
-  }
-  const name = resPath.slice(resPath.lastIndexOf("/") + 1);
-  const record = join33(projectPath, ".godot", "imported", `${name}-${createHash6("md5").update(resPath, "utf8").digest("hex")}.md5`);
-  let recorded = "";
-  try {
-    recorded = /^source_md5="([0-9a-f]*)"/m.exec(readFileSync28(record, "utf8"))?.[1] ?? "";
-  } catch {
-    recorded = "";
-  }
-  if (recorded === "") {
-    return "its import recorded no hash of its source";
-  }
-  const current = md5Of(onDisk(projectPath, resPath));
-  return current === null || current === recorded ? null : "the source changed after it was imported";
-}
-function staleImports(projectPath) {
-  const stale = [];
-  const visit = (directory, resDirectory) => {
-    if (existsSync28(join33(directory, ".gdignore")) || existsSync28(join33(directory, VERSION_MARKER))) {
-      return;
-    }
-    let entries;
-    try {
-      entries = readdirSync15(directory, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    const names = new Set(entries.map((entry) => entry.name));
-    for (const entry of entries) {
-      if (entry.name.startsWith(".")) {
-        continue;
-      }
-      const resPath = `${resDirectory}${entry.name}`;
-      if (entry.isDirectory()) {
-        visit(join33(directory, entry.name), `${resPath}/`);
-        continue;
-      }
-      if (!entry.isFile()) {
-        continue;
-      }
-      if (entry.name.endsWith(".import")) {
-        const source = resPath.slice(0, -".import".length);
-        if (!names.has(entry.name.slice(0, -".import".length))) {
-          continue;
-        }
-        let sidecar;
-        try {
-          sidecar = readFileSync28(join33(directory, entry.name), "utf8");
-        } catch {
-          continue;
-        }
-        const reason = behind(projectPath, source, sidecar);
-        if (reason !== null) {
-          stale.push({ path: source, reason });
-        }
-        continue;
-      }
-      const extension = entry.name.slice(entry.name.lastIndexOf(".") + 1).toLowerCase();
-      if (IMPORTABLE.has(extension) && !names.has(`${entry.name}.import`)) {
-        stale.push({ path: resPath, reason: "it has not been imported" });
-      }
-    }
-  };
-  visit(projectPath, "res://");
-  return stale.sort((one, other) => one.path.localeCompare(other.path));
-}
-var IMPORTABLE_EXTENSIONS, IMPORTABLE, hashes;
-var init_import_freshness = __esm(() => {
-  init_project_scan();
-  IMPORTABLE_EXTENSIONS = [
-    "png",
-    "jpg",
-    "jpeg",
-    "webp",
-    "svg",
-    "bmp",
-    "tga",
-    "exr",
-    "hdr",
-    "dds",
-    "ktx",
-    "wav",
-    "mp3",
-    "ogg",
-    "ttf",
-    "otf",
-    "ttc",
-    "otc",
-    "woff",
-    "woff2",
-    "pfb",
-    "pfm",
-    "fnt",
-    "font",
-    "glb",
-    "gltf",
-    "fbx",
-    "obj",
-    "dae"
-  ];
-  IMPORTABLE = new Set(IMPORTABLE_EXTENSIONS);
-  hashes = new Map;
-});
-
 // src/keeper-channel.ts
 import { connect as connect2, createServer as createServer2 } from "node:net";
 async function askTheKeeperToStop(address, withinMs) {
@@ -44636,7 +45230,7 @@ var init_prompts = __esm(() => {
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync18, readFileSync as readFileSync29, rmSync as rmSync15, writeFileSync as writeFileSync18 } from "node:fs";
+import { mkdirSync as mkdirSync18, readFileSync as readFileSync30, rmSync as rmSync15, writeFileSync as writeFileSync18 } from "node:fs";
 import { dirname as dirname23, join as join35 } from "node:path";
 function restartNotePath(projectPath) {
   return join35(projectPath, ".godot", "gdharness-restart.json");
@@ -44653,7 +45247,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync29(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync30(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -44679,7 +45273,7 @@ var init_restart_note = __esm(() => {
 
 // src/run-record.ts
 import { createHash as createHash7 } from "node:crypto";
-import { mkdirSync as mkdirSync19, openSync as openSync5, readdirSync as readdirSync16, readFileSync as readFileSync30, rmSync as rmSync16, statSync as statSync17 } from "node:fs";
+import { mkdirSync as mkdirSync19, openSync as openSync5, readdirSync as readdirSync16, readFileSync as readFileSync31, rmSync as rmSync16, statSync as statSync17 } from "node:fs";
 import { basename as basename10, join as join36, resolve as resolve8 } from "node:path";
 function runsDirectory() {
   return join36(runtimeDirectory(), "runs");
@@ -44703,7 +45297,7 @@ function writeLatestRun(servedBy, latest) {
 }
 function readLatestRun(servedBy, directory = runtimeDirectory()) {
   try {
-    const fields = JSON.parse(readFileSync30(latestRunPath(servedBy, directory), "utf8"));
+    const fields = JSON.parse(readFileSync31(latestRunPath(servedBy, directory), "utf8"));
     if (typeof fields !== "object" || fields === null) {
       return null;
     }
@@ -44752,7 +45346,7 @@ function readEditorRunNote(projectPath) {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync30(path, "utf8"));
+    parsed = JSON.parse(readFileSync31(path, "utf8"));
   } catch {
     return null;
   }
@@ -44802,7 +45396,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync30(path, "utf8"));
+    parsed = JSON.parse(readFileSync31(path, "utf8"));
   } catch {
     return null;
   }
@@ -44861,7 +45455,7 @@ async function runningAs(pid) {
     const began = await startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync30(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync31(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = (await runHidden("ps", ["-p", String(pid), "-o", "args="], { timeout: 15000 })).stdout.trim();
@@ -45049,10 +45643,10 @@ var init_run_record = __esm(() => {
 });
 
 // src/script-profile.ts
-import { readFileSync as readFileSync31 } from "node:fs";
+import { readFileSync as readFileSync32 } from "node:fs";
 function readProfileFile(path) {
   try {
-    const parsed = JSON.parse(readFileSync31(path, "utf8"));
+    const parsed = JSON.parse(readFileSync32(path, "utf8"));
     return typeof parsed === "object" && typeof parsed.connected === "boolean" ? parsed : null;
   } catch {
     return null;
@@ -45109,7 +45703,7 @@ function writeProfileMark(path, mark) {
 }
 function readProfileMark(path) {
   try {
-    const parsed = JSON.parse(readFileSync31(path, "utf8"));
+    const parsed = JSON.parse(readFileSync32(path, "utf8"));
     return typeof parsed === "object" && typeof parsed.totals === "object" ? parsed : null;
   } catch {
     return null;
@@ -45251,8 +45845,9 @@ function callersOf(totals, name, scripts) {
     property
   };
 }
-var QUEUE_SETTING = "limits/debugger/max_queued_messages", QUEUE_DEFAULT = 2048, QUEUE_HEADROOM = 512, UNNAMED_PREFIX = "#", PROFILE_FROM_START = "GDHARNESS_PROFILE_FROM_START", ms = (seconds) => Math.round(seconds * 1e6) / 1000, RUNTIME_SCRIPT = "gdharness_runtime/runtime_autoload.gd", PROFILER_PROBE = "_profiler_probe", PROFILER_CALIBRATOR = "_calibrate_the_profiler", RUNTIME_ADDON2 = "res://addons/gdharness_runtime/", CALL_SITES = 40;
+var QUEUE_SETTING = "limits/debugger/max_queued_messages", QUEUE_DEFAULT = 2048, QUEUE_HEADROOM = 512, UNNAMED_PREFIX = "#", PROFILE_FROM_START = "GDHARNESS_PROFILE_FROM_START", ms = (seconds) => Math.round(seconds * 1e6) / 1000, RUNTIME_SCRIPT = "gdharness_runtime/runtime_autoload.gd", PROFILER_PROBE = "_profiler_probe", PROFILER_CALIBRATOR = "_calibrate_the_profiler", CALL_SITES = 40;
 var init_script_profile = __esm(() => {
+  init_game_debugger();
   init_gdscript_source();
   init_godot_variant();
   init_resources();
@@ -45276,10 +45871,10 @@ var init_server_instructions = __esm(() => {
 });
 
 // src/test-selection.ts
-import { existsSync as existsSync29, readFileSync as readFileSync32 } from "node:fs";
+import { existsSync as existsSync29, readFileSync as readFileSync33 } from "node:fs";
 import { basename as basename11, join as join37 } from "node:path";
 function casesIn(projectPath, suite) {
-  const text = readFileSync32(join37(projectPath, suite.slice("res://".length)), "utf8");
+  const text = readFileSync33(join37(projectPath, suite.slice("res://".length)), "utf8");
   return [...text.matchAll(/^func\s+(test_\w*)\s*\(/gm)].map((match) => match[1] ?? "");
 }
 function suitesUnder(projectPath, asked) {
@@ -45351,7 +45946,7 @@ import {
   mkdirSync as mkdirSync20,
   openSync as openSync6,
   readdirSync as readdirSync17,
-  readFileSync as readFileSync33,
+  readFileSync as readFileSync34,
   readSync as readSync3,
   rmdirSync as rmdirSync2,
   statSync as statSync18,
@@ -45370,6 +45965,25 @@ function waitFromEnv(variable, fallback) {
 function greetingWaitMs() {
   return waitFromEnv("GDHARNESS_GREETING_WAIT_MS", 1e4);
 }
+function pictureToSend(pngPath, jpegPath) {
+  const png = readFileSync34(pngPath);
+  const beside = pngPath.replace(/\.png$/, ".jpg");
+  const jpeg = jpegPath !== undefined && normalize2(jpegPath) === normalize2(beside) && existsSync30(beside) ? readFileSync34(beside) : null;
+  const sent = jpeg !== null && jpeg.length < png.length ? jpeg : png;
+  return {
+    data: sent.toString("base64"),
+    mimeType: sent === png ? "image/png" : "image/jpeg",
+    bytes: sent.length,
+    pngBytes: png.length
+  };
+}
+function kilobytes(bytes) {
+  return `${String(Math.max(1, Math.round(bytes / 1024)))} KB`;
+}
+function savedScenesOf(asked, as = "savedScenes") {
+  const saved = readStringArray(asParams(JSON.parse(asked.content[0]?.text ?? "{}")), "saved");
+  return saved === undefined ? {} : { [as]: saved };
+}
 function restartUnderway(note, now = Date.now()) {
   return alive(note.byPid) && now - Date.parse(note.quitAt) < editorRestartTimeoutMs() + 30000;
 }
@@ -45787,7 +46401,7 @@ function endedToStartThis(ended) {
   return ` ${which} was ended to start this one; its output is no longer what editor_output answers about.`;
 }
 function lineBeyondScript(absolutePath, relativePath, line) {
-  const text = readFileSync33(absolutePath, "utf8");
+  const text = readFileSync34(absolutePath, "utf8");
   const lines = text === "" ? 0 : text.split(`
 `).length - (text.endsWith(`
 `) ? 1 : 0);
@@ -45987,7 +46601,7 @@ function notRunNote(notRun, failFast) {
 function exportPresetRefusal(projectPath, preset) {
   let text;
   try {
-    text = readFileSync33(join38(projectPath, "export_presets.cfg"), "utf8");
+    text = readFileSync34(join38(projectPath, "export_presets.cfg"), "utf8");
   } catch {
     return `This project has no export_presets.cfg, so it has no preset '${preset}' to export with. project_export add_preset writes one, as the editor's Project > Export does.`;
   }
@@ -46350,7 +46964,7 @@ function profileFrameFunctions(projectPath) {
   let projectGodot = null;
   if (projectPath !== null) {
     try {
-      projectGodot = readFileSync33(join38(projectPath, "project.godot"), "utf8");
+      projectGodot = readFileSync34(join38(projectPath, "project.godot"), "utf8");
     } catch {}
   }
   return frameFunctionsFor(queuedMessagesOf(projectGodot));
@@ -46374,7 +46988,7 @@ function projectSourceOf(projectPath) {
       let source = null;
       if (inside.ok) {
         try {
-          source = readFileSync33(inside.absolutePath, "utf8");
+          source = readFileSync34(inside.absolutePath, "utf8");
         } catch {}
       }
       read.set(script, source);
@@ -46529,7 +47143,7 @@ function foldedEntriesAnswer(log, floor = "warning") {
 }
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync33(join38(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync34(join38(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -46558,12 +47172,13 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function testPathsIn(projectPath, given) {
-  const entries = given === undefined || given === null || given === "" ? ["test"] : given;
+  const defaults = TEST_DIRECTORIES.filter((directory) => existsSync30(join38(projectPath, directory)));
+  const entries = given === undefined || given === null || given === "" ? defaults.length > 0 ? defaults : TEST_DIRECTORIES : given;
   const listed = Array.isArray(entries) ? entries : [entries];
   if (listed.length === 0) {
     return {
       ok: false,
-      reason: "path is an empty list: name a suite file or a directory, or leave path out for test."
+      reason: "path is an empty list: name a suite file or a directory, or leave path out for tests and test."
     };
   }
   const resolved = [];
@@ -46665,11 +47280,11 @@ function scriptsUnder(directory, prefix) {
   return found;
 }
 function mainSceneOf(projectFile) {
-  const scene = parseProjectGodot(readFileSync33(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync34(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "" ? scene : null;
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync33(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync34(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function ownArguments(params) {
@@ -48496,7 +49111,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync33(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync34(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -48767,6 +49382,8 @@ class GodotServer {
     const userData = scratchDirectory("tests");
     const suitesFile = join38(userData, "suites.txt");
     const skippingFile = join38(userData, "skipping.txt");
+    const engineLog = join38(userData, "engine.log");
+    const expectedFile = join38(userData, "expected.json");
     writeFileSync19(suitesFile, `${(selection.value?.suites ?? asked).join(`
 `)}
 `);
@@ -48778,6 +49395,8 @@ class GodotServer {
       "--path",
       project.value.path,
       ...flags.value,
+      "--log-file",
+      engineLog,
       "-s",
       this.listedRunner,
       "--ignoreHeadlessMode",
@@ -48791,7 +49410,9 @@ class GodotServer {
       suitesFile,
       "--skipping-in",
       skippingFile,
-      "--html-report-off"
+      "--html-report-off",
+      "--expected-errors-out",
+      expectedFile
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
@@ -48846,11 +49467,13 @@ class GodotServer {
     const reportsDir = join38(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
+    const casePrinted = readRun(existsSync30(engineLog) ? readFileSync34(engineLog, "utf8") : "");
+    const declaredErrors = readExpected(expectedFile);
     try {
       const written = existsSync30(reportsDir) && notCompiled === null ? readdirSync17(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync33(join38(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync34(join38(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -48961,7 +49584,44 @@ class GodotServer {
       orphans: suite.orphans,
       message: `${suite.orphans} node${suite.orphans === 1 ? "" : "s"} were still in the tree when this suite finished. A node built in a test and neither freed nor added to the tree is the usual cause; free it, or add it with auto_free().`
     }));
-    const unclean = report.suites.filter((suite) => suite.failures > 0 || suite.errors > 0 || suite.hookFailures > 0 || suite.hookErrors > 0 || suite.skipped > 0 || orphansIn(suite.path) > 0);
+    const judgedErrors = unexpectedErrors(casePrinted, declaredErrors, [...casePrinted.suites.keys()]);
+    const uncaughtTexts = new Set(uncaught.map((entry) => entry.text));
+    const undeclaredPrinted = judgedErrors.printed.filter((error) => !uncaughtTexts.has(error.text));
+    const undeclaredFolded = new Map;
+    for (const error of undeclaredPrinted) {
+      const key = `${error.suite ?? ""}
+${error.during ?? ""}
+${error.text}`;
+      const seen = undeclaredFolded.get(key);
+      if (seen === undefined) {
+        undeclaredFolded.set(key, {
+          suite: error.suite ?? undefined,
+          case: error.during ?? undefined,
+          text: error.text,
+          times: 1
+        });
+      } else {
+        seen.times += 1;
+      }
+    }
+    const undeclaredAll = [...undeclaredFolded.values()].map((error) => ({
+      ...error,
+      times: error.times > 1 ? error.times : undefined
+    }));
+    const undeclaredErrors = undeclaredAll.slice(0, MOST_UNDECLARED_ERRORS);
+    const declaredNotPrinted = judgedErrors.neverPrinted.map((missing) => ({
+      suite: missing.suite,
+      case: missing.during,
+      text: missing.text
+    }));
+    const erring = (path) => ({
+      undeclared: undeclaredPrinted.filter((error) => error.suite === path).length,
+      notPrinted: judgedErrors.neverPrinted.filter((missing) => missing.suite === path).length
+    });
+    const declaredAndPrinted = casePrinted.errors.length - judgedErrors.printed.length;
+    const ranIn = (suite) => suite.path === null ? suite.tests : casePrinted.suites.get(suite.path)?.cases.length ?? suite.tests;
+    const notRunIn = (suite) => Math.max(0, suite.discovered - ranIn(suite));
+    const unclean = report.suites.filter((suite) => suite.failures > 0 || suite.errors > 0 || suite.hookFailures > 0 || suite.hookErrors > 0 || suite.skipped > 0 || orphansIn(suite.path) > 0 || erring(suite.path).undeclared + erring(suite.path).notPrinted > 0);
     const hooksPrinted = hookFailuresPrinted(said);
     const hookFailures = report.suites.filter((suite) => suite.hookFailures + suite.hookErrors > 0).flatMap((suite) => {
       const printedHere = hooksPrinted.filter((hook) => hook.path === suite.path);
@@ -48973,16 +49633,24 @@ class GodotServer {
         }
       ];
     });
-    const notRun = report.suites.reduce((sum, suite) => sum + Math.max(0, suite.discovered - suite.tests), 0);
+    const notRun = report.suites.reduce((sum, suite) => sum + notRunIn(suite), 0);
     const uncaughtFolded = foldedRepeats(uncaught.map(aboveTheRunner));
     const listedAsUncaught = new Set(uncaughtFolded.map((entry) => entry.index));
     const notApplied = ignoredYetRan(report, ignored);
+    const scripts = ignored.length === 0 ? null : new ProjectScripts(project.value.path);
+    const ignoreRead = ignoredLeftOut(report, ignored, asked.flatMap((path) => scripts === null ? [] : path.endsWith(".gd") ? scripts.suite(path) ?? [] : scripts.suitesUnder([path])));
+    const unmatched = ignoreRead.unmatched.filter((entry) => !notApplied.some((one) => one.entry === entry));
     const testsNotRun = [
       ...new Set((selection.value?.selected ?? []).filter((one) => !report.suites.some((suite) => (suite.path === one.suite || suite.name === basename12(one.suite, ".gd")) && suite.cases.some((ran) => ran.name === one.test || new RegExp(`^${one.test}\\W`).test(ran.name)))).map((one) => `${basename12(one.suite, ".gd")}:${one.test}`))
     ];
     return this.jsonTextResponse({
-      passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0 && uncaught.length === 0 && missing.length === 0 && testsNotRun.length === 0,
-      verdict: testsNotRun.length === 0 ? verdict : `${verdict}; not run: ${testsNotRun.join(", ")}`,
+      passed: !timedOut && exitCode === 0 && nothingRan === null && report.tests > 0 && report.failures === 0 && report.errors === 0 && hookFailures.length === 0 && uncaught.length === 0 && undeclaredPrinted.length === 0 && declaredNotPrinted.length === 0 && missing.length === 0 && testsNotRun.length === 0,
+      verdict: [
+        verdict === "passed" && undeclaredPrinted.length + declaredNotPrinted.length > 0 ? undefined : verdict,
+        undeclaredPrinted.length > 0 ? `${undeclaredPrinted.length === 1 ? "one engine error" : `${String(undeclaredPrinted.length)} engine errors`} no suite declared` : undefined,
+        declaredNotPrinted.length > 0 ? `${declaredNotPrinted.length === 1 ? "one declared error" : `${String(declaredNotPrinted.length)} declared errors`} never printed` : undefined,
+        testsNotRun.length > 0 ? `not run: ${testsNotRun.join(", ")}` : undefined
+      ].filter((part) => part !== undefined).join("; "),
       ...missing.length > 0 ? { missing } : {},
       ...testsNotRun.length > 0 ? { testsNotRun } : {},
       ...timedOut ? { timedOut, hung, silentForMs } : {},
@@ -48998,10 +49666,15 @@ class GodotServer {
       failedWithoutDetail: briefed > 0 ? briefed : undefined,
       hookFailures: hookFailures.length > 0 ? hookFailures : undefined,
       uncaughtScriptErrors: uncaughtFolded.length > 0 ? uncaughtFolded : undefined,
+      undeclaredErrors: undeclaredErrors.length > 0 ? undeclaredErrors : undefined,
+      undeclaredErrorsOmitted: undeclaredAll.length > undeclaredErrors.length ? undeclaredAll.length - undeclaredErrors.length : undefined,
+      declaredNotPrinted: declaredNotPrinted.length > 0 ? declaredNotPrinted : undefined,
       warnings: warnings.length > 0 ? warnings : undefined,
       orphans: orphans.total > 0 ? orphans.total : undefined,
       notRun: notRun > 0 ? notRun : undefined,
       ignoreNotApplied: notApplied.length > 0 ? notApplied : undefined,
+      ignored: ignoreRead.leftOut.length > 0 ? ignoreRead.leftOut : undefined,
+      ignoreUnmatched: unmatched.length > 0 ? unmatched : undefined,
       ...printedLines,
       savesNote,
       ...scanned,
@@ -49010,14 +49683,19 @@ class GodotServer {
         testsNotRun.length > 0 ? `${testsNotRun.join(", ")} ${testsNotRun.length === 1 ? "was" : "were"} asked for and not run, so the run is not called passed: gdUnit4 runs a test_ function only in a script that extends GdUnitTestSuite, and leaves out a suite whose script does not load.` : undefined,
         briefed > 0 ? `${briefed} of the ${failed.length} failing cases, those with the largest reports, are named with their first message only, since their reports would have made the answer too large to deliver; pass one case's suite path to see its reports.` : undefined,
         notApplied.length > 0 ? "An ignore entry named a case that ran all the same: gdUnit4 leaves a case out only as suite_name:test_name, and reads an entry with no colon as a suite name or a piece of a suite path. ignoreNotApplied gives the form for each case that ran." : undefined,
+        unmatched.length > 0 ? `${unmatched.join(", ")} ${unmatched.length === 1 ? "names" : "name"} no suite or case under the paths run, so ${unmatched.length === 1 ? "it" : "they"} left nothing out.` : undefined,
         uncaughtNote(uncaught),
+        undeclaredErrors.length > 0 ? `An engine error a suite does not declare fails the run, as gdharness test judges it; ${declaringAdvice(undeclaredErrors[0]?.case ?? "test_name")}, once for each time it prints it.` : undefined,
+        declaredNotPrinted.length > 0 ? "A declared error the case did not print fails the run too, since the case no longer reaches what it was written to test." : undefined,
         ranAs.startsWith("warnings") && warnings.length === 0 ? "gdUnit4 exits 101 for orphan nodes when nothing failed, and this run printed no count of them: orphan reporting may be off in the project settings." : notRunNote(notRun, readBoolean(args, "failFast") === true)
       ].filter((part) => part !== undefined).join(" ") || undefined,
       suites: unclean.map((suite) => ({
         name: suite.name,
         path: suite.path,
-        tests: suite.tests,
-        notRun: suite.discovered > suite.tests ? suite.discovered - suite.tests : undefined,
+        tests: ranIn(suite),
+        notRun: notRunIn(suite) > 0 ? notRunIn(suite) : undefined,
+        undeclaredErrors: erring(suite.path).undeclared > 0 ? erring(suite.path).undeclared : undefined,
+        declaredNotPrinted: erring(suite.path).notPrinted > 0 ? erring(suite.path).notPrinted : undefined,
         failures: suite.failures,
         errors: suite.errors,
         hookFailures: suite.hookFailures + suite.hookErrors > 0 ? suite.hookFailures + suite.hookErrors : undefined,
@@ -49026,7 +49704,7 @@ class GodotServer {
         time: suite.time
       })),
       suitesPassed: report.suites.length - unclean.length,
-      engineErrors: run.log.count("error"),
+      engineErrors: Math.max(0, run.log.count("error") - declaredAndPrinted),
       engineWarnings: run.log.count("warning"),
       engineEntries: engineEntriesShown.map((entry) => listedAsUncaught.has(entry.index) ? { ...entry, detail: undefined, detailUnder: "uncaughtScriptErrors" } : entry),
       engineEntriesOmitted: engineEntries.length > engineEntriesShown.length ? engineEntries.length - engineEntriesShown.length : undefined,
@@ -49242,7 +49920,7 @@ class GodotServer {
         return null;
       }
       try {
-        return readFileSync33(contained.absolutePath, "utf8");
+        return readFileSync34(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -49336,7 +50014,7 @@ class GodotServer {
       return null;
     }
     try {
-      return readFileSync33(contained.absolutePath, "utf8");
+      return readFileSync34(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -49772,8 +50450,9 @@ class GodotServer {
     if (servers.dapListening !== false && servers.lspListening !== false) {
       return { servers, report: {} };
     }
-    const { rebound, said } = await this.editorServersSaid(servers.dapListening === false);
+    const { rebound, before, since } = await this.editorServersSaid(servers.dapListening === false);
     const after = rebound ? await this.editorServersListening() : servers;
+    const said = [...before, ...since];
     return {
       servers: after,
       report: {
@@ -49791,17 +50470,18 @@ class GodotServer {
     }
     return {
       rebound: readBoolean(answer, "rebound") === true,
-      said: [...readStringArray(answer, "said") ?? [], ...readStringArray(answer, "saidSince") ?? []]
+      before: readStringArray(answer, "said") ?? [],
+      since: readStringArray(answer, "saidSince") ?? []
     };
   }
   async handleRebindEditorServers() {
     if (!this.godotBridge.getStatus().connected) {
-      return this.createErrorResponse("No editor is connected, so there is no debug adapter to bind.", [
-        "editor_launch opens one on a project",
-        "editor_status says whether the bridge is up and what has reached it"
-      ]);
+      const refused = await this.noEditorYet({}, []);
+      if (refused !== null) {
+        return refused;
+      }
     }
-    const { rebound, said } = await this.editorServersSaid(true);
+    const { rebound, since: said } = await this.editorServersSaid(true);
     if (!rebound) {
       return this.createErrorResponse("The editor has no debug adapter to bind again: no DebugAdapterServer is in its tree.", ["editor_status says what the editor serves"]);
     }
@@ -49817,7 +50497,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync33(join38(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync34(join38(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -49865,6 +50545,7 @@ class GodotServer {
       serverVersion: SERVER_VERSION,
       addonIsStale: this.godotBridge.anotherRelease() !== undefined,
       staleNote: this.godotBridge.anotherRelease(),
+      ...savedScenesOf(asked),
       ...this.whatTheEditorDropped(settingsBefore, after),
       ...servers,
       ...rebinding,
@@ -49908,6 +50589,7 @@ class GodotServer {
       closed: true,
       editorPid: pid,
       projectPath: before.projectPath,
+      ...savedScenesOf(asked),
       ...this.whatTheEditorDropped(settingsBefore, this.settingKeysOf(before.projectPath)),
       tookMs: Date.now() - began
     });
@@ -49991,7 +50673,7 @@ class GodotServer {
     if (opened.error !== null) {
       return this.createErrorResponse(`The editor was asked to go and could not be started again: ${opened.error}`, [`editor_launch opens one on ${projectPath}`]);
     }
-    return this.jsonTextResponse({ restarting: true, pid: opened.pid });
+    return this.jsonTextResponse({ restarting: true, pid: opened.pid, ...savedScenesOf(asked, "saved") });
   }
   async waitForBridge(reached, deadline) {
     for (;; ) {
@@ -50050,7 +50732,7 @@ class GodotServer {
       dapPort: ports.dap,
       arguments: opened.arguments,
       finishesRestart: unfinished === null ? undefined : `This is the launch half of a restart begun at ${unfinished.quitAt} by server pid ${unfinished.byPid}, which quit editor pid ${unfinished.editorPid ?? "unknown"} and was ended before it could start one.`,
-      settingsNote: before === null ? "project.godot could not be read before this editor was opened, so nothing here will be able to say what the import saved away. Opening a project rewrites the file and drops any key sitting at its own default." : before.size === 0 ? undefined : "Opening a project imports it and saves project.godot, and Godot drops any key sitting at its own default. editor_status names anything lost under settingsDropped once this editor has connected."
+      settingsNote: before === null ? "project.godot could not be read before this editor was opened, so nothing here will be able to say what the import saved away. Opening a project rewrites the file and drops any key sitting at its own default." : before.size === 0 ? undefined : "Opening a project imports it and saves project.godot, and Godot drops any key sitting at its own default. editor_status names anything lost under settingsDropped once this editor has connected, and leaves settingsDropped out when nothing was."
     });
   }
   async editorsNotYetConnected(projectPath) {
@@ -50542,7 +51224,7 @@ class GodotServer {
       return 0;
     }
     try {
-      return reportAlreadyInTranscript(readFileSync33(game.transcript), readFileSync33(report));
+      return reportAlreadyInTranscript(readFileSync34(game.transcript), readFileSync34(report));
     } catch (error) {
       this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
       return 0;
@@ -52627,7 +53309,7 @@ class GodotServer {
     }
     const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const declared = new RegExp(`^\\s*(?:@\\w+(?:\\([^)]*\\))?\\s+)*class_name\\s+${escaped}\\b`, "m");
-    if (declared.test(readFileSync33(scriptPath, "utf8"))) {
+    if (declared.test(readFileSync34(scriptPath, "utf8"))) {
       return null;
     }
     const checked = await this.classesTheEditorCannotSee(args);
@@ -52692,6 +53374,10 @@ class GodotServer {
         "editor_launch open starts another"
       ]);
     }
+    const closed = this.closedHere;
+    if (closed !== null && (project === null || (await this.editorsNotYetConnected(project) ?? []).length === 0)) {
+      return this.createErrorResponse(`Editor not connected: this server closed the editor, pid ${closed.editorPid}, on request at ${closed.at}, so nothing is coming until one is opened.`, [...instead, "editor_launch open starts one on the project"]);
+    }
     return this.createErrorResponse("Editor not connected: no Godot editor with the gdharness editor addon has reached this server.", [
       ...instead,
       "Open the project in the editor with editor_launch, or by hand",
@@ -52840,7 +53526,8 @@ class GodotServer {
   }
   async handleRuntimeCommand(command, args, asked) {
     const timeoutMs = asked.patience ?? this.runtimeTimeoutMs();
-    const { op: _op, projectPath, pid, outputPath, ...params } = asParams(args);
+    const callArgs = asParams(args);
+    const { op: _op, projectPath, pid, outputPath, inline: _inline, ...params } = callArgs;
     const waited = typeof pid === "number" ? null : await this.ownRunOnItsWay(typeof projectPath === "string" ? projectPath : this.ownProject, timeoutMs);
     if (waited !== null) {
       return this.createErrorResponse(waited, [
@@ -52873,6 +53560,13 @@ class GodotServer {
     }
     const expectsScreenshot = command === "capture_screenshot" || command === "capture_viewport";
     const saveTo = expectsScreenshot && typeof outputPath === "string" ? outputPath : null;
+    const sendsThePicture = readBoolean(callArgs, "inline") !== false;
+    if (expectsScreenshot && !sendsThePicture && saveTo === null) {
+      return this.createErrorResponse("inline: false sends no picture back, so it needs outputPath to save one to; without it the capture would answer nothing to look at.", [
+        "Pass outputPath, an absolute path ending in .png outside the project",
+        "Or leave inline out to have the picture sent"
+      ]);
+    }
     if (saveTo !== null) {
       const refusal = captureDestinationRefusal(saveTo, [
         choice.endpoint.project.path,
@@ -52940,15 +53634,17 @@ class GodotServer {
         }
       }
       const ranWith = [...onGame.alongside];
+      const sent = sendsThePicture ? pictureToSend(screenshotPath, readString(payload, "jpegPath")) : null;
+      const how = sent === null ? ". Not sent, as inline: false asked" : sent.mimeType === "image/jpeg" ? `. Sent as JPEG, ${kilobytes(sent.bytes)} against the PNG's ${kilobytes(sent.pngBytes)}${saveTo === null ? "" : "; the saved PNG is lossless"}` : "";
       return {
         content: [
           {
             type: "text",
-            text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${captureDetail(payload)}${saveTo === null ? "" : `. Saved to ${saveTo}`}${ranWith.length === 0 ? "" : `
+            text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}${captureDetail(payload)}${saveTo === null ? "" : `. Saved to ${saveTo}`}${how}${ranWith.length === 0 ? "" : `
 
 Ran alongside ${ranWith.join(", ")}. ${ALONGSIDE_NOTE}`}`
           },
-          { type: "image", data: readFileSync33(screenshotPath).toString("base64"), mimeType: "image/png" }
+          ...sent === null ? [] : [{ type: "image", data: sent.data, mimeType: sent.mimeType }]
         ]
       };
     } finally {
@@ -53065,7 +53761,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, FAILED_BUDGET = 1e6, ANSWER_BUDGET = 4000000, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, ALONGSIDE_NOTE = "Another call on this game was running while this one was: calls sent together run together and are answered as each finishes, so this answer is not from after the other. Send a call meant to come after another once that one has answered.", OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, CLOSE_ASK_MS = 3000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", LOOPING_AFTER = 100, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, OUTPUT_PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, FAILED_BUDGET = 1e6, ANSWER_BUDGET = 4000000, __dirname2, PARENT_ASKED_AFTER_MS = 5000, EDITOR_SERVERS_START_MS = 20000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, ALONGSIDE_NOTE = "Another call on this game was running while this one was: calls sent together run together and are answered as each finishes, so this answer is not from after the other. Send a call meant to come after another once that one has answered.", OWN_DEBUGGER = " Its debugger is the keeper holding it rather than the editor, so the debug_* tools answer for it all the same: breakpoints stop it, and debug_control pause breaks into it wherever it is, which the editor offers no way to do.", PLAY_STARTS_WITHIN_MS = 30000, KEEPER_ANSWER_MS = 15000, KEEPER_DEBUG_MS, EXIT_REPORTED_WITHIN_MS = 2000, CLOSE_ASK_MS = 3000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, PROFILE_SEND_MS = 5000, MOST_GROUPS = 20, RUNTIME_LISTENING_LINE = "[gdharness] runtime listening on ", VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CONSOLE_WATCH_MS = 250, BOUNDARY_WAIT_MS = 2000, HANDOVER_MS, HANDOVER_POLL_MS = 250, CACHE_WRITE_MS = 2000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, OPS_ELSEWHERE, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", LOOPING_AFTER = 100, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, OUTPUT_PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/", PROFILE_FUNCTIONS = 30, PROFILER_ON_MS = 3000, PROPERTY_PLACES = "It is a property, so each place says whether it writes it (access write), which runs its set block, or reads it (access read), which runs its get block: withinCalls on a read says nothing of the set block, nor on a write of the get block unless the write is a compound one such as +=. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not listed.", CALLERS_FOUND_BY_NAME = "Found by name in the project's scripts, since the engine's profiler counts calls and time per function and records nothing about who made them: a method of the same name on another class is listed too, unless one class was asked about and it is called through another class by name or through a variable declared as one. Each place carries the profile's numbers for the function it is written in.", MOST_ENGINE_ENTRIES = 200, MOST_UNDECLARED_ERRORS = 20, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
 var init_server = __esm(() => {
   init_dist();
   init_stdio();
@@ -53123,6 +53819,8 @@ var init_server = __esm(() => {
   init_server_version();
   init_setup();
   init_spawn();
+  init_suite_judge();
+  init_suite_plan();
   init_test_selection();
   init_tool_definitions();
   init_tool_reference();
@@ -53172,6 +53870,7 @@ var init_server = __esm(() => {
   });
   PROJECT_INFO_SECTIONS2 = dictionary({
     autoloads: { operation: "list_autoloads", params: () => ({}) },
+    classes: { operation: "list_script_classes", params: () => ({}) },
     input_actions: { operation: "list_input_actions", params: () => ({}) },
     plugins: { operation: "list_plugins", params: () => ({}) },
     export_presets: { operation: "list_export_presets", params: () => ({}) },
@@ -54184,10 +54883,10 @@ init_setup();
 init_setup();
 init_tool_definitions();
 init_tool_reference();
-import { existsSync as existsSync14, mkdirSync as mkdirSync5, readdirSync as readdirSync9, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename as basename7, dirname as dirname9, join as join16 } from "node:path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync5, readdirSync as readdirSync10, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
+import { basename as basename7, dirname as dirname9, join as join17 } from "node:path";
 var SKILL_NAME = "gdharness";
-var SHARED_SKILLS = join16(".agents", "skills");
+var SHARED_SKILLS = join17(".agents", "skills");
 function skillMarkdown(version) {
   return `---
 name: ${SKILL_NAME}
@@ -54298,6 +54997,11 @@ engines would otherwise announce sixteen games that are not games. Set \`${SCRIP
 true in \`project.godot\` to serve one anyway, which is for driving a \`-s\` script on purpose. Read
 that setting rather than assuming the quiet: it is a default and not a property of script runs.
 
+A scene that is not the game, such as a bench, is run as a scene and is served like the game unless
+the project lists its folder in \`${QUIET_SCENES_SETTING}\`, a \`PackedStringArray\` of \`res://\`
+prefixes, empty by default. A run started on a scene under one of them neither serves nor
+announces, nor do the engines it starts, unless it was started to be profiled from its start.
+
 The autoload reaches an export. \`gdharness runtime off\` in the project before shipping.
 
 ## At a breakpoint
@@ -54419,27 +55123,27 @@ what they report while starting comes back under \`engine_messages_before_operat
 function skillFiles(version) {
   return new Map([
     ["SKILL.md", skillMarkdown(version)],
-    [join16("references", "tools.md"), renderToolsMarkdown()]
+    [join17("references", "tools.md"), renderToolsMarkdown()]
   ]);
 }
 function skillDirectories(harnesses, projectPath, exists) {
-  const directories = [join16(projectPath, SHARED_SKILLS, SKILL_NAME)];
+  const directories = [join17(projectPath, SHARED_SKILLS, SKILL_NAME)];
   for (const harness of harnesses) {
     if (harness.skills === undefined) {
       continue;
     }
-    const own = join16(projectPath, harness.skills.dir);
-    if ((!harness.skills.shared || exists(own)) && !directories.includes(join16(own, SKILL_NAME))) {
-      directories.push(join16(own, SKILL_NAME));
+    const own = join17(projectPath, harness.skills.dir);
+    if ((!harness.skills.shared || exists(own)) && !directories.includes(join17(own, SKILL_NAME))) {
+      directories.push(join17(own, SKILL_NAME));
     }
   }
   return directories;
 }
 function everySkillDirectory(projectPath, harnesses) {
-  const directories = new Set([join16(projectPath, SHARED_SKILLS, SKILL_NAME)]);
+  const directories = new Set([join17(projectPath, SHARED_SKILLS, SKILL_NAME)]);
   for (const harness of harnesses) {
     if (harness.skills !== undefined) {
-      directories.add(join16(projectPath, harness.skills.dir, SKILL_NAME));
+      directories.add(join17(projectPath, harness.skills.dir, SKILL_NAME));
     }
   }
   return [...directories];
@@ -54447,7 +55151,7 @@ function everySkillDirectory(projectPath, harnesses) {
 function removeSkill(directories, projectPath) {
   const removed = [];
   for (const directory of directories) {
-    if (existsSync14(directory)) {
+    if (existsSync15(directory)) {
       rmSync6(directory, { recursive: true, force: true });
       pruneEmpty(dirname9(directory), projectPath);
       removed.push(directory);
@@ -54456,10 +55160,10 @@ function removeSkill(directories, projectPath) {
   return removed;
 }
 function pruneEmpty(directory, projectPath) {
-  const shared = join16(projectPath, ".agents");
+  const shared = join17(projectPath, ".agents");
   let path = directory;
   while (path !== projectPath && (basename7(path) === "skills" || path === shared)) {
-    if (readdirSync9(path).length > 0) {
+    if (readdirSync10(path).length > 0) {
       return;
     }
     rmSync6(path, { recursive: true, force: true });
@@ -54469,10 +55173,10 @@ function pruneEmpty(directory, projectPath) {
 function writeSkill(directories, version) {
   const files = skillFiles(version);
   return directories.map((directory) => {
-    const replaced = existsSync14(directory);
+    const replaced = existsSync15(directory);
     rmSync6(directory, { recursive: true, force: true });
     for (const [name, contents] of files) {
-      const path = join16(directory, name);
+      const path = join17(directory, name);
       mkdirSync5(dirname9(path), { recursive: true });
       writeFileSync7(path, contents, "utf8");
     }
@@ -54485,27 +55189,27 @@ init_alive();
 init_desktop();
 import {
   closeSync as closeSync3,
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   fstatSync,
   mkdirSync as mkdirSync8,
   openSync as openSync3,
-  readdirSync as readdirSync11,
-  readFileSync as readFileSync17,
+  readdirSync as readdirSync12,
+  readFileSync as readFileSync19,
   readSync,
   rmSync as rmSync10,
-  statSync as statSync11,
+  statSync as statSync12,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { availableParallelism, freemem } from "node:os";
-import { isAbsolute as isAbsolute4, join as join21, relative as relative3, resolve as resolve4, sep as sep2 } from "node:path";
+import { availableParallelism, freemem, totalmem } from "node:os";
+import { isAbsolute as isAbsolute4, join as join22, relative as relative3, resolve as resolve4, sep as sep2 } from "node:path";
 import process12 from "node:process";
 import { setTimeout as delay3 } from "node:timers/promises";
 
 // src/engine-slots.ts
 init_alive();
 init_process_children();
-import { closeSync as closeSync2, mkdirSync as mkdirSync6, openSync as openSync2, readFileSync as readFileSync13, rmSync as rmSync8, statSync as statSync9, writeSync as writeSync2 } from "node:fs";
-import { join as join18 } from "node:path";
+import { closeSync as closeSync2, mkdirSync as mkdirSync6, openSync as openSync2, readFileSync as readFileSync14, rmSync as rmSync8, statSync as statSync10, 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";
 var START_TOLERANCE_MS = 2000;
@@ -54556,7 +55260,7 @@ class EngineSlots {
     for (;; ) {
       signal?.throwIfAborted();
       for (let slot = 0;slot < this.count; slot += 1) {
-        const lock = join18(this.directory, `${String(slot)}.lock`);
+        const lock = join19(this.directory, `${String(slot)}.lock`);
         if (this.made(lock) || await this.takenOver(lock)) {
           this.held.add(lock);
           return lock;
@@ -54573,7 +55277,7 @@ class EngineSlots {
   release(lock) {
     this.held.delete(lock);
     try {
-      if (holderOf(readFileSync13(lock, "utf8"))?.pid === this.holder.pid) {
+      if (holderOf(readFileSync14(lock, "utf8"))?.pid === this.holder.pid) {
         rmSync8(lock, { force: true });
       }
     } catch {}
@@ -54599,7 +55303,7 @@ class EngineSlots {
     const steal = `${lock}.steal`;
     if (!this.made(steal)) {
       try {
-        if (Date.now() - statSync9(steal).mtimeMs > UNWRITTEN_MS) {
+        if (Date.now() - statSync10(steal).mtimeMs > UNWRITTEN_MS) {
           rmSync8(steal, { force: true });
         }
       } catch {}
@@ -54623,8 +55327,8 @@ class EngineSlots {
     let content;
     let writtenAt;
     try {
-      content = readFileSync13(lock, "utf8");
-      writtenAt = statSync9(lock).mtimeMs;
+      content = readFileSync14(lock, "utf8");
+      writtenAt = statSync10(lock).mtimeMs;
     } catch {
       return false;
     }
@@ -54651,9 +55355,9 @@ init_spawn();
 
 // src/suite-fingerprint.ts
 init_class_cache();
-import { createHash as createHash5 } from "node:crypto";
-import { existsSync as existsSync16, readdirSync as readdirSync10, readFileSync as readFileSync14, statSync as statSync10 } from "node:fs";
-import { join as join19, posix as posix2 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { existsSync as existsSync17, readdirSync as readdirSync11, readFileSync as readFileSync15, statSync as statSync11 } from "node:fs";
+import { join as join20, posix as posix2 } from "node:path";
 var RES_LITERAL = /res:\/\/[^"'\s)\]<>]*/g;
 var RELATIVE_LOAD = /\b(?:pre)?load\(\s*["']((?!res:\/\/|uid:\/\/)[^"']+)["']/g;
 var REACHES_AT_RUN_TIME = [
@@ -54673,7 +55377,7 @@ class SuiteFingerprints {
   constructor(scripts, always) {
     this.scripts = scripts;
     this.everywhere = ["res://project.godot", ...extensionsOf(scripts.projectPath)];
-    this.alwaysDigest = createHash5("sha256").update(always.join(`
+    this.alwaysDigest = createHash6("sha256").update(always.join(`
 `)).digest("hex");
   }
   of(suite) {
@@ -54690,7 +55394,7 @@ class SuiteFingerprints {
       }
       pending.push(...reached.reaches);
     }
-    const hash = createHash5("sha256").update(this.alwaysDigest);
+    const hash = createHash6("sha256").update(this.alwaysDigest);
     for (const path of [...seen].sort()) {
       hash.update(`${path}
 ${this.read(path).digest}
@@ -54709,20 +55413,20 @@ ${this.read(path).digest}
     return reached;
   }
   addon(root) {
-    const hash = createHash5("sha256");
+    const hash = createHash6("sha256");
     const walk = (directory, under) => {
-      for (const entry of readdirSync10(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-        const file = join19(directory, entry.name);
+      for (const entry of readdirSync11(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+        const file = join20(directory, entry.name);
         if (entry.isDirectory()) {
           walk(file, `${under}${entry.name}/`);
         } else if (entry.isFile()) {
           hash.update(`${under}${entry.name}
-`).update(readFileSync14(file));
+`).update(readFileSync15(file));
         }
       }
     };
-    const directory = join19(this.scripts.projectPath, root.slice("res://".length));
-    if (existsSync16(directory)) {
+    const directory = join20(this.scripts.projectPath, root.slice("res://".length));
+    if (existsSync17(directory)) {
       walk(directory, "");
     }
     return { digest: hash.digest("hex"), reaches: [], unreadable: null };
@@ -54731,26 +55435,26 @@ ${this.read(path).digest}
     if (PLACEHOLDER.test(path)) {
       return { digest: "", reaches: [], unreadable: `${path} is filled in at run time` };
     }
-    const file = join19(this.scripts.projectPath, path.slice("res://".length));
-    if (!existsSync16(file)) {
+    const file = join20(this.scripts.projectPath, path.slice("res://".length));
+    if (!existsSync17(file)) {
       return { digest: "missing", reaches: [], unreadable: null };
     }
-    if (statSync10(file).isDirectory()) {
-      const inside = readdirSync10(file, { withFileTypes: true }).filter((entry) => !entry.name.startsWith(".")).map((entry) => `${path.endsWith("/") ? path : `${path}/`}${entry.name}`).sort();
+    if (statSync11(file).isDirectory()) {
+      const inside = readdirSync11(file, { withFileTypes: true }).filter((entry) => !entry.name.startsWith(".")).map((entry) => `${path.endsWith("/") ? path : `${path}/`}${entry.name}`).sort();
       return { digest: inside.join(`
 `), reaches: inside, unreadable: null };
     }
     if (BINARY_RESOURCE.test(path)) {
       return { digest: "", reaches: [], unreadable: `${path} is a binary resource` };
     }
-    const bytes = readFileSync14(file);
-    const digest = createHash5("sha256").update(bytes).digest("hex");
+    const bytes = readFileSync15(file);
+    const digest = createHash6("sha256").update(bytes).digest("hex");
     const text = bytes.toString("latin1");
     const reaches = new Set;
     for (const [literal] of text.matchAll(RES_LITERAL)) {
       reaches.add(literal);
     }
-    if (existsSync16(`${file}.import`)) {
+    if (existsSync17(`${file}.import`)) {
       reaches.add(`${path}.import`);
     }
     if (path.endsWith(".gd")) {
@@ -54780,532 +55484,28 @@ ${this.read(path).digest}
   }
 }
 function extensionsOf(projectPath) {
-  const list = join19(projectPath, ".godot", "extension_list.cfg");
-  return existsSync16(list) ? readFileSync14(list, "utf8").split(`
+  const list = join20(projectPath, ".godot", "extension_list.cfg");
+  return existsSync17(list) ? readFileSync15(list, "utf8").split(`
 `).map((line) => line.trim()).filter((line) => line.startsWith("res://")) : [];
 }
 
-// src/suite-judge.ts
-init_junit();
-import { stripVTControlCharacters } from "node:util";
-var SUITE_OPENED = /^Run Test Suite:\s*(res:\/\/.+?\.gd)\s*$/;
-var TIME = String.raw`(?:\d+h )?(?:\d+min )?(?:\d+s )?\d+ms`;
-var CASE_LINE = new RegExp(String.raw`^\s*(res://.+?\.gd) > (.+?) (STARTED|PASSED|FAILED|FLAKY|SKIPPED|WARNING)(?: \((?:retry \d+|\d+ retries)\))?(?: (${TIME}))?\s*$`);
-var STATISTICS = new RegExp(String.raw`^Statistics:.*\|\s*([A-Z]+)(?:\s+\(.*?\))?\s+(${TIME})\s*$`);
-var ERROR_LINE = /^\s*(?:SCRIPT |USER )?ERROR: (.*?)\s*$/;
-var EXECUTED = /^Executed test cases\s*:\s*\((\d+)\//;
-var DRIVER_FALLBACK = /^\s*WARNING: Your video card drivers .*, switching to /;
-var LEAK = /ObjectDB instances (?:were )?leaked at exit|resources? still in use at exit|Pages in use exist at exit/;
-var STARVED = [
-  /Parameter "mem(?:_new)?" is null\.?\s*\n\s*at: \w+ \((?:\.\/)?core\/(?:os\/memory\.cpp|templates\/cowdata\.h):/g,
-  /ERROR: Failed decoding WebP image\.\s*\n\s*at: _webp_unpack/g
-];
-function secondsOf(time) {
-  let ms = 0;
-  for (const [, amount, unit] of time.matchAll(/(\d+)(h|min|ms|s)\b/g)) {
-    ms += Number(amount) * (unit === "h" ? 3600000 : unit === "min" ? 60000 : unit === "s" ? 1000 : 1);
-  }
-  return ms / 1000;
-}
-function funcOf(name) {
-  const colon = name.indexOf(":");
-  return colon < 0 ? name : name.slice(0, colon);
-}
-function readRun(printed) {
-  const lines = stripVTControlCharacters(printed).replaceAll(`\r
-`, `
-`).split(`
-`);
-  const suites = new Map;
-  const errors = [];
-  const leaks = [];
-  let executed = null;
-  let open = null;
-  let during = null;
-  let afterCase = [];
-  let lastCase = null;
-  const settleAfterCase = (owner) => {
-    for (const held of afterCase) {
-      errors.push({ ...held, suite: open?.path ?? null, during: owner });
-    }
-    afterCase = [];
-  };
-  for (const [at, line] of lines.entries()) {
-    const opened = SUITE_OPENED.exec(line);
-    if (opened?.[1] !== undefined) {
-      settleAfterCase("after");
-      open = suites.get(opened[1]) ?? { path: opened[1], cases: [], closed: null };
-      suites.set(open.path, open);
-      during = "before";
-      lastCase = null;
-      continue;
-    }
-    const caseLine = CASE_LINE.exec(line);
-    if (caseLine !== null && open !== null) {
-      const name = caseLine[2] ?? "";
-      if (caseLine[3] === "STARTED") {
-        settleAfterCase(lastCase ?? "before");
-        during = name;
-      } else {
-        open.cases.push({
-          name,
-          func: funcOf(name),
-          verdict: caseLine[3] ?? "",
-          seconds: secondsOf(caseLine[4] ?? ""),
-          at
-        });
-        lastCase = name;
-        during = null;
-      }
-      continue;
-    }
-    const statistics = STATISTICS.exec(line);
-    if (statistics !== null && open !== null) {
-      settleAfterCase("after");
-      open.closed = { verdict: statistics[1] ?? "", seconds: secondsOf(statistics[2] ?? "") };
-      open = null;
-      during = null;
-      lastCase = null;
-      continue;
-    }
-    const counted = EXECUTED.exec(line);
-    if (counted?.[1] !== undefined) {
-      executed = Number(counted[1]);
-      continue;
-    }
-    if (LEAK.test(line)) {
-      leaks.push(line.trim());
-      continue;
-    }
-    if (suites.size === 0 && DRIVER_FALLBACK.test(line)) {
-      errors.length = 0;
-      continue;
-    }
-    const error = ERROR_LINE.exec(line);
-    if (error === null) {
-      continue;
-    }
-    const text = error[1] ?? "";
-    if (open === null) {
-      errors.push({ text, at, suite: null, during: null });
-    } else if (during === null) {
-      afterCase.push({ text, at });
-    } else {
-      errors.push({ text, at, suite: open.path, during });
-    }
-  }
-  const last = open;
-  const stoppedIn = last === null ? null : during === null ? `${last.path}, after ${lastCase ?? "its cases"}` : during === "before" ? `${last.path}, in before` : `${last.path} > ${during}`;
-  settleAfterCase("after");
-  const joined = lines.join(`
-`);
-  const starved = STARVED.flatMap((pattern) => [...joined.matchAll(pattern)].map((found) => found[0]));
-  const unloadable = scriptErrorsPrinted(lines).map((error) => `${error.path}${error.line === null ? "" : `:${String(error.line)}`}: ${error.message}`);
-  return { lines, suites, errors, leaks, starved, executed, unloadable, stoppedIn };
-}
-var WINDOWS_EXITS = new Map([
-  [3221225477, "STATUS_ACCESS_VIOLATION"],
-  [3221225495, "STATUS_NO_MEMORY"],
-  [3221225773, "STATUS_COMMITMENT_LIMIT"],
-  [3221225794, "STATUS_DLL_INIT_FAILED"],
-  [3221226505, "STATUS_STACK_BUFFER_OVERRUN"],
-  [3228369022, "a module that could not be found (VcppException)"],
-  [3228369023, "a procedure that could not be found (VcppException)"]
-]);
-var MEMORY_EXITS = new Set([3221225495, 3221225773]);
-function exitNamed(code) {
-  const unsigned = code >>> 0;
-  const name = WINDOWS_EXITS.get(unsigned);
-  return name === undefined ? String(code) : `0x${unsigned.toString(16).toUpperCase()} (${name})`;
-}
-var TAIL = 60;
-var MOST_NAMED = 8;
-function named(items) {
-  const shown = items.slice(0, MOST_NAMED).join(", ");
-  return items.length > MOST_NAMED ? `${shown} and ${String(items.length - MOST_NAMED)} more` : shown;
-}
-function judgeEngine(printed, handed, end) {
-  const faults = [];
-  const failing = new Set;
-  const shownAt = new Set;
-  if (end.ended !== null) {
-    faults.push(end.ended);
-  } else if (end.code !== 0) {
-    faults.push(end.code === null ? `the engine was ended by ${end.signal ?? "a signal"}` : `the engine exited ${exitNamed(end.code)}`);
-  }
-  if (printed.unloadable.length > 0) {
-    faults.push(`gdUnit4 could not load ${named(printed.unloadable)}, so it ran nothing`);
-  }
-  if (printed.executed === null || printed.executed === 0) {
-    faults.push(printed.executed === null ? "the run never printed its summary" : "the run executed no test case at all, whatever it exited with");
-  }
-  for (const { path, cases } of handed.suites) {
-    const suite = printed.suites.get(path);
-    if (suite === undefined) {
-      faults.push(`${path} never started`);
-      failing.add(path);
-      continue;
-    }
-    if (suite.closed === null) {
-      faults.push(`${path} never finished`);
-      failing.add(path);
-    } else if (suite.closed.verdict !== "PASSED") {
-      if (suite.cases.every((ran) => ran.verdict !== "FAILED")) {
-        faults.push(`${path} reported ${suite.closed.verdict} with every case passing, so a hook failed`);
-      }
-      failing.add(path);
-    }
-    const finished = new Set(suite.cases.map((ran) => ran.func));
-    const missing = cases.filter((func) => !finished.has(func));
-    if (missing.length > 0 && suite.closed !== null) {
-      faults.push(`${path} closed without running ${named(missing)}`);
-      failing.add(path);
-    }
-    const wanted = new Set(cases);
-    const unasked = [...finished].filter((func) => !wanted.has(func));
-    if (unasked.length > 0) {
-      faults.push(`${path} ran ${named(unasked)}, which gdharness did not read as cases of it to run here, so its ` + "plan of the cases was wrong");
-      failing.add(path);
-    }
-    for (const ran of suite.cases) {
-      if (ran.verdict === "FAILED" || ran.verdict === "FLAKY") {
-        faults.push(ran.verdict === "FLAKY" ? `${path} > ${ran.name} failed before it passed on a retry` : `${path} > ${ran.name} failed`);
-        failing.add(path);
-        for (let at = ran.at;at < printed.lines.length && (at === ran.at || printed.lines[at]?.trim()); at += 1) {
-          shownAt.add(at);
-        }
-      }
-    }
-  }
-  const unexpected = unexpectedErrors(printed, handed);
-  for (const error of unexpected.printed) {
-    const where = error.suite === null ? "outside every suite" : `in ${error.suite} > ${error.during ?? ""}`;
-    faults.push(`an engine error ${where}: ${error.text}`);
-    if (error.suite !== null) {
-      failing.add(error.suite);
-    }
-    shownAt.add(error.at);
-    shownAt.add(error.at + 1);
-  }
-  for (const missing of unexpected.neverPrinted) {
-    faults.push(`${missing.suite} > ${missing.during} declares the error "${missing.text}", which it never printed`);
-    failing.add(missing.suite);
-  }
-  for (const leak of printed.leaks) {
-    faults.push(`the engine exited holding what it should have freed: ${leak}`);
-  }
-  const memoryExit = end.code !== null && MEMORY_EXITS.has(end.code >>> 0);
-  const starved = memoryExit || printed.starved.length > 0;
-  if (printed.starved.length > 0) {
-    faults.push("the engine ran out of memory");
-  }
-  printed.lines.forEach((line, at) => {
-    if (/^(?:Overall Summary|Executed test|Total execution time| ?Exit code)/.test(line.trim())) {
-      shownAt.add(at);
-    }
-  });
-  const passed = faults.length === 0;
-  const passedSuites = handed.suites.map((suite) => suite.path).filter((path) => !failing.has(path));
-  const cutShort = end.ended !== null || printed.executed === null || handed.suites.some(({ path }) => printed.suites.get(path)?.closed == null);
-  return {
-    passed,
-    faults,
-    passedSuites,
-    starved,
-    shown: passed ? [] : linesShown(printed.lines, shownAt, cutShort)
-  };
-}
-function linesShown(lines, picked, cutShort) {
-  const summary = [...picked].filter((at) => at < lines.length).sort((a, b) => a - b);
-  const telling = summary.some((at) => !/^(?:Overall Summary|Executed test|Total execution|\s*Exit code)/.test(lines[at]?.trim() ?? ""));
-  if (!telling && !cutShort) {
-    return [];
-  }
-  if (!telling) {
-    return lines.slice(Math.max(0, lines.length - TAIL)).filter((line, at, all) => at < all.length - 1 || line !== "");
-  }
-  const shown = [];
-  let previous = -1;
-  for (const at of summary) {
-    if (previous >= 0 && at > previous + 1) {
-      shown.push("...");
-    }
-    shown.push(lines[at] ?? "");
-    previous = at;
-  }
-  return shown;
-}
-function unexpectedErrors(printed, handed) {
-  const owed = new Map;
-  for (const { path } of handed.suites) {
-    const suite = printed.suites.get(path);
-    const declared = handed.expected[path];
-    if (suite === undefined || declared === undefined) {
-      continue;
-    }
-    const ranHooks = suite.closed === null ? ["before"] : ["before", "after"];
-    for (const during of [...ranHooks, ...suite.cases.map((ran) => ran.name)]) {
-      const texts = declared[funcOf(during)];
-      if (Array.isArray(texts) && texts.length > 0) {
-        owed.set(`${path}
-${during}`, {
-          suite: path,
-          during,
-          texts: texts.map((text) => String(text))
-        });
-      }
-    }
-  }
-  const unexpected = [];
-  for (const error of printed.errors) {
-    const debt = error.suite === null || error.during === null ? undefined : owed.get(`${error.suite}
-${error.during}`);
-    const index = debt?.texts.indexOf(error.text) ?? -1;
-    if (debt === undefined || index < 0) {
-      unexpected.push(error);
-    } else {
-      debt.texts.splice(index, 1);
-    }
-  }
-  const neverPrinted = [...owed.values()].flatMap((debt) => debt.texts.map((text) => ({ suite: debt.suite, during: debt.during, text })));
-  return { printed: unexpected, neverPrinted };
-}
-
-// src/suite-plan.ts
-init_class_cache();
-init_gdscript_source();
-init_whole_file();
-import { existsSync as existsSync17, mkdirSync as mkdirSync7, readFileSync as readFileSync15 } from "node:fs";
-import { dirname as dirname10, posix as posix3 } from "node:path";
-var SUITE_BASE = "GdUnitTestSuite";
-var CASE_PREFIX = "test_";
-var NEEDS_WINDOW = /^const\s+GDHARNESS_NEEDS_WINDOW\b[^=\n]*=\s*true\b/m;
-var SCENE_RUNNER = /\bscene_runner\s*\(/;
-
-class ProjectScripts {
-  sources = new Map;
-  classes = new Map;
-  read = new Map;
-  projectPath;
-  constructor(projectPath) {
-    this.projectPath = projectPath;
-    eachScript(projectPath, (script, source) => {
-      this.sources.set(script, source);
-      const declared = declaredClassOf(source);
-      if (declared !== null) {
-        this.classes.set(declared, script);
-      }
-    });
-  }
-  script(path) {
-    const known = this.read.get(path);
-    if (known !== undefined) {
-      return known;
-    }
-    const source = this.sources.get(path);
-    if (source === undefined) {
-      return;
-    }
-    const shape = shapeOf(source);
-    const read = {
-      source,
-      extendsAs: shape.body.extendsAs,
-      funcs: shape.body.declarations.filter((d) => d.kind === "func").map((d) => d.name),
-      code: codeOf(source)
-    };
-    this.read.set(path, read);
-    return read;
-  }
-  base(path) {
-    const extendsAs = this.script(path)?.extendsAs ?? null;
-    if (extendsAs === null) {
-      return null;
-    }
-    const quote = extendsAs[0];
-    if (quote === '"' || quote === "'") {
-      const target = extendsAs.slice(1, -1);
-      return {
-        path: target.startsWith("res://") ? target : `res://${posix3.join(posix3.dirname(path.slice(6)), target)}`
-      };
-    }
-    const name = extendsAs.split(".")[0] ?? extendsAs;
-    const declaring = this.classes.get(name);
-    return declaring === undefined ? { name } : { path: declaring };
-  }
-  suite(path) {
-    const cases = new Set;
-    let windowed = false;
-    const seen = new Set;
-    let at = path;
-    while (!seen.has(at)) {
-      seen.add(at);
-      const read = this.script(at);
-      if (read === undefined) {
-        return null;
-      }
-      for (const func of read.funcs.filter((name) => name.startsWith(CASE_PREFIX))) {
-        cases.add(func);
-      }
-      windowed ||= NEEDS_WINDOW.test(read.code) || SCENE_RUNNER.test(read.code);
-      const base = this.base(at);
-      if (base === null) {
-        return null;
-      }
-      if ("name" in base ? base.name === SUITE_BASE : base.path === this.classes.get(SUITE_BASE)) {
-        return cases.size > 0 ? { path, cases: [...cases].sort(), windowed } : null;
-      }
-      if ("name" in base) {
-        return null;
-      }
-      at = base.path;
-    }
-    return null;
-  }
-  suitesUnder(roots) {
-    const prefixes = roots.map((root) => root.endsWith("/") ? root : `${root}/`);
-    return [...this.sources.keys()].filter((path) => prefixes.some((prefix) => path.startsWith(prefix))).sort().flatMap((path) => this.suite(path) ?? []);
-  }
-}
-function readTimes(file) {
-  try {
-    const parsed = JSON.parse(readFileSync15(file, "utf8"));
-    return typeof parsed === "object" && parsed !== null ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-function writeJson(file, value) {
-  mkdirSync7(dirname10(file), { recursive: true });
-  writeWhole(file, `${JSON.stringify(value, null, 1)}
-`);
-}
-function timesAfter(times, suites, runs) {
-  const next = { ...times };
-  const declared = new Map(suites.map((suite) => [suite.path, suite]));
-  const measured = new Map;
-  for (const run of runs) {
-    for (const printed of run.suites.values()) {
-      if (printed.closed === null || !declared.has(printed.path)) {
-        continue;
-      }
-      const entry = measured.get(printed.path) ?? { cases: new Map, around: 0 };
-      const own = new Map;
-      for (const ran of printed.cases) {
-        own.set(ran.func, (own.get(ran.func) ?? 0) + ran.seconds);
-      }
-      const inCases = [...own.values()].reduce((sum, seconds) => sum + seconds, 0);
-      entry.around = Math.max(entry.around, printed.closed.seconds - inCases);
-      for (const [func, seconds] of own) {
-        entry.cases.set(func, seconds);
-      }
-      measured.set(printed.path, entry);
-    }
-  }
-  for (const [path, entry] of measured) {
-    const suite = declared.get(path);
-    const cases = {};
-    for (const func of suite?.cases ?? []) {
-      const seconds = entry.cases.get(func) ?? times[path]?.cases[func];
-      if (seconds !== undefined) {
-        cases[func] = round(seconds);
-      }
-    }
-    const inCases = Object.values(cases).reduce((sum, seconds) => sum + seconds, 0);
-    next[path] = { seconds: round(entry.around + inCases), cases };
-  }
-  return next;
-}
-function round(seconds) {
-  return Math.round(seconds * 1000) / 1000;
-}
-var UNTIMED_CASE = 0.02;
-var SPLIT_PAST_SECONDS = 10;
-var ENGINE_START_SECONDS = 5;
-function median(values) {
-  if (values.length === 0) {
-    return;
-  }
-  const sorted = [...values].sort((a, b) => a - b);
-  const middle = Math.floor(sorted.length / 2);
-  return sorted.length % 2 === 1 ? sorted[middle] : ((sorted[middle - 1] ?? 0) + (sorted[middle] ?? 0)) / 2;
-}
-function unitsOf(suites, times, splitPast = SPLIT_PAST_SECONDS) {
-  const known = Object.values(times);
-  const caseCost = median(known.flatMap((time) => Object.values(time.cases))) ?? UNTIMED_CASE;
-  const aroundCost = median(known.map((time) => time.seconds - Object.values(time.cases).reduce((sum, s) => sum + s, 0))) ?? 0;
-  return suites.flatMap((suite) => {
-    const time = times[suite.path];
-    const costOf = (func) => time?.cases[func] ?? caseCost;
-    const around = time === undefined ? aroundCost : Math.max(0, time.seconds - Object.values(time.cases).reduce((sum, s) => sum + s, 0));
-    const whole = around + suite.cases.reduce((sum, func) => sum + costOf(func), 0);
-    if (suite.windowed || whole <= splitPast || suite.cases.length < 2) {
-      return [{ suite: suite.path, cases: suite.cases, cost: whole, windowed: suite.windowed }];
-    }
-    return suite.cases.map((func) => ({
-      suite: suite.path,
-      cases: [func],
-      cost: around + costOf(func),
-      windowed: false
-    }));
-  });
-}
-function dealt(units, declared, most) {
-  const windowed = units.filter((unit) => unit.windowed);
-  const headless = units.filter((unit) => !unit.windowed).sort((a, b) => b.cost - a.cost || a.suite.localeCompare(b.suite) || (a.cases[0] ?? "").localeCompare(b.cases[0] ?? ""));
-  const total = headless.reduce((sum, unit) => sum + unit.cost, 0);
-  const slowest = headless[0]?.cost ?? 0;
-  const room = Math.max(1, most - (windowed.length > 0 && most > 1 ? 1 : 0));
-  const count = headless.length === 0 ? 0 : Math.max(1, Math.min(room, headless.length, Math.ceil(total / Math.max(slowest, ENGINE_START_SECONDS))));
-  const bins = Array.from({ length: count }, () => []);
-  const loads = Array.from({ length: count }, () => 0);
-  for (const unit of headless) {
-    const lightest = loads.indexOf(Math.min(...loads));
-    bins[lightest]?.push(unit);
-    loads[lightest] = (loads[lightest] ?? 0) + unit.cost;
-  }
-  const plans = bins.map((bin) => planOf(bin, declared, false));
-  return windowed.length > 0 ? [planOf(windowed, declared, true), ...plans] : plans;
-}
-function inOneEngine(units, declared) {
-  return planOf(units, declared, units.some((unit) => unit.windowed));
-}
-function planOf(bin, declared, windowed) {
-  const held = new Map;
-  for (const unit of bin) {
-    held.set(unit.suite, [...held.get(unit.suite) ?? [], ...unit.cases]);
-  }
-  const skipping = [...held].flatMap(([path, cases]) => (declared.get(path) ?? []).filter((func) => !cases.includes(func)).map((func) => `${path}:${func}`));
-  return {
-    suites: [...held].map(([path, cases]) => ({ path, cases: [...cases].sort() })),
-    skipping,
-    cost: bin.reduce((sum, unit) => sum + unit.cost, 0),
-    windowed
-  };
-}
-function viewportOf(projectPath) {
-  const file = `${projectPath}/project.godot`;
-  if (!existsSync17(file)) {
-    return null;
-  }
-  const text = readFileSync15(file, "utf8");
-  const width = /^window\/size\/viewport_width\s*=\s*(\d+)/m.exec(text)?.[1];
-  const height = /^window\/size\/viewport_height\s*=\s*(\d+)/m.exec(text)?.[1];
-  return width === undefined || height === undefined ? null : { width: Number(width), height: Number(height) };
-}
+// src/suite-run.ts
+init_suite_judge();
+init_suite_plan();
 
 // src/version.ts
-import { readFileSync as readFileSync16 } from "node:fs";
-import { dirname as dirname11, join as join20 } from "node:path";
+import { readFileSync as readFileSync18 } from "node:fs";
+import { dirname as dirname11, join as join21 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getLocalVersion() {
   const currentDirectory = dirname11(fileURLToPath2(import.meta.url));
   const packageCandidates = [
-    join20(currentDirectory, "..", "package.json"),
-    join20(currentDirectory, "..", "..", "package.json")
+    join21(currentDirectory, "..", "package.json"),
+    join21(currentDirectory, "..", "..", "package.json")
   ];
   for (const packagePath of packageCandidates) {
     try {
-      const value = JSON.parse(readFileSync16(packagePath, "utf-8"));
+      const value = JSON.parse(readFileSync18(packagePath, "utf-8"));
       if (typeof value === "object" && value !== null && "name" in value && value.name === "gdharness" && "version" in value && typeof value.version === "string") {
         return value.version;
       }
@@ -55357,9 +55557,9 @@ function testOptionsOf(args, cwd) {
   }
   const first = positional[0];
   const named = first === undefined ? null : resolve4(cwd, first);
-  const projectNamed = named !== null && existsSync18(join21(named, "project.godot"));
+  const projectNamed = named !== null && existsSync19(join22(named, "project.godot"));
   const projectPath = projectNamed ? named : resolve4(cwd);
-  if (!existsSync18(join21(projectPath, "project.godot"))) {
+  if (!existsSync19(join22(projectPath, "project.godot"))) {
     throw new TestUsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   const last = (flag) => valued.get(flag)?.at(-1);
@@ -55402,7 +55602,8 @@ function resPathOf(entry, projectPath, cwd) {
   const caseAt = /^(.*\.gd):(\w+)$/.exec(entry);
   const file = caseAt?.[1] ?? entry;
   const fromProject = resolve4(projectPath, file);
-  const absolute = isAbsolute4(file) || !existsSync18(fromProject) ? resolve4(cwd, file) : fromProject;
+  const fromHere = resolve4(cwd, file);
+  const absolute = isAbsolute4(file) || !existsSync19(fromProject) && existsSync19(fromHere) ? fromHere : fromProject;
   const inside = relative3(projectPath, absolute);
   if (inside.startsWith("..") || isAbsolute4(inside)) {
     throw new TestUsageError(`${entry} is not inside the project at ${projectPath}.`);
@@ -55414,7 +55615,7 @@ function homeOf(projectPath) {
   return mainCheckoutOf(projectPath) ?? projectPath;
 }
 function selectedSuites(scripts, options) {
-  const roots = options.roots.length > 0 ? options.roots : ["res://tests", "res://test"].filter((root) => existsSync18(join21(options.projectPath, root.slice(6))));
+  const roots = options.roots.length > 0 ? options.roots : TEST_DIRECTORIES.filter((root) => existsSync19(join22(options.projectPath, root))).map((root) => `res://${root}`);
   if (options.selected.length === 0) {
     const found = scripts.suitesUnder(roots);
     if (found.length === 0) {
@@ -55426,10 +55627,10 @@ function selectedSuites(scripts, options) {
   for (const entry of options.selected) {
     const caseAt = /^(res:\/\/.*\.gd):(\w+)$/.exec(entry);
     const path = caseAt?.[1] ?? entry;
-    const directory = join21(options.projectPath, path.slice(6));
-    const suites = existsSync18(directory) && statSync11(directory).isDirectory() ? scripts.suitesUnder([path.replace(/\/$/, "")]) : [scripts.suite(path)].filter((suite) => suite !== null);
+    const directory = join22(options.projectPath, path.slice(6));
+    const suites = existsSync19(directory) && statSync12(directory).isDirectory() ? scripts.suitesUnder([path.replace(/\/$/, "")]) : [scripts.suite(path)].filter((suite) => suite !== null);
     if (suites.length === 0) {
-      throw new TestUsageError(existsSync18(directory) ? `${path} holds no gdUnit4 suite: nothing there extends GdUnitTestSuite and declares a test_ function.` : `Nothing at ${path}.`);
+      throw new TestUsageError(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}.`);
     }
     for (const suite of suites) {
       const picked = chosen.get(suite.path) ?? { suite, cases: new Set };
@@ -55448,9 +55649,32 @@ function selectedSuites(scripts, options) {
     cases: suite.cases.filter((c) => cases.has(c))
   }));
 }
-function roomFor(most) {
-  const byMemory = Math.floor((freemem() - MEMORY_KEPT) / MEMORY_PER_ENGINE);
-  return Math.max(1, Math.min(most, availableParallelism(), byMemory));
+function roomFor(most, processors, available) {
+  const byMemory = Math.floor((available - MEMORY_KEPT) / MEMORY_PER_ENGINE);
+  const engines = Math.max(1, Math.min(most, processors, byMemory));
+  if (engines >= most) {
+    return { engines, held: undefined };
+  }
+  const gigabytes = (bytes) => `${(bytes / 1024 ** 3).toFixed(1)} GB`;
+  return {
+    engines,
+    held: byMemory < processors ? `the machine has ${gigabytes(Math.max(0, available))} of memory free, ${gigabytes(MEMORY_KEPT)} of it kept for everything else and ${gigabytes(MEMORY_PER_ENGINE)} taken for each engine` : `the machine has ${plural(processors, "processor")}`
+  };
+}
+async function memoryAvailable() {
+  const level = await macMemoryLevel();
+  return level === null ? freemem() : totalmem() * level / 100;
+}
+async function macMemoryLevel() {
+  if (process12.platform !== "darwin") {
+    return null;
+  }
+  try {
+    const level = Number((await runHidden("sysctl", ["-n", "kern.memorystatus_level"])).stdout.trim());
+    return Number.isFinite(level) && level > 0 && level <= 100 ? level : null;
+  } catch {
+    return null;
+  }
 }
 function ordered(units, order) {
   const sorted = [...units].sort((a, b) => a.suite.localeCompare(b.suite));
@@ -55483,17 +55707,17 @@ async function runTestCommand(options, godotPath) {
   const startedAt = Date.now();
   const scripts = new ProjectScripts(options.projectPath);
   const home = homeOf(options.projectPath);
-  const state = join21(home, ".godot", "gdharness");
-  const timesFile = join21(state, "suite-times.json");
-  const passedFile = join21(state, "suite-passed.json");
+  const state = join22(home, ".godot", "gdharness");
+  const timesFile = join22(state, "suite-times.json");
+  const passedFile = join22(state, "suite-passed.json");
   let suites = selectedSuites(scripts, options);
   const wholeSuites = suites.map((suite) => scripts.suite(suite.path) ?? suite);
   const declared = new Map(wholeSuites.map((suite) => [suite.path, suite.cases]));
-  const testRuns = join21(options.projectPath, ".godot", "gdharness", "test-runs");
+  const testRuns = join22(options.projectPath, ".godot", "gdharness", "test-runs");
   sweepRunDirectories(testRuns);
-  const runDirectory = join21(testRuns, `${String(startedAt)}-${String(process12.pid)}`);
+  const runDirectory = join22(testRuns, `${String(startedAt)}-${String(process12.pid)}`);
   mkdirSync8(runDirectory, { recursive: true });
-  const slots = new EngineSlots(options.slotsDirectory ?? join21(home, ".godot", "gate", "slots"), options.slotCount ?? Math.min(MOST_ENGINES, availableParallelism()), { pid: process12.pid, started: await ownStart() });
+  const slots = new EngineSlots(options.slotsDirectory ?? join22(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) {
@@ -55522,9 +55746,9 @@ async function runTestCommand(options, godotPath) {
     }
     const fingerprints = new SuiteFingerprints(scripts, [
       getLocalVersion(),
-      readFileSync17(shippedListedRunner(), "utf8"),
+      readFileSync19(shippedListedRunner(), "utf8"),
       ...options.reachAlso.map((path) => `${path}
-${existsSync18(path) ? readFileSync17(path, "latin1") : "missing"}`)
+${existsSync19(path) ? readFileSync19(path, "latin1") : "missing"}`)
     ]);
     const printsOf = new Map(suites.map((suite) => [suite.path, fingerprints.of(suite)]));
     if (options.changedOnly) {
@@ -55535,7 +55759,7 @@ ${existsSync18(path) ? readFileSync17(path, "latin1") : "missing"}`)
       });
       suites = suites.filter((suite) => !unchanged.includes(suite));
       if (unchanged.length > 0) {
-        console.log(`${plural(unchanged.length, "suite")} passed with everything ${unchanged.length === 1 ? "it reaches" : "they reach"} as it stands now, and ${unchanged.length === 1 ? "is" : "are"} not run.`);
+        console.log(`${plural(unchanged.length, "suite")} passed with everything ${unchanged.length === 1 ? "it reaches" : "they reach"} as it stands now, and ${unchanged.length === 1 ? "is" : "are"} not run: ${named(unchanged.map((suite) => suite.path))}.`);
       }
       if (suites.length === 0) {
         console.log("Nothing has changed since every suite last passed.");
@@ -55545,9 +55769,16 @@ ${existsSync18(path) ? readFileSync17(path, "latin1") : "missing"}`)
     }
     const times = readTimes(timesFile);
     const units = unitsOf(suites, times);
-    const plans = options.order === null ? dealt(units, declared, roomFor(options.engines)) : [inOneEngine(ordered(units, options.order), declared)];
+    const room = roomFor(options.engines, availableParallelism(), await memoryAvailable());
+    const plans = options.order === null ? dealt(units, declared, room.engines) : [inOneEngine(ordered(units, options.order), declared)];
     const functions = suites.reduce((sum, suite) => sum + suite.cases.length, 0);
-    console.log(`${plural(functions, "test function")} in ${plural(suites.length, "suite")} over ${plural(plans.length, "engine")}${plans.some((plan) => plan.windowed) ? ", one of them windowed" : ""}.`);
+    const held = options.order === null && room.held !== undefined && plans.length === room.engines ? `, of the ${String(options.engines)} asked for, since ${room.held}` : "";
+    const how = options.order === null ? `${windowedSaid(plans)}${held}` : options.order === "reversed" ? ", in reverse order of path" : `, shuffled by ${String(options.order)}`;
+    console.log(`${plural(functions, "test function")} in ${plural(suites.length, "suite")} over ${plural(plans.length, "engine")}${how}.`);
+    const split = [...new Set(units.map((unit) => unit.suite))].filter((path) => units.filter((unit) => unit.suite === path).length > 1);
+    if (plans.length > 1 && split.length > 0) {
+      console.log(`Dealt out case by case, since ${split.length === 1 ? "it" : "each"} took more than ${String(SPLIT_PAST_SECONDS)} s last time: ${named(split)}.`);
+    }
     let ran = await Promise.all(plans.map((plan, index) => runEngine2(launch, plan, index, units)));
     if (ran.some((engine) => engine.verdict.starved) && ran.some((engine) => !engine.verdict.passed)) {
       console.log("An engine ran out of memory, so every engine that failed runs again, one at a time.");
@@ -55570,7 +55801,7 @@ function plural(count, noun) {
 }
 function readRecord(file) {
   try {
-    const parsed = JSON.parse(readFileSync17(file, "utf8"));
+    const parsed = JSON.parse(readFileSync19(file, "utf8"));
     return typeof parsed === "object" && parsed !== null ? parsed : {};
   } catch {
     return {};
@@ -55597,20 +55828,20 @@ function recordPassed(file, ran, printsOf) {
   writeJson(file, passed);
 }
 function sweepRunDirectories(testRuns) {
-  if (!existsSync18(testRuns)) {
+  if (!existsSync19(testRuns)) {
     return;
   }
-  for (const entry of readdirSync11(testRuns)) {
+  for (const entry of readdirSync12(testRuns)) {
     const pid = Number(/^\d+-(\d+)$/.exec(entry)?.[1]);
     if (!Number.isInteger(pid) || !alive(pid)) {
-      rmSync10(join21(testRuns, entry), { recursive: true, force: true });
+      rmSync10(join22(testRuns, entry), { recursive: true, force: true });
     }
   }
 }
 async function importProject(launch) {
-  const directory = join21(launch.runDirectory, "import");
-  mkdirSync8(join21(directory, "user"), { recursive: true });
-  const log = join21(directory, "import.log");
+  const directory = join22(launch.runDirectory, "import");
+  mkdirSync8(join22(directory, "user"), { recursive: true });
+  const log = join22(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);
@@ -55623,11 +55854,11 @@ async function importProject(launch) {
   }
 }
 async function runEngine2(launch, plan, index, units, again = "") {
-  const directory = join21(launch.runDirectory, `engine-${String(index)}${again === "" ? "" : `-${again}`}`);
-  mkdirSync8(join21(directory, "user"), { recursive: true });
-  const suitesFile = join21(directory, "suites.txt");
-  const skippingFile = join21(directory, "skipping.txt");
-  const expectedFile = join21(directory, "expected.json");
+  const directory = join22(launch.runDirectory, `engine-${String(index)}${again === "" ? "" : `-${again}`}`);
+  mkdirSync8(join22(directory, "user"), { recursive: true });
+  const suitesFile = join22(directory, "suites.txt");
+  const skippingFile = join22(directory, "skipping.txt");
+  const expectedFile = join22(directory, "expected.json");
   writeFileSync10(suitesFile, `${plan.suites.map((suite) => suite.path).join(`
 `)}
 `);
@@ -55647,7 +55878,7 @@ async function runEngine2(launch, plan, index, units, again = "") {
     ...plan.windowed ? [] : ["--ignoreHeadlessMode"],
     "-c",
     "-rd",
-    `res://${relative3(launch.projectPath, join21(directory, "reports")).split(sep2).join("/")}`,
+    `res://${relative3(launch.projectPath, join22(directory, "reports")).split(sep2).join("/")}`,
     "-rc",
     "1",
     "--",
@@ -55664,7 +55895,7 @@ async function runEngine2(launch, plan, index, units, again = "") {
   const held = new Set(plan.suites.map((suite) => suite.path));
   const slowest = Math.max(0, ...units.filter((unit) => held.has(unit.suite)).map((unit) => unit.cost));
   const silence = Math.max(launch.silenceFloorSeconds, SILENCE_TIMES_SLOWEST * slowest);
-  const log = join21(directory, "engine.log");
+  const log = join22(directory, "engine.log");
   const lock = await launch.slots.take();
   const began = Date.now();
   let end;
@@ -55673,7 +55904,7 @@ async function runEngine2(launch, plan, index, units, again = "") {
   } finally {
     launch.slots.release(lock);
   }
-  const printed = readRun(readFileSync17(log, "utf8"));
+  const printed = readRun(readFileSync19(log, "utf8"));
   const assignment = { suites: plan.suites, expected: readExpected(expectedFile) };
   return {
     index,
@@ -55684,16 +55915,8 @@ async function runEngine2(launch, plan, index, units, again = "") {
     seconds: (Date.now() - began) / 1000
   };
 }
-function readExpected(file) {
-  try {
-    const parsed = JSON.parse(readFileSync17(file, "utf8"));
-    return typeof parsed === "object" && parsed !== null ? parsed : {};
-  } catch {
-    return {};
-  }
-}
 async function watched(launch, args, directory, log, windowed, silenceSeconds) {
-  const user = join21(directory, "user");
+  const user = join22(directory, "user");
   const env = { ...process12.env, APPDATA: user, XDG_DATA_HOME: user };
   const output = openSync3(log, "w");
   let child;
@@ -55705,12 +55928,12 @@ async function watched(launch, args, directory, log, windowed, silenceSeconds) {
         const how = windowed ? "on a desktop of its own" : "through the desktop helper";
         return { code: null, signal: null, ended: `the engine could not be started ${how}: ${compiled}` };
       }
-      const stopFile = join21(directory, "stop");
+      const stopFile = join22(directory, "stop");
       const how = windowed ? { desktop: HIDDEN_DESKTOP, directory: launch.projectPath } : { directory: launch.projectPath };
       const wrapper = throughHelper(how, launch.godotPath, args, {
-        spec: join21(directory, "spec.json"),
-        pid: join21(directory, "pid"),
-        error: join21(directory, "error"),
+        spec: join22(directory, "spec.json"),
+        pid: join22(directory, "pid"),
+        error: join22(directory, "error"),
         stop: stopFile
       });
       child = spawnHidden(wrapper.command, wrapper.args, {
@@ -55813,12 +56036,17 @@ function report(ran, startedAt, runDirectory) {
   const suites = new Set(ran.flatMap((engine) => engine.plan.suites.map((suite) => suite.path))).size;
   const longest = Math.max(0, ...ran.map((engine) => engine.seconds));
   const took = (Date.now() - startedAt) / 1000;
+  const totals = `${plural(cases, "case")} in ${plural(suites, "suite")} across ${plural(ran.length, "engine")}, ${took.toFixed(1)} s; the longest engine took ${longest.toFixed(1)} s.`;
+  console.log("");
   if (failed.length === 0) {
     rmSync10(runDirectory, { recursive: true, force: true });
+    console.log(`Passed: ${totals}`);
+    return 0;
   }
-  console.log("");
-  console.log(`${failed.length === 0 ? "Passed" : "Failed"}: ${plural(cases, "case")} in ${plural(suites, "suite")} across ${plural(ran.length, "engine")}, ${took.toFixed(1)} s; the longest engine took ${longest.toFixed(1)} s.`);
-  return failed.length === 0 ? 0 : 1;
+  const problems = failed.reduce((sum, engine) => sum + engine.verdict.faults.length, 0);
+  console.log(`Failed: ${plural(problems, "problem")}, listed above. Ran ${totals}`);
+  console.log(`Every engine's output is kept under ${runDirectory} until the next run.`);
+  return 1;
 }
 
 // src/cli.ts