gdharness 1.3.29 → 1.3.30

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;
@@ -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
@@ -58464,7 +58553,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 +58601,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 +58761,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 +58834,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 +58864,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 +58945,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 +58957,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 +59017,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 +59670,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 +59679,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.30",
   "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",