gdharness 1.1.46 → 1.1.48

package/build/cli.js

@@ -7819,11 +7819,14 @@ function dictionary(entries) {
 
 // src/call-signal.ts
 import { AsyncLocalStorage } from "node:async_hooks";
-function withCallSignal(signal, answer) {
-  return signal === undefined ? answer() : current.run(signal, answer);
+function withCallSignal(signal, answer, progress) {
+  return signal === undefined && progress === undefined ? answer() : current.run({ signal, progress }, answer);
 }
 function callSignal() {
-  return current.getStore();
+  return current.getStore()?.signal;
+}
+function callProgress() {
+  return current.getStore()?.progress;
 }
 var current;
 var init_call_signal = __esm(() => {
@@ -17588,7 +17591,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "project_test",
-      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found, 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. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A 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. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. Needs gdUnit4 under addons/gdUnit4.",
+      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines. The class list is rebuilt first, so a suite written a moment ago is found, 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. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A 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. A client that sends a progress token is told as each suite finishes, and at least every twenty seconds through a long one, so an idle limit does not end a long tier. 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. Needs gdUnit4 under addons/gdUnit4.",
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
@@ -18158,7 +18161,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["find"],
-          description: 'find: part of what the node has written on it as drawn, the way the text op reads it, case-insensitively, which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern, and a glob that finds nothing says under note how many nodes it would find open at both ends. A label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Alternatives separated by | match when any one of them does, each by these rules ("*won*|*lost*"); write \\| for a bar that is part of the words.'
+          description: 'find: part of what the node has written on it as drawn, the way the text op reads it, case-insensitively and with a typed space matching any space the game draws (a non-breaking one included), which is how a button is reached by the word on it rather than by a generated path. Its own text, so a row is found by the label in it, and hidden nodes match. A bare word is a contains; write a glob and it is one, matched against the whole of what the node says, the same as namePattern, and a glob that finds nothing says under note how many nodes it would find open at both ends. A label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Alternatives separated by | match when any one of them does, each by these rules ("*won*|*lost*"); write \\| for a bar that is part of the words.'
         },
         limit: {
           type: "integer",
@@ -18336,7 +18339,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["click"],
-          description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it, and | separates alternatives), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. A control with something drawn over its centre that would take the pointer, such as a screen shown over it or a dialog stacked above its own, is not on screen; nor is one on a hidden canvas layer, one outside the viewport, or one a container clips away that a click does not scroll. The refusal counts those apart. The matches are ranked the way a person picks what to press: an enabled button before anything else, a disabled one included, then a control whose whole text, or one whole line of it such as the title on a card, is the words before one saying them as part of more, and the best one is pressed; found.picked says why. Several matches at the best rank are refused with each one listed, and index picks one. A match saying the words only as part of more is named under found.partOf, and is refused when a control saying exactly the words is hidden, off the screen or covered, since it would stand in for that one; index presses it anyway. An empty field says its placeholder. An item of an open menu is drawn by the menu rather than held as a control, so a click finds none, and the refusal names the menu and the choose call that picks it."
+          description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it, and | separates alternatives), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. A control with something drawn over its centre that would take the pointer, such as a screen shown over it or a dialog stacked above its own, is not on screen; nor is one on a hidden canvas layer, one outside the viewport, or one a container clips away that a click does not scroll. The refusal counts those apart. The matches are ranked the way a person picks what to press: an enabled button before anything else, a disabled one included, then a control whose whole text, or one whole line of it such as the title on a card, is the words before one saying them as part of more, and the best one is pressed; found.picked says why. Several matches at the best rank are refused with each one listed, and index picks one. A match saying the words only as part of more is named under found.partOf, and is refused when another control says exactly the words (hidden, off the screen, covered, or on screen taking clicks without being a button), since it would stand in for that one, and when it lets the pointer through to what is under it; index presses it anyway. Words found only inside longer words (\"out\" in \"Scout\") rank after every other match and are refused unless index is given; words starting a longer word (\"Recruit\" in \"Recruits\") count. An empty field says its placeholder, and a control with no text of its own, a picture on a button, says its accessibility name. An item of an open menu is drawn by the menu rather than held as a control, so a click finds none, and the refusal names the menu and the choose call that picks it."
         },
         action: {
           type: "string",
@@ -18413,7 +18416,7 @@ var init_tool_definitions = __esm(() => {
       requires: [],
       operations: {
         click: {
-          summary: `press and release on a Control, a frame apart, and answer with what was under the pointer and what became of the control: in_tree, removed or freed. The control is named by nodePath, or by says with the words on it, found under nodePath when both are given, and the answer then says under found which match it was. Words that are part of a RichTextLabel are pressed where they are drawn rather than at the label's middle, so a link among them is the one pressed: found.pressedOn says "the words", or "the middle of the label" with a note saying why they could not be placed, and link_pressed names the meta the label reports clicked. A control out of sight inside a ScrollContainer is scrolled to first, each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A disabled button, and a control that does not process (the game paused, say), are refused: the pointer reaches them and the press does nothing. A 3D node is clicked where it is drawn, and landed then 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`,
+          summary: `press and release on a Control, a frame apart, and answer with what was under the pointer and what became of the control: in_tree, removed or freed. The control is named by nodePath, or by says with the words on it, found under nodePath when both are given, and the answer then says under found which match it was. Words that are part of a RichTextLabel are pressed where they are drawn rather than at the label's middle, so a link among them is the one pressed: found.pressedOn says "the words", or "the middle of the label" with a note saying why they could not be placed, and 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 out of sight inside a ScrollContainer is scrolled to first, each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A disabled button, and a control that does not process (the game paused, say), are refused: the pointer reaches them and the press does nothing. A 3D node is clicked where it is drawn, and landed then 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`,
           requires: []
         },
         choose: {
@@ -34035,6 +34038,42 @@ var init_config_pin = __esm(() => {
   PINNED = /\bgdharness@(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)\b/g;
 });
 
+// src/cut-test-run.ts
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, readFileSync as readFileSync16, rmSync as rmSync8, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname12, join as join18 } from "node:path";
+function keptAt(projectPath) {
+  return join18(projectPath, ".godot", "gdharness-reports", "cut-run.json");
+}
+function keepCutTestRun(projectPath, run) {
+  const path = keptAt(projectPath);
+  try {
+    mkdirSync9(dirname12(path), { recursive: true });
+    writeFileSync11(path, `${JSON.stringify(run, null, 2)}
+`, "utf8");
+  } catch {}
+}
+function takeCutTestRun(projectPath) {
+  const path = keptAt(projectPath);
+  if (!existsSync14(path)) {
+    return null;
+  }
+  try {
+    const run = JSON.parse(readFileSync16(path, "utf8"));
+    rmSync8(path, { force: true });
+    return typeof run.cutAt === "string" && Array.isArray(run.paths) && run.paths.every((path) => typeof path === "string") ? run : null;
+  } catch {
+    rmSync8(path, { force: true });
+    return null;
+  }
+}
+function cutTestRunNote(run) {
+  const finished = run.suitesFinished?.length ?? 0;
+  const failing = run.suitesFailing?.length ?? 0;
+  const got = finished === 0 ? "before any suite had finished" : `after ${finished === 1 ? "one suite" : `${finished} suites`} had finished${failing === 0 ? "" : finished === 1 ? ", with failures" : `, ${failing} of them with failures`}`;
+  return `The test run before this one in this project, of ${run.paths.join(", ")}, was cut off by its client at ${run.cutAt} ${got}${run.suiteRunning === undefined ? "" : `, while ${run.suiteRunning} was running`}; what it finished is under previousRunCut.`;
+}
+var init_cut_test_run = () => {};
+
 // src/framing.ts
 function frame(message) {
   const body = Buffer.from(JSON.stringify(message), "utf8");
@@ -34823,25 +34862,25 @@ var init_desktop = () => {};
 // src/editor-log.ts
 import {
   closeSync,
-  existsSync as existsSync14,
-  mkdirSync as mkdirSync9,
+  existsSync as existsSync15,
+  mkdirSync as mkdirSync10,
   openSync,
-  readFileSync as readFileSync16,
+  readFileSync as readFileSync17,
   readSync,
-  rmSync as rmSync8,
+  rmSync as rmSync9,
   statSync as statSync7,
-  writeFileSync as writeFileSync11
+  writeFileSync as writeFileSync12
 } from "node:fs";
-import { dirname as dirname12, join as join18 } from "node:path";
+import { dirname as dirname13, join as join19 } from "node:path";
 function editorLogPath(projectPath) {
-  return join18(projectPath, ".godot", "gdharness-editor.log");
+  return join19(projectPath, ".godot", "gdharness-editor.log");
 }
 function editorLogNotePath(projectPath) {
-  return join18(projectPath, ".godot", "gdharness-editor.json");
+  return join19(projectPath, ".godot", "gdharness-editor.json");
 }
 function readEditorLogNote(projectPath) {
   try {
-    const fields = asParams(JSON.parse(readFileSync16(editorLogNotePath(projectPath), "utf8")));
+    const fields = asParams(JSON.parse(readFileSync17(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;
@@ -34852,16 +34891,16 @@ function readEditorLogNote(projectPath) {
 function clearEditorLog(projectPath) {
   try {
     const path = editorLogPath(projectPath);
-    mkdirSync9(dirname12(path), { recursive: true });
-    rmSync8(path, { force: true });
-    rmSync8(editorLogNotePath(projectPath), { force: true });
+    mkdirSync10(dirname13(path), { recursive: true });
+    rmSync9(path, { force: true });
+    rmSync9(editorLogNotePath(projectPath), { force: true });
   } catch {}
 }
 function writeEditorLogNote(projectPath, pid) {
   try {
     const path = editorLogNotePath(projectPath);
-    mkdirSync9(dirname12(path), { recursive: true });
-    writeFileSync11(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
+    mkdirSync10(dirname13(path), { recursive: true });
+    writeFileSync12(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
 function theConsoleWasNotCaptured(why, projectPath) {
@@ -34882,7 +34921,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
     return { kind: "older server", notedPid: noted?.pid ?? null };
   }
   const path = editorLogPath(projectPath);
-  if (!existsSync14(path)) {
+  if (!existsSync15(path)) {
     return { kind: "not written" };
   }
   const log = new GameLog;
@@ -34894,7 +34933,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
 function theFirstOf(path) {
   const whole = statSync7(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
-    return { text: readFileSync16(path, "utf8") };
+    return { text: readFileSync17(path, "utf8") };
   }
   const handle = openSync(path, "r");
   try {
@@ -38708,12 +38747,16 @@ function whyNoReport(printed, asked) {
   return printed.some((line) => NOTHING_RAN.test(line)) ? `no test cases found at ${asked}` : null;
 }
 function scriptErrorsPrinted(printed) {
+  return discoveryListing(printed)?.errors ?? [];
+}
+function discoveryListing(printed) {
   const start = printed.findIndex((line) => line.includes(DISCOVERY_FAILED));
   if (start < 0) {
-    return [];
+    return null;
   }
   const found = [];
   let message = null;
+  let to = start + 1;
   for (const line of printed.slice(start + 1)) {
     const at = /^\s*at (res:\/\/.+):(\d+)\s*$/.exec(line);
     if (at !== null && message !== null) {
@@ -38724,8 +38767,10 @@ function scriptErrorsPrinted(printed) {
     } else {
       break;
     }
+    to += 1;
   }
-  return found.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : (a.line ?? 0) - (b.line ?? 0));
+  const errors = found.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : (a.line ?? 0) - (b.line ?? 0));
+  return { errors, from: start, to };
 }
 function unspelled(text) {
   return text.replace(/<(?:LF|CR|TAB|BS|FF|VT|BEL|ESC|DEL|0x[0-9A-F]{2})>/g, (spelling) => spelling.startsWith("<0x") ? String.fromCharCode(Number.parseInt(spelling.slice(3, 5), 16)) : SPELLED[spelling] ?? spelling);
@@ -38835,7 +38880,51 @@ function orphansPrinted(printed) {
     suites
   };
 }
-var MalformedReportError, ENTITIES, ATTRIBUTE, HOOK_FAILURE, NOTHING_RAN, NO_SUCH_PATH, DISCOVERY_FAILED = "Script errors were detected during test discovery!", ESCAPE, LOCATION = `'[^'\\n]*' in \\S+:\\d+`, IGNORING_CASE = " \\(ignoring case\\)", PRINTED_ACTUAL, QUOTED_EQUALITY, COLOUR2, SPELLED, BOTH_SIDES_ALIKE_NOTE = "[gdharness: the expected and the actual printed alike because gdUnit4 drops the marks that tell them apart when it writes its report, and the runner printed no copy of this one, so neither side above is the value the assertion found.]", VALUE_NOT_RECOVERED_NOTE = '[gdharness: the value after "but was" may not be the one the assertion found. gdUnit4 writes a failing string into its report as a character diff against the expected one with the marks dropped, which merges the two, and the runner printed no copy of this one to read the value back from.]', RENDERED_AWAY_NOTE = '[gdharness: the two sides print alike, so what tells them apart is something gdUnit4 does not print. The usual cause is BBCode in the expected string, which gdUnit4 renders as formatting instead of showing; the value after "but was" is the one the assertion found.]', MASKED_BRACKET = "[lb]", PRINTED_DICTIONARY, RUNNING_SUITE, ORPHANS, OVERALL = "Overall Summary";
+function finishesASuite(line) {
+  return SUITE_COUNTS.test(line) && !line.includes(OVERALL);
+}
+function suitesPrinted(printed) {
+  const finished = [];
+  let running = null;
+  let failed = [];
+  for (const line of printed) {
+    const started = RUNNING_SUITE.exec(line);
+    if (started?.[1] !== undefined) {
+      running = started[1];
+      failed = [];
+      continue;
+    }
+    if (running === null) {
+      continue;
+    }
+    const failing = CASE_FAILED.exec(line)?.[1];
+    if (failing !== undefined) {
+      failed.push(failing);
+      continue;
+    }
+    const counted = finishesASuite(line) ? SUITE_COUNTS.exec(line) : null;
+    if (counted !== null) {
+      finished.push({
+        path: running,
+        cases: Number(counted[1]),
+        errors: Number(counted[2]),
+        failures: Number(counted[3]),
+        failed
+      });
+      running = null;
+    }
+  }
+  return { finished, running };
+}
+function testProgressMessage(printed, elapsedMs) {
+  const { finished, running } = suitesPrinted(printed);
+  const failing = finished.filter((suite) => suite.errors + suite.failures > 0).length;
+  const seconds = Math.floor(elapsedMs / 1000);
+  const took = seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  const done = finished.length === 0 ? "No suite has finished" : `${finished.length === 1 ? "One suite has" : `${finished.length} suites have`} finished${failing === 0 ? "" : `, ${failing} with failures`}`;
+  return `${done}${running === null ? "" : `; running ${running}`}; ${took} in.`;
+}
+var MalformedReportError, ENTITIES, ATTRIBUTE, HOOK_FAILURE, NOTHING_RAN, NO_SUCH_PATH, DISCOVERY_FAILED = "Script errors were detected during test discovery!", ESCAPE, LOCATION = `'[^'\\n]*' in \\S+:\\d+`, IGNORING_CASE = " \\(ignoring case\\)", PRINTED_ACTUAL, QUOTED_EQUALITY, COLOUR2, SPELLED, BOTH_SIDES_ALIKE_NOTE = "[gdharness: the expected and the actual printed alike because gdUnit4 drops the marks that tell them apart when it writes its report, and the runner printed no copy of this one, so neither side above is the value the assertion found.]", VALUE_NOT_RECOVERED_NOTE = '[gdharness: the value after "but was" may not be the one the assertion found. gdUnit4 writes a failing string into its report as a character diff against the expected one with the marks dropped, which merges the two, and the runner printed no copy of this one to read the value back from.]', RENDERED_AWAY_NOTE = '[gdharness: the two sides print alike, so what tells them apart is something gdUnit4 does not print. The usual cause is BBCode in the expected string, which gdUnit4 renders as formatting instead of showing; the value after "but was" is the one the assertion found.]', MASKED_BRACKET = "[lb]", PRINTED_DICTIONARY, RUNNING_SUITE, ORPHANS, OVERALL = "Overall Summary", SUITE_COUNTS, CASE_FAILED;
 var init_junit = __esm(() => {
   MalformedReportError = class MalformedReportError extends Error {
     constructor(message) {
@@ -38867,6 +38956,8 @@ var init_junit = __esm(() => {
   PRINTED_DICTIONARY = /^\{\n\t[\s\S]*\n {2}\}$/;
   RUNNING_SUITE = /Run Test Suite:\s*(res:\/\/.+?\.(?:gd|cs))(?=\s|$)/;
   ORPHANS = /(\d+)\s+orphans/;
+  SUITE_COUNTS = /(\d+)\s+test cases\s*\|\s*(\d+)\s+errors\s*\|\s*(\d+)\s+failures/;
+  CASE_FAILED = /^\s*res:\/\/.+?\.(?:gd|cs) > (.+?) (?:FAILED|ERROR)(?:\s|$)/;
 });
 
 // src/keeper-channel.ts
@@ -38912,10 +39003,10 @@ function askTheKeeperToStop(address, withinMs) {
 var init_keeper_channel = () => {};
 
 // src/lsp_client.ts
-import { existsSync as existsSync15, realpathSync as realpathSync4 } from "node:fs";
+import { existsSync as existsSync16, realpathSync as realpathSync4 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname13, join as join19, resolve as resolve5 } from "node:path";
+import { dirname as dirname14, join as join20, resolve as resolve5 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function diagnosticsKey(uri) {
   let decoded;
@@ -39047,7 +39138,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname13(resolve5(filePath));
+    const rootPath = this.rootPath ?? dirname14(resolve5(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params, timeoutMs = this.timeouts.requestMs) {
@@ -39458,7 +39549,7 @@ async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   } catch {
     throw new ArgumentRefusal(`Project path does not exist: ${requestedProjectPath}`);
   }
-  if (!existsSync15(join19(projectPath, "project.godot"))) {
+  if (!existsSync16(join20(projectPath, "project.godot"))) {
     throw new ArgumentRefusal(`Not a Godot project: ${projectPath}. Point projectPath at the directory holding project.godot.`);
   }
   const contained = resolveWithinProject(projectPath, scriptPathValue);
@@ -39667,13 +39758,13 @@ var init_process_time = __esm(() => {
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync16, readdirSync as readdirSync7, readFileSync as readFileSync17 } from "node:fs";
-import { join as join20 } from "node:path";
+import { existsSync as existsSync17, readdirSync as readdirSync7, readFileSync as readFileSync18 } from "node:fs";
+import { join as join21 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync16(join20(directory, ".gdignore"));
+  return existsSync17(join21(directory, ".gdignore"));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -39686,7 +39777,7 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join20(directory, entry.name));
+        visit(join21(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (SCENE_EXTENSIONS.has(extension)) {
@@ -39716,14 +39807,14 @@ function scriptsWithoutUid(projectPath) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join20(directory, entry.name), spelled);
+        visit(join21(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync16(join20(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync17(join21(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -39744,7 +39835,7 @@ function projectTexts(projectPath) {
       if (skipped(entry.name)) {
         continue;
       }
-      const absolute = join20(directory, entry.name);
+      const absolute = join21(directory, entry.name);
       const spelled = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
         visit(absolute, `${spelled}/`);
@@ -39754,7 +39845,7 @@ function projectTexts(projectPath) {
       if (!entry.isFile() || BINARY_EXTENSIONS.has(extension)) {
         continue;
       }
-      const bytes = readFileSync17(absolute);
+      const bytes = readFileSync18(absolute);
       if (!isBinary(bytes)) {
         found.push({ path: `res://${spelled}`, absolute, text: bytes.toString("utf8") });
       }
@@ -39771,7 +39862,7 @@ function ignoredTexts(projectPath) {
       if (skipped(entry.name)) {
         continue;
       }
-      const absolute = join20(directory, entry.name);
+      const absolute = join21(directory, entry.name);
       const spelled = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
         visit(absolute, `${spelled}/`, under);
@@ -39781,7 +39872,7 @@ function ignoredTexts(projectPath) {
       if (!under || !entry.isFile() || BINARY_EXTENSIONS.has(extension) || entry.name === ".gdignore") {
         continue;
       }
-      const bytes = readFileSync17(absolute);
+      const bytes = readFileSync18(absolute);
       if (!isBinary(bytes)) {
         found.push({ path: `res://${spelled}`, absolute, text: bytes.toString("utf8") });
       }
@@ -39811,7 +39902,7 @@ function searchProject(projectPath, options) {
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join20(directory, entry.name);
+      const entryPath = join21(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -39820,7 +39911,7 @@ function searchProject(projectPath, options) {
       if (!entry.isFile() || extensions !== null && !extensions.has(extension)) {
         continue;
       }
-      const bytes = readFileSync17(entryPath);
+      const bytes = readFileSync18(entryPath);
       if (extensions === null && isBinary(bytes)) {
         continue;
       }
@@ -39897,8 +39988,8 @@ var init_project_scan = __esm(() => {
 });
 
 // src/rename.ts
-import { existsSync as existsSync17, mkdirSync as mkdirSync10, readFileSync as readFileSync18, renameSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync12 } from "node:fs";
-import { dirname as dirname14, posix } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync11, readFileSync as readFileSync19, renameSync, unlinkSync as unlinkSync2, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname15, posix } from "node:path";
 
 class Script {
   path;
@@ -40599,25 +40690,25 @@ function rewritesOf(plan, texts, move) {
 }
 function applyRewrites(rewrites) {
   for (const rewrite of rewrites) {
-    const now = readFileSync18(rewrite.absolute, "utf8");
+    const now = readFileSync19(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 && existsSync17(rewrite.writeTo)) {
+    if (rewrite.writeTo !== rewrite.absolute && existsSync18(rewrite.writeTo)) {
       throw new Error(`${rewrite.writeTo} already exists; nothing was written`);
     }
   }
   const done = [];
   try {
     for (const rewrite of rewrites) {
-      mkdirSync10(dirname14(rewrite.writeTo), { recursive: true });
+      mkdirSync11(dirname15(rewrite.writeTo), { recursive: true });
       const staging = `${rewrite.writeTo}.gdharness-rename`;
-      writeFileSync12(staging, rewrite.after, "utf8");
+      writeFileSync13(staging, rewrite.after, "utf8");
       renameSync(staging, rewrite.writeTo);
       let movedUid = false;
       if (rewrite.writeTo !== rewrite.absolute) {
         unlinkSync2(rewrite.absolute);
-        if (existsSync17(`${rewrite.absolute}.uid`)) {
+        if (existsSync18(`${rewrite.absolute}.uid`)) {
           renameSync(`${rewrite.absolute}.uid`, `${rewrite.writeTo}.uid`);
           movedUid = true;
         }
@@ -40627,7 +40718,7 @@ function applyRewrites(rewrites) {
   } catch (error) {
     for (const { rewrite, movedUid } of done.reverse()) {
       try {
-        writeFileSync12(rewrite.absolute, rewrite.before, "utf8");
+        writeFileSync13(rewrite.absolute, rewrite.before, "utf8");
         if (rewrite.writeTo !== rewrite.absolute) {
           unlinkSync2(rewrite.writeTo);
           if (movedUid) {
@@ -40663,8 +40754,8 @@ var init_rename = __esm(() => {
 });
 
 // src/rename-symbol.ts
-import { existsSync as existsSync18, mkdirSync as mkdirSync11, readdirSync as readdirSync8, realpathSync as realpathSync5, rmSync as rmSync9, writeFileSync as writeFileSync13 } from "node:fs";
-import { basename as basename5, dirname as dirname15, join as join21, relative as relative4, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync19, mkdirSync as mkdirSync12, readdirSync as readdirSync8, realpathSync as realpathSync5, rmSync as rmSync10, writeFileSync as writeFileSync14 } from "node:fs";
+import { basename as basename5, dirname as dirname16, join as join22, relative as relative4, resolve as resolve6 } from "node:path";
 function resourcePathOf(projectPath, absolute) {
   const inside = relative4(onDiskSpelling(projectPath), onDiskSpelling(absolute));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
@@ -40677,9 +40768,9 @@ function onDiskSpelling(path) {
   let at = resolve6(path);
   for (;; ) {
     try {
-      return join21(realpathSync5.native(at), ...missing.reverse());
+      return join22(realpathSync5.native(at), ...missing.reverse());
     } catch {
-      const parent = dirname15(at);
+      const parent = dirname16(at);
       if (parent === at) {
         return resolve6(path);
       }
@@ -40730,7 +40821,7 @@ async function renameSymbol(request, services) {
         reason: `newScriptPath must be a .gd path inside the project, and ${request.newScriptPath} is not.`
       };
     }
-    if (existsSync18(request.newScriptPath)) {
+    if (existsSync19(request.newScriptPath)) {
       return { ok: false, reason: `${moveTo} already exists, so the script cannot be moved there.` };
     }
   }
@@ -40906,7 +40997,7 @@ async function renameSymbol(request, services) {
       scripts,
       from: declaringPath,
       to: moveTo,
-      exists: (path) => existsSync18(`${projectPath}/${path.slice("res://".length)}`)
+      exists: (path) => existsSync19(`${projectPath}/${path.slice("res://".length)}`)
     }, plan);
   }
   plan = mentionIgnored(plan, ignoredTexts(projectPath), symbol, moveTo === null ? null : declaringPath);
@@ -41105,15 +41196,15 @@ ${mention.kind}`;
   };
 }
 function writeLeftAloneDetail(projectPath, symbol, detail) {
-  const directory = join21(projectPath, ".godot", "gdharness-renames");
-  mkdirSync11(directory, { recursive: true });
+  const directory = join22(projectPath, ".godot", "gdharness-renames");
+  mkdirSync12(directory, { recursive: true });
   detailWrites += 1;
-  const path = join21(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
-  writeFileSync13(path, `${JSON.stringify(detail, null, 2)}
+  const path = join22(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
+  writeFileSync14(path, `${JSON.stringify(detail, null, 2)}
 `, "utf8");
   const kept = readdirSync8(directory).filter((name) => name.endsWith(".json")).sort().reverse();
   for (const old of kept.slice(10)) {
-    rmSync9(join21(directory, old), { force: true });
+    rmSync10(join22(directory, old), { force: true });
   }
   return path;
 }
@@ -41153,16 +41244,16 @@ var init_rename_symbol = __esm(() => {
 });
 
 // src/restart-note.ts
-import { mkdirSync as mkdirSync12, readFileSync as readFileSync19, rmSync as rmSync10, writeFileSync as writeFileSync14 } from "node:fs";
-import { dirname as dirname16, join as join22 } from "node:path";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync20, rmSync as rmSync11, writeFileSync as writeFileSync15 } from "node:fs";
+import { dirname as dirname17, join as join23 } from "node:path";
 function restartNotePath(projectPath) {
-  return join22(projectPath, ".godot", "gdharness-restart.json");
+  return join23(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync12(dirname16(path), { recursive: true });
-    writeFileSync14(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync13(dirname17(path), { recursive: true });
+    writeFileSync15(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
@@ -41170,7 +41261,7 @@ function noteRestartBegun(note) {
 }
 function restartOwed(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync19(restartNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync20(restartNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -41185,7 +41276,7 @@ function restartOwed(projectPath) {
 }
 function restartSettled(projectPath) {
   try {
-    rmSync10(restartNotePath(projectPath), { force: true });
+    rmSync11(restartNotePath(projectPath), { force: true });
   } catch (error) {
     console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
   }
@@ -41198,28 +41289,28 @@ var init_restart_note = __esm(() => {
 import { execFile as execFile4 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
 import {
-  mkdirSync as mkdirSync13,
+  mkdirSync as mkdirSync14,
   openSync as openSync2,
   readdirSync as readdirSync9,
-  readFileSync as readFileSync20,
+  readFileSync as readFileSync21,
   realpathSync as realpathSync6,
-  rmSync as rmSync11,
+  rmSync as rmSync12,
   statSync as statSync8,
-  writeFileSync as writeFileSync15
+  writeFileSync as writeFileSync16
 } from "node:fs";
-import { basename as basename6, dirname as dirname17, join as join23, resolve as resolve7 } from "node:path";
+import { basename as basename6, dirname as dirname18, join as join24, resolve as resolve7 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 function runsDirectory() {
-  return join23(runtimeDirectory(), "runs");
+  return join24(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join23(realpathSync6.native(at), ...missing);
+      return join24(realpathSync6.native(at), ...missing);
     } catch {
-      const parent = dirname17(at);
+      const parent = dirname18(at);
       if (parent === at) {
         return path;
       }
@@ -41234,26 +41325,26 @@ function projectKey(projectPath) {
   return createHash4("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join23(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join24(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function openTranscript(startedAt) {
-  mkdirSync13(runsDirectory(), { recursive: true });
-  const path = join23(runsDirectory(), `run-${startedAt}.log`);
+  mkdirSync14(runsDirectory(), { recursive: true });
+  const path = join24(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync2(path, "a") };
 }
 function noteIsAbout(note, playing) {
   return note.play !== undefined && playing !== null && note.play.play === playing.play && note.play.editorPid === playing.editorPid;
 }
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join23(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join24(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
-  mkdirSync13(runsDirectory(), { recursive: true });
-  writeFileSync15(editorNotePath(note.projectPath), JSON.stringify(note, null, 2), "utf8");
+  mkdirSync14(runsDirectory(), { recursive: true });
+  writeFileSync16(editorNotePath(note.projectPath), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join23(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join24(directory, "runs", "editor-run.json"));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -41263,7 +41354,7 @@ function readEditorRunNote(projectPath) {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync20(path, "utf8"));
+    parsed = JSON.parse(readFileSync21(path, "utf8"));
   } catch {
     return null;
   }
@@ -41287,7 +41378,7 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join23(directory, "runs", SHARED_NOTE));
+    const shared = recordAt(join24(directory, "runs", SHARED_NOTE));
     if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
       return shared;
     }
@@ -41299,13 +41390,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync9(join23(directory, "runs"));
+      entries = readdirSync9(join24(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join23(directory, "runs", entry));
+        const record = recordAt(join24(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -41317,7 +41408,7 @@ function everyRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync20(path, "utf8"));
+    parsed = JSON.parse(readFileSync21(path, "utf8"));
   } catch {
     return null;
   }
@@ -41368,7 +41459,7 @@ async function runningAs(pid) {
     const began = await startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync20(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync21(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = (await execFileAsync("ps", ["-p", String(pid), "-o", "args="], { encoding: "utf8", timeout: 15000 })).stdout.trim();
@@ -41513,12 +41604,12 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join23(directory, "runs", SHARED_NOTE);
+    const shared = join24(directory, "runs", SHARED_NOTE);
     const sharedRecord = recordAt(shared);
     const ours = sharedRecord !== null && sharedRecord.projectPath !== "" && isSameDirectory(sharedRecord.projectPath, projectPath);
     for (const path of [runRecordPath(projectPath, directory), ...ours ? [shared] : []]) {
       try {
-        rmSync11(path, { force: true });
+        rmSync12(path, { force: true });
       } catch {}
     }
   }
@@ -41543,12 +41634,12 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join23(directory, entry);
+    const path = join24(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
     try {
-      rmSync11(path);
+      rmSync12(path);
     } catch {}
   }
 }
@@ -41562,6 +41653,104 @@ var init_run_record = __esm(() => {
   execFileAsync = promisify4(execFile4);
 });
 
+// src/script-origins.ts
+import { join as join25 } from "node:path";
+function unresolvedClassIn(message) {
+  return UNRESOLVED.exec(message)?.[1] ?? null;
+}
+async function originsOf(errors, declared, check) {
+  const listed = new Set(errors.map((error) => error.path));
+  const origins = [];
+  const unconfirmed = [];
+  const asked = new Set;
+  const waiting = errors.map((error) => unresolvedClassIn(error.message)).filter((name) => name !== null);
+  while (waiting.length > 0 && asked.size < MOST_CHECKED) {
+    const name = waiting.shift() ?? "";
+    const path = declared.get(name);
+    if (path === undefined || listed.has(path) || asked.has(path)) {
+      continue;
+    }
+    asked.add(path);
+    const checked = await check(path);
+    const own = checked.errors.filter((error) => error.path === path);
+    if (own.length === 0) {
+      unconfirmed.push({
+        path,
+        declares: name,
+        why: checked.failure === null ? "the engine's check of it found no error" : `the engine's check of it did not finish (${checked.failure})`
+      });
+      continue;
+    }
+    for (const error of own) {
+      origins.push({ ...error, declares: name });
+      const deeper = unresolvedClassIn(error.message);
+      if (deeper !== null) {
+        waiting.push(deeper);
+      }
+    }
+  }
+  return { origins, unconfirmed };
+}
+function reloadedAt(entry) {
+  for (const line of entry.detail) {
+    const at = RELOADED_AT.exec(line.trim());
+    if (at !== null) {
+      return { path: at[1] ?? "", line: Number(at[2]) === 0 ? null : Number(at[2]) };
+    }
+  }
+  return null;
+}
+function checkWithEngine(godotPath, projectPath) {
+  return async (path) => {
+    const logDir = scratchDirectory("tests");
+    try {
+      const ran = await runEngine(godotPath, [
+        "--headless",
+        "--log-file",
+        join25(logDir, "engine.log"),
+        "--path",
+        projectPath,
+        "--check-only",
+        "-s",
+        path
+      ], { timeout: { ms: 60000, said: "minute" } });
+      const errors = ran.log.select({ severity: "error", sinceLastCall: false, limit: 50 }).entries.flatMap((entry) => {
+        const at = reloadedAt(entry);
+        return at === null ? [] : [{ ...at, message: entry.text }];
+      });
+      return { errors, failure: ran.failure === null ? null : howItEnded(ran) };
+    } finally {
+      discard(logDir);
+    }
+  };
+}
+function withoutListed(entries, errors) {
+  if (errors.length === 0) {
+    return [...entries];
+  }
+  const listing = discoveryListing(entries.map((entry) => entry.text));
+  const paths = new Set(errors.map((error) => error.path));
+  return entries.filter((entry, at) => {
+    if (listing !== null && at >= listing.from && at < listing.to) {
+      return false;
+    }
+    const reloaded = reloadedAt(entry);
+    if (reloaded !== null && errors.some((error) => error.path === reloaded.path && error.line === reloaded.line && error.message === entry.text)) {
+      return false;
+    }
+    const failedToLoad = /^Failed to load script "(res:\/\/[^"]+)" with error "[^"]+"\.$/.exec(entry.text);
+    return failedToLoad === null || !paths.has(failedToLoad[1] ?? "");
+  });
+}
+var UNRESOLVED, MOST_CHECKED = 8, RELOADED_AT;
+var init_script_origins = __esm(() => {
+  init_engine_run();
+  init_junit();
+  init_scratch();
+  UNRESOLVED = /Could not resolve class "([A-Za-z_][A-Za-z0-9_]*)", because of a parser error/;
+  RELOADED_AT = /GDScript::reload \((res:\/\/.+):(\d+)\)$/;
+});
+
 // src/server.ts
 import { execFile as execFile5, spawn as spawn4 } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -41570,17 +41759,17 @@ import {
   closeSync as closeSync2,
   constants,
   copyFileSync,
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   fstatSync,
-  mkdirSync as mkdirSync14,
+  mkdirSync as mkdirSync15,
   openSync as openSync3,
   readdirSync as readdirSync10,
-  readFileSync as readFileSync21,
+  readFileSync as readFileSync22,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
   statSync as statSync9
 } from "node:fs";
-import { basename as basename7, dirname as dirname18, extname as extname2, isAbsolute as isAbsolute3, join as join24, normalize as normalize2, relative as relative5 } from "node:path";
+import { basename as basename7, dirname as dirname19, extname as extname2, isAbsolute as isAbsolute3, join as join26, normalize as normalize2, relative as relative5 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 import { promisify as promisify5 } from "node:util";
@@ -41601,16 +41790,16 @@ function captureDestinationRefusal(outputPath, projects) {
   if (extname2(outputPath).toLowerCase() !== ".png") {
     return `outputPath ${outputPath} does not end in .png, which is what a capture is.`;
   }
-  const directory = realPathOr(dirname18(outputPath));
-  if (!existsSync19(directory)) {
-    return `outputPath's directory ${dirname18(outputPath)} does not exist; a capture creates no directories.`;
+  const directory = realPathOr(dirname19(outputPath));
+  if (!existsSync20(directory)) {
+    return `outputPath's directory ${dirname19(outputPath)} does not exist; a capture creates no directories.`;
   }
-  const where = join24(directory, basename7(outputPath));
+  const where = join26(directory, basename7(outputPath));
   const inside = projects.find((project) => project !== "" && isWithinRoot(realPathOr(project), where));
   if (inside !== undefined) {
     return `outputPath ${outputPath} is inside the project at ${inside}; a capture is saved outside it, so it never becomes part of the game.`;
   }
-  if (existsSync19(where)) {
+  if (existsSync20(where)) {
     return `outputPath ${outputPath} already exists; a capture is not written over a file. Name a new one.`;
   }
   return null;
@@ -42083,18 +42272,72 @@ function settingsNamedBy(op, args) {
   }
 }
 function foldedScriptErrors(errors) {
-  const scriptErrors = errors.filter((error) => !error.message.includes(DEPENDED_FAILED));
+  const unresolved = new Map;
+  for (const error of errors) {
+    const name = unresolvedClassIn(error.message);
+    if (name !== null) {
+      unresolved.set(error.path, (unresolved.get(error.path) ?? new Set).add(name));
+    }
+  }
+  const follows = (error) => {
+    const names = unresolved.get(error.path);
+    if (names === undefined) {
+      return false;
+    }
+    const reparsed = /Could not parse global class "([A-Za-z_][A-Za-z0-9_]*)"/.exec(error.message)?.[1];
+    return error.message.includes('the inferred type "Variant"') || reparsed !== undefined && names.has(reparsed);
+  };
+  const scriptErrors = errors.filter((error) => !error.message.includes(DEPENDED_FAILED) && !follows(error));
   const own = new Set(scriptErrors.map((error) => error.path));
   return {
     scriptErrors,
-    failedThroughDependency: [...new Set(errors.map((error) => error.path))].filter((path) => !own.has(path))
+    failedThroughDependency: [...new Set(errors.map((error) => error.path))].filter((path) => !own.has(path)),
+    followFromUnresolved: errors.filter(follows)
   };
 }
 function nonEmpty(lists) {
   return Object.fromEntries(Object.entries(lists).filter(([, list]) => list.length > 0));
 }
-function scriptErrorsNote(errors) {
-  const { scriptErrors: own, failedThroughDependency: dependents } = foldedScriptErrors(errors);
+function withPreviousCut(answer, previous) {
+  const content = answer.content.map((part) => ({ ...part }));
+  const last = content.at(-1);
+  let json = null;
+  try {
+    const parsed = JSON.parse(last?.text ?? "");
+    json = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? { ...parsed } : null;
+  } catch {}
+  if (last !== undefined && json !== null) {
+    last.text = answerJson({ ...json, previousRunCut: previous });
+  }
+  const note = cutTestRunNote(previous);
+  const first = content[0];
+  if (first === undefined || first === last && json !== null || typeof first.text !== "string") {
+    content.unshift({ type: "text", text: note });
+  } else {
+    first.text = `${first.text} ${note}`;
+  }
+  return { ...answer, content };
+}
+function finishedBeforeTheEnd(finished, failing, running) {
+  if (finished === 0 && running === null) {
+    return "";
+  }
+  const got = finished === 0 ? "no suite had finished" : `${finished === 1 ? "one suite" : `${finished} suites`} finished${failing === 0 ? "" : finished === 1 ? ", with failures" : `, ${failing} of them with failures`}`;
+  const listed = finished === 0 ? "" : `; ${finished === 1 ? "it is" : "they are"} under suitesFinished${failing === 0 ? "" : ", with the failing cases under suitesFailing"}, so a run of the rest need not repeat ${finished === 1 ? "it" : "them"}`;
+  return ` Before it ended, ${got}${running === null ? "" : `${finished === 0 ? " and" : ", and"} ${running} was running`}${listed}.`;
+}
+function scriptErrorsNote(errors, {
+  origins,
+  unconfirmed
+} = {
+  origins: [],
+  unconfirmed: []
+}) {
+  const {
+    scriptErrors: own,
+    failedThroughDependency: dependents,
+    followFromUnresolved: consequences
+  } = foldedScriptErrors(errors);
   const causes = new Map;
   for (const error of own) {
     if (!causes.has(error.path)) {
@@ -42102,16 +42345,29 @@ function scriptErrorsNote(errors) {
     }
   }
   const scripts = causes.size + dependents.length;
-  const named = [...causes.values()].map((error) => `${error.line === null ? error.path : `${error.path}:${error.line}`} ${error.message}${/[.!?]\)?$/.test(error.message) ? "" : "."}`).join(" ");
+  const at = (error) => error.line === null ? error.path : `${error.path}:${error.line}`;
+  const sentence = (text) => `${text}${/[.!?]\)?$/.test(text) ? "" : "."}`;
+  const traced = new Set;
+  const failedOn = (declares) => {
+    const through = [...causes.values()].filter((error) => unresolvedClassIn(error.message) === declares);
+    for (const error of through) {
+      traced.add(error.path);
+    }
+    return through.length === 0 ? "" : ` ${through.map(at).join(", ")} could not resolve ${declares} because of it.`;
+  };
+  const first = [...new Map(origins.map((origin) => [origin.path, origin])).values()].sort((a, b) => Number(unresolvedClassIn(a.message) !== null) - Number(unresolvedClassIn(b.message) !== null));
+  const named = [
+    ...first.map((origin) => `${at(origin)} ${sentence(origin.message)} gdUnit4 did not name this script, which declares ${origin.declares}; the engine's own check of it found the error.${failedOn(origin.declares)}`),
+    ...unconfirmed.map((origin) => `${origin.path} declares ${origin.declares}, which gdUnit4 did not name, and ${origin.why}.${failedOn(origin.declares)}`),
+    ...[...causes.values()].filter((error) => !traced.has(error.path)).map((error) => `${at(error)} ${sentence(error.message)}`)
+  ].join(" ");
   const following = dependents.length === 0 ? "" : causes.size === 0 ? `${dependents.join(", ")} ${dependents.length === 1 ? "depends" : "depend"} on a script that did not compile, and gdUnit4 named none with an error of its own: script_diagnostics on one of them finds it.` : `${dependents.length === 1 ? "One more" : `${dependents.length} more`} failed only because a script ${dependents.length === 1 ? "it depends" : "they depend"} on did: ${dependents.join(", ")}.`;
   const more = own.length - causes.size;
   const rest = more > 0 ? `${more === 1 ? "One more error" : `${more} more errors`} in ${causes.size === 1 ? "that script" : "those scripts"} ${more === 1 ? "is" : "are"} under scriptErrors.` : "";
-  return [
-    `No tests ran: gdUnit4 could not load ${scripts === 1 ? "one script" : `${scripts} scripts`} while looking for suites, and it runs no suite at all when one fails to load.`,
-    named,
-    following,
-    rest
-  ].filter((part) => part !== "").join(" ");
+  const after = consequences.length > 0 ? `${consequences.length === 1 ? "One more error comes" : `${consequences.length} more errors come`} only from a class that did not resolve, which the engine reads as Variant, and ${consequences.length === 1 ? "is" : "are"} under followFromUnresolved.` : "";
+  const unnamed = first.length;
+  const opening = unnamed === 0 ? `No tests ran: gdUnit4 could not load ${scripts === 1 ? "one script" : `${scripts} scripts`} while looking for suites, and it runs no suite at all when one fails to load.` : `No tests ran: ${scripts + unnamed} scripts did not compile, and gdUnit4 runs no suite at all when one fails to load. It could not load ${scripts === 1 ? "one" : scripts} of them while looking for suites, and ${unnamed === 1 ? "the one it did not name comes" : `the ${unnamed} it did not name come`} first.`;
+  return [opening, named, following, rest, after].filter((part) => part !== "").join(" ");
 }
 function timedOutVerdict(timeoutMs, silentForMs) {
   const quiet = Math.round(silentForMs);
@@ -42169,7 +42425,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync19(join24(projectPath, wanted))) {
+  if (wanted === "" || existsSync20(join26(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -42213,7 +42469,7 @@ function testPathsIn(projectPath, given) {
   };
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync21(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync22(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -42221,13 +42477,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync21(join24(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync22(join26(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync21(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync22(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -42246,7 +42502,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   mcp;
   locator = new GodotLocator;
-  operationsScript = join24(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join26(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -42549,11 +42805,20 @@ class GodotServer {
         return checked.response;
       }
       const named = args["projectPath"];
-      if (typeof named === "string" && existsSync19(join24(named, "project.godot"))) {
+      if (typeof named === "string" && existsSync20(join26(named, "project.godot"))) {
         this.lastProjectPath = named;
       }
       this.updates.refresh();
-      const answer = await withCallSignal(extra.signal, () => this.answered(spec.name, checked.op ?? "", args));
+      const token = request.params._meta?.progressToken;
+      const progress = token === undefined ? undefined : (done, message) => {
+        extra.sendNotification({
+          method: "notifications/progress",
+          params: { progressToken: token, progress: done, message }
+        }).catch((error) => {
+          this.logDebug(`Progress for ${spec.name} was not sent: ${errorMessage(error)}`);
+        });
+      };
+      const answer = await withCallSignal(extra.signal, () => this.answered(spec.name, checked.op ?? "", args), progress);
       return this.withFeedbackNotice(this.withUpdateNotice(answer));
     });
   }
@@ -43023,8 +43288,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join24(path, "project.godot");
-    if (!existsSync19(file)) {
+    const file = join26(path, "project.godot");
+    if (!existsSync20(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -43635,7 +43900,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync21(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync22(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -43691,18 +43956,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname18(output.absolutePath);
+    const folder = dirname19(output.absolutePath);
     try {
-      mkdirSync14(folder, { recursive: true });
+      mkdirSync15(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname18(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname19(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
     const exportLogs = scratchDirectory("export");
     const exportArgs = [
       "--headless",
       "--log-file",
-      join24(exportLogs, "engine.log"),
+      join26(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -43710,7 +43975,7 @@ class GodotServer {
       output.absolutePath
     ];
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
-    const writtenAt = () => existsSync19(output.absolutePath) ? statSync9(output.absolutePath).mtimeMs : null;
+    const writtenAt = () => existsSync20(output.absolutePath) ? statSync9(output.absolutePath).mtimeMs : null;
     const before = writtenAt();
     let ending;
     try {
@@ -43723,7 +43988,38 @@ class GodotServer {
     }
     return exportAnswer(ending, { preset, outputPath: output.relativePath, debug }, before, writtenAt());
   }
+  reportTestProgress(log) {
+    const progress = callProgress();
+    if (progress === undefined) {
+      return;
+    }
+    const began = Date.now();
+    let read = 0;
+    let lastSent = began;
+    const ticker = setInterval(() => {
+      const entries = log.all;
+      const finishedOne = entries.slice(read).some((entry) => finishesASuite(entry.text));
+      read = entries.length;
+      const now = Date.now();
+      if (!finishedOne && now - lastSent < TEST_HEARTBEAT_MS) {
+        return;
+      }
+      lastSent = now;
+      progress(Math.floor((now - began) / 1000), testProgressMessage(entries.map((entry) => entry.text), now - began));
+    }, 1000);
+    ticker.unref();
+    return ticker;
+  }
   async handleRunTests(args) {
+    const answer = await this.runTests(args);
+    const project = this.project(args);
+    if (!project.ok || callSignal()?.aborted === true) {
+      return answer;
+    }
+    const previous = takeCutTestRun(project.value.path);
+    return previous === null ? answer : withPreviousCut(answer, previous);
+  }
+  async runTests(args) {
     const project = this.project(args);
     if (!project.ok) {
       return project.response;
@@ -43732,7 +44028,7 @@ class GodotServer {
     if (!paths.ok) {
       return this.createErrorResponse(paths.reason, PATH_SOLUTIONS);
     }
-    const missing = paths.value.filter((path) => !existsSync19(join24(project.value.path, path.slice("res://".length))));
+    const missing = paths.value.filter((path) => !existsSync20(join26(project.value.path, path.slice("res://".length))));
     const asked = paths.value.filter((path) => !missing.includes(path));
     if (asked.length === 0) {
       const verdict = `nothing at ${missing.join(" and ")}`;
@@ -43748,7 +44044,7 @@ class GodotServer {
       };
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync19(join24(project.value.path, runner))) {
+    if (!existsSync20(join26(project.value.path, runner))) {
       return this.createErrorResponse(`gdUnit4 is not installed in this project: no ${runner}.`, [
         "Install gdUnit4 under addons/gdUnit4, from https://github.com/godot-gdunit-labs/gdUnit4"
       ]);
@@ -43793,6 +44089,7 @@ class GodotServer {
     run.process.stderr?.on("data", () => {
       lastSaid = Date.now();
     });
+    const reporting = this.reportTestProgress(run.log);
     let silentForMs = 0;
     const timedOut = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -43809,25 +44106,26 @@ class GodotServer {
         resolve(false);
       });
     });
+    clearInterval(reporting);
     if (timedOut && run.process.pid !== undefined) {
       await untilGone([run.process.pid]);
     }
     await run.settled;
-    const reportsDir = join24(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join26(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync19(reportsDir) ? readdirSync10(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync20(reportsDir) ? readdirSync10(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(readFileSync21(join24(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync22(join26(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
       discard(reportsDir, userData);
       try {
-        rmdirSync2(dirname18(reportsDir));
+        rmdirSync2(dirname19(reportsDir));
       } catch {}
     }
     const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries.map(aboveTheRunner);
@@ -43849,7 +44147,9 @@ class GodotServer {
     const nothingRan = timedOut ? null : whyNoReport(said, asked.join(" and "));
     const cutShort = timedOut ? timedOutVerdict(timeoutMs, silentForMs) : null;
     const hung = cutShort?.hung ?? false;
-    const scriptErrors = timedOut || exitCode !== 105 ? [] : scriptErrorsPrinted(said);
+    const printedErrors = timedOut || exitCode !== 105 ? [] : scriptErrorsPrinted(said);
+    const declaring = printedErrors.some((error) => unresolvedClassIn(error.message) !== null) ? await originsOf(printedErrors, declaredClasses(project.value.path), checkWithEngine(engine.value, project.value.path)) : { origins: [], unconfirmed: [] };
+    const scriptErrors = [...declaring.origins, ...printedErrors];
     const brokenScripts = new Set(scriptErrors.map((error) => error.path)).size;
     const ranAs = cutShort !== null ? cutShort.verdict : nothingRan ?? (brokenScripts > 0 ? `script errors in ${brokenScripts === 1 ? "one script" : `${brokenScripts} scripts`}, so no suite ran` : undefined) ?? (exitCode === null ? undefined : verdicts[exitCode]) ?? (run.exitSignal === null ? `exit ${exitCode ?? "unknown"}` : howItExited(run));
     const nothingAt = missing.join(" and ");
@@ -43862,9 +44162,28 @@ class GodotServer {
       printed: echoed.entries.map((entry) => entry.text),
       ...echoed.omitted > 0 ? { printedOmitted: echoed.omitted } : {}
     };
+    const sofar = report === null ? suitesPrinted(said) : null;
     if (report === null) {
-      const said = nothingRan !== null ? `No tests ran: ${ranAs}.` : scriptErrors.length > 0 ? scriptErrorsNote(scriptErrors) : reportProblem !== null ? `The test run's report could not be read (${reportProblem}); the engine's own verdict was ${ranAs}.` : `The test run wrote no report (${ranAs}).`;
+      const finished = sofar?.finished ?? [];
+      const running = sofar?.running ?? null;
+      const failing = finished.filter((suite) => suite.errors + suite.failures > 0);
+      const atTheEnd = {
+        ...nonEmpty({
+          suitesFinished: finished.map((suite) => suite.path),
+          suitesFailing: failing.map(({ path, errors, failures, failed }) => ({
+            path,
+            errors,
+            failures,
+            failed
+          }))
+        }),
+        ...running === null ? {} : { suiteRunning: running }
+      };
+      const said = nothingRan !== null ? `No tests ran: ${ranAs}.` : scriptErrors.length > 0 ? scriptErrorsNote(printedErrors, declaring) : reportProblem !== null ? `The test run's report could not be read (${reportProblem}); the engine's own verdict was ${ranAs}.` : `The test run wrote no report (${ranAs}).${finishedBeforeTheEnd(finished.length, failing.length, running)}`;
       const note = missingNote === undefined ? said : `${said} ${missingNote}`;
+      if (callSignal()?.aborted === true) {
+        keepCutTestRun(project.value.path, { cutAt: new Date().toISOString(), paths: asked, ...atTheEnd });
+      }
       return {
         content: [
           { type: "text", text: note },
@@ -43880,8 +44199,9 @@ class GodotServer {
               ...timedOut ? { timedOut, silentForMs } : {},
               ...missing.length > 0 ? { missing } : {},
               ...nonEmpty(foldedScriptErrors(scriptErrors)),
+              ...atTheEnd,
               arguments: cmdArgs,
-              entries: forAnswer(printed.slice(0, 60).map(aboveTheRunner)),
+              entries: forAnswer(withoutListed(printed, scriptErrors).slice(0, 60).map(aboveTheRunner)),
               ...printedLines,
               savesNote,
               ...scanned
@@ -44014,11 +44334,11 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const contradicted = cached === null ? [] : contradictedDiagnostics(messages, cached, (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync19(contained.absolutePath)) {
+      if (!contained.ok || !existsSync20(contained.absolutePath)) {
         return null;
       }
       try {
-        return readFileSync21(contained.absolutePath, "utf8");
+        return readFileSync22(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -44074,11 +44394,11 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync19(contained.absolutePath)) {
+    if (!contained.ok || !existsSync20(contained.absolutePath)) {
       return null;
     }
     try {
-      return readFileSync21(contained.absolutePath, "utf8");
+      return readFileSync22(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -44389,7 +44709,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync21(join24(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync22(join26(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -44711,7 +45031,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync19(join24(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync20(join26(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, {
         addon: false,
         budgetMs,
@@ -44970,7 +45290,7 @@ class GodotServer {
       return 0;
     }
     try {
-      return reportAlreadyInTranscript(readFileSync21(game.transcript), readFileSync21(report));
+      return reportAlreadyInTranscript(readFileSync22(game.transcript), readFileSync22(report));
     } catch (error) {
       this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
       return 0;
@@ -45728,7 +46048,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync19(join24(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync20(join26(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -46289,7 +46609,7 @@ class GodotServer {
     if (!scriptPath.ok) {
       return this.createErrorResponse(scriptPath.reason);
     }
-    if (!existsSync19(scriptPath.absolutePath)) {
+    if (!existsSync20(scriptPath.absolutePath)) {
       return this.createErrorResponse(`Script file does not exist: ${scriptPath.absolutePath}`);
     }
     const asked = readNonEmptyString(args, "newScriptPath");
@@ -46577,7 +46897,7 @@ class GodotServer {
   async ownRunOnItsWay(projectPath, budgetMs) {
     const run = await this.currentRun();
     const project = projectPath ?? run?.projectPath ?? null;
-    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync19(join24(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync20(join26(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -46661,7 +46981,7 @@ class GodotServer {
       }
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join24(screenshotDir, "capture.png") : null;
+    const screenshotPath = screenshotDir ? join26(screenshotDir, "capture.png") : null;
     const staleNote = this.runtimeStaleNote(choice.endpoint);
     const stale = staleNote === undefined ? {} : { addonIsStale: true, staleNote };
     const refused = (message) => this.createErrorResponse(staleNote === undefined ? message : `${message}
@@ -46710,7 +47030,7 @@ ${staleNote}`);
 
 ${staleNote}`}`
           },
-          { type: "image", data: readFileSync21(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync22(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -46811,7 +47131,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, GREETING_WAIT_MS = 1e4, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, KEEPER_ANSWER_MS = 15000, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, 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, SCAN_WAIT_MS = 30000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run4, __dirname2, GREETING_WAIT_MS = 1e4, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, STOP_WAIT_MS = 1e4, KEEPER_ANSWER_MS = 15000, EXIT_REPORTED_WITHIN_MS = 2000, CONSOLE_WRAPPER, LONGEST_BOOT_NOTED_MS, MOST_GROUPS = 20, 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, SCAN_WAIT_MS = 30000, STREAMS_GRACE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, SCAN_SETTLED_MS = 500, REIMPORT_TIMEOUT_MS = 300000, AUDIO_BUS_OPS, STALLED_AFTER_MS = 30000, TEST_HEARTBEAT_MS = 20000, DEPENDED_FAILED = "Failed to compile depended scripts", WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
@@ -46825,6 +47145,7 @@ var init_server3 = __esm(() => {
   init_class_cache();
   init_class_note();
   init_config_pin();
+  init_cut_test_run();
   init_dap_client();
   init_desktop();
   init_editor_log();
@@ -46852,12 +47173,13 @@ var init_server3 = __esm(() => {
   init_run_record();
   init_runtime_client();
   init_scratch();
+  init_script_origins();
   init_server_version();
   init_setup();
   init_tool_definitions();
   init_update_check();
   run4 = promisify5(execFile5);
-  __dirname2 = dirname18(fileURLToPath5(import.meta.url));
+  __dirname2 = dirname19(fileURLToPath5(import.meta.url));
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
   VALUE_NAMES = {
@@ -46907,8 +47229,8 @@ var init_server3 = __esm(() => {
 init_bridge_announce();
 init_errors();
 init_godot_path();
-import { existsSync as existsSync20 } from "node:fs";
-import { join as join25, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync21 } from "node:fs";
+import { join as join27, resolve as resolve8 } from "node:path";
 
 // src/harnesses.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
@@ -48239,7 +48561,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve8(named ?? ".");
-  if (!existsSync20(join25(projectPath, "project.godot"))) {
+  if (!existsSync21(join27(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -48284,7 +48606,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync20(join25(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync21(join27(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }
@@ -48416,7 +48738,7 @@ async function setup() {
       console.log("no harness configured; name one yourself, and gdharness harnesses lists them all");
     }
     if (!args.includes("--no-skill")) {
-      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync20);
+      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync21);
       for (const written of writeSkill(directories, getLocalVersion())) {
         console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
       }
@@ -48530,7 +48852,7 @@ async function upgrade() {
       moved.push(took.from);
     }
   }
-  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync20), version)) {
+  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync21), version)) {
     console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
   }
   console.log(`