gdharness 1.3.38 → 1.3.39

package/build/cli.js

@@ -11334,7 +11334,8 @@ import {
   readSync,
   rmSync as rmSync4,
   statSync as statSync5,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync4,
+  writeSync as writeSync2
 } from "node:fs";
 import { availableParallelism, freemem, totalmem } from "node:os";
 import { isAbsolute as isAbsolute3, join as join7, relative as relative3, resolve as resolve3, sep as sep2 } from "node:path";
@@ -11489,6 +11490,7 @@ async function watchedEngine(launch, args, directory, log, silenceSeconds, silen
   const output = openSync2(log, "w");
   let child;
   let stop;
+  let piped = null;
   let helper = null;
   try {
     if (process6.platform === "win32") {
@@ -11512,11 +11514,13 @@ async function watchedEngine(launch, args, directory, log, silenceSeconds, silen
         stop: stopFile,
         step: helper.step
       });
-      child = spawnHidden(wrapper.command, wrapper.args, {
-        stdio: ["ignore", output, output],
+      const helped = spawnHidden(wrapper.command, wrapper.args, {
+        stdio: ["ignore", "pipe", "pipe"],
         env: { ...env, [DESKTOP_VARIABLE]: HIDDEN_DESKTOP },
         cwd: directory
       });
+      piped = [helped.stdout, helped.stderr];
+      child = helped;
       stop = () => {
         writeFileSync4(stopFile, "");
       };
@@ -11533,7 +11537,9 @@ async function watchedEngine(launch, args, directory, log, silenceSeconds, silen
       };
     }
   } finally {
-    closeSync2(output);
+    if (piped === null) {
+      closeSync2(output);
+    }
   }
   launch.running.add(stop);
   let ended = null;
@@ -11546,6 +11552,7 @@ async function watchedEngine(launch, args, directory, log, silenceSeconds, silen
       });
     })
   ]);
