gdharness 1.3.20 → 1.3.22

package/build/cli.js

@@ -10620,11 +10620,29 @@ function masked(expected, actual) {
   const allSpelled = (value) => !PRINTED_DICTIONARY.test(value) && value.split("[").length === value.split(MASKED_BRACKET).length;
   return `${expected}${actual}`.includes(MASKED_BRACKET) && allSpelled(expected) && allSpelled(actual);
 }
+function orphansLeftOn(line) {
+  const named = ORPHANS_LEFT.exec(line);
+  if (named === null) {
+    return null;
+  }
+  return { suite: named[1] ?? "", during: named[2] ?? "", count: Number(named[3]), nodes: named[4] ?? "" };
+}
+function orphansLeftSaid(left) {
+  const nodes = left.count === 1 ? "1 node" : `${String(left.count)} nodes`;
+  const where = left.during === "after" ? `${left.suite}'s hooks` : `${left.suite} > ${left.during}`;
+  return `${where} left ${nodes} neither freed nor in the tree, which gdUnit4 counts as orphans: ${left.nodes}. Free each one, or make it with auto_free(), which frees it once the case is over.`;
+}
 function orphansPrinted(printed) {
   const suites = [];
   let total = null;
   let running = null;
+  const named = new Map;
   for (const line of printed) {
+    const left = orphansLeftOn(line);
+    if (left !== null) {
+      named.set(left.suite, [...named.get(left.suite) ?? [], left]);
+      continue;
+    }
     const started = RUNNING_SUITE.exec(line);
     if (started?.[1] !== undefined) {
       running = started[1];
@@ -10641,13 +10659,13 @@ function orphansPrinted(printed) {
       continue;
     }
     if (running !== null && orphans > 0) {
-      suites.push({ path: running, orphans });
+      suites.push({ path: running, orphans, left: [] });
     }
     running = null;
   }
   return {
     total: total ?? suites.reduce((sum, suite) => sum + suite.orphans, 0),
-    suites
+    suites: suites.map((suite) => ({ ...suite, left: named.get(suite.path) ?? [] }))
   };
 }
 function finishesASuite(line) {
@@ -10694,7 +10712,7 @@ function testProgressMessage(printed, elapsedMs) {
   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, COLOUR, 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.]', MOST_REPORTS_SHOWN = 20, LONGEST_DETAIL = 20000, MASKED_BRACKET = "[lb]", PRINTED_DICTIONARY, RUNNING_SUITE, ORPHANS, OVERALL = "Overall Summary", SUITE_COUNTS, CASE_FAILED;
+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, COLOUR, 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.]', MOST_REPORTS_SHOWN = 20, LONGEST_DETAIL = 20000, MASKED_BRACKET = "[lb]", PRINTED_DICTIONARY, ORPHANS_LEFT, RUNNING_SUITE, ORPHANS, OVERALL = "Overall Summary", SUITE_COUNTS, CASE_FAILED;
 var init_junit = __esm(() => {
   MalformedReportError = class MalformedReportError extends Error {
     constructor(message) {
@@ -10724,6 +10742,7 @@ var init_junit = __esm(() => {
     "<DEL>": ""
   };
   PRINTED_DICTIONARY = /^\{\n\t[\s\S]*\n {2}\}$/;
+  ORPHANS_LEFT = /^gdharness orphans: (res:\/\/.+?\.(?:gd|cs)) > (.+?) left (\d+): (.+?)\s*$/;
   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/;
@@ -10771,6 +10790,7 @@ function readRun(printed) {
     afterCase = [];
   };
   const leftOut = new Map;
+  const orphansLeft = [];
   let engineVersion = null;
   for (const [at, line] of lines.entries()) {
     const banner = engineVersion === null ? BANNER.exec(line) : null;
@@ -10778,6 +10798,11 @@ function readRun(printed) {
       engineVersion = banner[1] ?? null;
       continue;
     }
+    const orphaned = orphansLeftOn(line);
+    if (orphaned !== null) {
+      orphansLeft.push(orphaned);
+      continue;
+    }
     const left = LEFT_OUT.exec(line);
     if (left !== null) {
       const key = `${left[1] ?? ""} > ${left[2] ?? ""}`;
@@ -10864,7 +10889,19 @@ function readRun(printed) {
 `);
   const starved = STARVED.flatMap((pattern) => [...joined.matchAll(pattern)].map((found) => found[0]));
   const unloadable = scriptErrorsPrinted(lines).map((error) => `${error.path}${error.line === null ? "" : `:${String(error.line)}`}: ${error.message}`);
-  return { lines, suites, errors, leaks, starved, executed, unloadable, stoppedIn, leftOut, engineVersion };
+  return {
+    lines,
+    suites,
+    errors,
+    leaks,
+    starved,
+    executed,
+    unloadable,
+    stoppedIn,
+    leftOut,
+    engineVersion,
+    orphansLeft
+  };
 }
 function withNestedErrors(printed, piped) {
   const nested = piped.flatMap((entry, at) => {
@@ -10962,7 +10999,7 @@ function judgeEngine(printed, handed, end) {
   const faults = [];
   const failing = new Set;
   const shownAt = new Set;
-  const explained = end.code === GDUNIT_FAILED && [...printed.suites.values()].some((suite) => suite.cases.some((ran) => ran.verdict === "FAILED"));
+  const explained = end.code === GDUNIT_FAILED && [...printed.suites.values()].some((suite) => suite.cases.some((ran) => ran.verdict === "FAILED")) || end.code === GDUNIT_ORPHANS && printed.orphansLeft.length > 0;
   if (end.ended !== null) {
     faults.push(end.ended);
   } else if (end.code !== 0 && !explained) {
@@ -11027,6 +11064,10 @@ function judgeEngine(printed, handed, end) {
       }
     }
   }
+  for (const left of printed.orphansLeft) {
+    faults.push(orphansLeftSaid(left));
+    failing.add(left.suite);
+  }
   const unexpected = unexpectedErrors(printed, handed.expected, handed.suites.map((suite) => suite.path));
   for (const error of unexpected.printed) {
     faults.push(error.suite === null ? `an engine ${error.warning ? "warning" : "error"} outside every suite: ${error.text}` : `an engine ${error.warning ? "warning" : "error"} in ${error.suite} > ${error.during ?? ""}: ${error.text}; ${declaringAdvice(error.during ?? "", error.warning)}`);
@@ -11138,7 +11179,7 @@ ${String(error.warning)}`);
   const neverPrinted = [...owed.values()].flatMap((debt) => debt.texts.map((text) => ({ suite: debt.suite, during: debt.during, text, warning: debt.warning })));
   return { printed: unexpected, neverPrinted };
 }
-var SUITE_OPENED, TIME, CASE_LINE, STATISTICS, ERROR_LINE, WARNING_LINE, EXECUTED, BANNER, LEFT_OUT, DRIVER_FALLBACK, MACHINE_WARNED, ORPHANS_REPORTED, STARVED, NESTED_ERROR = "While attempting to print an error, another error was printed:", WINDOWS_EXITS, MEMORY_EXITS, GDUNIT_FAILED = 100, GDUNIT_EXITS, GODOT_EXITS, TAIL = 60, MOST_NAMED = 8;
+var SUITE_OPENED, TIME, CASE_LINE, STATISTICS, ERROR_LINE, WARNING_LINE, EXECUTED, BANNER, LEFT_OUT, DRIVER_FALLBACK, MACHINE_WARNED, ORPHANS_REPORTED, STARVED, NESTED_ERROR = "While attempting to print an error, another error was printed:", WINDOWS_EXITS, MEMORY_EXITS, GDUNIT_FAILED = 100, GDUNIT_ORPHANS = 101, GDUNIT_EXITS, GODOT_EXITS, TAIL = 60, MOST_NAMED = 8;
 var init_suite_judge = __esm(() => {
   init_engine_leaks();
   init_junit();
@@ -11170,7 +11211,7 @@ var init_suite_judge = __esm(() => {
   MEMORY_EXITS = new Set([3221225495, 3221225773]);
   GDUNIT_EXITS = new Map([
     [GDUNIT_FAILED, "gdUnit4's code for a case that failed or errored"],
-    [101, "gdUnit4's code for orphan nodes left behind"],
+    [GDUNIT_ORPHANS, "gdUnit4's code for orphan nodes left behind"],
     [103, "gdUnit4's code for a suite that cannot run headless"],
     [104, "gdUnit4's code for a Godot version it does not support"],
     [105, "gdUnit4's code for scripts that did not compile"]
@@ -11476,13 +11517,295 @@ var init_engine_launch = __esm(() => {
   MEMORY_PER_ENGINE = 1.5 * 1024 ** 3;
 });
 
+// src/call-signal.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+function stillGoingSaid(tool, op, elapsedMs) {
+  const seconds = Math.floor(elapsedMs / 1000);
+  const took = seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  return `${op === null || op === "" ? tool : `${tool} ${op}`} is still going; ${took} in.`;
+}
+async function withCallSignal(signal, answer, progress, still) {
+  if (progress === undefined) {
+    return signal === undefined ? answer() : current.run({ signal, progress: undefined }, answer);
+  }
+  const began = Date.now();
+  const rising = risingOnly(progress);
+  let going = still;
+  let quiet;
+  const rearm = () => {
+    clearTimeout(quiet);
+    if (going === undefined) {
+      return;
+    }
+    const { everyMs, said } = going;
+    quiet = setTimeout(() => {
+      const elapsed = Date.now() - began;
+      told(Math.floor(elapsed / 1000), said(elapsed));
+    }, everyMs);
+    quiet.unref();
+  };
+  const told = (number, message) => {
+    rising(number, message);
+    rearm();
+  };
+  rearm();
+  try {
+    return await current.run({ signal, progress: told }, answer);
+  } finally {
+    going = undefined;
+    clearTimeout(quiet);
+  }
+}
+function risingOnly(progress) {
+  let last = Number.NEGATIVE_INFINITY;
+  return (number, message) => {
+    last = number > last ? number : last + 1;
+    progress(last, message);
+  };
+}
+function callSignal() {
+  return current.getStore()?.signal;
+}
+function callProgress() {
+  return current.getStore()?.progress;
+}
+var current, CALL_HEARTBEAT_MS = 20000;
+var init_call_signal = __esm(() => {
+  current = new AsyncLocalStorage;
+});
+
+// src/engine-slots.ts
+import { closeSync as closeSync3, mkdirSync as mkdirSync3, openSync as openSync3, readFileSync as readFileSync7, rmSync as rmSync5, statSync as statSync6, writeSync as writeSync2 } from "node:fs";
+import { availableParallelism as availableParallelism2, homedir as homedir2 } from "node:os";
+import { join as join8, resolve as resolve4 } from "node:path";
+import process7 from "node:process";
+import { setTimeout as delay3 } from "node:timers/promises";
+function machineSlots(asked = {
+  directory: null,
+  count: null
+}, machine = {
+  env: process7.env,
+  platform: process7.platform,
+  processors: availableParallelism2(),
+  home: homedir2(),
+  cwd: process7.cwd()
+}) {
+  const { env } = machine;
+  const named = nonEmpty(env[SLOTS_VARIABLE]);
+  const xdg = nonEmpty(env["XDG_CACHE_HOME"]);
+  const local = machine.platform === "win32" ? nonEmpty(env["LOCALAPPDATA"]) : undefined;
+  const cache = join8(xdg ?? local ?? join8(machine.home, ".cache"), "gdharness");
+  const directory = asked.directory ?? (named === undefined ? join8(cache, "slots") : resolve4(machine.cwd, named));
+  const counted = nonEmpty(env[SLOT_COUNT_VARIABLE]);
+  let count = asked.count;
+  if (count === null && counted !== undefined) {
+    count = Number(counted);
+    if (!Number.isInteger(count) || count < 1) {
+      throw new EngineUsageError(`${SLOT_COUNT_VARIABLE} takes a whole number above 0, not ${counted}.`);
+    }
+  }
+  return { directory, count: count ?? Math.max(1, Math.floor(machine.processors / PROCESSORS_A_SLOT)) };
+}
+function nonEmpty(value) {
+  return value === undefined || value === "" ? undefined : value;
+}
+function holderOf(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const { pid, started } = parsed;
+    return typeof pid === "number" && Number.isInteger(pid) && pid > 0 && typeof started === "number" ? { pid, started } : null;
+  } catch {
+    return null;
+  }
+}
+function lockIsFree(content, writtenAt, now, isAlive, startOf) {
+  const holder = holderOf(content);
+  if (holder === null) {
+    return now - writtenAt > UNWRITTEN_MS;
+  }
+  if (!isAlive(holder.pid)) {
+    return true;
+  }
+  const started = startOf(holder.pid);
+  return started !== undefined && Math.abs(started - holder.started) > START_TOLERANCE_MS;
+}
+async function ownStart() {
+  const said = (await startTimesOf([process7.pid])).get(process7.pid);
+  return said ?? Math.round(Date.now() - process7.uptime() * 1000);
+}
+
+class EngineSlots {
+  starts = new Map;
+  held = new Set;
+  saidAt = Number.NEGATIVE_INFINITY;
+  directory;
+  count;
+  holder;
+  say;
+  constructor(directory, count, holder, say) {
+    this.directory = directory;
+    this.count = count;
+    this.holder = holder;
+    this.say = say;
+  }
+  async take(signal, waiting) {
+    mkdirSync3(this.directory, { recursive: true });
+    const began = Date.now();
+    let said = Number.NEGATIVE_INFINITY;
+    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 now = Date.now();
+      if (waiting !== undefined) {
+        if (now - said >= WAIT_SAID_MS) {
+          said = now;
+          waiting(now - began);
+        }
+      } else if (this.say !== undefined && this.held.size === 0 && now - began >= COMMAND_WAIT_SAID_MS && now - this.saidAt >= WAIT_SAID_MS) {
+        this.saidAt = now;
+        this.say(slotWaitSaid(now - began, this.count, this.directory));
+      }
+      await delay3(SLOT_WAIT_MS, undefined, signal === undefined ? {} : { signal });
+    }
+  }
+  releaseAll() {
+    for (const lock of this.held) {
+      this.release(lock);
+    }
+  }
+  release(lock) {
+    this.held.delete(lock);
+    try {
+      if (holderOf(readFileSync7(lock, "utf8"))?.pid === this.holder.pid) {
+        rmSync5(lock, { force: true });
+      }
+    } catch {}
+  }
+  made(path) {
+    let made;
+    try {
+      made = openSync3(path, "wx");
+    } catch {
+      return false;
+    }
+    try {
+      writeSync2(made, JSON.stringify(this.holder));
+    } finally {
+      closeSync3(made);
+    }
+    return true;
+  }
+  async takenOver(lock) {
+    if (!await this.free(lock)) {
+      return false;
+    }
+    const steal = `${lock}.steal`;
+    if (!this.made(steal)) {
+      try {
+        if (Date.now() - statSync6(steal).mtimeMs > UNWRITTEN_MS) {
+          rmSync5(steal, { force: true });
+        }
+      } catch {}
+      return false;
+    }
+    try {
+      if (!await this.free(lock)) {
+        return false;
+      }
+      try {
+        rmSync5(lock, { force: true });
+      } catch {
+        return false;
+      }
+      return this.made(lock);
+    } finally {
+      rmSync5(steal, { force: true });
+    }
+  }
+  async free(lock) {
+    let content;
+    let writtenAt;
+    try {
+      content = readFileSync7(lock, "utf8");
+      writtenAt = statSync6(lock).mtimeMs;
+    } catch {
+      return false;
+    }
+    const pid = holderOf(content)?.pid;
+    if (pid !== undefined && alive(pid)) {
+      await this.readStart(pid);
+    }
+    return lockIsFree(content, writtenAt, Date.now(), alive, (asked) => this.starts.get(asked)?.started);
+  }
+  async readStart(pid) {
+    const known = this.starts.get(pid);
+    if (known !== undefined && Date.now() - known.readAt < START_READ_MS) {
+      return;
+    }
+    const started = (await startTimesOf([pid])).get(pid);
+    this.starts.set(pid, { started, readAt: Date.now() });
+  }
+}
+function sayWaitsTo(say) {
+  saidTo = say;
+}
+function processSlots() {
+  ours ??= ownStart().then((started) => {
+    const chosen = machineSlots();
+    return new EngineSlots(chosen.directory, chosen.count, { pid: process7.pid, started }, (line) => {
+      saidTo?.(line);
+    });
+  });
+  return ours;
+}
+function slotWaitSaid(waitedMs, count, directory) {
+  const slots = count === 1 ? `the one engine slot on this machine (${directory}) is in use` : `all ${String(count)} engine slots on this machine (${directory}) are in use`;
+  return `Waiting${waitedMs >= 1000 ? ` ${String(Math.round(waitedMs / 1000))} s so far` : ""} for an engine: ${slots}, by a gate or another tool, and the engine starts when one is given back.`;
+}
+async function slotForCall() {
+  const slots = await processSlots();
+  const progress = callProgress();
+  const lock = await slots.take(callSignal(), progress === undefined ? undefined : (waitedMs) => {
+    progress(waitedMs / 1000, slotWaitSaid(waitedMs, slots.count, slots.directory));
+  });
+  return {
+    release: () => {
+      slots.release(lock);
+    }
+  };
+}
+async function inASlot(body) {
+  const held = await slotForCall();
+  try {
+    return await body();
+  } finally {
+    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_WAIT_MS = 50, WAIT_SAID_MS = 20000, COMMAND_WAIT_SAID_MS = 2000, START_READ_MS = 1e4, ours, saidTo;
+var init_engine_slots = __esm(() => {
+  init_alive();
+  init_call_signal();
+  init_engine_launch();
+  init_process_children();
+});
+
 // src/detection.ts
-import { existsSync as existsSync6, readdirSync as readdirSync4, statSync as statSync6 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join8 } from "node:path";
+import { existsSync as existsSync6, readdirSync as readdirSync4, statSync as statSync7 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join9 } from "node:path";
 function resolveHomeDirectory() {
   try {
-    return homedir2();
+    return homedir3();
   } catch {
     return "";
   }
@@ -11503,16 +11826,16 @@ function scanDirectoryForGodotBinaries(directory, platform) {
     if (!pattern.test(name)) {
       continue;
     }
-    const fullPath = join8(directory, name);
+    const fullPath = join9(directory, name);
     try {
-      const stat = statSync6(fullPath);
+      const stat = statSync7(fullPath);
       if (stat.isFile()) {
         matches.push({ name, mtime: stat.mtimeMs });
       }
     } catch {}
   }
   matches.sort((a, b) => b.mtime - a.mtime);
-  return matches.map((m) => join8(directory, m.name));
+  return matches.map((m) => join9(directory, m.name));
 }
 function conventionalPaths(platform, home) {
   const paths = ["godot"];
@@ -11719,7 +12042,7 @@ var init_launch = __esm(() => {
 
 // src/godot-path.ts
 import { existsSync as existsSync7 } from "node:fs";
-import { isAbsolute as isAbsolute4, normalize, resolve as resolve4 } from "node:path";
+import { isAbsolute as isAbsolute4, normalize, resolve as resolve5 } from "node:path";
 
 class GodotLocator {
   answered = new Map;
@@ -11731,7 +12054,7 @@ class GodotLocator {
     this.found = null;
     const named = envValue("GODOT_PATH");
     if (named !== undefined) {
-      const path = named === "godot" || isAbsolute4(named) ? named : resolve4(named);
+      const path = named === "godot" || isAbsolute4(named) ? named : resolve5(named);
       const reason = await this.whyNot(path);
       if (reason === null) {
         this.found = path;
@@ -11801,274 +12124,6 @@ function dictionary(entries) {
   return Object.assign(emptyRecord(), entries);
 }
 
-// src/call-signal.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-function stillGoingSaid(tool, op, elapsedMs) {
-  const seconds = Math.floor(elapsedMs / 1000);
-  const took = seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
-  return `${op === null || op === "" ? tool : `${tool} ${op}`} is still going; ${took} in.`;
-}
-async function withCallSignal(signal, answer, progress, still) {
-  if (progress === undefined) {
-    return signal === undefined ? answer() : current.run({ signal, progress: undefined }, answer);
-  }
-  const began = Date.now();
-  const rising = risingOnly(progress);
-  let going = still;
-  let quiet;
-  const rearm = () => {
-    clearTimeout(quiet);
-    if (going === undefined) {
-      return;
-    }
-    const { everyMs, said } = going;
-    quiet = setTimeout(() => {
-      const elapsed = Date.now() - began;
-      told(Math.floor(elapsed / 1000), said(elapsed));
-    }, everyMs);
-    quiet.unref();
-  };
-  const told = (number, message) => {
-    rising(number, message);
-    rearm();
-  };
-  rearm();
-  try {
-    return await current.run({ signal, progress: told }, answer);
-  } finally {
-    going = undefined;
-    clearTimeout(quiet);
-  }
-}
-function risingOnly(progress) {
-  let last = Number.NEGATIVE_INFINITY;
-  return (number, message) => {
-    last = number > last ? number : last + 1;
-    progress(last, message);
-  };
-}
-function callSignal() {
-  return current.getStore()?.signal;
-}
-function callProgress() {
-  return current.getStore()?.progress;
-}
-var current, CALL_HEARTBEAT_MS = 20000;
-var init_call_signal = __esm(() => {
-  current = new AsyncLocalStorage;
-});
-
-// src/engine-slots.ts
-import { closeSync as closeSync3, mkdirSync as mkdirSync3, openSync as openSync3, readFileSync as readFileSync7, rmSync as rmSync5, statSync as statSync7, writeSync as writeSync2 } from "node:fs";
-import { availableParallelism as availableParallelism2, homedir as homedir3 } from "node:os";
-import { join as join9, resolve as resolve5 } from "node:path";
-import process8 from "node:process";
-import { setTimeout as delay3 } from "node:timers/promises";
-function machineSlots(asked = {
-  directory: null,
-  count: null
-}, machine = {
-  env: process8.env,
-  platform: process8.platform,
-  processors: availableParallelism2(),
-  home: homedir3(),
-  cwd: process8.cwd()
-}) {
-  const { env } = machine;
-  const named = nonEmpty(env[SLOTS_VARIABLE]);
-  const xdg = nonEmpty(env["XDG_CACHE_HOME"]);
-  const local = machine.platform === "win32" ? nonEmpty(env["LOCALAPPDATA"]) : undefined;
-  const cache = join9(xdg ?? local ?? join9(machine.home, ".cache"), "gdharness");
-  const directory = asked.directory ?? (named === undefined ? join9(cache, "slots") : resolve5(machine.cwd, named));
-  const counted = nonEmpty(env[SLOT_COUNT_VARIABLE]);
-  let count = asked.count;
-  if (count === null && counted !== undefined) {
-    count = Number(counted);
-    if (!Number.isInteger(count) || count < 1) {
-      throw new EngineUsageError(`${SLOT_COUNT_VARIABLE} takes a whole number above 0, not ${counted}.`);
-    }
-  }
-  return { directory, count: count ?? Math.max(1, Math.floor(machine.processors / PROCESSORS_A_SLOT)) };
-}
-function nonEmpty(value) {
-  return value === undefined || value === "" ? undefined : value;
-}
-function holderOf(content) {
-  try {
-    const parsed = JSON.parse(content);
-    if (typeof parsed !== "object" || parsed === null) {
-      return null;
-    }
-    const { pid, started } = parsed;
-    return typeof pid === "number" && Number.isInteger(pid) && pid > 0 && typeof started === "number" ? { pid, started } : null;
-  } catch {
-    return null;
-  }
-}
-function lockIsFree(content, writtenAt, now, isAlive, startOf) {
-  const holder = holderOf(content);
-  if (holder === null) {
-    return now - writtenAt > UNWRITTEN_MS;
-  }
-  if (!isAlive(holder.pid)) {
-    return true;
-  }
-  const started = startOf(holder.pid);
-  return started !== undefined && Math.abs(started - holder.started) > START_TOLERANCE_MS;
-}
-async function ownStart() {
-  const said = (await startTimesOf([process8.pid])).get(process8.pid);
-  return said ?? Math.round(Date.now() - process8.uptime() * 1000);
-}
-
-class EngineSlots {
-  starts = new Map;
-  held = new Set;
-  directory;
-  count;
-  holder;
-  constructor(directory, count, holder) {
-    this.directory = directory;
-    this.count = count;
-    this.holder = holder;
-  }
-  async take(signal, waiting) {
-    mkdirSync3(this.directory, { recursive: true });
-    const began = Date.now();
-    let said = Number.NEGATIVE_INFINITY;
-    for (;; ) {
-      signal?.throwIfAborted();
-      for (let slot = 0;slot < this.count; slot += 1) {
-        const lock = join9(this.directory, `${String(slot)}.lock`);
-        if (this.made(lock) || await this.takenOver(lock)) {
-          this.held.add(lock);
-          return lock;
-        }
-      }
-      if (waiting !== undefined && Date.now() - said >= WAIT_SAID_MS) {
-        said = Date.now();
-        waiting(said - began);
-      }
-      await delay3(SLOT_WAIT_MS, undefined, signal === undefined ? {} : { signal });
-    }
-  }
-  releaseAll() {
-    for (const lock of this.held) {
-      this.release(lock);
-    }
-  }
-  release(lock) {
-    this.held.delete(lock);
-    try {
-      if (holderOf(readFileSync7(lock, "utf8"))?.pid === this.holder.pid) {
-        rmSync5(lock, { force: true });
-      }
-    } catch {}
-  }
-  made(path) {
-    let made;
-    try {
-      made = openSync3(path, "wx");
-    } catch {
-      return false;
-    }
-    try {
-      writeSync2(made, JSON.stringify(this.holder));
-    } finally {
-      closeSync3(made);
-    }
-    return true;
-  }
-  async takenOver(lock) {
-    if (!await this.free(lock)) {
-      return false;
-    }
-    const steal = `${lock}.steal`;
-    if (!this.made(steal)) {
-      try {
-        if (Date.now() - statSync7(steal).mtimeMs > UNWRITTEN_MS) {
-          rmSync5(steal, { force: true });
-        }
-      } catch {}
-      return false;
-    }
-    try {
-      if (!await this.free(lock)) {
-        return false;
-      }
-      try {
-        rmSync5(lock, { force: true });
-      } catch {
-        return false;
-      }
-      return this.made(lock);
-    } finally {
-      rmSync5(steal, { force: true });
-    }
-  }
-  async free(lock) {
-    let content;
-    let writtenAt;
-    try {
-      content = readFileSync7(lock, "utf8");
-      writtenAt = statSync7(lock).mtimeMs;
-    } catch {
-      return false;
-    }
-    const pid = holderOf(content)?.pid;
-    if (pid !== undefined && alive(pid)) {
-      await this.readStart(pid);
-    }
-    return lockIsFree(content, writtenAt, Date.now(), alive, (asked) => this.starts.get(asked)?.started);
-  }
-  async readStart(pid) {
-    const known = this.starts.get(pid);
-    if (known !== undefined && Date.now() - known.readAt < START_READ_MS) {
-      return;
-    }
-    const started = (await startTimesOf([pid])).get(pid);
-    this.starts.set(pid, { started, readAt: Date.now() });
-  }
-}
-function processSlots() {
-  ours ??= ownStart().then((started) => {
-    const chosen = machineSlots();
-    return new EngineSlots(chosen.directory, chosen.count, { pid: process8.pid, started });
-  });
-  return ours;
-}
-function slotWaitSaid(waitedMs, count, directory) {
-  const slots = count === 1 ? `the one engine slot on this machine (${directory}) is in use` : `all ${String(count)} engine slots on this machine (${directory}) are in use`;
-  return `Waiting${waitedMs >= 1000 ? ` ${String(Math.round(waitedMs / 1000))} s so far` : ""} for an engine: ${slots}, by a gate or another tool, and the engine starts when one is given back.`;
-}
-async function slotForCall() {
-  const slots = await processSlots();
-  const progress = callProgress();
-  const lock = await slots.take(callSignal(), progress === undefined ? undefined : (waitedMs) => {
-    progress(waitedMs / 1000, slotWaitSaid(waitedMs, slots.count, slots.directory));
-  });
-  return {
-    release: () => {
-      slots.release(lock);
-    }
-  };
-}
-async function inASlot(body) {
-  const held = await slotForCall();
-  try {
-    return await body();
-  } finally {
-    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_WAIT_MS = 50, WAIT_SAID_MS = 20000, START_READ_MS = 1e4, ours;
-var init_engine_slots = __esm(() => {
-  init_alive();
-  init_call_signal();
-  init_engine_launch();
-  init_process_children();
-});
-
 // src/game-log.ts
 import { StringDecoder } from "node:string_decoder";
 function announced(line) {
@@ -16407,7 +16462,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. 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 or memory pages, 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. 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 or memory pages, 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 (after for the suite's hooks) 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: {
@@ -16680,7 +16735,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "scene_animation",
       title: "Animations",
-      description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. The player and the tree are nodes, so scene_node add puts one in the scene first. read answers with every track of an animation in the shape add_track takes, so a track read off one animation can be added to another. add_track on a path the animation already has a track of that type for adds the keys to that track, as the editor keys a property it already animates, answering existingTrack true and keysAdded beside keys, the track's count; a key at a time that track already has a key at is refused. A key add_track writes past the animation's end, where it never plays, is written and named under pastLength. remove_track takes out every track of the type, nodePath and property given, with its keys; a method track given a method loses only the keys calling it, and goes once none is left. read_states gives each state that plays an animation animationFound, and animationMissing saying why when the player lacks it. remove clears the player's autoplay when it named the animation and names under statesPlayingNothing the states that played it, which stay in their trees playing nothing until remove_state takes them out. Every state machine has Start and End, which cannot be added or removed; a transition from Start sets the state it begins in. read and read_states need no editor: one serving the project answers and says whether it holds unsaved changes to the scene, and with none a headless engine reads the file without running the scene's scripts. The ops that write go through the editor when one serves the project; with none, a headless engine runs the editor's own tool and the answer says so under writtenBy. That engine runs every script of the file, where the editor runs only tool scripts, so what a script changes as the file loads is put back before anything is saved, and a file where that cannot be done, such as a scene whose script does not compile, is refused and nothing is written. An editor of the project that is running and has not reached this server is waited for rather than written around. " + ALSO_SAVED,
+      description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. The player and the tree are nodes, so scene_node add puts one in the scene first, and the animation a player plays on load is its autoplay property, which scene_node set sets. read answers with every track of an animation in the shape add_track takes, so a track read off one animation can be added to another. add_track on a path the animation already has a track of that type for adds the keys to that track, as the editor keys a property it already animates, answering existingTrack true and keysAdded beside keys, the track's count; a key at a time that track already has a key at is refused unless replaceKeys is true, which is how one key's value is changed. A key add_track writes past the animation's end, where it never plays, is written and named under pastLength. remove_track takes out every track of the type, nodePath and property given, with its keys; a method track given a method loses only the keys calling it, and goes once none is left. read_states gives each state that plays an animation animationFound, and animationMissing saying why when the player lacks it. remove clears the player's autoplay when it named the animation and names under statesPlayingNothing the states that played it, which stay in their trees playing nothing until remove_state takes them out. Every state machine has Start and End, which cannot be added or removed; a transition from Start sets the state it begins in. read and read_states need no editor: one serving the project answers and says whether it holds unsaved changes to the scene, and with none a headless engine reads the file without running the scene's scripts. The ops that write go through the editor when one serves the project; with none, a headless engine runs the editor's own tool and the answer says so under writtenBy. That engine runs every script of the file, where the editor runs only tool scripts, so what a script changes as the file loads is put back before anything is saved, and a file where that cannot be done, such as a scene whose script does not compile, is refused and nothing is written. An editor of the project that is running and has not reached this server is waited for rather than written around. " + ALSO_SAVED,
       parameters: {
         projectPath: PROJECT_PATH,
         scenePath: SCENE_PATH,
@@ -16716,6 +16771,11 @@ var init_tool_definitions = __esm(() => {
           description: "create and set: keyframe snap in seconds, 0 or more. create: default 0.1."
         },
         track: { ...ANIMATION_TRACK, ops: ["add_track", "remove_track"] },
+        replaceKeys: {
+          type: "boolean",
+          ops: ["add_track"],
+          description: "add_track: true puts a keyframe at a time the track already has a key at in that key's place, and names each key replaced under keysReplaced, its time and the value it held (a method key's method and args); keysAdded then counts only the new times. Default false, which refuses the call and writes nothing."
+        },
         animTreePath: {
           type: "string",
           ops: ["read_states", "add_state", "remove_state", "connect_states", "disconnect_states"],
@@ -16944,7 +17004,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "resource_edit",
       title: "Edit resources",
-      description: 'Resource files: read one, create any ClassDB resource as .tres, change one, write a shader, build a TileSet, or set a Theme colour or font size. A material is a create with resourceType StandardMaterial3D, ShaderMaterial or CanvasItemMaterial. read answers with the properties the file sets, in the form modify takes, with resourceType the engine class and scriptClass the class_name of its script when it declares one, and a Theme lists its items there as "Button/colors/font_color". create and modify answer each property given under properties as the file holds it once saved, in the same form. A create or modify whose properties made the engine change others, as a Gradient given more colours than offsets gives each new point an offset of 0, names each of those under alsoChanged with what it held before and holds now. A property holding a resource takes its res:// path; a file never imported is refused with the reimport that imports it. move takes any file of the project, a script or an image as much as a resource, or a directory, and works from the files, so it needs no editor; one serving the project is brought up to it as after a move in its own FileSystem dock, its open scenes and cached resources named for the new paths and the project settings the move rewrote taken from the file. read needs no editor either: with none serving the project, a headless engine reads the file. The ops that write a resource go through the editor when one serves the project; with none, a headless engine runs the tool the editor would and the answer says so under writtenBy. That engine runs the script of the resource, where the editor runs only tool scripts, so what a script changes as the file loads or as a property is set is put back before the save, and a resource where that cannot be done is refused and the file left as it was.',
+      description: 'Resource files: read one, create any ClassDB resource as .tres, change one, write a shader, build a TileSet, or set a Theme colour or font size. A material is a create with resourceType StandardMaterial3D, ShaderMaterial or CanvasItemMaterial. read answers with the properties the file sets, in the form modify takes, with resourceType the engine class and scriptClass the class_name of its script when it declares one, and a Theme lists its items there as "Button/colors/font_color". A Curve, Curve2D or Curve3D reads as the inspector shows it, point_count and point_0/position and the rest, rather than the _data list the file stores, and so does one built into a resource or a scene. create and modify answer each property given under properties as the file holds it once saved, in the same form. A create or modify whose properties made the engine change others, as a Gradient given more colours than offsets gives each new point an offset of 0, names each of those under alsoChanged with what it held before and holds now. A property holding a resource takes its res:// path; a file never imported is refused with the reimport that imports it. move takes any file of the project, a script or an image as much as a resource, or a directory, and works from the files, so it needs no editor; one serving the project is brought up to it as after a move in its own FileSystem dock, its open scenes and cached resources named for the new paths and the project settings the move rewrote taken from the file. read needs no editor either: with none serving the project, a headless engine reads the file. The ops that write a resource go through the editor when one serves the project; with none, a headless engine runs the tool the editor would and the answer says so under writtenBy. That engine runs the script of the resource, where the editor runs only tool scripts, so what a script changes as the file loads or as a property is set is put back before the save, and a resource where that cannot be done is refused and the file left as it was.',
       parameters: {
         projectPath: PROJECT_PATH,
         resourcePath: {
@@ -52462,7 +52522,8 @@ ${platform}`;
       path: suite.path,
       name: report.suites.find((entry) => entry.path === suite.path)?.name ?? suite.path,
       orphans: suite.orphans,
-      message: `${suite.orphans === 1 ? "1 node" : `${String(suite.orphans)} nodes`} built during this suite ${suite.orphans === 1 ? "was" : "were"} neither freed nor in the tree when it finished, which gdUnit4 counts as orphans. Free each one, or make it with auto_free(), which frees it once the case is over.`
+      ...suite.left.length > 0 ? { left: suite.left.map(({ during, count, nodes }) => ({ case: during, count, nodes })) } : {},
+      message: suite.left.length > 0 ? suite.left.map(orphansLeftSaid).join(" ") : `${suite.orphans === 1 ? "1 node" : `${String(suite.orphans)} nodes`} built during this suite ${suite.orphans === 1 ? "was" : "were"} neither freed nor in the tree when it finished, which gdUnit4 counts as orphans. Free each one, or make it with auto_free(), which frees it once the case is over.`
     }));
     const judgedErrors = unexpectedErrors(casePrinted, declaredErrors, [...casePrinted.suites.keys()]);
     const uncaughtTexts = new Set(uncaught.map((entry) => entry.text));
@@ -57184,15 +57245,16 @@ var init_server = __esm(() => {
 // src/cli.ts
 init_bridge_announce();
 init_engine_launch();
+init_engine_slots();
 import { existsSync as existsSync35 } from "node:fs";
 import { dirname as dirname26, join as join44, resolve as resolve14 } from "node:path";
 
 // src/error-mode.ts
-import process7 from "node:process";
+import process8 from "node:process";
 var NO_FAULT_ERROR_BOX = 2;
-var cleared = process7.platform !== "win32";
+var cleared = process8.platform !== "win32";
 async function letWindowsReportCrashes() {
-  if (cleared || !("bun" in process7.versions)) {
+  if (cleared || !("bun" in process8.versions)) {
     return;
   }
   try {
@@ -57456,7 +57518,7 @@ metadata:
 
 # gdharness
 
-An MCP server and three Godot addons. Together they answer about the editor that is open, the game
+An MCP server and four Godot addons. Together they answer about the editor that is open, the game
 that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`domain_verb\`.
 
 \`references/tools.md\` is every tool, op and argument.
@@ -57885,7 +57947,9 @@ async function runSpreadCommand(options, godotPath) {
   mkdirSync8(shareDirectory, { recursive: true });
   const chosen = machineSlots({ directory: options.slotsDirectory, count: options.slotCount });
   const slotCount = chosen.count;
-  const slots = new EngineSlots(chosen.directory, slotCount, { pid: process13.pid, started: await ownStart() });
+  const slots = new EngineSlots(chosen.directory, slotCount, { pid: process13.pid, started: await ownStart() }, (line) => {
+    console.log(`[spread] ${line}`);
+  });
   const launch = {
     godotPath,
     projectPath: options.projectPath,
@@ -58416,9 +58480,8 @@ async function runTestCommand(options, godotPath) {
   mkdirSync10(runDirectory, { recursive: true });
   const logs = new RunLogs(runDirectory, keptRuns === testRuns ? null : join27(keptRuns, runName));
   const chosen = machineSlots({ directory: options.slotsDirectory, count: options.slotCount });
-  const slots = new EngineSlots(chosen.directory, chosen.count, {
-    pid: process14.pid,
-    started: await ownStart()
+  const slots = new EngineSlots(chosen.directory, chosen.count, { pid: process14.pid, started: await ownStart() }, (line) => {
+    console.log(line);
   });
   const running = new Set;
   const interrupted = () => {
@@ -59126,6 +59189,9 @@ async function upgrade() {
   const digestBefore = installedEditorDigest(projectPath);
   for (const addon of installAddons(projectPath)) {
     console.log(`${addon.replaced ? "replaced" : "installed"} ${addon.path}`);
+    if (!addon.replaced) {
+      console.log(`  addons/${addon.name}/ is new to this project: a .gitignore entry or export filter naming gdharness's addons one by one has to name it too`);
+    }
   }
   const enabled = await enablePlugins(godot, projectPath, EDITOR_PLUGINS);
   for (const [index, outcome] of enabled.entries()) {
@@ -59359,6 +59425,11 @@ async function spread() {
 }
 async function main() {
   await letWindowsReportCrashes();
+  if (command !== undefined) {
+    sayWaitsTo((line) => {
+      console.error(`gdharness: ${line}`);
+    });
+  }
   if (command === "test") {
     await test();
     return;