gdharness 1.3.29 → 1.3.31

package/build/cli.js

@@ -10176,6 +10176,36 @@ function walkStoppedPartWay(lines) {
   }
   return began;
 }
+function heldAtExit(lines) {
+  const objects = new Map;
+  const inUse = [];
+  for (const line of lines) {
+    const object = LEAKED_INSTANCE.exec(line.trim())?.[1];
+    if (object !== undefined) {
+      objects.set(object, (objects.get(object) ?? 0) + 1);
+    }
+    const resource = STILL_IN_USE.exec(line.trim())?.[1];
+    if (resource !== undefined) {
+      inUse.push(resource);
+    }
+  }
+  if (objects.size === 0 && inUse.length === 0) {
+    return;
+  }
+  const counted = [...objects].sort(([a, many], [b, more]) => more - many || a.localeCompare(b));
+  const objectsSaid = counted.map(([name, many]) => `${String(many)} ${name}`);
+  const ownFirst = [
+    ...inUse.filter((path) => !path.startsWith("res://addons/")),
+    ...inUse.filter((path) => path.startsWith("res://addons/"))
+  ];
+  const named = ownFirst.slice(0, IN_USE_NAMED);
+  const more = ownFirst.length - named.length;
+  const parts = [
+    objectsSaid.length === 0 ? undefined : `objects left alive: ${objectsSaid.join(", ")}`,
+    named.length === 0 ? undefined : `resources still in use: ${named.join(", ")}${more > 0 ? `, and ${String(more)} more` : ""}`
+  ].filter((part) => part !== undefined);
+  return `The engine named them: ${parts.join("; ")}.`;
+}
 function selfTypedExports(sources) {
   const found = [];
   for (const [script, source] of sources) {
@@ -10208,11 +10238,13 @@ function selfTypedSentence(found) {
   const one = found.length === 1;
   return `Godot never frees a script exporting an array or dictionary typed with its own class once a run ` + `has loaded it, and reports it as leaked at exit: ${named} ${one ? "does" : "do"}, so a run loading ` + `${one ? "it" : "one"} ends with this report whatever else it frees. Typed with a class it extends ` + `instead, as Array[Resource], ${one ? "it is" : "each is"} freed.`;
 }
-var EXIT_LEAK, WALK_BEGAN = "gdharness: the engine's shutdown began clearing scripts", WALK_ENDED = "gdharness: the engine's shutdown cleared every script", WALK_STOPPED_SENTENCE, NAME2 = "[\\p{L}_][\\p{L}\\p{N}_]*", EXPORTED;
+var EXIT_LEAK, WALK_BEGAN = "gdharness: the engine's shutdown began clearing scripts", WALK_ENDED = "gdharness: the engine's shutdown cleared every script", LEAKED_INSTANCE, STILL_IN_USE, IN_USE_NAMED = 8, WALK_STOPPED_SENTENCE, NAME2 = "[\\p{L}_][\\p{L}\\p{N}_]*", EXPORTED;
 var init_engine_leaks = __esm(() => {
   init_class_cache();
   init_gdscript_source();
   EXIT_LEAK = /ObjectDB instances? (?:was |were )?leaked at exit|resources? still in use at exit|Pages in use exist at exit|RIDs? of type ["'][^"']+["'] (?:was|were) leaked/;
+  LEAKED_INSTANCE = /^Leaked instance: (\w+):/;
+  STILL_IN_USE = /^Resource still in use: (.+?) \(\w+\)$/;
   WALK_STOPPED_SENTENCE = "The engine's shutdown stopped part way through its scripts (godot#117991, fixed in 4.8 by " + "godot#120976), so it reported as leaked at exit what it never got to free, and the report is the " + "engine's rather than the run's. gdharness holds every script loaded from a file past that walk, " + "which keeps it whole, so this one stopped on a script it could not hold, such as one made in code. " + "A leak of the run's own is not told apart in such a run.";
   EXPORTED = new RegExp(`@export(?!_(?:group|subgroup|category)\\b)\\w*(?:\\([^)]*\\))?\\s+(?:@${NAME2}(?:\\([^)]*\\))?\\s+)*` + `(?:static\\s+)?var\\s+(${NAME2})\\s*:\\s*(?:Array|Dictionary)\\s*\\[([^\\]]*)\\]`, "gu");
 });
@@ -11104,9 +11136,11 @@ function judgeEngine(printed, handed, end) {
   if (printed.leaks.length > 0 && walkStoppedPartWay(printed.lines)) {
     notes.push(`${WALK_STOPPED_SENTENCE} It said: ${printed.leaks.join(" ")}`);
   } else {
+    const held = heldAtExit(printed.lines);
     printed.leaks.forEach((leak, at) => {
       const last = at === printed.leaks.length - 1;
-      faults.push(`the engine exited holding what it should have freed: ${leak}${last && selfTyped !== undefined ? ` ${selfTyped}` : ""}`);
+      const after = last ? [held, selfTyped].filter((part) => part !== undefined) : [];
+      faults.push(`the engine exited holding what it should have freed: ${[leak, ...after].join(" ")}`);
     });
   }
   const memoryExit = end.code !== null && MEMORY_EXITS.has(end.code >>> 0);
@@ -11734,12 +11768,9 @@ class EngineSlots {
     try {
       for (;; ) {
         signal?.throwIfAborted();
-        for (let slot = 0;slot < this.count; slot += 1) {
-          const lock = join8(this.directory, `${String(slot)}.lock`);
-          if (this.made(lock) || await this.takenOver(lock)) {
-            this.held.add(lock);
-            return lock;
-          }
+        const lock = await this.takeFree();
+        if (lock !== null) {
+          return lock;
         }
         mark ??= this.waitMarked();
         const now = Date.now();
@@ -11760,6 +11791,17 @@ class EngineSlots {
       }
     }
   }
+  async takeFree() {
+    mkdirSync3(this.directory, { recursive: true });
+    for (let slot = 0;slot < this.count; slot += 1) {
+      const lock = join8(this.directory, `${String(slot)}.lock`);
+      if (this.made(lock) || await this.takenOver(lock)) {
+        this.held.add(lock);
+        return lock;
+      }
+    }
+    return null;
+  }
   waitMarked() {
     const marks = join8(this.directory, WAITING_FOLDER);
     waitsMarked += 1;
@@ -16606,7 +16648,7 @@ var init_tool_definitions = __esm(() => {
       title: "Run tests",
       effect: "additive",
       description: "Runs the project's gdUnit4 tests and answers with every case that did not pass: where it is, and what the assertion said. Each entry under failed carries its first report as message and detail, and, when it has more than one, its reports under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. Identical reports fold into one with times, at most twenty different ones are kept (reportsLeftOut counts the rest), and past about a megabyte the largest cases keep only their first message (failedWithoutDetail). failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted, not listed, and an engine message keeps the frames above gdUnit4, not the twenty inside it; identical engine messages come back once under engineEntries, with times saying how often they were printed, and with script, line and function for the project script one points at, as editor_output's entries have. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes. What changed on disk since it was imported is then imported before any suite runs, and named under importedFirst. On Windows and Linux the run gets a user:// of its own, away from a player's saves; on macOS the engine reads user:// off HOME, so it writes where the player keeps theirs, and savesNote says so. The run is headless unless a suite in it needs a window as gdharness test reads it, and then has one, on a desktop of its own on Windows. A run that found nothing to run is never called a pass, and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. An autoload that does not compile stops the run at once, its errors listed the same way. A client sending a progress token is told as each suite finishes, and at least every twenty seconds. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but orphan nodes were left comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and is not listed there, and none are when the project turns off gdUnit4's report/godot/script_error setting; a suite declares them all the same. Needs gdUnit4 under addons/gdUnit4.",
-      answer: "passed is the verdict to read. exitCode is the engine's own exit, gdUnit4's code for what it saw, and is 0 beside passed false when the run is failed for something gdUnit4 does not judge, such as an engine error no suite declared. time is gdUnit4's own sum of the seconds its cases took, from its report. tookMs is the whole call in milliseconds, from the class rebuild to the engine's exit, which is what a caller waits for, and tookMsBy splits it into the class rebuild (classes), the import after it (import) and the engine running the suites (engine), each with any wait for an engine slot or the editor's scan in it. The run is judged as gdharness test judges it: undeclaredErrors names each engine error that no suite declared in its GDHARNESS_EXPECTED_ERRORS constant, and each engine warning a suite printed and did not declare in its GDHARNESS_EXPECTED_WARNINGS, marked warning true, with the suite and the case that printed it, and declaredNotPrinted each declared error or warning its case did not print. A declared text must be the whole line after ERROR: or WARNING: and its space, so a longer one its case printed holding the text is named under printedInstead. Either fails the run, and each suite holding one is listed with its count. leakedAtExit holds the engine's lines saying it exited still holding objects, resources, memory pages or a server's RIDs, which fail the run too, and the note names any script of the project Godot itself never frees. engineErrors counts every engine error the run printed but those a suite declared. orphans totals the orphan nodes gdUnit4 counted, and each suite that left some has its count, and a warning saying how to free them, under warnings, with left naming each case that left some (before or after for one of the suite's hooks, or the one value \"before or after\" where no case began and the two cannot be told apart) and the nodes, by class, name and script. suites lists only the suites with something to say (a case that failed, erred or was skipped, a hook that failed, orphans, or an error undeclared or declared and not printed), and suitesPassed counts the rest. Under classes, the classes each addon declares are counted under addedInAddons and changedInAddons rather than named, and a class the rebuild 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. A suite needs a window when it declares const GDHARNESS_NEEDS_WINDOW: bool = true, or calls scene_runner and declares nothing; a run holding one has a window, at the size project.godot gives its viewport and with no sound, and windowed is true and windowNote names those suites and any saying it runs headless that shared the window. On a machine with no display such a run is headless, windowed is false, and windowNote says so. " + IMPORTED_FIRST,
+      answer: "passed is the verdict to read. exitCode is the engine's own exit, gdUnit4's code for what it saw, and is 0 beside passed false when the run is failed for something gdUnit4 does not judge, such as an engine error no suite declared. time is gdUnit4's own sum of the seconds its cases took, from its report. tookMs is the whole call in milliseconds, from the class rebuild to the engine's exit, which is what a caller waits for, and tookMsBy splits it into the class rebuild (classes), the import after it (import) and the engine running the suites (engine), each with any wait for an engine slot or the editor's scan in it. The run is judged as gdharness test judges it: undeclaredErrors names each engine error that no suite declared in its GDHARNESS_EXPECTED_ERRORS constant, and each engine warning a suite printed and did not declare in its GDHARNESS_EXPECTED_WARNINGS, marked warning true, with the suite and the case that printed it, and declaredNotPrinted each declared error or warning its case did not print. A declared text must be the whole line after ERROR: or WARNING: and its space, so a longer one its case printed holding the text is named under printedInstead. Either fails the run, and each suite holding one is listed with its count. leakedAtExit holds the engine's lines saying it exited still holding objects, resources, memory pages or a server's RIDs, which fail the run too, and the note names any script of the project Godot itself never frees and, on a run with engineArgs [\"--verbose\"], what the engine held. engineErrors counts every engine error the run printed but those a suite declared. orphans totals the orphan nodes gdUnit4 counted, and each suite that left some has its count, and a warning saying how to free them, under warnings, with left naming each case that left some (before or after for one of the suite's hooks, or the one value \"before or after\" where no case began and the two cannot be told apart) and the nodes, by class, name and script. suites lists only the suites with something to say (a case that failed, erred or was skipped, a hook that failed, orphans, or an error undeclared or declared and not printed), and suitesPassed counts the rest. Under classes, the classes each addon declares are counted under addedInAddons and changedInAddons rather than named, and a class the rebuild 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. A suite needs a window when it declares const GDHARNESS_NEEDS_WINDOW: bool = true, or calls scene_runner and declares nothing; a run holding one has a window, at the size project.godot gives its viewport and with no sound, and windowed is true and windowNote names those suites and any saying it runs headless that shared the window. On a machine with no display such a run is headless, windowed is false, and windowNote says so. " + IMPORTED_FIRST,
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
@@ -16627,7 +16669,7 @@ var init_tool_definitions = __esm(() => {
         engineArgs: {
           type: "array",
           items: { type: "string" },
-          description: `The engine's own flags for the run, such as ["--verbose"], a value going as the next entry. Only those that change what the engine logs, draws for debugging, checks on the GPU, which renderer draws, how it times frames or whether it builds the tree a screen reader reads: ${Object.keys(ENGINE_FLAGS).join(", ")}. Any other is refused. With --verbose, engineEntries holds the ordinary lines the run printed as well, which is where the engine names the instances leaked and the resources still in use at exit.`
+          description: `The engine's own flags for the run, such as ["--verbose"], a value going as the next entry. Only those that change what the engine logs, draws for debugging, checks on the GPU, which renderer draws, how it times frames or whether it builds the tree a screen reader reads: ${Object.keys(ENGINE_FLAGS).join(", ")}. Any other is refused. With --verbose, engineEntries holds the ordinary lines the run printed as well, the newest of them, and a leak at exit is named in the note: the objects left alive counted by class, and the resources still in use, the project's own before its addons'.`
         },
         failFast: {
           type: "boolean",
@@ -18638,7 +18680,7 @@ function dealt(units, declared, most) {
     return [];
   }
   const windowed = units.filter((unit) => unit.windowed);
-  const headless = units.filter((unit) => !unit.windowed).sort((a, b) => b.cost - a.cost || a.suite.localeCompare(b.suite) || (a.cases[0] ?? "").localeCompare(b.cases[0] ?? "") || (a.row?.index ?? 0) - (b.row?.index ?? 0));
+  const headless = units.filter((unit) => !unit.windowed).sort(slowestFirst);
   const together = windowed.reduce((sum, unit) => sum + unit.cost, 0);
   const restart = windowed.length > 0 ? ENGINE_START_SECONDS : 0;
   const total = units.reduce((sum, unit) => sum + unit.cost, 0);
@@ -18656,6 +18698,52 @@ function dealt(units, declared, most) {
     ...bins.flatMap((bin, lane) => bin.length === 0 ? [] : [planOf(bin, declared, false, lane, units)])
   ];
 }
+function slowestFirst(a, b) {
+  return b.cost - a.cost || a.suite.localeCompare(b.suite) || (a.cases[0] ?? "").localeCompare(b.cases[0] ?? "") || (a.row?.index ?? 0) - (b.row?.index ?? 0);
+}
+
+class Shares {
+  windowed;
+  headless;
+  declared;
+  all;
+  lanes;
+  constructor(units, declared, lanes) {
+    this.windowed = units.filter((unit) => unit.windowed);
+    this.headless = units.filter((unit) => !unit.windowed).sort(slowestFirst);
+    this.declared = declared;
+    this.all = units;
+    this.lanes = Math.max(1, lanes);
+  }
+  get empty() {
+    return this.windowed.length === 0 && this.headless.length === 0;
+  }
+  next(lane) {
+    if (this.windowed.length > 0) {
+      const windowed = this.windowed;
+      this.windowed = [];
+      return planOf(windowed, this.declared, true, lane, this.all);
+    }
+    if (this.headless.length === 0) {
+      return null;
+    }
+    const left = this.headless.reduce((sum, unit) => sum + unit.cost, 0);
+    const target = Math.max(SHARE_FLOOR_SECONDS, left / this.lanes);
+    const share = [];
+    const rest = [];
+    let cost = 0;
+    for (const unit of this.headless) {
+      if (share.length === 0 || cost + unit.cost <= target) {
+        share.push(unit);
+        cost += unit.cost;
+      } else {
+        rest.push(unit);
+      }
+    }
+    this.headless = rest;
+    return planOf(share, this.declared, false, lane, this.all);
+  }
+}
 function lanesOf(plans) {
   return new Set(plans.map((plan) => plan.lane)).size;
 }
@@ -18726,7 +18814,7 @@ 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;
+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 init_suite_plan = __esm(() => {
   init_class_cache();
   init_gdscript_source();
@@ -18735,6 +18823,7 @@ var init_suite_plan = __esm(() => {
   NEEDS_WINDOW = /^const\s+GDHARNESS_NEEDS_WINDOW\b[^=\n]*=\s*(true|false)\b/m;
   TEST_DIRECTORIES = ["tests", "test"];
   SCENE_RUNNER = /\bscene_runner\s*\(/;
+  SHARE_FLOOR_SECONDS = 6 * ENGINE_START_SECONDS;
 });
 
 // node_modules/@modelcontextprotocol/server/dist/chunk-Br0eD_fh.mjs
@@ -52693,6 +52782,7 @@ ${error.text}`;
     ];
     const walkStopped = leakedAtExit.length > 0 && walkStoppedPartWay(run.log.all.map((entry) => entry.text));
     const countedLeaks = walkStopped ? [] : leakedAtExit;
+    const heldNamed = countedLeaks.length > 0 ? heldAtExit(run.log.all.map((entry) => entry.text)) : undefined;
     const declaredNotPrinted = judgedErrors.neverPrinted.map((missing) => ({
       suite: missing.suite,
       case: missing.during,
@@ -52787,7 +52877,7 @@ ${error.text}`;
         declaredNotPrinted.length > 0 ? "A declared error or warning the case did not print fails the run too, since the case no longer reaches what it was written to test." : undefined,
         walkStopped ? WALK_STOPPED_SENTENCE : undefined,
         countedLeaks.length > 0 ? [
-          'What the engine still held as it exited fails the run, as gdharness test judges it; engineArgs ["--verbose"] names each instance and resource under engineEntries.',
+          heldNamed === undefined ? 'What the engine still held as it exited fails the run, as gdharness test judges it; engineArgs ["--verbose"] has the engine name what it held.' : `What the engine still held as it exited fails the run, as gdharness test judges it. ${heldNamed}`,
           selfTypedSentence(projectSelfTypedExports(project.value.path))
         ].filter((part) => part !== undefined).join(" ") : undefined,
         ranAs.startsWith("warnings") && warnings.length === 0 ? "gdUnit4 exits 101 for orphan nodes when nothing failed, and this run printed no count of them: orphan reporting may be off in the project settings." : notRunNote(notRun, readBoolean(args, "failFast") === true)
@@ -58464,7 +58554,7 @@ var VALUED2 = new Set([
   "--order",
   "--result"
 ]);
-var SWITCHES = new Set(["--changed-only", "--import", "--print-output"]);
+var SWITCHES = new Set(["--changed-only", "--import", "--print-output", "--verbose"]);
 function testOptionsOf(args, cwd) {
   const valued = new Map;
   const switches = new Set;
@@ -58512,6 +58602,7 @@ function testOptionsOf(args, cwd) {
     importFirst: switches.has("--import"),
     order: order === undefined ? null : order === "reversed" ? "reversed" : seedOf(order),
     printOutput: switches.has("--print-output"),
+    verbose: switches.has("--verbose"),
     resultFile: last("--result") === undefined ? null : resolve10(cwd, last("--result") ?? "")
   };
 }
@@ -58671,7 +58762,8 @@ async function runTestCommand(options, godotPath) {
     running,
     selfTyped: selfTypedExports(scripts.sources),
     godotVersion: options.godotVersion,
-    cores: options.cores
+    cores: options.cores,
+    verbose: options.verbose
   };
   try {
     if (options.importFirst) {
@@ -58743,7 +58835,19 @@ ${existsSync23(path) ? readFileSync22(path, "latin1") : "missing"}`)
       console.log(`Dealt out row by row, since ${byRows.length === 1 ? "it" : "each"} took more than ${String(SPLIT_PAST_SECONDS)} s last time: ${named(byRows)}.`);
     }
     const lanes = [...new Set(plans.map((plan) => plan.lane))].map((lane) => plans.flatMap((plan, index) => plan.lane === lane ? [{ plan, index }] : []));
-    let ran = (await inTurns(lanes, room.engines, (lane) => runLane(launch, lane, times))).flat().sort((a, b) => a.index - b.index);
+    const taken = [];
+    while (taken.length < lanes.length) {
+      const lock = await slots.takeFree();
+      if (lock === null) {
+        break;
+      }
+      taken.push(lock);
+    }
+    const shared = options.order === null && lanes.length > 1 && taken.length < lanes.length;
+    if (shared) {
+      console.log(sharesSaid(taken.length, lanes.length));
+    }
+    let ran = shared ? await runShares(launch, units, declared, lanes.length, taken, times) : (await Promise.all(lanes.map((lane, at) => runLane(launch, lane, times, taken[at] ?? null)))).flat().sort((a, b) => a.index - b.index);
     if (ran.some((engine) => engine.verdict.starved) && ran.some((engine) => !engine.verdict.passed)) {
       console.log("An engine ran out of memory, so every engine that failed runs again, one at a time.");
       const again = [];
@@ -58761,6 +58865,9 @@ ${existsSync23(path) ? readFileSync22(path, "latin1") : "missing"}`)
     process14.off("SIGTERM", interrupted);
   }
 }
+function sharesSaid(free, lanes) {
+  return `${free === 0 ? "None" : String(free)} of the ${String(lanes)} slots this run uses ${free === 1 ? "was" : "were"} free as it began, so its engines are handed the suites a share at a time as each starts, and an engine starts as each slot comes free.`;
+}
 function roomSaid(engines, lanes, unheld, held, asked) {
   if (held === undefined || lanes >= unheld) {
     return "";
@@ -58839,8 +58946,8 @@ async function importProject(launch) {
     launch.slots.release(lock);
   }
 }
-async function runLane(launch, lane, times) {
-  const lock = await launch.slots.take();
+async function runLane(launch, lane, times, taken) {
+  const lock = taken ?? await launch.slots.take();
   try {
     const ran = [];
     for (const { plan, index } of lane) {
@@ -58851,6 +58958,39 @@ async function runLane(launch, lane, times) {
     launch.slots.release(lock);
   }
 }
+async function runShares(launch, units, declared, lanes, taken, times) {
+  const shares = new Shares(units, declared, lanes);
+  const handedOut = new AbortController;
+  let engines = 0;
+  const lane = async (at) => {
+    let lock = taken[at] ?? null;
+    if (lock === null) {
+      try {
+        lock = await launch.slots.take(handedOut.signal);
+      } catch (error) {
+        if (handedOut.signal.aborted) {
+          return [];
+        }
+        throw error;
+      }
+    }
+    try {
+      const ran = [];
+      for (let plan = shares.next(at);plan !== null; plan = shares.next(at)) {
+        if (shares.empty) {
+          handedOut.abort();
+        }
+        const index = engines;
+        engines += 1;
+        ran.push(await runEngine2(launch, plan, index, times, "", lock));
+      }
+      return ran;
+    } finally {
+      launch.slots.release(lock);
+    }
+  };
+  return (await Promise.all(Array.from({ length: lanes }, (_, at) => lane(at)))).flat().sort((a, b) => a.index - b.index);
+}
 async function runEngine2(launch, plan, index, times, again = "", slot = null) {
   const directory = join27(launch.runDirectory, `engine-${String(index)}${again === "" ? "" : `-${again}`}`);
   mkdirSync10(join27(directory, "user"), { recursive: true });
@@ -58878,6 +59018,7 @@ async function runEngine2(launch, plan, index, times, again = "", slot = null) {
     "Dummy",
     "--path",
     launch.projectPath,
+    ...launch.verbose ? ["--verbose"] : [],
     "-s",
     shippedListedRunner(),
     ...plan.windowed ? [] : ["--ignoreHeadlessMode"],
@@ -59530,7 +59671,7 @@ Usage:
   gdharness test [project] [suite ...] [--engines N] [--slots DIR] [--slot-count N]
                  [--silence S] [--deadline S] [--tests DIR] [--changed-only] [--reach-also PATH]
                  [--import] [--godot PATH] [--godot-version V] [--cores N]
-                 [--order reversed|SEED] [--print-output] [--result FILE] [--runner]
+                 [--order reversed|SEED] [--print-output] [--verbose] [--result FILE] [--runner]
                                      Run the project's gdUnit4 suites over several engines and
                                      judge every line they print: exit 1 on a failing case, an
                                      engine error no case declared, a case that never finished
@@ -59539,7 +59680,8 @@ Usage:
                                      suites that passed with everything they reach unchanged; it
                                      is for iterating, and no gate passes it. --print-output
                                      prints what every engine printed, for a
-                                     benchmark run by hand. --result writes the outcome, each
+                                     benchmark run by hand. --verbose starts every engine verbose,
+                                     so a leak at exit is named. --result writes the outcome, each
                                      suite's time and every problem as JSON for a gate. --runner
                                      prints the shipped runner's path. docs/test-runs.md has the
                                      rest.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.3.29",
+  "version": "1.3.31",
   "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",