+  const copied = piped === null ? null : copiedInto(output, piped, exited);
   const finished = { now: false };
   exited.then(() => {
     finished.now = true;
@@ -11598,12 +11605,42 @@ async function watchedEngine(launch, args, directory, log, silenceSeconds, silen
   }
   const { code, signal } = await exited;
   const freeBytes = code !== null && code >>> 0 >= WINDOWS_EXCEPTION ? freemem() : undefined;
+  if (copied !== null) {
+    await copied;
+    closeSync2(output);
+  }
   const failed = helper === null ? null : helperFailure(helper.error);
   if (failed !== null && helper !== null) {
     ended ??= `the engine could not be started ${helper.how}: ${failed}`;
   }
   return { code, signal, ended, ...freeBytes === undefined ? {} : { freeBytes } };
 }
+function copiedInto(output, streams, exited) {
+  let writing = true;
+  const ended = streams.map((stream) => new Promise((settle) => {
+    stream.on("data", (chunk) => {
+      if (!writing) {
+        return;
+      }
+      try {
+        writeSync2(output, chunk);
+      } catch {
+        writing = false;
+      }
+    });
+    stream.once("close", settle);
+  }));
+  const all = Promise.all(ended).then(() => {
+    return;
+  });
+  const drained = exited.then(() => delay2(DRAIN_MS, undefined, { ref: false }));
+  return Promise.race([all, drained]).then(() => {
+    writing = false;
+    for (const stream of streams) {
+      stream.destroy();
+    }
+  });
+}
 function endTree(child) {
   if (child.pid === undefined) {
     return;
@@ -11616,7 +11653,7 @@ function endTree(child) {
     process6.kill(-child.pid, "SIGKILL");
   } catch {}
 }
-var EngineUsageError, MOST_ENGINES = 4, SILENCE_FLOOR_SECONDS = 300, CONTROL_SEQUENCE, WINDOWS_EXCEPTION = 3221225472, MEMORY_KEPT, MEMORY_PER_ENGINE, LOOK_MS = 500, COMMIT_ASK_MS = 15000, AUTOLOAD_FAILED = "Failed to instantiate an autoload", KEPT_RUN_DIRECTORIES = 5;
+var EngineUsageError, MOST_ENGINES = 4, SILENCE_FLOOR_SECONDS = 300, CONTROL_SEQUENCE, WINDOWS_EXCEPTION = 3221225472, MEMORY_KEPT, MEMORY_PER_ENGINE, LOOK_MS = 500, COMMIT_ASK_MS = 15000, AUTOLOAD_FAILED = "Failed to instantiate an autoload", KEPT_RUN_DIRECTORIES = 5, DRAIN_MS = 5000;
 var init_engine_launch = __esm(() => {
   init_alive();
   init_desktop();
@@ -11744,7 +11781,7 @@ import {
   rmSync as rmSync6,
   statSync as statSync6,
   watch,
-  writeSync as writeSync2
+  writeSync as writeSync3
 } from "node:fs";
 import { availableParallelism as availableParallelism2, homedir as homedir2 } from "node:os";
 import { join as join8, resolve as resolve4 } from "node:path";
@@ -11970,7 +12007,7 @@ class EngineSlots {
       return false;
     }
     try {
-      writeSync2(made, JSON.stringify(this.holder));
+      writeSync3(made, JSON.stringify(this.holder));
     } finally {
       closeSync3(made);
     }
@@ -12084,7 +12121,7 @@ async function inASlot(body) {
     held.release();
   }
 }
-var SLOTS_VARIABLE = "GODOT_ENGINE_SLOTS", SLOT_COUNT_VARIABLE = "GODOT_ENGINE_SLOT_COUNT", PROCESSORS_A_SLOT = 5, START_TOLERANCE_MS = 2000, UNWRITTEN_MS = 1e4, SLOT_LOOK_MS = 1000, SLOT_SETTLE_MS = 50, WAIT_SAID_MS = 20000, COMMAND_WAIT_SAID_MS = 2000, START_READ_MS = 1e4, WAITING_FOLDER = "waiting", waitsMarked = 0, ours, saidTo, takenBy;
+var SLOTS_VARIABLE = "GODOT_ENGINE_SLOTS", SLOT_COUNT_VARIABLE = "GODOT_ENGINE_SLOT_COUNT", PROCESSORS_A_SLOT = 2, START_TOLERANCE_MS = 2000, UNWRITTEN_MS = 1e4, SLOT_LOOK_MS = 1000, SLOT_SETTLE_MS = 50, WAIT_SAID_MS = 20000, COMMAND_WAIT_SAID_MS = 2000, START_READ_MS = 1e4, WAITING_FOLDER = "waiting", waitsMarked = 0, ours, saidTo, takenBy;
 var init_engine_slots = __esm(() => {
   init_alive();
   init_call_signal();
@@ -17364,7 +17401,7 @@ var init_tool_definitions = __esm(() => {
       name: "script_diagnostics",
       title: "Script diagnostics",
       effect: "read",
-      description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. With no editor of this project open, so no language server of it to ask, a short headless engine compiles the scripts instead and the answer says checkedBy: engine rather than language server: every error that stops a script compiling, up to its first syntax error, with its line and no column (a call to a method another class lacks is not one, since GDScript checks those only on self: the object may be a subclass that has it, so it fails at run time instead), dependenciesWithErrors naming the other scripts that failed while it loaded, typesMissingFromTheClassCache naming a class the project declares that the engine could not resolve because the class cache lacks it, with staleAnalysis saying what rewrites the cache, and warnings null, since the engine reports warnings only to an editor. Of several scripts, a language server that stops answering partway leaves the rest to the engine, and checkedBy then says language server, then engine, with checkedByLanguageServer counting the scripts it answered. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, or a project class it extends does, a method, property, constant, static function or enum member, comes back under contradictedByTheFile with the script declaring it, and so does one a diagnostic names alone as an external class member, read against the class it is looked up on in the line it is on; and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
+      description: "Errors and warnings for a script, or for several, from the editor's language server, and whether each is clean. With no editor of this project open, so no language server of it to ask, a short headless engine compiles the scripts instead and the answer says checkedBy: engine rather than language server: every error that stops a script compiling, up to its first syntax error, with its line and no column (a call to a method another class lacks is not one, since GDScript checks those only on self: the object may be a subclass that has it, so it fails at run time instead), dependenciesWithErrors naming the other scripts that failed while it loaded, typesMissingFromTheClassCache naming a class the project declares that the engine could not resolve because the class cache lacks it, with staleAnalysis saying what rewrites the cache, and the warnings at the levels the project sets, which a second engine reports by raising each warning set to warn as an error for that run only, each at its line with no column, warnings being null when that engine could not answer. Of several scripts, a language server that stops answering partway leaves the rest to the engine, and checkedBy then says language server, then engine, with checkedByLanguageServer counting the scripts it answered. Each diagnostic carries its severity (error or warning), its message, and where it is as the editor shows it: line and column counted from 1, and endLine and endColumn just past its end. Diagnostics are checked against the project's own files, and the two that the files disprove are named rather than passed on: a member the class cache's file declares, or a project class it extends does, a method, property, constant, static function or enum member, comes back under contradictedByTheFile with the script declaring it, and so does one a diagnostic names alone as an external class member, read against the class it is looked up on in the line it is on; and a class this project declares that the diagnostic could not resolve comes back under typesTheEditorHasNotLoaded, with inTheClassCache saying whether a launched game would resolve it. staleAnalysis then says what to do, and for both states it is editor_rescan first: it asks the editor already running, starts nothing, and has cleared each in every reproduction measured. Two exceptions are named when they apply. For an enum member, constant or static function of a global class the reload comes first: in the one project that has reproduced a stale enum member, editor_rescan with reloadScript on the declaring script cleared it and a plain rescan did not. And an editor whose last scan wrote the class cache shorter than the file holds a list behind the files and writes it on every scan, so on that editor the rescan loads nothing and staleAnalysis says editor_launch restart instead. What follows differs: for a stale analysed type, editor_rescan with reloadScript recompiles the held copy and editor_launch restart is the last resort that costs a window; for a class missing from the cache, project_import refresh_classes rewrites the cache from disk at the cost of a short headless engine, which matters beside a running bench.",
       parameters: {
         projectPath: PROJECT_PATH,
         scriptPath: {
@@ -18665,6 +18702,7 @@ class ProjectScripts {
   suite(path) {
     const cases = new Set;
     let said;
+    let together;
     let guessed = false;
     const seen = new Set;
     let at = path;
@@ -18679,13 +18717,21 @@ class ProjectScripts {
       }
       const declared = NEEDS_WINDOW.exec(read.code)?.[1];
       said ??= declared === undefined ? undefined : declared === "true";
+      const kept = TOGETHER.exec(read.code)?.[1];
+      together ??= kept === undefined ? undefined : kept === "true";
       guessed ||= this.guessWindow && 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: said ?? guessed, headless: said === false } : null;
+        return cases.size > 0 ? {
+          path,
+          cases: [...cases].sort(),
+          windowed: said ?? guessed,
+          headless: said === false,
+          together: together === true
+        } : null;
       }
       if ("name" in base) {
         return null;
@@ -18808,6 +18854,10 @@ function rowsAfter(before, measured, cutShort) {
 function round(seconds) {
   return Math.round(seconds * 1000) / 1000;
 }
+function splitPastFor(suites, times, engines) {
+  const whole = unitsOf(suites, times, Number.POSITIVE_INFINITY).reduce((sum, unit) => sum + unit.cost, 0);
+  return Math.max(SPLIT_PAST_SECONDS, whole / Math.max(1, engines));
+}
 function median(values) {
   if (values.length === 0) {
     return;
@@ -18834,7 +18884,7 @@ function unitsOf(suites, times, splitPast = SPLIT_PAST_SECONDS) {
       windowed: suite.windowed,
       headless: suite.headless
     };
-    if (suite.windowed || whole <= splitPast) {
+    if (suite.windowed || suite.together || whole <= splitPast) {
       return [wholly];
     }
     const units = suite.cases.flatMap((func) => {
@@ -19003,13 +19053,14 @@ function viewportOf(projectPath) {
   const height = /^window\/size\/viewport_height\s*=\s*(\d+)/m.exec(text)?.[1];
   return width === undefined || height === undefined ? null : { width: Number(width), height: Number(height) };
 }
-var SUITE_BASE = "GdUnitTestSuite", CASE_PREFIX = "test_", NEEDS_WINDOW, TEST_DIRECTORIES, SCENE_RUNNER, NOT_SEARCHED_SETTING = "gdharness/tests/not_searched", GUESS_WINDOW_SETTING = "gdharness/tests/scene_runner_needs_window", UNTIMED_CASE = 0.02, SPLIT_PAST_SECONDS = 10, ENGINE_START_SECONDS = 5, SHARE_FLOOR_SECONDS;
+var SUITE_BASE = "GdUnitTestSuite", CASE_PREFIX = "test_", NEEDS_WINDOW, TOGETHER, TEST_DIRECTORIES, SCENE_RUNNER, NOT_SEARCHED_SETTING = "gdharness/tests/not_searched", GUESS_WINDOW_SETTING = "gdharness/tests/scene_runner_needs_window", UNTIMED_CASE = 0.02, SPLIT_PAST_SECONDS = 10, ENGINE_START_SECONDS = 5, SHARE_FLOOR_SECONDS;
 var init_suite_plan = __esm(() => {
   init_class_cache();
   init_gdscript_source();
   init_resources();
   init_whole_file();
   NEEDS_WINDOW = /^const\s+GDHARNESS_NEEDS_WINDOW\b[^=\n]*=\s*(true|false)\b/m;
+  TOGETHER = /^const\s+GDHARNESS_TOGETHER\b[^=\n]*=\s*(true|false)\b/m;
   TEST_DIRECTORIES = ["tests", "test"];
   SCENE_RUNNER = /\bscene_runner\s*\(/;
   SHARE_FLOOR_SECONDS = 6 * ENGINE_START_SECONDS;
@@ -50416,9 +50467,13 @@ function engineChecked(why) {
   return {
     checkedBy: "engine",
     languageServer: why,
-    note: "No editor of this project is open to ask, so a headless engine compiled the scripts the way loading them does. It reports every error that stops a script compiling, at its line and without a column, but stops reading a script at its first syntax error, so an error after one shows once it is fixed. It reports no warnings, which the engine tells only an editor: warnings is null rather than 0. editor_launch with hidden: true opens this project's editor without a window, and its language server reports both. Until then clean says only that every script compiles."
+    note: "No editor of this project is open to ask, so a headless engine compiled the scripts the way loading them does. It reports every error that stops a script compiling, at its line and without a column, but stops reading a script at its first syntax error, so an error after one shows once it is fixed. A second engine reports the warnings, at the levels the project sets, by raising each warning set to warn as an error for that run only, since the engine tells a warning as one only to an editor; each comes at its line without a column, and warnings is null when that engine could not answer. editor_launch with hidden: true opens this project's editor without a window, and its language server reports both with their columns."
   };
 }
+function asWarning(raised) {
+  const bare = raised.endsWith(RAISED_WARNING) ? raised.slice(0, -RAISED_WARNING.length) : raised;
+  return bare.startsWith(PARSE_ERROR2) ? bare.slice(PARSE_ERROR2.length) : bare;
+}
 function isDirectory(path) {
   try {
     return statSync20(path).isDirectory();
@@ -53206,6 +53261,7 @@ ${error.text}`;
     const nothingReported = [];
     let errors = 0;
     let warnings = 0;
+    let engineWarned = 0;
     let unread = 0;
     let byEngine = null;
     let byServer = 0;
@@ -53224,6 +53280,7 @@ ${error.text}`;
         }
         for (const answer of checked.answers) {
           errors += Number(answer["errors"]);
+          engineWarned = answer["warnings"] === null || engineWarned === null ? null : engineWarned + Number(answer["warnings"]);
           if (readArray(answer, "diagnostics")?.length === 0) {
             nothingReported.push(String(answer["scriptPath"]));
           } else {
@@ -53254,7 +53311,7 @@ ${error.text}`;
       clean: errors === 0 && unread === 0,
       scriptsChecked: scripts.value.length,
       errors,
-      warnings: byEngine === null ? warnings : null,
+      warnings: engineWarned === null ? null : warnings + engineWarned,
       ...unread > 0 ? { scriptsNotRead: unread } : {},
       scripts: reported,
       nothingReported,
@@ -53289,6 +53346,20 @@ ${error.text}`;
     }
     return { ok: true, payload, extras: engineExtras({ messages }) };
   }
+  async engineWarnings(projectPath, paths) {
+    const ran = await this.operation("check_warnings", { paths: [...paths] }, projectPath);
+    if (!ran.ok) {
+      this.logDebug(`check_warnings did not answer: ${ran.message}`);
+      return null;
+    }
+    return new Map((readArray(ran.payload, "scripts") ?? []).map((entry) => [
+      String(asParams(entry)["path"]),
+      (readArray(asParams(entry), "warnings") ?? []).map((warning) => ({
+        line: Number(asParams(warning)["line"]),
+        message: String(asParams(warning)["message"])
+      }))
+    ]));
+  }
   async engineDiagnostics(projectPath, scripts, why) {
     const named = scripts.map((script) => {
       const contained = resolveWithinProject(projectPath, script);
@@ -53305,21 +53376,25 @@ ${error.text}`;
       asParams(entry)
     ]));
     const errorsOf = scripts.map((_, at) => readArray(failures.get(named[at] ?? "") ?? {}, "errors") ?? []);
+    const warned = await this.engineWarnings(projectPath, named);
     const uncachedPer = uncachedFor(projectPath, errorsOf.map((errors) => errors.map((entry) => String(asParams(entry)["message"]))));
     return {
       answers: scripts.map((scriptPath, at) => {
         const failure = failures.get(named[at] ?? "");
-        const diagnostics = (errorsOf[at] ?? []).map((entry) => {
+        const errors = (errorsOf[at] ?? []).map((entry) => {
           const { line, message } = asParams(entry);
           return { severity: "error", message, ...typeof line === "number" && line > 0 ? { line } : {} };
         });
+        const raised = new Set(errors.map(({ message, line }) => `${line ?? 0}:${String(message)}`));
+        const warnings = warned === null ? [] : (warned.get(named[at] ?? "") ?? []).filter(({ line, message }) => !raised.has(`${line}:${message}`)).map(({ line, message }) => ({ severity: "warning", message: asWarning(message), line }));
+        const diagnostics = [...errors, ...warnings].sort((a, b) => (a.line ?? 0) - (b.line ?? 0));
         const dependencies = readArray(failure ?? {}, "dependencies_with_errors");
         const uncached = uncachedPer[at] ?? [];
         return {
           scriptPath,
-          clean: diagnostics.length === 0,
-          errors: diagnostics.length,
-          warnings: null,
+          clean: errors.length === 0,
+          errors: errors.length,
+          warnings: warned === null ? null : warnings.length,
           diagnostics,
           ...dependencies === undefined ? {} : { dependenciesWithErrors: dependencies },
           ...uncached.length === 0 ? {} : {
@@ -57669,7 +57744,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, SUCCESSOR_SOUGHT_WITHIN_MS = 20000, 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, DESTINATION_ARGUMENTS, 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_PRINTED_LINES = 50, MOST_UNDECLARED_ERRORS = 20, 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, SUCCESSOR_SOUGHT_WITHIN_MS = 20000, 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, DESTINATION_ARGUMENTS, 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_PRINTED_LINES = 50, MOST_UNDECLARED_ERRORS = 20, ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd", RAISED_WARNING = " (Warning treated as error.)", PARSE_ERROR2 = "Parse Error: ", EXTERNAL_MEMBER = 'Could not resolve external class member "', STATIC_LIST_HINT;
 var init_server = __esm(() => {
   init_dist2();
   init_stdio();
@@ -59116,7 +59191,6 @@ ${existsSync23(path) ? readFileSync22(path, "latin1") : "missing"}`)
       }
     }
     const times = readTimes(timesFile);
-    const units = unitsOf(suites, times);
     const memory = await memoryAvailable();
     if (memory.unread !== undefined) {
       console.log(`Windows did not say how much memory it can still commit (${memory.unread}), so engines are sized by the physical memory free.`);
@@ -59125,9 +59199,13 @@ ${existsSync23(path) ? readFileSync22(path, "latin1") : "missing"}`)
     if (options.cores !== null && process14.platform === "darwin") {
       console.log("macOS offers no way to hold a process to some processors, so --cores holds only the number of engines here.");
     }
+    const splitPast = splitPastFor(suites, times, room.engines);
+    const units = unitsOf(suites, times, splitPast);
+    const past = splitPast > SPLIT_PAST_SECONDS ? `an engine's share of this run (${String(Math.round(splitPast))} s)` : `${String(SPLIT_PAST_SECONDS)} s`;
     const plans = options.order === null ? dealt(units, declared, room.engines) : [inOneEngine(ordered(units, options.order), declared)];
     const functions = suites.reduce((sum, suite) => sum + suite.cases.length, 0);
-    const how = options.order === null ? `${windowedSaid(plans)}${roomSaid(plans.length, lanesOf(plans), lanesOf(dealt(units, declared, options.engines)), room.held, options.engines)}` : options.order === "reversed" ? ", in reverse order of path" : `, shuffled by ${String(options.order)}`;
+    const asked = unitsOf(suites, times, splitPastFor(suites, times, options.engines));
+    const how = options.order === null ? `${windowedSaid(plans)}${roomSaid(plans.length, lanesOf(plans), lanesOf(dealt(asked, declared, options.engines)), room.held, options.engines)}` : 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 windowedAnyway = headlessInAWindow(plans, units);
     if (windowedAnyway.length > 0) {
@@ -59136,13 +59214,18 @@ ${existsSync23(path) ? readFileSync22(path, "latin1") : "missing"}`)
     }
     const split = [...new Set(units.map((unit) => unit.suite))].filter((path) => units.filter((unit) => unit.suite === path && unit.row === undefined).length > 1);
     if (plans.length > 1 && split.length > 0) {
-      console.log(`Dealt out case by case, since ${split.length === 1 ? "it" : "each"} took more than ${String(SPLIT_PAST_SECONDS)} s last time: ${named(split)}.`);
+      console.log(`Dealt out case by case, since ${split.length === 1 ? "it" : "each"} took more than ${past} last time: ${named(split)}.`);
     }
     const byRows = [
       ...new Set(units.flatMap((unit) => unit.row === undefined ? [] : [`${unit.suite} > ${unit.cases[0] ?? ""}`]))
     ];
     if (plans.length > 1 && byRows.length > 0) {
-      console.log(`Dealt out row by row, since ${byRows.length === 1 ? "it" : "each"} took more than ${String(SPLIT_PAST_SECONDS)} s last time: ${named(byRows)}.`);
+      console.log(`Dealt out row by row, since ${byRows.length === 1 ? "it" : "each"} took more than ${past} last time: ${named(byRows)}.`);
+    }
+    const keptWhole = units.flatMap((unit) => unit.cost > splitPast && !unit.windowed && suites.some((s) => s.path === unit.suite && s.together) ? [unit.suite] : []);
+    if (options.order === null && room.engines > 1 && keptWhole.length > 0) {
+      const one = keptWhole.length === 1;
+      console.log(`Kept whole in one engine, since ${one ? "it declares" : "each declares"} GDHARNESS_TOGETHER: ${named(keptWhole)}.`);
     }
     const lanes = [...new Set(plans.map((plan) => plan.lane))].map((lane) => plans.flatMap((plan, index) => plan.lane === lane ? [{ plan, index }] : []));
     const taken = [];

package/build/godot/operations/godot_operations.gd

@@ -51,6 +51,7 @@ const BEGUN: String = "[gdharness] begun"
 ## scene or a resource, loads the scripts of the file it opens.
 const AFTER_THE_AUTOLOADS: Array[String] = [
 	"check_scripts",
+	"check_warnings",
 	"create_script",
 	# An exporter made in _init, before an editor's main loop has started, crashed the engine.
 	"export_options",
@@ -99,6 +100,8 @@ func _init() -> void:
 	var params: Dictionary = read
 
 	_log.info("Executing operation: " + operation)
+	if operation == "check_warnings":
+		GdhScriptCheck.raise_warnings()
 
 	var answer_path: String = args[answer_index]
 	if operation in AFTER_THE_AUTOLOADS:
@@ -279,6 +282,8 @@ func _run(operation: String, params: Dictionary) -> Dictionary:
 			payload = GdhRenameChecks.new(_log).names_taken(params)
 		"check_scripts":
 			payload = GdhScriptCheck.new(_log).check_scripts(params)
+		"check_warnings":
+			payload = GdhScriptCheck.new(_log).check_warnings(params)
 
 		# Plugins and input
 		"list_plugins":

package/build/godot/operations/script_check.gd

@@ -19,6 +19,15 @@ const GdhLog = preload("logger.gd")
 ## Where the engine raises a script's compile errors from.
 const RELOAD: String = "GDScript::reload"
 
+## What the engine puts on the end of a warning it raised as an error. Kept in step with
+## `RAISED_WARNING` in src/server.ts.
+const RAISED: String = " (Warning treated as error.)"
+
+## Where the project's warning levels are, each 0 to ignore, 1 to warn and 2 to raise as an error.
+const WARNING_LEVELS: String = "debug/gdscript/warnings/"
+const WARN: int = 1
+const ERROR_LEVEL: int = 2
+
 var _log: GdhLog
 
 
@@ -112,3 +121,52 @@ func check_scripts(params: Dictionary) -> Dictionary:
 		break
 	OS.remove_logger(caught)
 	return {"checked": checked, "failed": failed, "scripts": scripts}
+
+
+## Raises every warning the project sets to warn so that the engine reports it as an error, which is
+## the one way it reports a warning outside an editor or a debugger. Not saved. The analyser reads
+## the levels again only once the settings change has been flushed, at the next frame, so this is
+## called in `_init` and the scripts are loaded after it; the project's autoloads, compiled before
+## that frame, compile under the project's own levels. A warning set to ignore stays ignored, and
+## @warning_ignore and the directory rules hold as they do in the editor, since the analyser applies
+## them itself.
+static func raise_warnings() -> void:
+	for property: Dictionary in ProjectSettings.get_property_list():
+		var setting: String = str(property.get("name", ""))
+		if (
+			not setting.begins_with(WARNING_LEVELS)
+			or GdhRead.as_int(property.get("type", TYPE_NIL)) != TYPE_INT
+		):
+			continue
+		if GdhRead.as_int(ProjectSettings.get_setting(setting)) == WARN:
+			ProjectSettings.set_setting(setting, ERROR_LEVEL)
+
+
+## The warnings of each script in [code]paths[/code], under the levels [method raise_warnings] left:
+## [code]scripts[/code] holds each that has any, with its warnings' lines and the engine's messages
+## as raised. The analyser runs before anything is compiled, so a script whose dependency failed on a
+## warning still reports its own, and loading on past a failure loses nothing; only what is raised at
+## the script's own path is its, since a dependency is read on its own entry as well.
+func check_warnings(params: Dictionary) -> Dictionary:
+	var asked: Array = params.get("paths", [])
+	var caught: GdhCaught = GdhCaught.new()
+	OS.add_logger(caught)
+	var checked: Array[String] = []
+	var scripts: Array[Dictionary] = []
+	for entry: Variant in asked:
+		var path: String = str(entry)
+		checked.append(path)
+		caught.raised.clear()
+		var _loaded: Resource = ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_IGNORE)
+		var warnings: Array[Dictionary] = []
+		for error: Dictionary in caught.raised:
+			var message: String = str(error["message"])
+			if str(error["path"]) != path or not message.ends_with(RAISED):
+				continue
+			var found: Dictionary = {"line": GdhRead.as_int(error["line"]), "message": message}
+			if not found in warnings:
+				warnings.append(found)
+		if not warnings.is_empty():
+			scripts.append({"path": path, "warnings": warnings})
+	OS.remove_logger(caught)
+	return {"checked": checked, "scripts": scripts}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.3.38",
+  "version": "1.3.39",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",