gdharness 1.2.39 → 1.2.41

package/build/cli.js

@@ -8577,512 +8577,1127 @@ var init_scratch = __esm(() => {
   ];
 });
 
-// src/headless.ts
-import { existsSync as existsSync9, readFileSync as readFileSync5, realpathSync as realpathSync2, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname6, join as join9 } from "node:path";
-function snakeCased(params) {
-  const result = emptyRecord();
-  for (const [key, value] of Object.entries(params)) {
-    const name = key.startsWith("_") ? key : key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-    result[name] = value;
-  }
-  return result;
-}
-function engineExtras(outcome) {
-  const after = outcome.afterAnswerMessages ?? [];
-  const before = outcome.beforeOperationMessages ?? [];
-  return {
-    ...outcome.messages.length > 0 ? { engine_messages: outcome.messages } : {},
-    ...before.length > 0 ? {
-      engine_messages_before_operation: before,
-      engine_messages_before_operation_note: BEFORE_OPERATION_NOTE
-    } : {},
-    ...outcome.beforeOperationOmitted === undefined ? {} : { engine_messages_before_operation_omitted: outcome.beforeOperationOmitted },
-    ...outcome.messagesOmitted === undefined ? {} : { engine_messages_omitted: outcome.messagesOmitted },
-    ...after.length > 0 ? { engine_messages_after_answer: after, engine_messages_after_answer_note: AFTER_ANSWER_NOTE } : {},
-    ...outcome.afterAnswerOmitted === undefined ? {} : { engine_messages_after_answer_omitted: outcome.afterAnswerOmitted },
-    ...outcome.afterAnswer === undefined ? {} : { engine_after_answer: outcome.afterAnswer }
-  };
-}
-function problemsIn(log) {
-  return problemsAmong(log.everything());
-}
-function problemsAmong(entries) {
-  return entries.flatMap((entry) => {
-    if (entry.severity !== "info") {
-      return [entry];
+// src/junit.ts
+function decoded(text) {
+  return text.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z]+);/g, (whole, entity) => {
+    if (entity.startsWith("#")) {
+      const code = entity.startsWith("#x") ? Number.parseInt(entity.slice(2), 16) : Number.parseInt(entity.slice(1), 10);
+      if (!Number.isInteger(code) || code < 0 || code > 1114111) {
+        throw new MalformedReportError(`Not a character: ${whole}`);
+      }
+      return String.fromCodePoint(code);
     }
-    if (entry.source === "stderr" && entry.text.startsWith(OWN_ERROR)) {
-      return [{ ...entry, severity: "error", text: entry.text.slice(OWN_ERROR.length) }];
+    const named = ENTITIES[entity];
+    if (named === undefined) {
+      throw new MalformedReportError(`Unknown entity ${whole}`);
     }
-    return [];
-  });
-}
-function reported2(problems) {
-  const omitted = Math.max(0, problems.length - MESSAGES_KEPT);
-  return omitted === 0 ? { messages: problems } : { messages: problems.slice(omitted), messagesOmitted: omitted };
-}
-function reason(log, problems) {
-  const own = refusalsIn(log);
-  if (own.length > 0) {
-    return own.map((entry) => entry.text.slice(OWN_ERROR.length)).join("; ");
-  }
-  const errors = problems.filter((entry) => entry.severity === "error").map((entry) => entry.text);
-  if (errors.length > 0) {
-    const rest = errors.length - ERRORS_NAMED;
-    return rest > 0 ? `${errors.slice(0, ERRORS_NAMED).join("; ")}; and ${rest} more error${rest === 1 ? "" : "s"}` : errors.join("; ");
-  }
-  const printed = log.everything().filter((entry) => entry.source === "stdout");
-  return printed.at(-1)?.text ?? "no output at all";
-}
-function refusalsIn(log) {
-  return log.everything().filter((entry) => entry.source === "stderr" && entry.severity === "info" && entry.text.startsWith(OWN_ERROR));
-}
-function scriptFault(problems, script) {
-  const spelled = (path) => `(${path.replaceAll("\\", "/").toLowerCase()}/`;
-  const directories = [...new Set([spelled(dirname6(script)), spelled(resolvedOr(dirname6(script)))])];
-  return problems.find((entry) => {
-    const at = entry.detail.find((line) => line.startsWith("at: "))?.replaceAll("\\", "/").toLowerCase();
-    return entry.severity === "error" && at !== undefined && directories.some((directory) => at.includes(directory));
+    return named;
   });
 }
-function resolvedOr(path) {
-  try {
-    return realpathSync2.native(path);
-  } catch {
-    return path;
+function tagEnd(source, from) {
+  let quote = null;
+  for (let at = from + 1;at < source.length; at += 1) {
+    const character = source[at];
+    if (quote !== null) {
+      if (character === quote) {
+        quote = null;
+      }
+    } else if (character === '"' || character === "'") {
+      quote = character;
+    } else if (character === ">") {
+      return at;
+    }
   }
+  return -1;
 }
-function librariesNotCopied(messages) {
-  const found = new Set;
-  for (const entry of messages) {
-    const library = /Error copying library: (.+)$/.exec(entry.text)?.[1]?.trim();
-    if (library !== undefined && library !== "") {
-      found.add(library);
+function parseXml(source) {
+  const root = { name: "", attributes: {}, children: [], text: "" };
+  const open = [root];
+  let at = 0;
+  const current = () => {
+    const element = open.at(-1);
+    if (element === undefined) {
+      throw new MalformedReportError("A close tag with nothing open");
+    }
+    return element;
+  };
+  while (at < source.length) {
+    const next = source.indexOf("<", at);
+    if (next === -1) {
+      current().text += decoded(source.slice(at));
+      break;
+    }
+    current().text += decoded(source.slice(at, next));
+    at = next;
+    if (source.startsWith("<![CDATA[", at)) {
+      const end = source.indexOf("]]>", at);
+      if (end === -1) {
+        throw new MalformedReportError("CDATA that never ends");
+      }
+      current().text += source.slice(at + "<![CDATA[".length, end);
+      at = end + "]]>".length;
+      continue;
+    }
+    if (source.startsWith("<!--", at)) {
+      const end = source.indexOf("-->", at);
+      if (end === -1) {
+        throw new MalformedReportError("A comment that never ends");
+      }
+      at = end + "-->".length;
+      continue;
+    }
+    if (source.startsWith("<?", at) || source.startsWith("<!", at)) {
+      const end = source.indexOf(">", at);
+      if (end === -1) {
+        throw new MalformedReportError("A declaration that never ends");
+      }
+      at = end + 1;
+      continue;
+    }
+    const end = tagEnd(source, at);
+    if (end === -1) {
+      throw new MalformedReportError("A tag that never ends");
+    }
+    const tag = source.slice(at + 1, end);
+    at = end + 1;
+    if (tag.startsWith("/")) {
+      const closing = tag.slice(1).trim();
+      const element = current();
+      if (element === root || element.name !== closing) {
+        throw new MalformedReportError(`</${closing}> closes <${element.name || "nothing"}>`);
+      }
+      open.pop();
+      continue;
+    }
+    const selfClosing = tag.endsWith("/");
+    const body = selfClosing ? tag.slice(0, -1) : tag;
+    const nameMatch = /^([^\s/>]+)/.exec(body);
+    if (!nameMatch?.[1]) {
+      throw new MalformedReportError(`A tag with no name: <${tag}>`);
+    }
+    const attributes = {};
+    let read = nameMatch[0].length;
+    ATTRIBUTE.lastIndex = read;
+    let attribute = ATTRIBUTE.exec(body);
+    while (attribute) {
+      attributes[attribute[1] ?? ""] = decoded(attribute[2] ?? attribute[3] ?? "");
+      read = ATTRIBUTE.lastIndex;
+      attribute = ATTRIBUTE.exec(body);
+    }
+    if (body.slice(read).trim() !== "") {
+      throw new MalformedReportError(`Unreadable attributes in <${tag}>`);
+    }
+    const element = { name: nameMatch[1], attributes, children: [], text: "" };
+    current().children.push(element);
+    if (!selfClosing) {
+      open.push(element);
     }
   }
-  return [...found];
+  if (open.length !== 1) {
+    throw new MalformedReportError(`<${current().name}> is never closed`);
+  }
+  return root;
 }
-function extensionRetryNote(libraries, stillNotLoaded = []) {
-  const second = stillNotLoaded.length === 0 ? "so the import was run again and loaded the extension, and the messages are from that second run." : `so the import was run again, and it still could not load ${stillNotLoaded.join(" and ")}: this answer is from an import without ${stillNotLoaded.length === 1 ? "it" : "them"}, and its messages say what the engine hit.`;
-  return `The first import could not load ${libraries.join(" and ")}: on Windows an engine running as the editor ` + "loads a GDExtension from a ~ copy beside the library, and the editor open on this project holds its own " + "copy there, so the first engine started beside it cannot make one. That failed attempt moves the " + `editor's copy aside, ${second} The editor's copy is left beside the library as a ~RF….TMP file, which ` + "the next import, export or editor this server starts on the project deletes once the editor has exited.";
+function count(attributes, name) {
+  const value = Number(attributes[name] ?? "0");
+  return Number.isFinite(value) ? value : 0;
 }
-async function runImport(godotPath, projectPath, options = {}) {
-  const once = options.once ?? importOnce;
-  const pass = () => {
-    for (const target of options.forcing ?? []) {
-      forceNextImport(projectPath, target);
+function ignoredYetRan(report, ignored) {
+  const found = [];
+  for (const entry of ignored) {
+    const bare = entry.replace("res://", "");
+    const at = bare.lastIndexOf(":");
+    const suiteNamed = at === -1 ? null : bare.slice(0, at);
+    const testNamed = at === -1 ? bare : bare.slice(at + 1);
+    for (const suite of report.suites) {
+      const suiteMatches = suiteNamed === null || suite.name === suiteNamed || (suite.path ?? "").includes(suiteNamed);
+      const ran = suiteMatches ? suite.cases.find((one) => one.name === testNamed) : undefined;
+      if (ran !== undefined) {
+        found.push({ entry, ran: `${suite.name}:${ran.name}` });
+      }
     }
-    freeLibraryCopies(projectPath);
-    return once(godotPath, projectPath);
-  };
-  const first = await pass();
-  const collided = librariesNotCopied(first.messages);
-  const crash = first.docCacheNote;
-  if (collided.length === 0 && crash === undefined) {
-    return first;
   }
-  const { docCacheNote: _, ...again } = await pass();
-  const second = again.ok || crash === undefined ? again : { ...again, message: `${again.message.replace(/[.\s]+$/, "")}. ${crash}` };
-  const still = librariesNotCopied(second.messages);
-  return {
-    ...second,
-    ...collided.length === 0 ? {} : {
-      librariesRetried: collided,
-      ...still.length === 0 ? {} : { librariesNotLoaded: still },
-      extensionNote: extensionRetryNote(collided, still)
-    },
-    ...crash === undefined ? {} : { docCacheNote: crash }
-  };
+  return found;
 }
-async function importOnce(godotPath, projectPath) {
-  const logDir = scratchDirectory("import");
-  const caches = editorCacheDirectory(godotPath);
-  const cachesBefore = docCachesWritten(caches);
-  let ran;
-  try {
-    ran = await runEngine(godotPath, [
-      "--headless",
-      "--log-file",
-      join9(logDir, "engine.log"),
-      "--path",
-      projectPath,
-      "--import"
-    ]);
-  } finally {
-    discard(logDir);
-  }
-  const problems = problemsIn(ran.log);
-  const crash = docCacheCrash(ran, cachesBefore, docCachesWritten(caches), "import");
-  if (ran.exitCode === 0 && ran.failure === null) {
-    return { ok: true, ...reported2(problems), ...crash === null ? {} : { docCacheNote: crash } };
-  }
+function caseOf(suite, element) {
+  const of = (kind) => element.children.filter((child) => child.name === kind).map((child) => {
+    const detail = child.text.trim();
+    return { kind, message: child.attributes["message"] ?? null, detail: detail === "" ? null : detail };
+  });
+  const reports = [...of("failure"), ...of("error"), ...of("skipped")];
+  const status = reports.some((report) => report.kind === "error") ? "error" : reports.some((report) => report.kind === "failure") ? "failed" : reports.length > 0 ? "skipped" : "passed";
   return {
-    ok: false,
-    message: `the import pass failed (${howItEnded(ran)}): ${reason(ran.log, problems)}`,
-    ...reported2(problems),
-    ...crash === null ? {} : { docCacheNote: crash }
+    suite: suite.attributes["name"] ?? "",
+    name: element.attributes["name"] ?? "",
+    status,
+    time: count(element.attributes, "time"),
+    message: reports[0]?.message ?? null,
+    detail: reports[0]?.detail ?? null,
+    reports
   };
 }
-async function runOperation(engine, operation, params, projectPath) {
-  const paramsDir = scratchDirectory("params");
-  const paramsFile = join9(paramsDir, `${operation}.json`);
-  const answerFile = join9(paramsDir, "answer.json");
-  writeFileSync4(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
-  const args = [
-    "--headless",
-    "--log-file",
-    join9(paramsDir, "engine.log"),
-    "--path",
-    projectPath,
-    "--script",
-    engine.script,
-    operation,
-    `@file:${paramsFile}`,
-    answerFile,
-    ...engine.debug ? ["--debug-godot"] : []
-  ];
-  let ran;
-  let answer;
-  try {
-    ran = await runEngine(engine.godotPath, args);
-    answer = answerIn(answerFile);
-  } finally {
-    discard(paramsDir);
-  }
-  const everything = ran.log.everything();
-  const marked = (text) => everything.findIndex((entry) => entry.source === "stderr" && entry.text === text);
-  const answered = marked(ANSWERED);
-  const waiting = marked(WAITING);
-  const begun = marked(BEGUN);
-  const ended = answered === -1 ? everything.length : answered;
-  const problems = waiting === -1 ? problemsAmong(everything.slice(0, ended)) : problemsAmong([
-    ...everything.slice(0, waiting),
-    ...begun === -1 ? [] : everything.slice(begun + 1, ended)
-  ]);
-  const startup = waiting === -1 ? [] : problemsAmong(everything.slice(waiting + 1, begun === -1 ? ended : begun));
-  const after = answered === -1 ? [] : problemsAmong(everything.slice(answered + 1));
-  const afterAnswered = {
-    ...after.length === 0 ? {} : { afterAnswerMessages: after.slice(-MESSAGES_KEPT) },
-    ...after.length > MESSAGES_KEPT ? { afterAnswerOmitted: after.length - MESSAGES_KEPT } : {},
-    ...startup.length === 0 ? {} : { beforeOperationMessages: startup.slice(-MESSAGES_KEPT) },
-    ...startup.length > MESSAGES_KEPT ? { beforeOperationOmitted: startup.length - MESSAGES_KEPT } : {}
-  };
-  if (answer.kind === "unreadable") {
-    return {
-      ok: false,
-      message: `${operation} wrote an answer that could not be read (${answer.why})`,
-      ...reported2(problems),
-      ...afterAnswered
-    };
-  }
-  if (answer.kind === "none") {
-    if (waiting !== -1 && begun === -1) {
-      return {
-        ok: false,
-        message: `${operation} never ran: the engine ended (${howItEnded(ran)}) while it started the project's ` + `autoloads, which this operation waits for. The last it reported: ${reason(ran.log, startup)}`,
-        ...reported2(problems),
-        ...afterAnswered
-      };
-    }
-    const refusals = refusalsIn(ran.log);
-    if (refusals.length > 0) {
-      const said = new Set(refusals.map((entry) => entry.index));
-      return {
-        ok: false,
-        message: refusals.map((entry) => entry.text.slice(OWN_ERROR.length)).join("; "),
-        ...reported2(problems.filter((entry) => !said.has(entry.index)))
-      };
-    }
-    const ending = ran.exitCode === 0 && ran.failure === null ? "produced no result" : `failed (${howItEnded(ran)})`;
-    return {
-      ok: false,
-      message: `${operation} ${ending}: ${reason(ran.log, problems)}`,
-      ...reported2(problems)
-    };
+function failedAnAssertion(entry) {
+  return entry.reports.some((report) => report.kind === "failure");
+}
+function pathOf(suite) {
+  const directory = suite.attributes["package"];
+  const name = suite.attributes["name"];
+  return directory && name ? `res://${directory}/${name}.gd` : null;
+}
+function parseJUnit(xml) {
+  const document = parseXml(xml);
+  const top = document.children.find((child) => child.name === "testsuites" || child.name === "testsuite");
+  if (top === undefined) {
+    throw new MalformedReportError("No <testsuites> or <testsuite> in the report");
   }
-  const fault = scriptFault(problems, engine.script);
-  if (fault !== undefined) {
+  const suiteElements = top.name === "testsuite" ? [top] : top.children.filter((child) => child.name === "testsuite");
+  const suites = suiteElements.map((suite) => {
+    const cases = suite.children.filter((child) => child.name === "testcase").map((element) => caseOf(suite, element));
+    const failures = cases.filter(failedAnAssertion).length;
+    const errors = cases.filter((entry) => entry.status === "error").length;
+    const written = (kind) => suite.children.filter((child) => child.name === "testcase").reduce((sum, element) => sum + element.children.filter((child) => child.name === kind).length, 0);
     return {
-      ok: false,
-      message: `${operation} hit an error in the operations script, so its answer is left out: part of it was ` + `never computed. ${fault.text} (${fault.detail[0]?.slice("at: ".length) ?? "no location given"})`,
-      ...reported2(problems),
-      ...afterAnswered
+      name: suite.attributes["name"] ?? "",
+      path: pathOf(suite),
+      tests: cases.length,
+      discovered: count(suite.attributes, "tests"),
+      failures,
+      errors,
+      hookFailures: Math.max(0, count(suite.attributes, "failures") - written("failure")),
+      hookErrors: Math.max(0, count(suite.attributes, "errors") - written("error")),
+      skipped: cases.filter((entry) => entry.status === "skipped").length,
+      time: count(suite.attributes, "time"),
+      cases
     };
-  }
-  const afterAnswer = ran.exitCode === 0 && ran.failure === null ? undefined : `The operation finished and wrote this answer, and then the engine did not exit cleanly (${howItEnded(ran)}). Anything it reported on the way out is under ${answered === -1 ? "engine_messages" : "engine_messages_after_answer"}.`;
+  });
+  const all = suites.flatMap((suite) => suite.cases);
   return {
-    ok: true,
-    payload: answer.payload,
-    ...reported2(problems),
-    ...afterAnswered,
-    ...afterAnswer === undefined ? {} : { afterAnswer }
+    tests: all.length,
+    failures: all.filter(failedAnAssertion).length,
+    errors: all.filter((entry) => entry.status === "error").length,
+    hookFailures: suites.reduce((sum, suite) => sum + suite.hookFailures, 0),
+    hookErrors: suites.reduce((sum, suite) => sum + suite.hookErrors, 0),
+    skipped: all.filter((entry) => entry.status === "skipped").length,
+    time: suites.reduce((sum, suite) => sum + suite.time, 0),
+    suites
   };
 }
-function answerIn(file) {
-  if (!existsSync9(file)) {
-    return { kind: "none" };
-  }
-  const text = readFileSync5(file, "utf8");
-  try {
-    const parsed = JSON.parse(text);
-    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? { kind: "answer", payload: parsed } : { kind: "unreadable", why: `it is JSON but not an object: ${text.slice(0, 200)}` };
-  } catch (error) {
-    return {
-      kind: "unreadable",
-      why: `${error instanceof Error ? error.message : String(error)}: ${text.slice(0, 200)}`
-    };
-  }
-}
-var AFTER_ANSWER_NOTE = "Printed after this operation had written its answer, while the engine ran the project's autoloads and shut down: Godot starts a project's autoloads in every script run and cannot be told not to. An error raised in a project script here is that autoload's own, and none of these changes the answer.", BEFORE_OPERATION_NOTE = "Printed while the engine started the project's autoloads, before this operation ran: an operation that compiles the project's scripts waits for them, because the engine knows an autoload's name only once it is in the tree. An error raised in a project script here is that autoload's own.", OWN_ERROR = "[ERROR] ", ANSWERED = "[gdharness] answered", WAITING = "[gdharness] waiting for the autoloads", BEGUN = "[gdharness] begun", MESSAGES_KEPT = 200, ERRORS_NAMED = 3;
-var init_headless = __esm(() => {
-  init_doc_cache();
-  init_engine_run();
-  init_library_copies();
-  init_reimport();
-  init_scratch();
-});
-
-// src/update-check.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir4, tmpdir as tmpdir3 } from "node:os";
-import { join as join10 } from "node:path";
-function packageUrl(root) {
-  return `${root.replace(/\/+$/, "")}/gdharness/latest`;
+function hookFailuresPrinted(printed) {
+  return printed.flatMap((line) => {
+    const found = HOOK_FAILURE.exec(line);
+    return found === null ? [] : [{ hook: found[2] ?? "", path: found[3] ?? "", line: Number(found[4]), message: found[1] ?? "" }];
+  });
 }
-function registryFor(environment) {
-  const named = environment["GDHARNESS_REGISTRY"] ?? "";
-  if (named === "") {
-    return packageUrl(REGISTRY_ROOT);
-  }
-  try {
-    return new URL(named).protocol === "https:" ? packageUrl(named) : packageUrl(REGISTRY_ROOT);
-  } catch {
-    return packageUrl(REGISTRY_ROOT);
+function whyNoReport(printed, asked) {
+  const missing = printed.map((line) => NO_SUCH_PATH.exec(line)).find((found) => found !== null);
+  if (missing !== undefined) {
+    return `nothing at ${missing[1] ?? asked}`;
   }
+  return printed.some((line) => NOTHING_RAN.test(line)) ? `no test cases found at ${asked}` : null;
 }
-function cacheDirectory(environment) {
-  const set = (name) => {
-    const value = environment[name];
-    return value !== undefined && value !== "" ? value : null;
-  };
-  const home = set("HOME") ?? homedir4();
-  if (process.platform === "win32") {
-    return join10(set("LOCALAPPDATA") ?? home, "gdharness");
-  }
-  if (process.platform === "darwin") {
-    return join10(home, "Library", "Caches", "gdharness");
-  }
-  return join10(set("XDG_CACHE_HOME") ?? join10(home, ".cache"), "gdharness");
+function scriptErrorsPrinted(printed) {
+  return discoveryListing(printed)?.errors ?? [];
 }
-function cacheFile(environment = process.env) {
-  try {
-    const directory = cacheDirectory(environment);
-    mkdirSync3(directory, { recursive: true, mode: 448 });
-    return join10(directory, "update-check.json");
-  } catch {
-    return join10(tmpdir3(), "gdharness-update-check.json");
+function discoveryListing(printed) {
+  const start = printed.findIndex((line) => line.includes(DISCOVERY_FAILED));
+  if (start < 0) {
+    return null;
   }
-}
-function readCache(path) {
-  try {
-    if (!existsSync10(path)) {
-      return null;
-    }
-    const parsed = JSON.parse(readFileSync6(path, "utf8"));
-    if (typeof parsed !== "object" || parsed === null) {
-      return null;
-    }
-    const record = parsed;
-    const checkedAt = record["checkedAt"];
-    const latest = record["latest"];
-    if (typeof checkedAt !== "number" || typeof latest !== "string" || !VERSION.test(latest)) {
-      return null;
+  const found = [];
+  let message = null;
+  let to = start + 1;
+  for (const line of printed.slice(start + 1)) {
+    const at = /^\s*at (res:\/\/.+):(\d+)\s*$/.exec(line);
+    if (at !== null && message !== null) {
+      found.push({ path: at[1] ?? "", line: Number(at[2]) === 0 ? null : Number(at[2]), message });
+      message = null;
+    } else if (at === null && message === null && /^ {2}\S/.test(line)) {
+      message = line.trim();
+    } else {
+      break;
     }
-    return { checkedAt, latest };
-  } catch {
-    return null;
+    to += 1;
   }
+  const errors = found.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : (a.line ?? 0) - (b.line ?? 0));
+  return { errors, from: start, to };
 }
-function writeCache(path, entry) {
-  try {
-    writeFileSync5(path, JSON.stringify(entry), { encoding: "utf8", mode: 384 });
-  } catch {}
+function unspelled(text) {
+  return text.replace(/<(?:LF|CR|TAB|BS|FF|VT|BEL|ESC|DEL|0x[0-9A-F]{2})>/g, (spelling) => spelling.startsWith("<0x") ? String.fromCharCode(Number.parseInt(spelling.slice(3, 5), 16)) : SPELLED[spelling] ?? spelling);
 }
-function parts(version) {
-  const withoutBuild = version.split("+")[0] ?? version;
-  const dash = withoutBuild.indexOf("-");
-  const numeric = dash === -1 ? withoutBuild : withoutBuild.slice(0, dash);
-  return {
-    numbers: numeric.split(".").map((piece) => Number.parseInt(piece, 10) || 0),
-    prerelease: dash !== -1
-  };
-}
-function isNewer(candidate, current) {
-  const left = parts(candidate);
-  const right = parts(current);
-  for (let index = 0;index < 3; index += 1) {
-    const a = left.numbers[index] ?? 0;
-    const b = right.numbers[index] ?? 0;
-    if (a !== b) {
-      return a > b;
+function readDiff(printed) {
+  let merged = "";
+  let actual = "";
+  let background = null;
+  let last = 0;
+  const take = (text) => {
+    merged += text;
+    if (background === null) {
+      actual += text;
+    } else if (background === "added") {
+      actual += unspelled(text);
+    }
+  };
+  for (const match of printed.matchAll(COLOUR)) {
+    take(printed.slice(last, match.index));
+    last = match.index + match[0].length;
+    const codes = (match[1] ?? "").split(";");
+    if (codes[0] === "48" && codes[1] === "2") {
+      background = Number(codes[2]) > Number(codes[3]) ? "missing" : "added";
+    } else if (codes[0] === "0" || codes[0] === "") {
+      background = null;
     }
   }
-  return !left.prerelease && right.prerelease;
+  take(printed.slice(last));
+  return { merged, actual };
 }
-async function fetchLatest(registry) {
-  const response = await fetch(registry, {
-    headers: { accept: "application/vnd.npm.install-v1+json, application/json" },
-    redirect: "error",
-    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+function withActualsPrinted(failed, printed) {
+  const diffs = [...printed.replaceAll(`\r
+`, `
+`).matchAll(PRINTED_ACTUAL)].map((match) => ({
+    suffix: match[3] ?? "",
+    at: match[5] ?? "",
+    ...readDiff(match[1] ?? "")
+  }));
+  const used = new Set;
+  return failed.map((entry) => {
+    if (entry.detail === null) {
+      return entry;
+    }
+    let detail = entry.detail;
+    let recovered = false;
+    for (const [index, diff] of diffs.entries()) {
+      if (used.has(index)) {
+        continue;
+      }
+      const wrong = ` but was
+ '${diff.merged.replaceAll("\r", "")}'${diff.suffix}
+	at ${diff.at}`;
+      if (detail.includes(wrong)) {
+        detail = detail.replace(wrong, () => ` but was
+ '${diff.actual}'${diff.suffix}
+	at ${diff.at}`);
+        recovered = true;
+        used.add(index);
+      }
+    }
+    const quoted = QUOTED_EQUALITY.exec(detail);
+    if (quoted !== null) {
+      const alike = quoted[1] === quoted[2];
+      const note = recovered ? alike ? RENDERED_AWAY_NOTE : null : alike ? BOTH_SIDES_ALIKE_NOTE : VALUE_NOT_RECOVERED_NOTE;
+      detail = note === null ? detail : `${detail}
+${note}`;
+    }
+    if (quoted !== null && masked(quoted[1] ?? "", quoted[2] ?? "")) {
+      const end = quoted[0].length - `
+	at `.length;
+      detail = detail.slice(0, end).replaceAll(MASKED_BRACKET, "[") + detail.slice(end);
+    }
+    return detail === entry.detail ? entry : { ...entry, detail };
   });
-  if (!response.ok || response.body === null) {
-    return null;
+}
+function shortened(detail) {
+  if (detail === null || detail.length <= LONGEST_DETAIL) {
+    return detail;
   }
-  const declared = Number.parseInt(response.headers.get("content-length") ?? "", 10);
-  if (Number.isFinite(declared) && declared > MAX_BODY_BYTES) {
-    return null;
+  return `${detail.slice(0, LONGEST_DETAIL)}
+[${detail.length - LONGEST_DETAIL} more characters left out]`;
+}
+function foldedReports(reports) {
+  const first = new Map;
+  for (const report of reports) {
+    const key = JSON.stringify([report.kind, report.message, report.detail]);
+    const seen = first.get(key);
+    if (seen === undefined) {
+      first.set(key, { report, times: 1 });
+    } else {
+      seen.times += 1;
+    }
   }
-  const chunks = [];
-  let size = 0;
-  for await (const chunk of response.body) {
-    size += chunk.byteLength;
-    if (size > MAX_BODY_BYTES) {
-      return null;
+  return [...first.values()].map(({ report, times }) => {
+    const kept = { ...report, detail: shortened(report.detail) };
+    return times === 1 ? kept : { ...kept, times };
+  });
+}
+function failedCases(report, printed) {
+  const cases = report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ entry, path: suite.path })));
+  const read = withActualsPrinted(cases.flatMap(({ entry }) => entry.reports), printed);
+  let next = 0;
+  return cases.map(({ entry, path }) => {
+    const reports = read.slice(next, next + entry.reports.length);
+    next += entry.reports.length;
+    const folded = foldedReports(reports);
+    const shown = folded.slice(0, MOST_REPORTS_SHOWN);
+    return {
+      suite: entry.suite,
+      name: entry.name,
+      status: entry.status,
+      time: entry.time,
+      path,
+      message: reports[0]?.message ?? null,
+      detail: shortened(reports[0]?.detail ?? null),
+      ...reports.length > 1 ? { reports: shown, reportCount: reports.length } : {},
+      ...folded.length > shown.length ? { reportsLeftOut: folded.length - shown.length } : {}
+    };
+  });
+}
+function failedWithin(failed, budget) {
+  const sizes = failed.map((entry) => JSON.stringify(entry).length);
+  const smallestFirst = sizes.map((_, index) => index).sort((a, b) => (sizes[a] ?? 0) - (sizes[b] ?? 0));
+  const whole = new Set;
+  let spent = 0;
+  for (const index of smallestFirst) {
+    const size = sizes[index] ?? 0;
+    if (spent + size > budget) {
+      break;
     }
-    chunks.push(chunk);
+    spent += size;
+    whole.add(index);
   }
-  const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-  if (typeof parsed !== "object" || parsed === null) {
-    return null;
+  const kept = failed.map((entry, index) => {
+    if (whole.has(index)) {
+      return entry;
+    }
+    const { detail: _detail, reports: _reports, reportsLeftOut: _left, ...named } = entry;
+    return { ...named, message: entry.message?.slice(0, 500) ?? null, detail: null };
+  });
+  return { failed: kept, briefed: failed.length - whole.size };
+}
+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 orphansPrinted(printed) {
+  const suites = [];
+  let total = null;
+  let running = null;
+  for (const line of printed) {
+    const started = RUNNING_SUITE.exec(line);
+    if (started?.[1] !== undefined) {
+      running = started[1];
+      continue;
+    }
+    const counted = ORPHANS.exec(line);
+    if (counted?.[1] === undefined) {
+      continue;
+    }
+    const orphans = Number(counted[1]);
+    if (line.includes(OVERALL)) {
+      total = orphans;
+      running = null;
+      continue;
+    }
+    if (running !== null && orphans > 0) {
+      suites.push({ path: running, orphans });
+    }
+    running = null;
   }
-  const version = parsed["version"];
-  return typeof version === "string" && VERSION.test(version) ? version : null;
+  return {
+    total: total ?? suites.reduce((sum, suite) => sum + suite.orphans, 0),
+    suites
+  };
 }
-
-class UpdateCheck {
-  latest = null;
-  checking = false;
-  asked = false;
-  checkedAt = 0;
-  retryAt = 0;
-  backoffMs = FIRST_RETRY_MS;
-  enabled;
-  current;
-  cachePath;
-  ask;
-  constructor(current, environment = process.env, ask = () => fetchLatest(registryFor(environment))) {
-    this.current = current;
-    this.enabled = (environment["GDHARNESS_NO_UPDATE_CHECK"] ?? "") === "";
-    this.cachePath = cacheFile(environment);
-    this.ask = ask;
-    const cached = this.enabled ? readCache(this.cachePath) : null;
-    if (cached !== null) {
-      this.latest = cached.latest;
-      this.checkedAt = cached.checkedAt;
+function finishesASuite(line) {
+  return SUITE_COUNTS.test(line) && !line.includes(OVERALL);
+}
+function suitesPrinted(printed) {
+  const finished = [];
+  let running = null;
+  let failed = [];
+  for (const line of printed) {
+    const started = RUNNING_SUITE.exec(line);
+    if (started?.[1] !== undefined) {
+      running = started[1];
+      failed = [];
+      continue;
+    }
+    if (running === null) {
+      continue;
+    }
+    const failing = CASE_FAILED.exec(line)?.[1];
+    if (failing !== undefined) {
+      failed.push(failing);
+      continue;
+    }
+    const counted = finishesASuite(line) ? SUITE_COUNTS.exec(line) : null;
+    if (counted !== null) {
+      finished.push({
+        path: running,
+        cases: Number(counted[1]),
+        errors: Number(counted[2]),
+        failures: Number(counted[3]),
+        failed
+      });
+      running = null;
     }
   }
-  refresh(now = Date.now()) {
-    if (!this.enabled || this.checking || now < this.retryAt || this.asked && !this.stale(now)) {
-      return;
+  return { finished, running };
+}
+function testProgressMessage(printed, elapsedMs) {
+  const { finished, running } = suitesPrinted(printed);
+  const failing = finished.filter((suite) => suite.errors + suite.failures > 0).length;
+  const seconds = Math.floor(elapsedMs / 1000);
+  const took = seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  const done = finished.length === 0 ? "No suite has finished" : `${finished.length === 1 ? "One suite has" : `${finished.length} suites have`} finished${failing === 0 ? "" : `, ${failing} with failures`}`;
+  return `${done}${running === null ? "" : `; running ${running}`}; ${took} in.`;
+}
+var MalformedReportError, ENTITIES, ATTRIBUTE, HOOK_FAILURE, NOTHING_RAN, NO_SUCH_PATH, DISCOVERY_FAILED = "Script errors were detected during test discovery!", ESCAPE, LOCATION = `'[^'\\n]*' in \\S+:\\d+`, IGNORING_CASE = " \\(ignoring case\\)", PRINTED_ACTUAL, QUOTED_EQUALITY, 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 init_junit = __esm(() => {
+  MalformedReportError = class MalformedReportError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "MalformedReportError";
     }
-    this.asked = true;
-    this.checking = true;
-    this.ask().then((version) => {
-      if (version === null) {
-        this.scheduleRetry(now);
-        return;
+  };
+  ENTITIES = { lt: "<", gt: ">", amp: "&", quot: '"', apos: "'" };
+  ATTRIBUTE = /\s*([^\s=/>]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/y;
+  HOOK_FAILURE = /^\s*(.*?)\s*\tat '(before|after)' in (res:\/\/.+?):(\d+)\s*$/;
+  NOTHING_RAN = /no test cases found/i;
+  NO_SUCH_PATH = /given directory or file does not exists:\s*(.+?)\s*$/i;
+  ESCAPE = String.fromCharCode(27);
+  PRINTED_ACTUAL = new RegExp(` but was\\n '((?:(?!\\tat ${LOCATION})[\\s\\S])*?)'((?:${ESCAPE}\\[[0-9;]*m)*)(${IGNORING_CASE})?((?:${ESCAPE}\\[[0-9;]*m)*)\\tat (${LOCATION})`, "g");
+  QUOTED_EQUALITY = new RegExp(`^Expecting(?: error message)?:\\n '([\\s\\S]*)'\\n but was\\n '([\\s\\S]*)'(?:${IGNORING_CASE})?\\n\\tat `);
+  COLOUR = new RegExp(`${ESCAPE}\\[([0-9;]*)m`, "g");
+  SPELLED = {
+    "<LF>": `
+`,
+    "<CR>": "\r",
+    "<TAB>": "\t",
+    "<BS>": "\b",
+    "<FF>": "\f",
+    "<VT>": "\v",
+    "<BEL>": "\x07",
+    "<ESC>": ESCAPE,
+    "<DEL>": ""
+  };
+  PRINTED_DICTIONARY = /^\{\n\t[\s\S]*\n {2}\}$/;
+  RUNNING_SUITE = /Run Test Suite:\s*(res:\/\/.+?\.(?:gd|cs))(?=\s|$)/;
+  ORPHANS = /(\d+)\s+orphans/;
+  SUITE_COUNTS = /(\d+)\s+test cases\s*\|\s*(\d+)\s+errors\s*\|\s*(\d+)\s+failures/;
+  CASE_FAILED = /^\s*res:\/\/.+?\.(?:gd|cs) > (.+?) (?:FAILED|ERROR)(?:\s|$)/;
+});
+
+// src/script-origins.ts
+import { join as join9 } from "node:path";
+function unresolvedClassIn(message) {
+  return UNRESOLVED.exec(message)?.[1] ?? null;
+}
+async function originsOf(errors, declared, check) {
+  const listed = new Set(errors.map((error) => error.path));
+  const origins = [];
+  const unconfirmed = [];
+  const asked = new Set;
+  const waiting = errors.map((error) => unresolvedClassIn(error.message)).filter((name) => name !== null);
+  while (waiting.length > 0 && asked.size < MOST_CHECKED) {
+    const name = waiting.shift() ?? "";
+    const path = declared.get(name);
+    if (path === undefined || listed.has(path) || asked.has(path)) {
+      continue;
+    }
+    asked.add(path);
+    const checked = await check(path);
+    const own = checked.errors.filter((error) => error.path === path);
+    if (own.length === 0) {
+      unconfirmed.push({
+        path,
+        declares: name,
+        why: checked.failure === null ? "the engine's check of it found no error" : `the engine's check of it did not finish (${checked.failure})`
+      });
+      continue;
+    }
+    for (const error of own) {
+      origins.push({ ...error, declares: name });
+      const deeper = unresolvedClassIn(error.message);
+      if (deeper !== null) {
+        waiting.push(deeper);
       }
-      this.latest = version;
-      this.checkedAt = Date.now();
-      this.backoffMs = FIRST_RETRY_MS;
-      this.retryAt = 0;
-      writeCache(this.cachePath, { checkedAt: this.checkedAt, latest: version });
-    }).catch(() => {
-      this.scheduleRetry(now);
-    }).finally(() => {
-      this.checking = false;
-    });
+    }
   }
-  stale(now) {
-    return now - this.checkedAt >= CACHE_MS;
+  return { origins, unconfirmed };
+}
+function notCompiledIn(entry) {
+  return NOT_COMPILED.exec(entry.text)?.[1];
+}
+function compileErrorsIn(entries) {
+  return entries.flatMap((entry) => {
+    const at = entry.severity === "error" ? reloadedAt(entry) : null;
+    return at === null ? [] : [{ ...at, message: entry.text }];
+  });
+}
+function reloadedAt(entry) {
+  for (const line of entry.detail) {
+    const at = RELOADED_AT.exec(line.trim());
+    if (at !== null) {
+      return { path: at[1] ?? "", line: Number(at[2]) === 0 ? null : Number(at[2]) };
+    }
   }
-  scheduleRetry(now) {
-    this.retryAt = now + this.backoffMs;
-    this.backoffMs = Math.min(this.backoffMs * 2, MAX_RETRY_MS);
+  return null;
+}
+function checkWithEngine(godotPath, projectPath) {
+  return async (path) => {
+    const logDir = scratchDirectory("tests");
+    try {
+      const ran = await runEngine(godotPath, [
+        "--headless",
+        "--log-file",
+        join9(logDir, "engine.log"),
+        "--path",
+        projectPath,
+        "--check-only",
+        "-s",
+        path
+      ], { timeout: { ms: 60000, said: "minute" } });
+      const errors = ran.log.select({ severity: "error", sinceLastCall: false, limit: 50 }).entries.flatMap((entry) => {
+        const at = reloadedAt(entry);
+        return at === null ? [] : [{ ...at, message: entry.text }];
+      });
+      return { errors, failure: ran.failure === null ? null : howItEnded(ran) };
+    } finally {
+      discard(logDir);
+    }
+  };
+}
+function withoutListed(entries, errors) {
+  if (errors.length === 0) {
+    return [...entries];
   }
-  notice(now = Date.now()) {
-    const latest = this.latest;
-    if (!this.enabled || latest === null || !isNewer(latest, this.current)) {
-      return null;
+  const listing = discoveryListing(entries.map((entry) => entry.text));
+  const paths = new Set(errors.map((error) => error.path));
+  return entries.filter((entry, at) => {
+    if (listing !== null && at >= listing.from && at < listing.to) {
+      return false;
     }
-    if (this.checking && this.stale(now)) {
-      return null;
+    const reloaded = reloadedAt(entry);
+    if (reloaded !== null && errors.some((error) => error.path === reloaded.path && error.line === reloaded.line && error.message === entry.text)) {
+      return false;
     }
-    return {
-      current: this.current,
-      latest,
-      releaseNotes: `${RELEASES}/v${latest}`,
-      upgrade: runLine(currentRunner(), latest, "upgrade")
-    };
-  }
+    const failedToLoad = /^Failed to load script "(res:\/\/[^"]+)" with error "[^"]+"\.$/.exec(entry.text);
+    return failedToLoad === null || !paths.has(failedToLoad[1] ?? "");
+  });
 }
-var REGISTRY_ROOT = "https://registry.npmjs.org", RELEASES = "https://github.com/Aureliolo/gdharness/releases/tag", CACHE_MS, REQUEST_TIMEOUT_MS = 1e4, MAX_BODY_BYTES, FIRST_RETRY_MS = 30000, MAX_RETRY_MS, VERSION;
-var init_update_check = __esm(() => {
-  init_runner();
-  CACHE_MS = 10 * 60 * 1000;
-  MAX_BODY_BYTES = 1 << 20;
-  MAX_RETRY_MS = 60 * 60 * 1000;
-  VERSION = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+var UNRESOLVED, MOST_CHECKED = 8, RELOADED_AT, NOT_COMPILED;
+var init_script_origins = __esm(() => {
+  init_engine_run();
+  init_junit();
+  init_scratch();
+  UNRESOLVED = /Could not resolve class "([A-Za-z_][A-Za-z0-9_]*)", because of a parser error/;
+  RELOADED_AT = /GDScript::reload \((res:\/\/.+):(\d+)\)$/;
+  NOT_COMPILED = /^Failed to load script "(res:\/\/[^"]+)" with error "(?:Parse error|Compilation failed)"/;
 });
 
-// src/server-version.ts
-import { readFileSync as readFileSync7 } from "node:fs";
-function editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest) {
-  if (addonDigest !== undefined && addonDigest !== "" && shippedDigest !== undefined) {
-    return addonDigest !== shippedDigest;
+// src/headless.ts
+import { existsSync as existsSync9, readFileSync as readFileSync5, realpathSync as realpathSync2, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname6, join as join10 } from "node:path";
+function snakeCased(params) {
+  const result = emptyRecord();
+  for (const [key, value] of Object.entries(params)) {
+    const name = key.startsWith("_") ? key : key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+    result[name] = value;
   }
-  return addonVersion !== serverVersion;
+  return result;
 }
-function sameCodeNote(addonVersion, serverVersion, addonDigest, shippedDigest) {
-  if (addonVersion === undefined || addonVersion === serverVersion || addonDigest === undefined || addonDigest === "" || addonDigest !== shippedDigest) {
-    return;
-  }
-  const same = `The editor loaded the ${addonVersion} addons, which are the same code this ${serverVersion} server ships, so nothing needs restarting`;
-  return isNewer(addonVersion, serverVersion) ? `${same}. This server is the older of the two, which a reconnect in your harness settles once the project pins ${addonVersion}.` : `${same}; addonVersion is the version the editor loaded when it started.`;
+function engineExtras(outcome) {
+  const after = outcome.afterAnswerMessages ?? [];
+  const before = outcome.beforeOperationMessages ?? [];
+  return {
+    ...outcome.messages.length > 0 ? { engine_messages: outcome.messages } : {},
+    ...before.length > 0 ? {
+      engine_messages_before_operation: before,
+      engine_messages_before_operation_note: withNotCompiled(BEFORE_OPERATION_NOTE, before)
+    } : {},
+    ...outcome.beforeOperationOmitted === undefined ? {} : { engine_messages_before_operation_omitted: outcome.beforeOperationOmitted },
+    ...outcome.messagesOmitted === undefined ? {} : { engine_messages_omitted: outcome.messagesOmitted },
+    ...after.length > 0 ? {
+      engine_messages_after_answer: after,
+      engine_messages_after_answer_note: withNotCompiled(AFTER_ANSWER_NOTE, after)
+    } : {},
+    ...outcome.afterAnswerOmitted === undefined ? {} : { engine_messages_after_answer_omitted: outcome.afterAnswerOmitted },
+    ...outcome.afterAnswer === undefined ? {} : { engine_after_answer: outcome.afterAnswer }
+  };
 }
-function addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest, onDisk) {
-  if (!editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest)) {
-    return;
-  }
-  const reported = addonVersion ?? "";
-  const restart = onDisk !== undefined && onDisk !== shippedDigest ? `The project's own addons are not this server's either, so a restart would load the same code again: run  ${gdharnessCommand(serverVersion, "upgrade")}  in a shell in the project directory, which installs the ${serverVersion} addons, and editor_launch restart then picks them up.` : "Restart it with editor_launch restart to pick this one up.";
-  if (reported === serverVersion) {
-    return `The editor is running a different build of the ${reported} addon from the one this server ships. ${restart}`;
-  }
-  const editor = reported === "" ? UNVERSIONED : `the ${reported} addon`;
-  const both = `The editor is running ${editor} while this server ships ${serverVersion}.`;
-  if (reported !== "" && isNewer(reported, serverVersion)) {
-    return `${both} This server is the older half: reconnect it in your harness so it spawns ${reported}.`;
-  }
-  return `${both} ${restart}`;
+function withNotCompiled(note, entries) {
+  const path = entries.map(notCompiledIn).find((found) => found !== undefined);
+  return path === undefined ? note : `${note} ${path} did not compile, so every run of this project starts its autoloads without it until it is fixed; its errors are among these.`;
 }
-function gdharnessCommand(version, args) {
-  return `npx -y gdharness@${version} ${args}`;
+function problemsIn(log) {
+  return problemsAmong(log.everything());
 }
-function runtimeAddonUnknown(addon) {
-  return addon?.version === "" && addon.digest === "";
+function problemsAmong(entries) {
+  return entries.flatMap((entry) => {
+    if (entry.severity !== "info") {
+      return [entry];
+    }
+    if (entry.source === "stderr" && entry.text.startsWith(OWN_ERROR)) {
+      return [{ ...entry, severity: "error", text: entry.text.slice(OWN_ERROR.length) }];
+    }
+    return [];
+  });
 }
-function runtimeMismatch(pid, addon, serverVersion, shippedDigest, onDisk, projectPath) {
-  if (runtimeAddonUnknown(addon)) {
-    return;
-  }
-  if (addon !== undefined && !editorIsStale(addon.version, serverVersion, addon.digest, shippedDigest)) {
-    return;
+function reported2(problems) {
+  const omitted = Math.max(0, problems.length - MESSAGES_KEPT);
+  return omitted === 0 ? { messages: problems } : { messages: problems.slice(omitted), messagesOmitted: omitted };
+}
+function reason(log, problems) {
+  const own = refusalsIn(log);
+  if (own.length > 0) {
+    return own.map((entry) => entry.text.slice(OWN_ERROR.length)).join("; ");
   }
-  const game = `The game (pid ${pid})`;
-  if (addon !== undefined && addon.version !== "" && isNewer(addon.version, serverVersion)) {
-    return `${game} is running the ${addon.version} runtime addon while this server ships ${serverVersion}. This server is the older half: reconnect it in your harness so it spawns ${addon.version}.`;
+  const errors = problems.filter((entry) => entry.severity === "error").map((entry) => entry.text);
+  if (errors.length > 0) {
+    const rest = errors.length - ERRORS_NAMED;
+    return rest > 0 ? `${errors.slice(0, ERRORS_NAMED).join("; ")}; and ${rest} more error${rest === 1 ? "" : "s"}` : errors.join("; ");
+  }
+  const printed = log.everything().filter((entry) => entry.source === "stdout");
+  return printed.at(-1)?.text ?? "no output at all";
+}
+function refusalsIn(log) {
+  return log.everything().filter((entry) => entry.source === "stderr" && entry.severity === "info" && entry.text.startsWith(OWN_ERROR));
+}
+function scriptFault(problems, script) {
+  const spelled = (path) => `(${path.replaceAll("\\", "/").toLowerCase()}/`;
+  const directories = [...new Set([spelled(dirname6(script)), spelled(resolvedOr(dirname6(script)))])];
+  return problems.find((entry) => {
+    const at = entry.detail.find((line) => line.startsWith("at: "))?.replaceAll("\\", "/").toLowerCase();
+    return entry.severity === "error" && at !== undefined && directories.some((directory) => at.includes(directory));
+  });
+}
+function resolvedOr(path) {
+  try {
+    return realpathSync2.native(path);
+  } catch {
+    return path;
+  }
+}
+function librariesNotCopied(messages) {
+  const found = new Set;
+  for (const entry of messages) {
+    const library = /Error copying library: (.+)$/.exec(entry.text)?.[1]?.trim();
+    if (library !== undefined && library !== "") {
+      found.add(library);
+    }
+  }
+  return [...found];
+}
+function extensionRetryNote(libraries, stillNotLoaded = []) {
+  const second = stillNotLoaded.length === 0 ? "so the import was run again and loaded the extension, and the messages are from that second run." : `so the import was run again, and it still could not load ${stillNotLoaded.join(" and ")}: this answer is from an import without ${stillNotLoaded.length === 1 ? "it" : "them"}, and its messages say what the engine hit.`;
+  return `The first import could not load ${libraries.join(" and ")}: on Windows an engine running as the editor ` + "loads a GDExtension from a ~ copy beside the library, and the editor open on this project holds its own " + "copy there, so the first engine started beside it cannot make one. That failed attempt moves the " + `editor's copy aside, ${second} The editor's copy is left beside the library as a ~RF….TMP file, which ` + "the next import, export or editor this server starts on the project deletes once the editor has exited.";
+}
+async function runImport(godotPath, projectPath, options = {}) {
+  const once = options.once ?? importOnce;
+  const pass = () => {
+    for (const target of options.forcing ?? []) {
+      forceNextImport(projectPath, target);
+    }
+    freeLibraryCopies(projectPath);
+    return once(godotPath, projectPath);
+  };
+  const first = await pass();
+  const collided = librariesNotCopied(first.messages);
+  const crash = first.docCacheNote;
+  if (collided.length === 0 && crash === undefined) {
+    return first;
+  }
+  const { docCacheNote: _, ...again } = await pass();
+  const second = again.ok || crash === undefined ? again : { ...again, message: `${again.message.replace(/[.\s]+$/, "")}. ${crash}` };
+  const still = librariesNotCopied(second.messages);
+  return {
+    ...second,
+    ...collided.length === 0 ? {} : {
+      librariesRetried: collided,
+      ...still.length === 0 ? {} : { librariesNotLoaded: still },
+      extensionNote: extensionRetryNote(collided, still)
+    },
+    ...crash === undefined ? {} : { docCacheNote: crash }
+  };
+}
+async function importOnce(godotPath, projectPath) {
+  const logDir = scratchDirectory("import");
+  const caches = editorCacheDirectory(godotPath);
+  const cachesBefore = docCachesWritten(caches);
+  let ran;
+  try {
+    ran = await runEngine(godotPath, [
+      "--headless",
+      "--log-file",
+      join10(logDir, "engine.log"),
+      "--path",
+      projectPath,
+      "--import"
+    ]);
+  } finally {
+    discard(logDir);
+  }
+  const problems = problemsIn(ran.log);
+  const crash = docCacheCrash(ran, cachesBefore, docCachesWritten(caches), "import");
+  if (ran.exitCode === 0 && ran.failure === null) {
+    return { ok: true, ...reported2(problems), ...crash === null ? {} : { docCacheNote: crash } };
+  }
+  return {
+    ok: false,
+    message: `the import pass failed (${howItEnded(ran)}): ${reason(ran.log, problems)}`,
+    ...reported2(problems),
+    ...crash === null ? {} : { docCacheNote: crash }
+  };
+}
+async function runOperation(engine, operation, params, projectPath) {
+  const paramsDir = scratchDirectory("params");
+  const paramsFile = join10(paramsDir, `${operation}.json`);
+  const answerFile = join10(paramsDir, "answer.json");
+  writeFileSync4(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
+  const args = [
+    "--headless",
+    "--log-file",
+    join10(paramsDir, "engine.log"),
+    "--path",
+    projectPath,
+    "--script",
+    engine.script,
+    operation,
+    `@file:${paramsFile}`,
+    answerFile,
+    ...engine.debug ? ["--debug-godot"] : []
+  ];
+  let ran;
+  let answer;
+  try {
+    ran = await runEngine(engine.godotPath, args);
+    answer = answerIn(answerFile);
+  } finally {
+    discard(paramsDir);
+  }
+  const everything = ran.log.everything();
+  const marked = (text) => everything.findIndex((entry) => entry.source === "stderr" && entry.text === text);
+  const answered = marked(ANSWERED);
+  const waiting = marked(WAITING);
+  const begun = marked(BEGUN);
+  const ended = answered === -1 ? everything.length : answered;
+  const problems = waiting === -1 ? problemsAmong(everything.slice(0, ended)) : problemsAmong([
+    ...everything.slice(0, waiting),
+    ...begun === -1 ? [] : everything.slice(begun + 1, ended)
+  ]);
+  const startup = waiting === -1 ? [] : problemsAmong(everything.slice(waiting + 1, begun === -1 ? ended : begun));
+  const after = answered === -1 ? [] : problemsAmong(everything.slice(answered + 1));
+  const afterAnswered = {
+    ...after.length === 0 ? {} : { afterAnswerMessages: after.slice(-MESSAGES_KEPT) },
+    ...after.length > MESSAGES_KEPT ? { afterAnswerOmitted: after.length - MESSAGES_KEPT } : {},
+    ...startup.length === 0 ? {} : { beforeOperationMessages: startup.slice(-MESSAGES_KEPT) },
+    ...startup.length > MESSAGES_KEPT ? { beforeOperationOmitted: startup.length - MESSAGES_KEPT } : {}
+  };
+  if (answer.kind === "unreadable") {
+    return {
+      ok: false,
+      message: `${operation} wrote an answer that could not be read (${answer.why})`,
+      ...reported2(problems),
+      ...afterAnswered
+    };
+  }
+  if (answer.kind === "none") {
+    if (waiting !== -1 && begun === -1) {
+      return {
+        ok: false,
+        message: `${operation} never ran: the engine ended (${howItEnded(ran)}) while it started the project's ` + `autoloads, which this operation waits for. The last it reported: ${reason(ran.log, startup)}`,
+        ...reported2(problems),
+        ...afterAnswered
+      };
+    }
+    const refusals = refusalsIn(ran.log);
+    if (refusals.length > 0) {
+      const said = new Set(refusals.map((entry) => entry.index));
+      return {
+        ok: false,
+        message: refusals.map((entry) => entry.text.slice(OWN_ERROR.length)).join("; "),
+        ...reported2(problems.filter((entry) => !said.has(entry.index)))
+      };
+    }
+    const ending = ran.exitCode === 0 && ran.failure === null ? "produced no result" : `failed (${howItEnded(ran)})`;
+    return {
+      ok: false,
+      message: `${operation} ${ending}: ${reason(ran.log, problems)}`,
+      ...reported2(problems)
+    };
+  }
+  const fault = scriptFault(problems, engine.script);
+  if (fault !== undefined) {
+    return {
+      ok: false,
+      message: `${operation} hit an error in the operations script, so its answer is left out: part of it was ` + `never computed. ${fault.text} (${fault.detail[0]?.slice("at: ".length) ?? "no location given"})`,
+      ...reported2(problems),
+      ...afterAnswered
+    };
+  }
+  const afterAnswer = ran.exitCode === 0 && ran.failure === null ? undefined : `The operation finished and wrote this answer, and then the engine did not exit cleanly (${howItEnded(ran)}). Anything it reported on the way out is under ${answered === -1 ? "engine_messages" : "engine_messages_after_answer"}.`;
+  return {
+    ok: true,
+    payload: answer.payload,
+    ...reported2(problems),
+    ...afterAnswered,
+    ...afterAnswer === undefined ? {} : { afterAnswer }
+  };
+}
+function answerIn(file) {
+  if (!existsSync9(file)) {
+    return { kind: "none" };
+  }
+  const text = readFileSync5(file, "utf8");
+  try {
+    const parsed = JSON.parse(text);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? { kind: "answer", payload: parsed } : { kind: "unreadable", why: `it is JSON but not an object: ${text.slice(0, 200)}` };
+  } catch (error) {
+    return {
+      kind: "unreadable",
+      why: `${error instanceof Error ? error.message : String(error)}: ${text.slice(0, 200)}`
+    };
+  }
+}
+var AFTER_ANSWER_NOTE = "Printed after this operation had written its answer, while the engine ran the project's autoloads and shut down: Godot starts a project's autoloads in every script run and cannot be told not to. An error raised in a project script here is that autoload's own, and none of these changes the answer.", BEFORE_OPERATION_NOTE = "Printed while the engine started the project's autoloads, before this operation ran: an operation that compiles the project's scripts waits for them, because the engine knows an autoload's name only once it is in the tree. An error raised in a project script here is that autoload's own.", OWN_ERROR = "[ERROR] ", ANSWERED = "[gdharness] answered", WAITING = "[gdharness] waiting for the autoloads", BEGUN = "[gdharness] begun", MESSAGES_KEPT = 200, ERRORS_NAMED = 3;
+var init_headless = __esm(() => {
+  init_doc_cache();
+  init_engine_run();
+  init_library_copies();
+  init_reimport();
+  init_scratch();
+  init_script_origins();
+});
+
+// src/update-check.ts
+import { existsSync as existsSync10, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { homedir as homedir4, tmpdir as tmpdir3 } from "node:os";
+import { join as join11 } from "node:path";
+function packageUrl(root) {
+  return `${root.replace(/\/+$/, "")}/gdharness/latest`;
+}
+function registryFor(environment) {
+  const named = environment["GDHARNESS_REGISTRY"] ?? "";
+  if (named === "") {
+    return packageUrl(REGISTRY_ROOT);
+  }
+  try {
+    return new URL(named).protocol === "https:" ? packageUrl(named) : packageUrl(REGISTRY_ROOT);
+  } catch {
+    return packageUrl(REGISTRY_ROOT);
+  }
+}
+function cacheDirectory(environment) {
+  const set = (name) => {
+    const value = environment[name];
+    return value !== undefined && value !== "" ? value : null;
+  };
+  const home = set("HOME") ?? homedir4();
+  if (process.platform === "win32") {
+    return join11(set("LOCALAPPDATA") ?? home, "gdharness");
+  }
+  if (process.platform === "darwin") {
+    return join11(home, "Library", "Caches", "gdharness");
+  }
+  return join11(set("XDG_CACHE_HOME") ?? join11(home, ".cache"), "gdharness");
+}
+function cacheFile(environment = process.env) {
+  try {
+    const directory = cacheDirectory(environment);
+    mkdirSync3(directory, { recursive: true, mode: 448 });
+    return join11(directory, "update-check.json");
+  } catch {
+    return join11(tmpdir3(), "gdharness-update-check.json");
+  }
+}
+function readCache(path) {
+  try {
+    if (!existsSync10(path)) {
+      return null;
+    }
+    const parsed = JSON.parse(readFileSync6(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const record = parsed;
+    const checkedAt = record["checkedAt"];
+    const latest = record["latest"];
+    if (typeof checkedAt !== "number" || typeof latest !== "string" || !VERSION.test(latest)) {
+      return null;
+    }
+    return { checkedAt, latest };
+  } catch {
+    return null;
+  }
+}
+function writeCache(path, entry) {
+  try {
+    writeFileSync5(path, JSON.stringify(entry), { encoding: "utf8", mode: 384 });
+  } catch {}
+}
+function parts(version) {
+  const withoutBuild = version.split("+")[0] ?? version;
+  const dash = withoutBuild.indexOf("-");
+  const numeric = dash === -1 ? withoutBuild : withoutBuild.slice(0, dash);
+  return {
+    numbers: numeric.split(".").map((piece) => Number.parseInt(piece, 10) || 0),
+    prerelease: dash !== -1
+  };
+}
+function isNewer(candidate, current) {
+  const left = parts(candidate);
+  const right = parts(current);
+  for (let index = 0;index < 3; index += 1) {
+    const a = left.numbers[index] ?? 0;
+    const b = right.numbers[index] ?? 0;
+    if (a !== b) {
+      return a > b;
+    }
+  }
+  return !left.prerelease && right.prerelease;
+}
+async function fetchLatest(registry) {
+  const response = await fetch(registry, {
+    headers: { accept: "application/vnd.npm.install-v1+json, application/json" },
+    redirect: "error",
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (!response.ok || response.body === null) {
+    return null;
+  }
+  const declared = Number.parseInt(response.headers.get("content-length") ?? "", 10);
+  if (Number.isFinite(declared) && declared > MAX_BODY_BYTES) {
+    return null;
+  }
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of response.body) {
+    size += chunk.byteLength;
+    if (size > MAX_BODY_BYTES) {
+      return null;
+    }
+    chunks.push(chunk);
+  }
+  const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  if (typeof parsed !== "object" || parsed === null) {
+    return null;
+  }
+  const version = parsed["version"];
+  return typeof version === "string" && VERSION.test(version) ? version : null;
+}
+
+class UpdateCheck {
+  latest = null;
+  checking = false;
+  asked = false;
+  checkedAt = 0;
+  retryAt = 0;
+  backoffMs = FIRST_RETRY_MS;
+  enabled;
+  current;
+  cachePath;
+  ask;
+  constructor(current, environment = process.env, ask = () => fetchLatest(registryFor(environment))) {
+    this.current = current;
+    this.enabled = (environment["GDHARNESS_NO_UPDATE_CHECK"] ?? "") === "";
+    this.cachePath = cacheFile(environment);
+    this.ask = ask;
+    const cached = this.enabled ? readCache(this.cachePath) : null;
+    if (cached !== null) {
+      this.latest = cached.latest;
+      this.checkedAt = cached.checkedAt;
+    }
+  }
+  refresh(now = Date.now()) {
+    if (!this.enabled || this.checking || now < this.retryAt || this.asked && !this.stale(now)) {
+      return;
+    }
+    this.asked = true;
+    this.checking = true;
+    this.ask().then((version) => {
+      if (version === null) {
+        this.scheduleRetry(now);
+        return;
+      }
+      this.latest = version;
+      this.checkedAt = Date.now();
+      this.backoffMs = FIRST_RETRY_MS;
+      this.retryAt = 0;
+      writeCache(this.cachePath, { checkedAt: this.checkedAt, latest: version });
+    }).catch(() => {
+      this.scheduleRetry(now);
+    }).finally(() => {
+      this.checking = false;
+    });
+  }
+  stale(now) {
+    return now - this.checkedAt >= CACHE_MS;
+  }
+  scheduleRetry(now) {
+    this.retryAt = now + this.backoffMs;
+    this.backoffMs = Math.min(this.backoffMs * 2, MAX_RETRY_MS);
+  }
+  notice(now = Date.now()) {
+    const latest = this.latest;
+    if (!this.enabled || latest === null || !isNewer(latest, this.current)) {
+      return null;
+    }
+    if (this.checking && this.stale(now)) {
+      return null;
+    }
+    return {
+      current: this.current,
+      latest,
+      releaseNotes: `${RELEASES}/v${latest}`,
+      upgrade: runLine(currentRunner(), latest, "upgrade")
+    };
+  }
+}
+var REGISTRY_ROOT = "https://registry.npmjs.org", RELEASES = "https://github.com/Aureliolo/gdharness/releases/tag", CACHE_MS, REQUEST_TIMEOUT_MS = 1e4, MAX_BODY_BYTES, FIRST_RETRY_MS = 30000, MAX_RETRY_MS, VERSION;
+var init_update_check = __esm(() => {
+  init_runner();
+  CACHE_MS = 10 * 60 * 1000;
+  MAX_BODY_BYTES = 1 << 20;
+  MAX_RETRY_MS = 60 * 60 * 1000;
+  VERSION = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+});
+
+// src/server-version.ts
+import { readFileSync as readFileSync7 } from "node:fs";
+function editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest) {
+  if (addonDigest !== undefined && addonDigest !== "" && shippedDigest !== undefined) {
+    return addonDigest !== shippedDigest;
+  }
+  return addonVersion !== serverVersion;
+}
+function sameCodeNote(addonVersion, serverVersion, addonDigest, shippedDigest) {
+  if (addonVersion === undefined || addonVersion === serverVersion || addonDigest === undefined || addonDigest === "" || addonDigest !== shippedDigest) {
+    return;
+  }
+  const same = `The editor loaded the ${addonVersion} addons, which are the same code this ${serverVersion} server ships, so nothing needs restarting`;
+  return isNewer(addonVersion, serverVersion) ? `${same}. This server is the older of the two, which a reconnect in your harness settles once the project pins ${addonVersion}.` : `${same}; addonVersion is the version the editor loaded when it started.`;
+}
+function addonMismatch(addonVersion, serverVersion, addonDigest, shippedDigest, onDisk) {
+  if (!editorIsStale(addonVersion, serverVersion, addonDigest, shippedDigest)) {
+    return;
+  }
+  const reported = addonVersion ?? "";
+  const restart = onDisk !== undefined && onDisk !== shippedDigest ? `The project's own addons are not this server's either, so a restart would load the same code again: run  ${gdharnessCommand(serverVersion, "upgrade")}  in a shell in the project directory, which installs the ${serverVersion} addons, and editor_launch restart then picks them up.` : "Restart it with editor_launch restart to pick this one up.";
+  if (reported === serverVersion) {
+    return `The editor is running a different build of the ${reported} addon from the one this server ships. ${restart}`;
+  }
+  const editor = reported === "" ? UNVERSIONED : `the ${reported} addon`;
+  const both = `The editor is running ${editor} while this server ships ${serverVersion}.`;
+  if (reported !== "" && isNewer(reported, serverVersion)) {
+    return `${both} This server is the older half: reconnect it in your harness so it spawns ${reported}.`;
+  }
+  return `${both} ${restart}`;
+}
+function gdharnessCommand(version, args) {
+  return `npx -y gdharness@${version} ${args}`;
+}
+function runtimeAddonUnknown(addon) {
+  return addon?.version === "" && addon.digest === "";
+}
+function runtimeMismatch(pid, addon, serverVersion, shippedDigest, onDisk, projectPath) {
+  if (runtimeAddonUnknown(addon)) {
+    return;
+  }
+  if (addon !== undefined && !editorIsStale(addon.version, serverVersion, addon.digest, shippedDigest)) {
+    return;
+  }
+  const game = `The game (pid ${pid})`;
+  if (addon !== undefined && addon.version !== "" && isNewer(addon.version, serverVersion)) {
+    return `${game} is running the ${addon.version} runtime addon while this server ships ${serverVersion}. This server is the older half: reconnect it in your harness so it spawns ${addon.version}.`;
   }
   let loaded;
   if (addon === undefined) {
@@ -9897,7 +10512,7 @@ var init_gdscript_source = __esm(() => {
 
 // src/class-cache.ts
 import { existsSync as existsSync11, readdirSync as readdirSync6, readFileSync as readFileSync8, statSync as statSync6 } from "node:fs";
-import { join as join11, posix } from "node:path";
+import { join as join12, posix } from "node:path";
 function isToolScript(source) {
   return TOOL.test(codeOf(source));
 }
@@ -9913,14 +10528,14 @@ function declaredClasses(projectPath) {
 }
 function eachScript(projectPath, each) {
   const visit = (directory, prefix) => {
-    if (existsSync11(join11(directory, ".gdignore"))) {
+    if (existsSync11(join12(directory, ".gdignore"))) {
       return;
     }
     for (const entry of readdirSync6(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const path = join11(directory, entry.name);
+      const path = join12(directory, entry.name);
       if (entry.isDirectory()) {
         visit(path, `${prefix}${entry.name}/`);
       } else if (entry.isFile() && entry.name.endsWith(".gd")) {
@@ -9946,7 +10561,7 @@ function scriptsNaming(projectPath, classes) {
   return naming.sort((a, b) => a.script.localeCompare(b.script));
 }
 function cachedClasses(projectPath) {
-  const cache = join11(projectPath, ".godot", "global_script_class_cache.cfg");
+  const cache = join12(projectPath, ".godot", "global_script_class_cache.cfg");
   if (!existsSync11(cache)) {
     return null;
   }
@@ -10217,7 +10832,7 @@ function uncachedClassNote(types) {
   return `${types.join(", ")} ${one ? "is declared" : "are declared"} in this project and missing from ` + `.godot/global_script_class_cache.cfg, so a game launched now would not resolve ${one ? "it" : "them"} ` + "either. Try editor_rescan first: it asks the editor already running and starts nothing, and it " + "cleared this in 314ms in a second project with a 31-worker fan-out still importing. It is not " + "always enough, because a file another engine has already imported reads as settled and the " + "walk does not look inside it. project_import refresh_classes rewrites the cache from the " + "declarations on disk and does reach that case, at the cost of a short headless engine, which " + "is worth knowing when something else is already running against this project.";
 }
 function cacheWrittenAt(projectPath) {
-  const cache = join11(projectPath, ".godot", "global_script_class_cache.cfg");
+  const cache = join12(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
     return statSync6(cache).mtimeMs;
   } catch {
@@ -10231,14 +10846,14 @@ function declaredSince(projectPath, paths, names, since) {
       return false;
     }
     try {
-      return statSync6(join11(projectPath, path.slice("res://".length))).mtimeMs > since;
+      return statSync6(join12(projectPath, path.slice("res://".length))).mtimeMs > since;
     } catch {
       return false;
     }
   });
 }
 function cachedAtMissingPaths(cached, projectPath) {
-  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync11(join11(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
+  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync11(join12(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
 }
 function staleAgainst(cached, projectPath) {
   return [...declaredClasses(projectPath)].filter(([name, path]) => cached.get(name) !== path).map(([name]) => name);
@@ -10264,7 +10879,7 @@ var init_class_cache = __esm(() => {
 
 // src/project-scan.ts
 import { existsSync as existsSync12, readdirSync as readdirSync7, readFileSync as readFileSync9 } from "node:fs";
-import { extname, join as join12 } from "node:path";
+import { extname, join as join13 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
@@ -10272,10 +10887,10 @@ function steppedOver(directory) {
   return gdignored(directory) || installedByUs(directory);
 }
 function gdignored(directory) {
-  return existsSync12(join12(directory, ".gdignore"));
+  return existsSync12(join13(directory, ".gdignore"));
 }
 function installedByUs(directory) {
-  return existsSync12(join12(directory, VERSION_MARKER));
+  return existsSync12(join13(directory, VERSION_MARKER));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -10288,7 +10903,7 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join12(directory, entry.name));
+        visit(join13(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (SCENE_EXTENSIONS.has(extension)) {
@@ -10318,7 +10933,7 @@ function projectFiles(projectPath, extensions) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join12(directory, entry.name), spelled);
+        visit(join13(directory, entry.name), spelled);
       } else if (entry.isFile() && extensions.includes(extname(entry.name).toLowerCase())) {
         found.push(spelled);
       }
@@ -10339,14 +10954,14 @@ function scriptsWithoutUid(projectPath) {
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join12(directory, entry.name), spelled);
+        visit(join13(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync12(join12(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync12(join13(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -10367,7 +10982,7 @@ function projectTexts(projectPath) {
       if (skipped(entry.name)) {
         continue;
       }
-      const absolute = join12(directory, entry.name);
+      const absolute = join13(directory, entry.name);
       const spelled = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
         visit(absolute, `${spelled}/`);
@@ -10397,7 +11012,7 @@ function ignoredTexts(projectPath) {
       if (skipped(entry.name)) {
         continue;
       }
-      const absolute = join12(directory, entry.name);
+      const absolute = join13(directory, entry.name);
       const spelled = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
         visit(absolute, `${spelled}/`, under);
@@ -10437,7 +11052,7 @@ function searchProject(projectPath, options) {
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join12(directory, entry.name);
+      const entryPath = join13(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -10891,7 +11506,7 @@ import {
   statSync as statSync7,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname7, join as join13 } from "node:path";
+import { dirname as dirname7, join as join14 } from "node:path";
 import { fileURLToPath } from "node:url";
 function editorAddonDigest(from = shippedAddonsDirectory()) {
   return addonsDigest(EDITOR_PLUGINS, from);
@@ -10906,7 +11521,7 @@ function addonsDigest(names, from) {
       if (name === VERSION_MARKER || name === DIGEST_MARKER) {
         continue;
       }
-      const path = join13(directory, name);
+      const path = join14(directory, name);
       const inside = `${relative}/${name}`;
       if (statSync7(path).isDirectory()) {
         walk(path, inside);
@@ -10920,7 +11535,7 @@ function addonsDigest(names, from) {
     }
   };
   for (const name of names) {
-    walk(join13(from, name), name);
+    walk(join14(from, name), name);
   }
   return hash.digest("hex");
 }
@@ -10951,7 +11566,7 @@ function installedRuntimeDigest(projectPath) {
   return digestMarker(projectPath, RUNTIME_ADDON);
 }
 function digestMarker(projectPath, addon) {
-  const marker = join13(projectPath, "addons", addon, DIGEST_MARKER);
+  const marker = join14(projectPath, "addons", addon, DIGEST_MARKER);
   if (!existsSync13(marker)) {
     return null;
   }
@@ -10959,35 +11574,35 @@ function digestMarker(projectPath, addon) {
   return said === "" ? null : said;
 }
 function shippedAddonsDirectory() {
-  return join13(dirname7(fileURLToPath(import.meta.url)), "godot", "addons");
+  return join14(dirname7(fileURLToPath(import.meta.url)), "godot", "addons");
 }
 function shippedOperationsScript() {
-  return join13(dirname7(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
+  return join14(dirname7(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
 }
 function installAddons(projectPath, from = shippedAddonsDirectory()) {
   const installed = [];
   for (const name of ADDONS) {
-    const source = join13(from, name);
-    if (!existsSync13(join13(source, name === RUNTIME_ADDON ? "runtime_autoload.gd" : "plugin.cfg"))) {
+    const source = join14(from, name);
+    if (!existsSync13(join14(source, name === RUNTIME_ADDON ? "runtime_autoload.gd" : "plugin.cfg"))) {
       throw new Error(`The package holds no ${name} addon at ${source}.`);
     }
-    const target = join13(projectPath, "addons", name);
+    const target = join14(projectPath, "addons", name);
     const replaced = existsSync13(target);
     rmSync5(target, { recursive: true, force: true });
     mkdirSync4(dirname7(target), { recursive: true });
     cpSync(source, target, { recursive: true });
-    writeFileSync6(join13(target, VERSION_MARKER), `${SERVER_VERSION}
+    writeFileSync6(join14(target, VERSION_MARKER), `${SERVER_VERSION}
 `);
     installed.push({ name, path: target, replaced });
   }
-  writeFileSync6(join13(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
+  writeFileSync6(join14(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
 `);
-  writeFileSync6(join13(projectPath, "addons", RUNTIME_ADDON, DIGEST_MARKER), `${runtimeAddonDigest(from)}
+  writeFileSync6(join14(projectPath, "addons", RUNTIME_ADDON, DIGEST_MARKER), `${runtimeAddonDigest(from)}
 `);
   return installed;
 }
 function installedAddonVersion(projectPath) {
-  const marker = join13(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  const marker = join14(projectPath, "addons", ADDONS[0], VERSION_MARKER);
   if (!existsSync13(marker)) {
     return null;
   }
@@ -10997,13 +11612,13 @@ function installedAddonVersion(projectPath) {
 function removeAddons(projectPath) {
   const removed = [];
   for (const name of ADDONS) {
-    const target = join13(projectPath, "addons", name);
+    const target = join14(projectPath, "addons", name);
     if (existsSync13(target)) {
       rmSync5(target, { recursive: true, force: true });
       removed.push(target);
     }
   }
-  const addons = join13(projectPath, "addons");
+  const addons = join14(projectPath, "addons");
   if (removed.length > 0 && existsSync13(addons) && readdirSync8(addons).length === 0) {
     rmdirSync(addons);
     removed.push(addons);
@@ -11038,7 +11653,7 @@ function loaderAmong(projectPath, named) {
     }
     let source = null;
     try {
-      source = readFileSync11(join13(projectPath, path), "utf8");
+      source = readFileSync11(join14(projectPath, path), "utf8");
     } catch {}
     if (source?.includes(RUNTIME_AUTOLOAD.path)) {
       return { name: entry, path, exists: true };
@@ -11080,8 +11695,8 @@ function enabledPlugins(settings) {
 function inspectProject(projectPath) {
   const problems = [];
   const addons = ADDONS.map((name) => {
-    const directory = join13(projectPath, "addons", name);
-    const marker = join13(directory, VERSION_MARKER);
+    const directory = join14(projectPath, "addons", name);
+    const marker = join14(directory, VERSION_MARKER);
     const installed = existsSync13(directory);
     const version = existsSync13(marker) ? readFileSync11(marker, "utf8").trim() : null;
     const current = version === SERVER_VERSION;
@@ -11092,7 +11707,7 @@ function inspectProject(projectPath) {
     }
     return { name, installed, version, current };
   });
-  const settings = parseProjectGodot(readFileSync11(join13(projectPath, "project.godot"), "utf8"));
+  const settings = parseProjectGodot(readFileSync11(join14(projectPath, "project.godot"), "utf8"));
   const pluginsEnabled = enabledPlugins(settings);
   for (const name of EDITOR_PLUGINS) {
     if (!pluginsEnabled.includes(name)) {
@@ -11108,7 +11723,7 @@ function inspectProject(projectPath) {
   const tracked = trackedByGit(projectPath, [...named.values()]);
   const addonMissing = (path) => addons.some((addon) => !addon.installed && path.startsWith(`addons/${addon.name}/`));
   for (const [name, path] of named) {
-    if (!existsSync13(join13(projectPath, path))) {
+    if (!existsSync13(join14(projectPath, path))) {
       if (!addonMissing(path)) {
         problems.push(`the ${name} autoload names res://${path}, which is not in this project, so it boots with a missing script; restore that file, or point the autoload at one that is here`);
       }
@@ -11256,7 +11871,7 @@ function annotationsOf(spec) {
     openWorldHint: false
   };
 }
-var PROJECT_INFO_SECTIONS, PROJECT_PATH, RUNNING_PROJECT_PATH, RUNNING_PID, SCENE_PATH, WITHOUT_AN_EDITOR = "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, or readBy for a read. That engine runs every script of the file, 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 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.", WHOLE_NUMBERS = 'A whole number of 2^53 or more, such as a 64-bit seed or a resource uid, is written as its digits, {"_type": "int", "value": "9007199254740993"}, the form a read answers with: a JSON number that large can arrive as a neighbour of the one sent, so sent as a number it is refused.', SCRIPT_PATH, RESOURCE_FILE = 'File inside the project, such as "sprites/hero.png" or "materials/steel.tres".', RESOURCE_PATH, NODE_PATH, PROPERTIES, XY, ANIMATION_TRACK, SCRIPT_MODIFICATIONS, INPUT_EVENTS, TILESET_SOURCES, TILEMAP_CELLS, COLOUR, TOOL_SPECS, SPECS_BY_NAME;
+var PROJECT_INFO_SECTIONS, PROJECT_PATH, RUNNING_PROJECT_PATH, RUNNING_PID, SCENE_PATH, WITHOUT_AN_EDITOR = "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, or readBy for a read. That engine runs every script of the file, 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 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.", WHOLE_NUMBERS = 'A whole number of 2^53 or more, such as a 64-bit seed or a resource uid, is written as its digits, {"_type": "int", "value": "9007199254740993"}, the form a read answers with: a JSON number that large can arrive as a neighbour of the one sent, so sent as a number it is refused.', SCRIPT_PATH, RESOURCE_FILE = 'File inside the project, such as "sprites/hero.png" or "materials/steel.tres".', RESOURCE_PATH, NODE_PATH, PROPERTIES, XY, ANIMATION_TRACK, SCRIPT_MODIFICATIONS, INPUT_EVENTS, TILESET_SOURCES, TILEMAP_CELLS, COLOUR2, TOOL_SPECS, SPECS_BY_NAME;
 var init_tool_definitions = __esm(() => {
   init_launch();
   PROJECT_INFO_SECTIONS = [
@@ -11310,7 +11925,10 @@ var init_tool_definitions = __esm(() => {
       type: { type: "string", enum: ["property", "method"] },
       nodePath: { type: "string", description: "Target node, relative to the AnimationPlayer root." },
       property: { type: "string", description: "For property tracks: the property to animate." },
-      method: { type: "string", description: "For method tracks: the method to call." },
+      method: {
+        type: "string",
+        description: "For method tracks: the method to call. The answer's methodFound says whether the target node has it; a method it lacks is still added, since it may be written next, and until it exists each call the track makes fails."
+      },
       keyframes: {
         type: "array",
         items: {
@@ -11412,7 +12030,7 @@ var init_tool_definitions = __esm(() => {
       additionalProperties: false
     }
   };
-  COLOUR = {
+  COLOUR2 = {
     type: "object",
     description: "set_theme_color: r, g and b from 0 to 1, with a optional and opaque by default.",
     properties: { r: { type: "number" }, g: { type: "number" }, b: { type: "number" }, a: { type: "number" } },
@@ -11725,7 +12343,8 @@ var init_tool_definitions = __esm(() => {
       name: "project_test",
       title: "Run tests",
       effect: "additive",
-      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. 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 rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. A client that sends a progress token is told as each suite finishes, and at least every twenty seconds through a long one, so an idle limit does not end a long tier. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. 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 does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
+      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. 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 engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, 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. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. 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, so an idle limit does not end a long tier. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. 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 does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
+      answer: "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.",
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
@@ -11891,7 +12510,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "scene_signal",
       title: "Scene signals",
-      description: `Signal connections in a scene file. Each connection answers with its flags as the number and as flagNames; persist is on every connection, since a scene saves no other kind. A connect of a pair already connected says alreadyConnected, with flagsBefore when it changed the flags. ${WITHOUT_AN_EDITOR}`,
+      description: `Signal connections in a scene file. Each connection answers with its flags as the number and as flagNames; persist is on every connection, since a scene saves no other kind. A connect of a pair already connected says alreadyConnected, with flagsBefore when it changed the flags. A connect to a method the target does not have is still written, as the editor's own dialog allows, since the method may be written next; methodFound false says so, and until the method exists the signal fails each time it is emitted. list marks editable false on a connection an instanced scene makes inside itself, which only that scene can change. ${WITHOUT_AN_EDITOR}`,
       parameters: {
         projectPath: PROJECT_PATH,
         scenePath: SCENE_PATH,
@@ -11936,7 +12555,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "scene_animation",
       title: "Animations",
-      description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. 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. 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 need the editor connected.",
+      description: "Animations in an AnimationPlayer and states in an AnimationTree state machine. 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. 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.",
       parameters: {
         projectPath: PROJECT_PATH,
         scenePath: SCENE_PATH,
@@ -11948,7 +12567,7 @@ var init_tool_definitions = __esm(() => {
         animationName: {
           type: "string",
           ops: ["read", "create", "add_track", "add_state"],
-          description: "The animation in the player. read: the one to answer with whole; without it, read lists them. add_state: the one that state plays."
+          description: "The animation in the player. read: the one to answer with whole, its tracks a list; without it, read lists them, each with the number of its tracks under tracks. add_state: the one that state plays."
         },
         length: { type: "number", ops: ["create"], description: "create: seconds. Default 1." },
         loopMode: {
@@ -12203,20 +12822,24 @@ var init_tool_definitions = __esm(() => {
         controlType: {
           type: "string",
           ops: ["set_theme_color", "set_theme_font_size"],
-          description: 'Theme ops: the Control class, such as "Button".'
+          description: 'Theme ops: the theme type, a Control or Window class such as "Button", or the name of a type variation, which can be any name. A name that is no such class is set as a variation and answered with a note saying so.'
         },
         colorName: {
           type: "string",
           ops: ["set_theme_color"],
           description: 'set_theme_color: such as "font_color".'
         },
-        color: { ...COLOUR, ops: ["set_theme_color"] },
+        color: { ...COLOUR2, ops: ["set_theme_color"] },
         fontSizeName: {
           type: "string",
           ops: ["set_theme_font_size"],
           description: 'set_theme_font_size: such as "font_size".'
         },
-        size: { type: "number", ops: ["set_theme_font_size"], description: "set_theme_font_size: pixels." }
+        size: {
+          type: "number",
+          ops: ["set_theme_font_size"],
+          description: "set_theme_font_size: pixels, a whole number of 1 or more."
+        }
       },
       requires: ["projectPath", "resourcePath"],
       operations: {
@@ -12421,7 +13044,7 @@ var init_tool_definitions = __esm(() => {
           requires: []
         }
       },
-      answer: "stop: endedPid is, for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. stopped is false, with the number under notSignalled, when that number no longer answers as the process the run was started as and nothing was signalled, the note naming which property it failed on, and false with the number under stillGoing when what was told to end was still running ten seconds later. endedThrough says how the stop ended a run that was going: close (the game was asked to close and exited, so exitCode is its own), keeper (the process that started the game ended it through the handle it holds), signal (its pid was signalled once shown to still be the run), or editor (the editor playing it was asked). A start that ends the run before it says how under endedPreviousRunThrough, with the same values, and one that refused to signal that run names the property it failed on under previousRunLeftBecause. check: hung is a run killed at timeoutMs, and errors and warnings count what it printed, which comes back under entries with repeats folded together. entries holds the errors and warnings and not the ordinary lines the run printed, which printedLinesNotShown counts; a check given --verbose holds those too, and editor_run start then editor_output reads everything. An engine crash is an error whatever it prints after: the crash handler's report is the entry, and the engine version and the native and GDScript backtraces are its detail, so a crashed run is never booted or clean. arguments is the engine command line the check ran, as a start's is. profile: per function its script, the function (Class.name when the script declares a class_name), the line its body's first statement is on, for a lambda the named function it is written in (within), calls, and self and total milliseconds, with functionsCounted, scriptMs (the self time of them all) and coveredMs. The runtime addon's own functions, gdharness answering its tools inside the game, are not among them: their self time is runtimeAddonMs, over runtimeAddonFunctions functions. complete is true when the engine's own totals arrived, which it sends only when the profiler is switched off: the runtime addon does that as a game quits, so a scene that does its work in _ready and quits is covered whole; otherwise the answer is the frames summed so far and the note says what that misses. frames counts the frames of the profile that arrived, and the engine's totals also hold the work after the last of them, so once complete a function run every frame can show a call more than frames. Self time counts a call into the engine's own methods as the caller's, and a call through super too, while the overridden function's row counts it again: such a row carries selfIncludesSuper, so self times along an override chain overlap. The profiler's own cost of timing a call lands in the self time of the function called; with the runtime addon it is measured each run on an empty function, as perCallOverheadUs, and a row with at least half its selfMs in it carries overheadMs, since a small function called often costs that much less without the profiler. A function the profiler started inside is left out, since its time would be counted from the engine's start. The milliseconds are time passed while the function ran, not processor time given to it, so they grow when other processes compete for the processor: compare two profiles taken under the same load. They are also summed over every thread: a function run by WorkerThreadPool or a Thread on several threads at once counts each thread's time, the engine does not say which thread a call ran on, and a function waiting for them has the wait in its own self time, so selfMs is not time taken from frames, and scriptMs can exceed coveredMs, which the note then says. A property's get and set blocks are named Class.@name_getter and Class.@name_setter, as the engine names them, and their rows carry property, the property's name. A game the editor plays that was not started with profile: true says, in the answer, that it was profiled from the moment it was asked. A profile with mark answers marked: true; one with since answers since: \"mark\" and markSetMsAgo, and lessThanAtMark counts the functions left out for reading less than at the mark, which the engine's own totals, capped, can do when they replace the frames' sum.",
+      answer: "start: through is gdharness for a game this server started itself, and editor for one the editor plays. scene is the scene the game started in, the project's main scene when none was given. refreshedClasses names the class_name declarations on disk that the engine's class cache was missing, which were added to it before the game started so the game could resolve them; it is empty when the cache was current. stop: endedPid is, for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. stopped is false, with the number under notSignalled, when that number no longer answers as the process the run was started as and nothing was signalled, the note naming which property it failed on, and false with the number under stillGoing when what was told to end was still running ten seconds later. endedThrough says how the stop ended a run that was going: close (the game was asked to close and exited, so exitCode is its own), keeper (the process that started the game ended it through the handle it holds), signal (its pid was signalled once shown to still be the run), or editor (the editor playing it was asked). A start that ends the run before it says how under endedPreviousRunThrough, with the same values, and one that refused to signal that run names the property it failed on under previousRunLeftBecause. check: hung is a run killed at timeoutMs, and errors and warnings count what it printed, which comes back under entries with repeats folded together. entries holds the errors and warnings and not the ordinary lines the run printed, which printedLinesNotShown counts; a check given --verbose holds those too, and editor_run start then editor_output reads everything. An engine crash is an error whatever it prints after: the crash handler's report is the entry, and the engine version and the native and GDScript backtraces are its detail, so a crashed run is never booted or clean. arguments is the engine command line the check ran, as a start's is. profile: per function its script, the function (Class.name when the script declares a class_name), the line its body's first statement is on, for a lambda the named function it is written in (within), calls, and self and total milliseconds, with functionsCounted, scriptMs (the self time of them all) and coveredMs. The runtime addon's own functions, gdharness answering its tools inside the game, are not among them: their self time is runtimeAddonMs, over runtimeAddonFunctions functions. complete is true when the engine's own totals arrived, which it sends only when the profiler is switched off: the runtime addon does that as a game quits, so a scene that does its work in _ready and quits is covered whole; otherwise the answer is the frames summed so far and the note says what that misses. frames counts the frames of the profile that arrived, and the engine's totals also hold the work after the last of them, so once complete a function run every frame can show a call more than frames. Self time counts a call into the engine's own methods as the caller's, and a call through super too, while the overridden function's row counts it again: such a row carries selfIncludesSuper, so self times along an override chain overlap. The profiler's own cost of timing a call lands in the self time of the function called; with the runtime addon it is measured each run on an empty function, as perCallOverheadUs, and a row with at least half its selfMs in it carries overheadMs, since a small function called often costs that much less without the profiler. A function the profiler started inside is left out, since its time would be counted from the engine's start. The milliseconds are time passed while the function ran, not processor time given to it, so they grow when other processes compete for the processor: compare two profiles taken under the same load. They are also summed over every thread: a function run by WorkerThreadPool or a Thread on several threads at once counts each thread's time, the engine does not say which thread a call ran on, and a function waiting for them has the wait in its own self time, so selfMs is not time taken from frames, and scriptMs can exceed coveredMs, which the note then says. A property's get and set blocks are named Class.@name_getter and Class.@name_setter, as the engine names them, and their rows carry property, the property's name. A game the editor plays that was not started with profile: true says, in the answer, that it was profiled from the moment it was asked. A profile with mark answers marked: true; one with since answers since: \"mark\" and markSetMsAgo, and lessThanAtMark counts the functions left out for reading less than at the mark, which the engine's own totals, capped, can do when they replace the frames' sum.",
       defaultOperation: "start"
     },
     {
@@ -12589,7 +13212,7 @@ var init_tool_definitions = __esm(() => {
         property: {
           type: "string",
           ops: ["property", "find"],
-          description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A packed list, such as a PackedStringArray, steps the same way. A negative number counts from the end. A vector, a colour, a rectangle or a transform is stepped into by its components as GDScript names them, so one axis is one number: "size:x", "global_position:y", "modulate:a", "global_transform:origin:z"; a name the value does not have is refused, naming the ones it has. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that only reads (an engine method the engine marks as reading, or a game method not declared -> void, so queue_free() is refused) and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. An engine method that reads takes literal arguments in its brackets, words in double quotes, numbers, true, false or null, so a control\'s theme is read where it is drawn: \'get_theme_stylebox("panel"):content_margin_top\' or \'get_theme_constant("separation")\'. A game method is given none in a path, since nothing marks one as only reading; runtime_invoke call takes those. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.'
+          description: `property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A key holding a colon, a bracket or a quote is written in double quotes, 'stock:"base:dew"', as a refusal listing the keys writes it. A packed list, such as a PackedStringArray, steps the same way. A negative number counts from the end. A vector, a colour, a rectangle or a transform is stepped into by its components as GDScript names them, so one axis is one number: "size:x", "global_position:y", "modulate:a", "global_transform:origin:z"; a name the value does not have is refused, naming the ones it has. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that only reads (an engine method the engine marks as reading, or a game method not declared -> void, so queue_free() is refused) and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. An engine method that reads takes literal arguments in its brackets, words in double quotes, numbers, true, false or null, so a control's theme is read where it is drawn: 'get_theme_stylebox("panel"):content_margin_top' or 'get_theme_constant("separation")'. A game method is given none in a path, since nothing marks one as only reading; runtime_invoke call takes those. A list or a map answers the calls that read it and take no arguments, "_game:run:board:size()" or "_game:inbox:keys()", and not those that change it, such as clear() or sort(). A step that is not there is named, and says what was there instead.`
         },
         depth: {
           type: "integer",
@@ -12809,7 +13432,7 @@ var init_tool_definitions = __esm(() => {
       name: "runtime_input",
       title: "Send input to the game",
       description: "Input to the running game: a whole click on a Control or a 3D node named by path or on a control named by the words on it, an item chosen out of a menu, typing into whatever has the focus, or a raw action, key, mouse button, mouse motion or drag. All of it works headless, where the viewport is the project's window size and the GUI only takes what is inside it. On gdharness's own desktop, where a windowed run goes, Windows refuses to say where the pointer is: every pointer answer there carries pointer_on_hidden_desktop, and the first of the run pointer_note saying why it matters: get_mouse_position() on the root window, and the mouse positions derived from it, read a meaningless position, while what reads the event itself (the control under it, hover, tooltips, input handlers) gets the injected position. A native window no real pointer has entered gets no hover from Godot, so the runtime supplies it there and the answers say hover_supplied.",
-      answer: 'click: what was under the pointer, and what became of the control: in_tree, removed or freed. Named by says, found says which match it was, and found.pressedOn says "the words" for words in a RichTextLabel pressed where they are drawn, or "the middle of the label" with a note saying why they could not be placed; on a rich label link_pressed says whether the press reached a link, with link_meta giving the meta the label reports clicked, an empty one included. A control scrolled into view first is scrolled each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A button in toggle mode, a CheckBox or CheckButton included, answers pressed with before and after, its button_pressed either side of the click: the same value twice is a click the game undid, and after is null when the click freed it. A refusal for a pointer turned off names where mouse_behavior_recursive was set. On a 3D node landed says the interface did not swallow the press: no control under the pointer stopped it, a control letting the pointer pass included, and every viewport on the way out from the room had the pointer over what shows the room. choose: what was chosen, read before the press, which is heard rather than assumed; what became of the control named (in_tree, removed or freed, since a game can rebuild its screen on the pick); and what the button in front of the menu shows now when it is still there. A menu is opened rather than clicked because its items are drawn rather than built, and the item is looked for as the menu stands once open, since a game can fill a menu as it opens. action, key, mouse_click and joypad_button: the event as it was sent, with whole saying whether the press was let go of again, for a key the keycode, physical_keycode and unicode it carried, and for a controller button its number, its name and the device. mouse_motion: the position and the relative movement sent. mouse_drag: from, to, motions sent and relative_total. joypad_motion: the axis by number and name, the value and the device. None of these is aimed at anything, so none says what the event reached: click on a nodePath or says answers what was under the pointer.',
+      answer: `click: what was under the pointer, and what became of the control: in_tree, removed or freed. Named by says, found says which match it was, its index being the index argument that presses the same match again, found.item names the tab, list entry, tree row or menu bar title pressed (kind; index, the item's own number in its control, which is not found.index; says; and for a row the column of the cell saying the words), and found.pressedOn says "the words" for words in a RichTextLabel pressed where they are drawn, or "the middle of the label" with a note saying why they could not be placed; on a rich label link_pressed says whether the press reached a link, with link_meta giving the meta the label reports clicked, an empty one included. A control scrolled into view first is scrolled each container out from it a frame after the one inside, and scrolled_into_view says whether a scroll value changed. A button in toggle mode, a CheckBox or CheckButton included, answers pressed with before and after, its button_pressed either side of the click: the same value twice is a click the game undid, and after is null when the click freed it. A refusal for a pointer turned off names where mouse_behavior_recursive was set. On a 3D node landed says the interface did not swallow the press: no control under the pointer stopped it, a control letting the pointer pass included, and every viewport on the way out from the room had the pointer over what shows the room. choose: what was chosen, read before the press, which is heard rather than assumed; what became of the control named (in_tree, removed or freed, since a game can rebuild its screen on the pick); and what the button in front of the menu shows now when it is still there. A menu is opened rather than clicked because its items are drawn rather than built, and the item is looked for as the menu stands once open, since a game can fill a menu as it opens. action, key, mouse_click and joypad_button: the event as it was sent, with whole saying whether the press was let go of again, for a key the keycode, physical_keycode and unicode it carried, and for a controller button its number, its name and the device. mouse_motion: the position and the relative movement sent. mouse_drag: from, to, motions sent and relative_total. joypad_motion: the axis by number and name, the value and the device. None of these is aimed at anything, so none says what the event reached: click on a nodePath or says answers what was under the pointer.`,
       parameters: {
         projectPath: RUNNING_PROJECT_PATH,
         pid: RUNNING_PID,
@@ -12821,7 +13444,7 @@ var init_tool_definitions = __esm(() => {
         says: {
           type: "string",
           ops: ["click"],
-          description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it, and | separates alternatives), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. A control with something drawn over its centre that would take the pointer, such as a screen shown over it or a dialog stacked above its own, is not on screen; nor is one on a hidden canvas layer, one outside the viewport, or one a container clips away that a click does not scroll. The refusal counts those apart. The matches are ranked the way a person picks what to press: an enabled button before anything else, a disabled one included, then a control whose whole text, or one whole line of it such as the title on a card, is the words before one saying them as part of more, and the best one is pressed; found.picked says why. Several matches at the best rank are refused with each one listed, and index picks one. A match saying the words only as part of more is named under found.partOf, and is refused when another control says exactly the words (hidden, off the screen, covered, or on screen taking clicks without being a button), since it would stand in for that one, and when it lets the pointer through to what is under it; index presses it anyway. Words found only inside longer words (\"out\" in \"Scout\") rank after every other match and are refused unless index is given; words starting a longer word (\"Recruit\" in \"Recruits\") count. An empty field says its placeholder, and a control with no text of its own, a picture on a button, says its accessibility name. An item of an open menu is drawn by the menu rather than held as a control, so a click finds none, and the refusal names the menu and the choose call that picks it."
+          description: "click: the words on the control to click, matched the way runtime_inspect find matches says (a plain word is contained in the text, a pattern with * or ? is a glob over it, and | separates alternatives), among the controls on screen, and pressed in the same frame it was found in, so a panel rebuilding between a find and a click cannot free it first. Words on a label inside a button press the button. A control with something drawn over its centre that would take the pointer, such as a screen shown over it or a dialog stacked above its own, is not on screen; nor is one on a hidden canvas layer, one outside the viewport, or one a container clips away that a click does not scroll. The refusal counts those apart. The matches are ranked the way a person picks what to press: an enabled button before anything else, a disabled one included, then a control whose whole text, or one whole line of it such as the title on a card, is the words before one saying them as part of more, and the best one is pressed; found.picked says why. Several matches at the best rank are refused with each one listed, and index picks one. A match saying the words only as part of more is named under found.partOf, and is refused when another control says exactly the words (hidden, off the screen, covered, or on screen taking clicks without being a button), since it would stand in for that one, and when it lets the pointer through to what is under it; index presses it anyway. Words found only inside longer words (\"out\" in \"Scout\") rank after every other match and are refused unless index is given; words starting a longer word (\"Recruit\" in \"Recruits\") count. An empty field says its placeholder, and a control with no text of its own, a picture on a button, says its accessibility name. A tab, a list entry, a tree row and a menu bar title each count as a match of their own and are pressed where they are drawn, after their control scrolls them into view; a disabled one is refused. An item of an open menu is drawn by the menu rather than held as a control, so a click finds none, and the refusal names the menu and the choose call that picks it."
         },
         action: {
           type: "string",
@@ -34901,12 +35524,12 @@ var init_stdio = __esm(() => {
 
 // src/autoload-failure.ts
 import { existsSync as existsSync15, readFileSync as readFileSync13 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 function scriptsAutoloaded(projectPath) {
   const scripts = new Map;
   let settings;
   try {
-    settings = parseProjectGodot(readFileSync13(join16(projectPath, "project.godot"), "utf8"));
+    settings = parseProjectGodot(readFileSync13(join17(projectPath, "project.godot"), "utf8"));
   } catch {
     return scripts;
   }
@@ -34915,7 +35538,7 @@ function scriptsAutoloaded(projectPath) {
       scripts.set(`res://${path}`, name);
       continue;
     }
-    const scene = join16(projectPath, path);
+    const scene = join17(projectPath, path);
     if (!existsSync15(scene)) {
       continue;
     }
@@ -34928,22 +35551,21 @@ function scriptsAutoloaded(projectPath) {
   return scripts;
 }
 function autoloadNotCompiled(entry, autoloaded) {
-  const path = NOT_COMPILED.exec(entry.text)?.[1];
+  const path = notCompiledIn(entry);
   const name = path === undefined ? undefined : autoloaded.get(path);
   return path === undefined || name === undefined ? null : { name, path };
 }
-var NOT_COMPILED;
 var init_autoload_failure = __esm(() => {
   init_resources();
+  init_script_origins();
   init_setup();
-  NOT_COMPILED = /^Failed to load script "(res:\/\/[^"]+)" with error "Compilation failed"/;
 });
 
 // src/runtime-client.ts
 import { existsSync as existsSync16, readdirSync as readdirSync10, readFileSync as readFileSync14, statSync as statSync8, unlinkSync as unlinkSync2 } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname10, join as join17, resolve as resolve4 } from "node:path";
+import { dirname as dirname10, join as join18, resolve as resolve4 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
@@ -34951,19 +35573,19 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join17(perUser ?? tmpdir4(), "gdharness");
+  return join18(perUser ?? tmpdir4(), "gdharness");
 }
 function runtimeDirectories(variables = process.env) {
   const candidates = [runtimeDirectory(variables)];
   const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
   for (const base of fallbacks) {
-    candidates.push(join17(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join18(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
   }
   return [...new Set(candidates.map((path) => resolve4(path)))];
 }
 function errorReportOf(pid, directories = runtimeDirectories()) {
   for (const directory of directories) {
-    const path = join17(directory, `runtime-${pid}.log`);
+    const path = join18(directory, `runtime-${pid}.log`);
     if (existsSync16(path)) {
       return path;
     }
@@ -35113,14 +35735,14 @@ function announcedIn(directory) {
   for (const entry of readdirSync10(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
-      sweepErrorReport(join17(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      sweepErrorReport(join18(directory, entry), Number.parseInt(report[1] ?? "", 10));
       continue;
     }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
     }
-    const file = join17(directory, entry);
+    const file = join18(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const running = alive(pid);
     entries.push({ file, pid, running });
@@ -35148,7 +35770,7 @@ function announcedIn(directory) {
     found.push(announced);
   }
   const held = new Set(entries.map((one) => one.file));
-  const here = join17(directory, ".");
+  const here = join18(directory, ".");
   for (const file of verdicts.keys()) {
     if (dirname10(file) === here && !held.has(file)) {
       verdicts.delete(file);
@@ -35157,7 +35779,7 @@ function announcedIn(directory) {
   return found;
 }
 async function announcementEnded(pid, directories = runtimeDirectories()) {
-  const files = directories.map((directory) => join17(directory, `runtime-${pid}.json`)).filter((file) => existsSync16(file));
+  const files = directories.map((directory) => join18(directory, `runtime-${pid}.json`)).filter((file) => existsSync16(file));
   const first = files[0];
   if (first === undefined) {
     return;
@@ -35569,9 +36191,9 @@ var init_runtime_client = __esm(() => {
 
 // src/boot-note.ts
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname11, join as join18 } from "node:path";
+import { dirname as dirname11, join as join19 } from "node:path";
 function bootNotePath(projectPath) {
-  return join18(projectPath, ".godot", "gdharness-boot.json");
+  return join19(projectPath, ".godot", "gdharness-boot.json");
 }
 function readScenes(projectPath) {
   try {
@@ -35618,9 +36240,9 @@ var init_boot_note = __esm(() => {
 
 // src/breakpoint-note.ts
 import { mkdirSync as mkdirSync7, readFileSync as readFileSync16, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname12, isAbsolute as isAbsolute4, join as join19, relative as relative3 } from "node:path";
+import { dirname as dirname12, isAbsolute as isAbsolute4, join as join20, relative as relative3 } from "node:path";
 function breakpointNotePath(projectPath) {
-  return join19(projectPath, ".godot", "gdharness-breakpoints.json");
+  return join20(projectPath, ".godot", "gdharness-breakpoints.json");
 }
 function writeBreakpointNote(projectPath, held) {
   const path = breakpointNotePath(projectPath);
@@ -35661,7 +36283,7 @@ function readBreakpointNote(projectPath) {
       }
       const lines = Array.isArray(listed) ? listed.filter((line) => Number.isInteger(line) && line > 0) : [];
       if (lines.length > 0) {
-        held.push({ scriptPath: realPathOr(join19(projectPath, script)), lines });
+        held.push({ scriptPath: realPathOr(join20(projectPath, script)), lines });
       }
     }
     return held;
@@ -35711,9 +36333,9 @@ var init_whole_file = __esm(() => {
 
 // src/class-note.ts
 import { mkdirSync as mkdirSync8, readFileSync as readFileSync17 } from "node:fs";
-import { dirname as dirname13, join as join20 } from "node:path";
+import { dirname as dirname13, join as join21 } from "node:path";
 function classNotePath(projectPath) {
-  return join20(projectPath, ".godot", "gdharness-classes.json");
+  return join21(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
@@ -35760,9 +36382,9 @@ var init_class_note = __esm(() => {
 
 // src/config-pin.ts
 import { existsSync as existsSync17, readFileSync as readFileSync18 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join21(projectPath, ".mcp.json");
+  const config = join22(projectPath, ".mcp.json");
   if (!existsSync17(config)) {
     return [];
   }
@@ -35790,9 +36412,9 @@ var init_config_pin = __esm(() => {
 
 // src/cut-test-run.ts
 import { existsSync as existsSync18, mkdirSync as mkdirSync9, readFileSync as readFileSync19, rmSync as rmSync9, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname14, join as join22 } from "node:path";
+import { dirname as dirname14, join as join23 } from "node:path";
 function keptAt(projectPath) {
-  return join22(projectPath, ".godot", "gdharness-reports", "cut-run.json");
+  return join23(projectPath, ".godot", "gdharness-reports", "cut-run.json");
 }
 function keepCutTestRun(projectPath, run) {
   const path = keptAt(projectPath);
@@ -36631,10 +37253,10 @@ import {
   writeSync
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 function helperAssembly(directory = tmpdir5()) {
-  return join23(directory, `gdharness-desktop-${DIGEST}.dll`);
+  return join24(directory, `gdharness-desktop-${DIGEST}.dll`);
 }
 async function ensureHelperCompiled(directory = tmpdir5(), budgetMs = HELPER_COMPILE_MS, wait = true) {
   const assembly = helperAssembly(directory);
@@ -36674,8 +37296,8 @@ async function ensureHelperCompiled(directory = tmpdir5(), budgetMs = HELPER_COM
   return `the desktop helper was not compiled within ${String(budgetMs)} ms`;
 }
 async function compileHelper(directory, assembly, budgetMs) {
-  const scratch = mkdtempSync2(join23(directory, "gdharness-desktop-source-"));
-  const source = join23(scratch, "helper.cs");
+  const scratch = mkdtempSync2(join24(directory, "gdharness-desktop-source-"));
+  const source = join24(scratch, "helper.cs");
   writeFileSync12(source, SOURCE, "utf8");
   const literal = (path) => `'${path.replaceAll("'", "''")}'`;
   const script = [
@@ -36889,12 +37511,12 @@ import {
   statSync as statSync10,
   writeFileSync as writeFileSync13
 } from "node:fs";
-import { dirname as dirname15, join as join24 } from "node:path";
+import { dirname as dirname15, join as join25 } from "node:path";
 function editorLogPath(projectPath) {
-  return join24(projectPath, ".godot", "gdharness-editor.log");
+  return join25(projectPath, ".godot", "gdharness-editor.log");
 }
 function editorLogNotePath(projectPath) {
-  return join24(projectPath, ".godot", "gdharness-editor.json");
+  return join25(projectPath, ".godot", "gdharness-editor.json");
 }
 function readEditorLogNote(projectPath) {
   try {
@@ -37930,7 +38552,7 @@ var init_rename = __esm(() => {
 import { existsSync as existsSync22, realpathSync as realpathSync4 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname17, join as join25, resolve as resolve5 } from "node:path";
+import { dirname as dirname17, join as join26, resolve as resolve5 } from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function initializeTimeoutMs() {
@@ -38608,7 +39230,7 @@ async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   } catch {
     throw new ArgumentRefusal(`Project path does not exist: ${requestedProjectPath}`);
   }
-  if (!existsSync22(join25(projectPath, "project.godot"))) {
+  if (!existsSync22(join26(projectPath, "project.godot"))) {
     throw new ArgumentRefusal(`Not a Godot project: ${projectPath}. Point projectPath at the directory holding project.godot.`);
   }
   const contained = resolveWithinProject(projectPath, scriptPathValue);
@@ -38769,7 +39391,7 @@ var init_lsp_client = __esm(() => {
 
 // src/rename-symbol.ts
 import { existsSync as existsSync23, mkdirSync as mkdirSync12, readdirSync as readdirSync11, realpathSync as realpathSync5, rmSync as rmSync12, writeFileSync as writeFileSync15 } from "node:fs";
-import { basename as basename7, dirname as dirname18, join as join26, relative as relative4, resolve as resolve6 } from "node:path";
+import { basename as basename7, dirname as dirname18, join as join27, relative as relative4, resolve as resolve6 } from "node:path";
 function resourcePathOf(projectPath, absolute) {
   const inside = relative4(onDiskSpelling(projectPath), onDiskSpelling(absolute));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
@@ -38782,7 +39404,7 @@ function onDiskSpelling(path) {
   let at = resolve6(path);
   for (;; ) {
     try {
-      return join26(realpathSync5.native(at), ...missing.reverse());
+      return join27(realpathSync5.native(at), ...missing.reverse());
     } catch {
       const parent = dirname18(at);
       if (parent === at) {
@@ -39210,15 +39832,15 @@ ${mention.kind}`;
   };
 }
 function writeLeftAloneDetail(projectPath, symbol, detail) {
-  const directory = join26(projectPath, ".godot", "gdharness-renames");
+  const directory = join27(projectPath, ".godot", "gdharness-renames");
   mkdirSync12(directory, { recursive: true });
   detailWrites += 1;
-  const path = join26(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
+  const path = join27(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
   writeFileSync15(path, `${JSON.stringify(detail, null, 2)}
 `, "utf8");
   const kept = readdirSync11(directory).filter((name) => name.endsWith(".json")).sort().reverse();
   for (const old of kept.slice(10)) {
-    rmSync12(join26(directory, old), { force: true });
+    rmSync12(join27(directory, old), { force: true });
   }
   return path;
 }
@@ -39267,10 +39889,10 @@ import {
   statSync as statSync11,
   writeFileSync as writeFileSync16
 } from "node:fs";
-import { basename as basename8, dirname as dirname19, extname as extname3, join as join27, relative as relative5 } from "node:path";
+import { basename as basename8, dirname as dirname19, extname as extname3, join as join28, relative as relative5 } from "node:path";
 function filesUnder(directory) {
   return readdirSync12(directory, { withFileTypes: true }).flatMap((entry) => {
-    const path = join27(directory, entry.name);
+    const path = join28(directory, entry.name);
     return entry.isDirectory() ? filesUnder(path) : [path];
   });
 }
@@ -39291,8 +39913,8 @@ function unseenByTheEngine(projectPath, path) {
       return `${path} is under ${step}, and the engine passes over every directory whose name starts with a dot`;
     }
     if (at < steps.length - 1) {
-      directory = join27(directory, step);
-      if (existsSync24(join27(directory, ".gdignore"))) {
+      directory = join28(directory, step);
+      if (existsSync24(join28(directory, ".gdignore"))) {
         return `${path} is under a directory holding a .gdignore, which the engine does not load`;
       }
     }
@@ -39304,12 +39926,12 @@ function installedAddonOf(projectPath, path) {
   if (steps[0] !== "addons" || steps[1] === undefined) {
     return null;
   }
-  return existsSync24(join27(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
+  return existsSync24(join28(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
 }
 function binaryResources(projectPath) {
   const found = [];
   const visit = (directory, prefix) => {
-    if (existsSync24(join27(directory, ".gdignore"))) {
+    if (existsSync24(join28(directory, ".gdignore"))) {
       return;
     }
     for (const entry of readdirSync12(directory, { withFileTypes: true })) {
@@ -39318,7 +39940,7 @@ function binaryResources(projectPath) {
       }
       const path = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join27(directory, entry.name), `${path}/`);
+        visit(join28(directory, entry.name), `${path}/`);
       } else if (/\.(scn|res)$/i.test(entry.name)) {
         found.push(path);
       }
@@ -39328,7 +39950,7 @@ function binaryResources(projectPath) {
   return found;
 }
 function targetPathOf(projectPath, absolute) {
-  const inside = relative5(onDiskSpelling(projectPath), join27(onDiskSpelling(dirname19(absolute)), basename8(absolute)));
+  const inside = relative5(onDiskSpelling(projectPath), join28(onDiskSpelling(dirname19(absolute)), basename8(absolute)));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
     return null;
   }
@@ -39383,7 +40005,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
     return { ok: false, reason: `${unseen}, so nothing there could load what was moved.` };
   }
   if (!isDirectory) {
-    const owner = SIDECARS.map((sidecar) => from.endsWith(sidecar) ? from.slice(0, -sidecar.length) : null).find((path) => path !== null && existsSync24(join27(projectPath, path.slice("res://".length))));
+    const owner = SIDECARS.map((sidecar) => from.endsWith(sidecar) ? from.slice(0, -sidecar.length) : null).find((path) => path !== null && existsSync24(join28(projectPath, path.slice("res://".length))));
     if (owner !== undefined && owner !== null) {
       return { ok: false, reason: `${from} belongs to ${owner} and moves with it: move ${owner} instead.` };
     }
@@ -39417,12 +40039,12 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
     scripts,
     moves,
     named: [from],
-    exists: (path) => existsSync24(join27(projectPath, path.slice("res://".length)))
+    exists: (path) => existsSync24(join28(projectPath, path.slice("res://".length)))
   }, { edits: [], mentions: [] });
   plan = mentionIgnored(plan, ignoredTexts(projectPath), null, [from]);
   const binaries = [];
   for (const path of binaryResources(projectPath)) {
-    const bytes = readFileSync23(join27(projectPath, path.slice("res://".length)));
+    const bytes = readFileSync23(join28(projectPath, path.slice("res://".length)));
     const names = [...moves.keys()].find((moving) => bytes.includes(moving));
     if (names !== undefined) {
       binaries.push({
@@ -39441,7 +40063,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   }));
   const left = leftAloneReport(mentions);
   const rewrites = rewritesOf(plan, texts, null);
-  const absoluteOf = (path) => join27(projectPath, path.slice("res://".length));
+  const absoluteOf = (path) => join28(projectPath, path.slice("res://".length));
   const rewritten = new Map(rewrites.map((rewrite) => [rewrite.path, rewrite]));
   const moved = [...moves].map(([source, target]) => {
     const rewrite = rewritten.get(source);
@@ -42882,742 +43504,243 @@ var init_godot_bridge = __esm(() => {
             this.connectionInfo.greeted = true;
             const pid = this.connectionInfo.editorPid;
             if (!this.connectionInfo.openedByAServer && pid !== undefined && this.oneShotReader !== null) {
-              this.identify(pid);
-              return;
-            }
-            this.emitBridgeEvent("godot_connected", { projectPath: message.project_path });
-          }
-          return;
-        case "pong":
-          if (this.connectionInfo) {
-            this.connectionInfo.lastPongAt = new Date;
-          }
-          return;
-      }
-    }
-    invokeToolDirect(toolName, args, counted, resourceKey) {
-      if (!this.isConnected()) {
-        return Promise.reject(new Error("Godot is not connected"));
-      }
-      const requestId = randomUUID();
-      const message = {
-        type: "tool_invoke",
-        id: requestId,
-        tool: toolName,
-        args
-      };
-      return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-          this.pendingRequests.delete(requestId);
-          reject(new BridgeTimeout(toolName, this.timeoutMs));
-        }, this.timeoutMs);
-        this.pendingRequests.set(requestId, {
-          toolName,
-          timeout,
-          resolve,
-          reject,
-          startedAt: Date.now(),
-          resourceKey,
-          counted
-        });
-        this.emitBridgeEvent("tool_start", {
-          tool: toolName,
-          id: requestId,
-          args
-        });
-        try {
-          this.sendMessage(message);
-        } catch (error) {
-          clearTimeout(timeout);
-          this.pendingRequests.delete(requestId);
-          reject(toError(error));
-        }
-      });
-    }
-    sendMessage(message) {
-      if (this.socket?.readyState !== import_websocket.default.OPEN) {
-        throw new Refusal("Godot is not connected");
-      }
-      this.socket.send(JSON.stringify(message));
-    }
-    startKeepalive() {
-      this.stopKeepalive();
-      this.pingInterval = setInterval(() => {
-        if (!this.isConnected()) {
-          return;
-        }
-        try {
-          const ping = { type: "ping" };
-          this.sendMessage(ping);
-        } catch (error) {
-          this.log("warn", `Failed to send ping: ${errorMessage(error)}`);
-        }
-      }, KEEPALIVE_INTERVAL_MS);
-    }
-    stopKeepalive() {
-      if (!this.pingInterval) {
-        return;
-      }
-      clearInterval(this.pingInterval);
-      this.pingInterval = null;
-    }
-    belongsElsewhere(theirProject) {
-      if (this.ownProject === null || theirProject.trim() === "") {
-        return false;
-      }
-      return !isSameDirectory(this.ownProject, theirProject);
-    }
-    sendElsewhere(theirProject) {
-      const said = `this server serves ${this.ownProject ?? ""}, and that editor has ${theirProject} open`;
-      this.log("warn", `Turning away an editor from another project: ${said}`);
-      const stranger = this.socket;
-      this.socket = null;
-      this.connectionInfo = null;
-      this.stopKeepalive();
-      const fits = closeReason(said, "start") === said;
-      stranger?.close(OTHER_PROJECT_CLOSE_CODE, fits ? said : closeReason(`this server serves ${this.ownProject ?? ""}`, "end"));
-    }
-    elsewhereUnlessOneShot(theirProject, pid, openedByAServer) {
-      const known = pid === undefined ? undefined : this.oneShots.get(pid);
-      if (pid !== undefined && known !== undefined) {
-        this.turnAway(pid, known);
-        return;
-      }
-      const info = this.connectionInfo;
-      const socket = this.socket;
-      const reader = this.oneShotReader;
-      if (pid === undefined || openedByAServer || info === null || reader === null) {
-        this.sendElsewhere(theirProject);
-        return;
-      }
-      info.identifying = true;
-      reader(pid).catch(() => {
-        return;
-      }).then((option) => {
-        if (this.socket !== socket || this.connectionInfo !== info) {
-          return;
-        }
-        if (typeof option === "string") {
-          this.oneShots.set(pid, option);
-          this.turnAway(pid, option);
-          return;
-        }
-        this.sendElsewhere(theirProject);
-      });
-    }
-    identify(pid) {
-      const known = this.oneShots.get(pid);
-      if (known !== undefined) {
-        this.turnAway(pid, known);
-        return;
-      }
-      const info = this.connectionInfo;
-      const socket = this.socket;
-      const reader = this.oneShotReader;
-      if (info === null || reader === null) {
-        return;
-      }
-      info.identifying = true;
-      reader(pid).catch(() => {
-        return;
-      }).then((option) => {
-        if (this.socket !== socket || this.connectionInfo !== info) {
-          return;
-        }
-        if (typeof option === "string") {
-          this.oneShots.set(pid, option);
-          this.turnAway(pid, option);
-          return;
-        }
-        info.identifying = false;
-        this.log("info", `Godot editor identified: pid ${pid}`);
-        this.emitBridgeEvent("godot_connected", { projectPath: info.projectPath });
-      });
-    }
-    turnAway(pid, option) {
-      const said = `pid ${pid} was started with ${option}, which does one job and quits, so it is not an editor`;
-      this.log("info", `Turning away an engine run: ${said}`);
-      this.turnedAway = { pid, option, at: new Date };
-      const run = this.socket;
-      this.socket = null;
-      this.connectionInfo = null;
-      this.stopKeepalive();
-      run?.close(ONE_SHOT_CLOSE_CODE, closeReason(said, "start"));
-    }
-    handleDisconnect(disconnectedSocket, reason) {
-      if (disconnectedSocket && this.socket && disconnectedSocket !== this.socket) {
-        this.log("debug", "Ignoring stale Godot socket disconnect event");
-        return;
-      }
-      this.stopKeepalive();
-      this.socket = null;
-      this.connectionInfo = null;
-      this.emitBridgeEvent("godot_disconnected", {});
-      this.rejectAllPending(reason);
-      this.resourceQueues.clear();
-    }
-    emitBridgeEvent(eventName, payload) {
-      this.emit(eventName, payload);
-    }
-    rejectAllPending(error) {
-      for (const pending of this.pendingRequests.values()) {
-        clearTimeout(pending.timeout);
-        pending.reject(error);
-      }
-      this.pendingRequests.clear();
-    }
-    enqueueResourceRequest(resourceKey, task) {
-      const previous = this.resourceQueues.get(resourceKey) ?? Promise.resolve();
-      const taskPromise = previous.catch(() => {
-        return;
-      }).then(task);
-      const tail = taskPromise.then(() => {
-        return;
-      }, () => {
-        return;
-      });
-      this.resourceQueues.set(resourceKey, tail);
-      return taskPromise.finally(() => {
-        if (this.resourceQueues.get(resourceKey) === tail) {
-          this.resourceQueues.delete(resourceKey);
-        }
-      });
-    }
-    getResourceKey(args) {
-      const scenePath = this.getStringArg(args, "scenePath") ?? this.getStringArg(args, "scene_path");
-      if (scenePath) {
-        return `scene:${scenePath}`;
-      }
-      const resourcePath = this.getStringArg(args, "resourcePath") ?? this.getStringArg(args, "resource_path");
-      if (resourcePath) {
-        return `resource:${resourcePath}`;
-      }
-      return;
-    }
-    getStringArg(args, key) {
-      const value = args[key];
-      return typeof value === "string" && value.length > 0 ? value : undefined;
-    }
-    isIncomingMessage(value) {
-      if (!value || typeof value !== "object") {
-        return false;
-      }
-      const message = value;
-      const type = message["type"];
-      if (type !== "tool_result" && type !== "pong" && type !== "godot_ready") {
-        return false;
-      }
-      if (type === "pong") {
-        return true;
-      }
-      if (type === "godot_ready") {
-        return typeof message["project_path"] === "string";
-      }
-      return typeof message["id"] === "string" && typeof message["success"] === "boolean" && (message["error"] === undefined || typeof message["error"] === "string") && (message["busy"] === undefined || typeof message["busy"] === "boolean");
-    }
-    log(level, message) {
-      console.error(`[${new Date().toISOString()}] [GodotBridge:${level.toUpperCase()}] ${message}`);
-    }
-  };
-});
-
-// src/junit.ts
-function decoded(text) {
-  return text.replace(/&(#x[0-9a-fA-F]+|#[0-9]+|[a-zA-Z]+);/g, (whole, entity) => {
-    if (entity.startsWith("#")) {
-      const code = entity.startsWith("#x") ? Number.parseInt(entity.slice(2), 16) : Number.parseInt(entity.slice(1), 10);
-      if (!Number.isInteger(code) || code < 0 || code > 1114111) {
-        throw new MalformedReportError(`Not a character: ${whole}`);
-      }
-      return String.fromCodePoint(code);
-    }
-    const named = ENTITIES[entity];
-    if (named === undefined) {
-      throw new MalformedReportError(`Unknown entity ${whole}`);
-    }
-    return named;
-  });
-}
-function tagEnd(source, from) {
-  let quote = null;
-  for (let at = from + 1;at < source.length; at += 1) {
-    const character = source[at];
-    if (quote !== null) {
-      if (character === quote) {
-        quote = null;
-      }
-    } else if (character === '"' || character === "'") {
-      quote = character;
-    } else if (character === ">") {
-      return at;
-    }
-  }
-  return -1;
-}
-function parseXml(source) {
-  const root = { name: "", attributes: {}, children: [], text: "" };
-  const open = [root];
-  let at = 0;
-  const current = () => {
-    const element = open.at(-1);
-    if (element === undefined) {
-      throw new MalformedReportError("A close tag with nothing open");
-    }
-    return element;
-  };
-  while (at < source.length) {
-    const next = source.indexOf("<", at);
-    if (next === -1) {
-      current().text += decoded(source.slice(at));
-      break;
-    }
-    current().text += decoded(source.slice(at, next));
-    at = next;
-    if (source.startsWith("<![CDATA[", at)) {
-      const end = source.indexOf("]]>", at);
-      if (end === -1) {
-        throw new MalformedReportError("CDATA that never ends");
-      }
-      current().text += source.slice(at + "<![CDATA[".length, end);
-      at = end + "]]>".length;
-      continue;
-    }
-    if (source.startsWith("<!--", at)) {
-      const end = source.indexOf("-->", at);
-      if (end === -1) {
-        throw new MalformedReportError("A comment that never ends");
-      }
-      at = end + "-->".length;
-      continue;
-    }
-    if (source.startsWith("<?", at) || source.startsWith("<!", at)) {
-      const end = source.indexOf(">", at);
-      if (end === -1) {
-        throw new MalformedReportError("A declaration that never ends");
-      }
-      at = end + 1;
-      continue;
-    }
-    const end = tagEnd(source, at);
-    if (end === -1) {
-      throw new MalformedReportError("A tag that never ends");
-    }
-    const tag = source.slice(at + 1, end);
-    at = end + 1;
-    if (tag.startsWith("/")) {
-      const closing = tag.slice(1).trim();
-      const element = current();
-      if (element === root || element.name !== closing) {
-        throw new MalformedReportError(`</${closing}> closes <${element.name || "nothing"}>`);
-      }
-      open.pop();
-      continue;
-    }
-    const selfClosing = tag.endsWith("/");
-    const body = selfClosing ? tag.slice(0, -1) : tag;
-    const nameMatch = /^([^\s/>]+)/.exec(body);
-    if (!nameMatch?.[1]) {
-      throw new MalformedReportError(`A tag with no name: <${tag}>`);
-    }
-    const attributes = {};
-    let read = nameMatch[0].length;
-    ATTRIBUTE.lastIndex = read;
-    let attribute = ATTRIBUTE.exec(body);
-    while (attribute) {
-      attributes[attribute[1] ?? ""] = decoded(attribute[2] ?? attribute[3] ?? "");
-      read = ATTRIBUTE.lastIndex;
-      attribute = ATTRIBUTE.exec(body);
-    }
-    if (body.slice(read).trim() !== "") {
-      throw new MalformedReportError(`Unreadable attributes in <${tag}>`);
-    }
-    const element = { name: nameMatch[1], attributes, children: [], text: "" };
-    current().children.push(element);
-    if (!selfClosing) {
-      open.push(element);
-    }
-  }
-  if (open.length !== 1) {
-    throw new MalformedReportError(`<${current().name}> is never closed`);
-  }
-  return root;
-}
-function count(attributes, name) {
-  const value = Number(attributes[name] ?? "0");
-  return Number.isFinite(value) ? value : 0;
-}
-function ignoredYetRan(report, ignored) {
-  const found = [];
-  for (const entry of ignored) {
-    const bare = entry.replace("res://", "");
-    const at = bare.lastIndexOf(":");
-    const suiteNamed = at === -1 ? null : bare.slice(0, at);
-    const testNamed = at === -1 ? bare : bare.slice(at + 1);
-    for (const suite of report.suites) {
-      const suiteMatches = suiteNamed === null || suite.name === suiteNamed || (suite.path ?? "").includes(suiteNamed);
-      const ran = suiteMatches ? suite.cases.find((one) => one.name === testNamed) : undefined;
-      if (ran !== undefined) {
-        found.push({ entry, ran: `${suite.name}:${ran.name}` });
-      }
-    }
-  }
-  return found;
-}
-function caseOf(suite, element) {
-  const of = (kind) => element.children.filter((child) => child.name === kind).map((child) => {
-    const detail = child.text.trim();
-    return { kind, message: child.attributes["message"] ?? null, detail: detail === "" ? null : detail };
-  });
-  const reports = [...of("failure"), ...of("error"), ...of("skipped")];
-  const status = reports.some((report) => report.kind === "error") ? "error" : reports.some((report) => report.kind === "failure") ? "failed" : reports.length > 0 ? "skipped" : "passed";
-  return {
-    suite: suite.attributes["name"] ?? "",
-    name: element.attributes["name"] ?? "",
-    status,
-    time: count(element.attributes, "time"),
-    message: reports[0]?.message ?? null,
-    detail: reports[0]?.detail ?? null,
-    reports
-  };
-}
-function failedAnAssertion(entry) {
-  return entry.reports.some((report) => report.kind === "failure");
-}
-function pathOf(suite) {
-  const directory = suite.attributes["package"];
-  const name = suite.attributes["name"];
-  return directory && name ? `res://${directory}/${name}.gd` : null;
-}
-function parseJUnit(xml) {
-  const document = parseXml(xml);
-  const top = document.children.find((child) => child.name === "testsuites" || child.name === "testsuite");
-  if (top === undefined) {
-    throw new MalformedReportError("No <testsuites> or <testsuite> in the report");
-  }
-  const suiteElements = top.name === "testsuite" ? [top] : top.children.filter((child) => child.name === "testsuite");
-  const suites = suiteElements.map((suite) => {
-    const cases = suite.children.filter((child) => child.name === "testcase").map((element) => caseOf(suite, element));
-    const failures = cases.filter(failedAnAssertion).length;
-    const errors = cases.filter((entry) => entry.status === "error").length;
-    const written = (kind) => suite.children.filter((child) => child.name === "testcase").reduce((sum, element) => sum + element.children.filter((child) => child.name === kind).length, 0);
-    return {
-      name: suite.attributes["name"] ?? "",
-      path: pathOf(suite),
-      tests: cases.length,
-      discovered: count(suite.attributes, "tests"),
-      failures,
-      errors,
-      hookFailures: Math.max(0, count(suite.attributes, "failures") - written("failure")),
-      hookErrors: Math.max(0, count(suite.attributes, "errors") - written("error")),
-      skipped: cases.filter((entry) => entry.status === "skipped").length,
-      time: count(suite.attributes, "time"),
-      cases
-    };
-  });
-  const all = suites.flatMap((suite) => suite.cases);
-  return {
-    tests: all.length,
-    failures: all.filter(failedAnAssertion).length,
-    errors: all.filter((entry) => entry.status === "error").length,
-    hookFailures: suites.reduce((sum, suite) => sum + suite.hookFailures, 0),
-    hookErrors: suites.reduce((sum, suite) => sum + suite.hookErrors, 0),
-    skipped: all.filter((entry) => entry.status === "skipped").length,
-    time: suites.reduce((sum, suite) => sum + suite.time, 0),
-    suites
-  };
-}
-function hookFailuresPrinted(printed) {
-  return printed.flatMap((line) => {
-    const found = HOOK_FAILURE.exec(line);
-    return found === null ? [] : [{ hook: found[2] ?? "", path: found[3] ?? "", line: Number(found[4]), message: found[1] ?? "" }];
-  });
-}
-function whyNoReport(printed, asked) {
-  const missing = printed.map((line) => NO_SUCH_PATH.exec(line)).find((found) => found !== null);
-  if (missing !== undefined) {
-    return `nothing at ${missing[1] ?? asked}`;
-  }
-  return printed.some((line) => NOTHING_RAN.test(line)) ? `no test cases found at ${asked}` : null;
-}
-function scriptErrorsPrinted(printed) {
-  return discoveryListing(printed)?.errors ?? [];
-}
-function discoveryListing(printed) {
-  const start = printed.findIndex((line) => line.includes(DISCOVERY_FAILED));
-  if (start < 0) {
-    return null;
-  }
-  const found = [];
-  let message = null;
-  let to = start + 1;
-  for (const line of printed.slice(start + 1)) {
-    const at = /^\s*at (res:\/\/.+):(\d+)\s*$/.exec(line);
-    if (at !== null && message !== null) {
-      found.push({ path: at[1] ?? "", line: Number(at[2]) === 0 ? null : Number(at[2]), message });
-      message = null;
-    } else if (at === null && message === null && /^ {2}\S/.test(line)) {
-      message = line.trim();
-    } else {
-      break;
-    }
-    to += 1;
-  }
-  const errors = found.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : (a.line ?? 0) - (b.line ?? 0));
-  return { errors, from: start, to };
-}
-function unspelled(text) {
-  return text.replace(/<(?:LF|CR|TAB|BS|FF|VT|BEL|ESC|DEL|0x[0-9A-F]{2})>/g, (spelling) => spelling.startsWith("<0x") ? String.fromCharCode(Number.parseInt(spelling.slice(3, 5), 16)) : SPELLED[spelling] ?? spelling);
-}
-function readDiff(printed) {
-  let merged = "";
-  let actual = "";
-  let background = null;
-  let last = 0;
-  const take = (text) => {
-    merged += text;
-    if (background === null) {
-      actual += text;
-    } else if (background === "added") {
-      actual += unspelled(text);
-    }
-  };
-  for (const match of printed.matchAll(COLOUR2)) {
-    take(printed.slice(last, match.index));
-    last = match.index + match[0].length;
-    const codes = (match[1] ?? "").split(";");
-    if (codes[0] === "48" && codes[1] === "2") {
-      background = Number(codes[2]) > Number(codes[3]) ? "missing" : "added";
-    } else if (codes[0] === "0" || codes[0] === "") {
-      background = null;
-    }
-  }
-  take(printed.slice(last));
-  return { merged, actual };
-}
-function withActualsPrinted(failed, printed) {
-  const diffs = [...printed.replaceAll(`\r
-`, `
-`).matchAll(PRINTED_ACTUAL)].map((match) => ({
-    suffix: match[3] ?? "",
-    at: match[5] ?? "",
-    ...readDiff(match[1] ?? "")
-  }));
-  const used = new Set;
-  return failed.map((entry) => {
-    if (entry.detail === null) {
-      return entry;
+              this.identify(pid);
+              return;
+            }
+            this.emitBridgeEvent("godot_connected", { projectPath: message.project_path });
+          }
+          return;
+        case "pong":
+          if (this.connectionInfo) {
+            this.connectionInfo.lastPongAt = new Date;
+          }
+          return;
+      }
     }
-    let detail = entry.detail;
-    let recovered = false;
-    for (const [index, diff] of diffs.entries()) {
-      if (used.has(index)) {
-        continue;
+    invokeToolDirect(toolName, args, counted, resourceKey) {
+      if (!this.isConnected()) {
+        return Promise.reject(new Error("Godot is not connected"));
       }
-      const wrong = ` but was
- '${diff.merged.replaceAll("\r", "")}'${diff.suffix}
-	at ${diff.at}`;
-      if (detail.includes(wrong)) {
-        detail = detail.replace(wrong, () => ` but was
- '${diff.actual}'${diff.suffix}
-	at ${diff.at}`);
-        recovered = true;
-        used.add(index);
+      const requestId = randomUUID();
+      const message = {
+        type: "tool_invoke",
+        id: requestId,
+        tool: toolName,
+        args
+      };
+      return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          this.pendingRequests.delete(requestId);
+          reject(new BridgeTimeout(toolName, this.timeoutMs));
+        }, this.timeoutMs);
+        this.pendingRequests.set(requestId, {
+          toolName,
+          timeout,
+          resolve,
+          reject,
+          startedAt: Date.now(),
+          resourceKey,
+          counted
+        });
+        this.emitBridgeEvent("tool_start", {
+          tool: toolName,
+          id: requestId,
+          args
+        });
+        try {
+          this.sendMessage(message);
+        } catch (error) {
+          clearTimeout(timeout);
+          this.pendingRequests.delete(requestId);
+          reject(toError(error));
+        }
+      });
+    }
+    sendMessage(message) {
+      if (this.socket?.readyState !== import_websocket.default.OPEN) {
+        throw new Refusal("Godot is not connected");
       }
+      this.socket.send(JSON.stringify(message));
     }
-    const quoted = QUOTED_EQUALITY.exec(detail);
-    if (quoted !== null) {
-      const alike = quoted[1] === quoted[2];
-      const note = recovered ? alike ? RENDERED_AWAY_NOTE : null : alike ? BOTH_SIDES_ALIKE_NOTE : VALUE_NOT_RECOVERED_NOTE;
-      detail = note === null ? detail : `${detail}
-${note}`;
+    startKeepalive() {
+      this.stopKeepalive();
+      this.pingInterval = setInterval(() => {
+        if (!this.isConnected()) {
+          return;
+        }
+        try {
+          const ping = { type: "ping" };
+          this.sendMessage(ping);
+        } catch (error) {
+          this.log("warn", `Failed to send ping: ${errorMessage(error)}`);
+        }
+      }, KEEPALIVE_INTERVAL_MS);
     }
-    if (quoted !== null && masked(quoted[1] ?? "", quoted[2] ?? "")) {
-      const end = quoted[0].length - `
-	at `.length;
-      detail = detail.slice(0, end).replaceAll(MASKED_BRACKET, "[") + detail.slice(end);
+    stopKeepalive() {
+      if (!this.pingInterval) {
+        return;
+      }
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
     }
-    return detail === entry.detail ? entry : { ...entry, detail };
-  });
-}
-function shortened(detail) {
-  if (detail === null || detail.length <= LONGEST_DETAIL) {
-    return detail;
-  }
-  return `${detail.slice(0, LONGEST_DETAIL)}
-[${detail.length - LONGEST_DETAIL} more characters left out]`;
-}
-function foldedReports(reports) {
-  const first = new Map;
-  for (const report of reports) {
-    const key = JSON.stringify([report.kind, report.message, report.detail]);
-    const seen = first.get(key);
-    if (seen === undefined) {
-      first.set(key, { report, times: 1 });
-    } else {
-      seen.times += 1;
+    belongsElsewhere(theirProject) {
+      if (this.ownProject === null || theirProject.trim() === "") {
+        return false;
+      }
+      return !isSameDirectory(this.ownProject, theirProject);
     }
-  }
-  return [...first.values()].map(({ report, times }) => {
-    const kept = { ...report, detail: shortened(report.detail) };
-    return times === 1 ? kept : { ...kept, times };
-  });
-}
-function failedCases(report, printed) {
-  const cases = report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ entry, path: suite.path })));
-  const read = withActualsPrinted(cases.flatMap(({ entry }) => entry.reports), printed);
-  let next = 0;
-  return cases.map(({ entry, path }) => {
-    const reports = read.slice(next, next + entry.reports.length);
-    next += entry.reports.length;
-    const folded = foldedReports(reports);
-    const shown = folded.slice(0, MOST_REPORTS_SHOWN);
-    return {
-      suite: entry.suite,
-      name: entry.name,
-      status: entry.status,
-      time: entry.time,
-      path,
-      message: reports[0]?.message ?? null,
-      detail: shortened(reports[0]?.detail ?? null),
-      ...reports.length > 1 ? { reports: shown, reportCount: reports.length } : {},
-      ...folded.length > shown.length ? { reportsLeftOut: folded.length - shown.length } : {}
-    };
-  });
-}
-function failedWithin(failed, budget) {
-  const sizes = failed.map((entry) => JSON.stringify(entry).length);
-  const smallestFirst = sizes.map((_, index) => index).sort((a, b) => (sizes[a] ?? 0) - (sizes[b] ?? 0));
-  const whole = new Set;
-  let spent = 0;
-  for (const index of smallestFirst) {
-    const size = sizes[index] ?? 0;
-    if (spent + size > budget) {
-      break;
+    sendElsewhere(theirProject) {
+      const said = `this server serves ${this.ownProject ?? ""}, and that editor has ${theirProject} open`;
+      this.log("warn", `Turning away an editor from another project: ${said}`);
+      const stranger = this.socket;
+      this.socket = null;
+      this.connectionInfo = null;
+      this.stopKeepalive();
+      const fits = closeReason(said, "start") === said;
+      stranger?.close(OTHER_PROJECT_CLOSE_CODE, fits ? said : closeReason(`this server serves ${this.ownProject ?? ""}`, "end"));
     }
-    spent += size;
-    whole.add(index);
-  }
-  const kept = failed.map((entry, index) => {
-    if (whole.has(index)) {
-      return entry;
+    elsewhereUnlessOneShot(theirProject, pid, openedByAServer) {
+      const known = pid === undefined ? undefined : this.oneShots.get(pid);
+      if (pid !== undefined && known !== undefined) {
+        this.turnAway(pid, known);
+        return;
+      }
+      const info = this.connectionInfo;
+      const socket = this.socket;
+      const reader = this.oneShotReader;
+      if (pid === undefined || openedByAServer || info === null || reader === null) {
+        this.sendElsewhere(theirProject);
+        return;
+      }
+      info.identifying = true;
+      reader(pid).catch(() => {
+        return;
+      }).then((option) => {
+        if (this.socket !== socket || this.connectionInfo !== info) {
+          return;
+        }
+        if (typeof option === "string") {
+          this.oneShots.set(pid, option);
+          this.turnAway(pid, option);
+          return;
+        }
+        this.sendElsewhere(theirProject);
+      });
     }
-    const { detail: _detail, reports: _reports, reportsLeftOut: _left, ...named } = entry;
-    return { ...named, message: entry.message?.slice(0, 500) ?? null, detail: null };
-  });
-  return { failed: kept, briefed: failed.length - whole.size };
-}
-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 orphansPrinted(printed) {
-  const suites = [];
-  let total = null;
-  let running = null;
-  for (const line of printed) {
-    const started = RUNNING_SUITE.exec(line);
-    if (started?.[1] !== undefined) {
-      running = started[1];
-      continue;
+    identify(pid) {
+      const known = this.oneShots.get(pid);
+      if (known !== undefined) {
+        this.turnAway(pid, known);
+        return;
+      }
+      const info = this.connectionInfo;
+      const socket = this.socket;
+      const reader = this.oneShotReader;
+      if (info === null || reader === null) {
+        return;
+      }
+      info.identifying = true;
+      reader(pid).catch(() => {
+        return;
+      }).then((option) => {
+        if (this.socket !== socket || this.connectionInfo !== info) {
+          return;
+        }
+        if (typeof option === "string") {
+          this.oneShots.set(pid, option);
+          this.turnAway(pid, option);
+          return;
+        }
+        info.identifying = false;
+        this.log("info", `Godot editor identified: pid ${pid}`);
+        this.emitBridgeEvent("godot_connected", { projectPath: info.projectPath });
+      });
     }
-    const counted = ORPHANS.exec(line);
-    if (counted?.[1] === undefined) {
-      continue;
+    turnAway(pid, option) {
+      const said = `pid ${pid} was started with ${option}, which does one job and quits, so it is not an editor`;
+      this.log("info", `Turning away an engine run: ${said}`);
+      this.turnedAway = { pid, option, at: new Date };
+      const run = this.socket;
+      this.socket = null;
+      this.connectionInfo = null;
+      this.stopKeepalive();
+      run?.close(ONE_SHOT_CLOSE_CODE, closeReason(said, "start"));
     }
-    const orphans = Number(counted[1]);
-    if (line.includes(OVERALL)) {
-      total = orphans;
-      running = null;
-      continue;
+    handleDisconnect(disconnectedSocket, reason) {
+      if (disconnectedSocket && this.socket && disconnectedSocket !== this.socket) {
+        this.log("debug", "Ignoring stale Godot socket disconnect event");
+        return;
+      }
+      this.stopKeepalive();
+      this.socket = null;
+      this.connectionInfo = null;
+      this.emitBridgeEvent("godot_disconnected", {});
+      this.rejectAllPending(reason);
+      this.resourceQueues.clear();
     }
-    if (running !== null && orphans > 0) {
-      suites.push({ path: running, orphans });
+    emitBridgeEvent(eventName, payload) {
+      this.emit(eventName, payload);
     }
-    running = null;
-  }
-  return {
-    total: total ?? suites.reduce((sum, suite) => sum + suite.orphans, 0),
-    suites
-  };
-}
-function finishesASuite(line) {
-  return SUITE_COUNTS.test(line) && !line.includes(OVERALL);
-}
-function suitesPrinted(printed) {
-  const finished = [];
-  let running = null;
-  let failed = [];
-  for (const line of printed) {
-    const started = RUNNING_SUITE.exec(line);
-    if (started?.[1] !== undefined) {
-      running = started[1];
-      failed = [];
-      continue;
+    rejectAllPending(error) {
+      for (const pending of this.pendingRequests.values()) {
+        clearTimeout(pending.timeout);
+        pending.reject(error);
+      }
+      this.pendingRequests.clear();
     }
-    if (running === null) {
-      continue;
+    enqueueResourceRequest(resourceKey, task) {
+      const previous = this.resourceQueues.get(resourceKey) ?? Promise.resolve();
+      const taskPromise = previous.catch(() => {
+        return;
+      }).then(task);
+      const tail = taskPromise.then(() => {
+        return;
+      }, () => {
+        return;
+      });
+      this.resourceQueues.set(resourceKey, tail);
+      return taskPromise.finally(() => {
+        if (this.resourceQueues.get(resourceKey) === tail) {
+          this.resourceQueues.delete(resourceKey);
+        }
+      });
     }
-    const failing = CASE_FAILED.exec(line)?.[1];
-    if (failing !== undefined) {
-      failed.push(failing);
-      continue;
+    getResourceKey(args) {
+      const scenePath = this.getStringArg(args, "scenePath") ?? this.getStringArg(args, "scene_path");
+      if (scenePath) {
+        return `scene:${scenePath}`;
+      }
+      const resourcePath = this.getStringArg(args, "resourcePath") ?? this.getStringArg(args, "resource_path");
+      if (resourcePath) {
+        return `resource:${resourcePath}`;
+      }
+      return;
     }
-    const counted = finishesASuite(line) ? SUITE_COUNTS.exec(line) : null;
-    if (counted !== null) {
-      finished.push({
-        path: running,
-        cases: Number(counted[1]),
-        errors: Number(counted[2]),
-        failures: Number(counted[3]),
-        failed
-      });
-      running = null;
+    getStringArg(args, key) {
+      const value = args[key];
+      return typeof value === "string" && value.length > 0 ? value : undefined;
     }
-  }
-  return { finished, running };
-}
-function testProgressMessage(printed, elapsedMs) {
-  const { finished, running } = suitesPrinted(printed);
-  const failing = finished.filter((suite) => suite.errors + suite.failures > 0).length;
-  const seconds = Math.floor(elapsedMs / 1000);
-  const took = seconds < 60 ? `${seconds}s` : `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
-  const done = finished.length === 0 ? "No suite has finished" : `${finished.length === 1 ? "One suite has" : `${finished.length} suites have`} finished${failing === 0 ? "" : `, ${failing} with failures`}`;
-  return `${done}${running === null ? "" : `; running ${running}`}; ${took} in.`;
-}
-var MalformedReportError, ENTITIES, ATTRIBUTE, HOOK_FAILURE, NOTHING_RAN, NO_SUCH_PATH, DISCOVERY_FAILED = "Script errors were detected during test discovery!", ESCAPE, LOCATION = `'[^'\\n]*' in \\S+:\\d+`, IGNORING_CASE = " \\(ignoring case\\)", PRINTED_ACTUAL, QUOTED_EQUALITY, COLOUR2, SPELLED, BOTH_SIDES_ALIKE_NOTE = "[gdharness: the expected and the actual printed alike because gdUnit4 drops the marks that tell them apart when it writes its report, and the runner printed no copy of this one, so neither side above is the value the assertion found.]", VALUE_NOT_RECOVERED_NOTE = '[gdharness: the value after "but was" may not be the one the assertion found. gdUnit4 writes a failing string into its report as a character diff against the expected one with the marks dropped, which merges the two, and the runner printed no copy of this one to read the value back from.]', RENDERED_AWAY_NOTE = '[gdharness: the two sides print alike, so what tells them apart is something gdUnit4 does not print. The usual cause is BBCode in the expected string, which gdUnit4 renders as formatting instead of showing; the value after "but was" is the one the assertion found.]', MOST_REPORTS_SHOWN = 20, LONGEST_DETAIL = 20000, MASKED_BRACKET = "[lb]", PRINTED_DICTIONARY, RUNNING_SUITE, ORPHANS, OVERALL = "Overall Summary", SUITE_COUNTS, CASE_FAILED;
-var init_junit = __esm(() => {
-  MalformedReportError = class MalformedReportError extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "MalformedReportError";
+    isIncomingMessage(value) {
+      if (!value || typeof value !== "object") {
+        return false;
+      }
+      const message = value;
+      const type = message["type"];
+      if (type !== "tool_result" && type !== "pong" && type !== "godot_ready") {
+        return false;
+      }
+      if (type === "pong") {
+        return true;
+      }
+      if (type === "godot_ready") {
+        return typeof message["project_path"] === "string";
+      }
+      return typeof message["id"] === "string" && typeof message["success"] === "boolean" && (message["error"] === undefined || typeof message["error"] === "string") && (message["busy"] === undefined || typeof message["busy"] === "boolean");
+    }
+    log(level, message) {
+      console.error(`[${new Date().toISOString()}] [GodotBridge:${level.toUpperCase()}] ${message}`);
     }
   };
-  ENTITIES = { lt: "<", gt: ">", amp: "&", quot: '"', apos: "'" };
-  ATTRIBUTE = /\s*([^\s=/>]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/y;
-  HOOK_FAILURE = /^\s*(.*?)\s*\tat '(before|after)' in (res:\/\/.+?):(\d+)\s*$/;
-  NOTHING_RAN = /no test cases found/i;
-  NO_SUCH_PATH = /given directory or file does not exists:\s*(.+?)\s*$/i;
-  ESCAPE = String.fromCharCode(27);
-  PRINTED_ACTUAL = new RegExp(` but was\\n '((?:(?!\\tat ${LOCATION})[\\s\\S])*?)'((?:${ESCAPE}\\[[0-9;]*m)*)(${IGNORING_CASE})?((?:${ESCAPE}\\[[0-9;]*m)*)\\tat (${LOCATION})`, "g");
-  QUOTED_EQUALITY = new RegExp(`^Expecting(?: error message)?:\\n '([\\s\\S]*)'\\n but was\\n '([\\s\\S]*)'(?:${IGNORING_CASE})?\\n\\tat `);
-  COLOUR2 = new RegExp(`${ESCAPE}\\[([0-9;]*)m`, "g");
-  SPELLED = {
-    "<LF>": `
-`,
-    "<CR>": "\r",
-    "<TAB>": "\t",
-    "<BS>": "\b",
-    "<FF>": "\f",
-    "<VT>": "\v",
-    "<BEL>": "\x07",
-    "<ESC>": ESCAPE,
-    "<DEL>": ""
-  };
-  PRINTED_DICTIONARY = /^\{\n\t[\s\S]*\n {2}\}$/;
-  RUNNING_SUITE = /Run Test Suite:\s*(res:\/\/.+?\.(?:gd|cs))(?=\s|$)/;
-  ORPHANS = /(\d+)\s+orphans/;
-  SUITE_COUNTS = /(\d+)\s+test cases\s*\|\s*(\d+)\s+errors\s*\|\s*(\d+)\s+failures/;
-  CASE_FAILED = /^\s*res:\/\/.+?\.(?:gd|cs) > (.+?) (?:FAILED|ERROR)(?:\s|$)/;
 });
 
 // src/keeper-channel.ts
@@ -43687,10 +43810,10 @@ var init_keeper_channel = () => {};
 
 // src/lifecycle-log.ts
 import { appendFileSync, mkdirSync as mkdirSync14, renameSync as renameSync5, statSync as statSync12 } from "node:fs";
-import { dirname as dirname20, join as join28 } from "node:path";
+import { dirname as dirname20, join as join29 } from "node:path";
 import process11 from "node:process";
 function lifecycleLogPath() {
-  return join28(runtimeDirectory(), "servers.log");
+  return join29(runtimeDirectory(), "servers.log");
 }
 function writeLifecycle(event, fields = {}) {
   const path = lifecycleLogPath();
@@ -44011,9 +44134,9 @@ var init_prompts = __esm(() => {
 
 // src/restart-note.ts
 import { mkdirSync as mkdirSync15, readFileSync as readFileSync24, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "node:fs";
-import { dirname as dirname21, join as join29 } from "node:path";
+import { dirname as dirname21, join as join30 } from "node:path";
 function restartNotePath(projectPath) {
-  return join29(projectPath, ".godot", "gdharness-restart.json");
+  return join30(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
@@ -44054,16 +44177,16 @@ var init_restart_note = __esm(() => {
 // src/run-record.ts
 import { createHash as createHash5 } from "node:crypto";
 import { mkdirSync as mkdirSync16, openSync as openSync3, readdirSync as readdirSync13, readFileSync as readFileSync25, realpathSync as realpathSync6, rmSync as rmSync14, statSync as statSync13 } from "node:fs";
-import { basename as basename9, dirname as dirname22, join as join30, resolve as resolve7 } from "node:path";
+import { basename as basename9, dirname as dirname22, join as join31, resolve as resolve7 } from "node:path";
 function runsDirectory() {
-  return join30(runtimeDirectory(), "runs");
+  return join31(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join30(realpathSync6.native(at), ...missing);
+      return join31(realpathSync6.native(at), ...missing);
     } catch {
       const parent = dirname22(at);
       if (parent === at) {
@@ -44080,10 +44203,10 @@ function projectKey(projectPath) {
   return createHash5("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join30(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join31(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function latestRunPath(servedBy, directory = runtimeDirectory()) {
-  return join30(directory, "runs", `latest-${projectKey(servedBy)}.json`);
+  return join31(directory, "runs", `latest-${projectKey(servedBy)}.json`);
 }
 function writeLatestRun(servedBy, latest) {
   try {
@@ -44108,20 +44231,20 @@ function readLatestRun(servedBy, directory = runtimeDirectory()) {
 }
 function openTranscript(startedAt) {
   mkdirSync16(runsDirectory(), { recursive: true });
-  const path = join30(runsDirectory(), `run-${startedAt}.log`);
+  const path = join31(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync3(path, "a") };
 }
 function profilePath(startedAt) {
-  return join30(runsDirectory(), `run-${startedAt}.profile.json`);
+  return join31(runsDirectory(), `run-${startedAt}.profile.json`);
 }
 function profileMarkPath(startedAt) {
-  return join30(runsDirectory(), `run-${startedAt}.profile-mark.json`);
+  return join31(runsDirectory(), `run-${startedAt}.profile-mark.json`);
 }
 function noteIsAbout(note, playing) {
   return note.play !== undefined && playing !== null && note.play.play === playing.play && note.play.editorPid === playing.editorPid;
 }
 function editorNotePath(projectPath, directory = runtimeDirectory()) {
-  return join30(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join31(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
   mkdirSync16(runsDirectory(), { recursive: true });
@@ -44132,7 +44255,7 @@ function writeEditorRunNote(note) {
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join30(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join31(directory, "runs", "editor-run.json"));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -44166,7 +44289,7 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join30(directory, "runs", SHARED_NOTE));
+    const shared = recordAt(join31(directory, "runs", SHARED_NOTE));
     if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
       return shared;
     }
@@ -44178,13 +44301,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync13(join30(directory, "runs"));
+      entries = readdirSync13(join31(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join30(directory, "runs", entry));
+        const record = recordAt(join31(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -44392,7 +44515,7 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join30(directory, "runs", SHARED_NOTE);
+    const shared = join31(directory, "runs", SHARED_NOTE);
     const sharedRecord = recordAt(shared);
     const ours = sharedRecord !== null && sharedRecord.projectPath !== "" && isSameDirectory(sharedRecord.projectPath, projectPath);
     for (const path of [runRecordPath(projectPath, directory), ...ours ? [shared] : []]) {
@@ -44427,7 +44550,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!transcript && !entry.endsWith(".partial")) {
       continue;
     }
-    const path = join30(directory, entry);
+    const path = join31(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -44447,110 +44570,6 @@ var init_run_record = __esm(() => {
   init_windows_ask();
 });
 
-// src/script-origins.ts
-import { join as join31 } from "node:path";
-function unresolvedClassIn(message) {
-  return UNRESOLVED.exec(message)?.[1] ?? null;
-}
-async function originsOf(errors, declared, check) {
-  const listed = new Set(errors.map((error) => error.path));
-  const origins = [];
-  const unconfirmed = [];
-  const asked = new Set;
-  const waiting = errors.map((error) => unresolvedClassIn(error.message)).filter((name) => name !== null);
-  while (waiting.length > 0 && asked.size < MOST_CHECKED) {
-    const name = waiting.shift() ?? "";
-    const path = declared.get(name);
-    if (path === undefined || listed.has(path) || asked.has(path)) {
-      continue;
-    }
-    asked.add(path);
-    const checked = await check(path);
-    const own = checked.errors.filter((error) => error.path === path);
-    if (own.length === 0) {
-      unconfirmed.push({
-        path,
-        declares: name,
-        why: checked.failure === null ? "the engine's check of it found no error" : `the engine's check of it did not finish (${checked.failure})`
-      });
-      continue;
-    }
-    for (const error of own) {
-      origins.push({ ...error, declares: name });
-      const deeper = unresolvedClassIn(error.message);
-      if (deeper !== null) {
-        waiting.push(deeper);
-      }
-    }
-  }
-  return { origins, unconfirmed };
-}
-function compileErrorsIn(entries) {
-  return entries.flatMap((entry) => {
-    const at = entry.severity === "error" ? reloadedAt(entry) : null;
-    return at === null ? [] : [{ ...at, message: entry.text }];
-  });
-}
-function reloadedAt(entry) {
-  for (const line of entry.detail) {
-    const at = RELOADED_AT.exec(line.trim());
-    if (at !== null) {
-      return { path: at[1] ?? "", line: Number(at[2]) === 0 ? null : Number(at[2]) };
-    }
-  }
-  return null;
-}
-function checkWithEngine(godotPath, projectPath) {
-  return async (path) => {
-    const logDir = scratchDirectory("tests");
-    try {
-      const ran = await runEngine(godotPath, [
-        "--headless",
-        "--log-file",
-        join31(logDir, "engine.log"),
-        "--path",
-        projectPath,
-        "--check-only",
-        "-s",
-        path
-      ], { timeout: { ms: 60000, said: "minute" } });
-      const errors = ran.log.select({ severity: "error", sinceLastCall: false, limit: 50 }).entries.flatMap((entry) => {
-        const at = reloadedAt(entry);
-        return at === null ? [] : [{ ...at, message: entry.text }];
-      });
-      return { errors, failure: ran.failure === null ? null : howItEnded(ran) };
-    } finally {
-      discard(logDir);
-    }
-  };
-}
-function withoutListed(entries, errors) {
-  if (errors.length === 0) {
-    return [...entries];
-  }
-  const listing = discoveryListing(entries.map((entry) => entry.text));
-  const paths = new Set(errors.map((error) => error.path));
-  return entries.filter((entry, at) => {
-    if (listing !== null && at >= listing.from && at < listing.to) {
-      return false;
-    }
-    const reloaded = reloadedAt(entry);
-    if (reloaded !== null && errors.some((error) => error.path === reloaded.path && error.line === reloaded.line && error.message === entry.text)) {
-      return false;
-    }
-    const failedToLoad = /^Failed to load script "(res:\/\/[^"]+)" with error "[^"]+"\.$/.exec(entry.text);
-    return failedToLoad === null || !paths.has(failedToLoad[1] ?? "");
-  });
-}
-var UNRESOLVED, MOST_CHECKED = 8, RELOADED_AT;
-var init_script_origins = __esm(() => {
-  init_engine_run();
-  init_junit();
-  init_scratch();
-  UNRESOLVED = /Could not resolve class "([A-Za-z_][A-Za-z0-9_]*)", because of a parser error/;
-  RELOADED_AT = /GDScript::reload \((res:\/\/.+):(\d+)\)$/;
-});
-
 // src/script-profile.ts
 import { readFileSync as readFileSync26 } from "node:fs";
 function readProfileFile(path) {
@@ -45660,7 +45679,8 @@ function repeatingScriptError(entries, byScript) {
   if (last === undefined || !byScript(last)) {
     return null;
   }
-  const where = last.detail[0] ?? null;
+  const whole = last.detail.length > 0 ? last : entries.findLast((entry) => entry.text === last.text && entry.detail.length > 0 && byScript(entry)) ?? last;
+  const where = whole.detail[0] ?? null;
   const times = entries.filter((entry) => entry.text === last.text && (entry.detail[0] ?? null) === where && byScript(entry)).length;
   return times >= LOOPING_AFTER ? { text: last.text, where: where?.replace(/^at: /, "") ?? null, times } : null;
 }
@@ -46056,9 +46076,9 @@ function scriptsUnder(directory, prefix) {
   }
   return found;
 }
-function hasMainScene(projectFile) {
+function mainSceneOf(projectFile) {
   const scene = parseProjectGodot(readFileSync27(projectFile, "utf8"))["application"]?.["run/main_scene"];
-  return typeof scene === "string" && scene !== "";
+  return typeof scene === "string" && scene !== "" ? scene : null;
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
   if (projectPath === null) {
@@ -46888,13 +46908,13 @@ class GodotServer {
               stateMachinePath: readString(args, "stateMachinePath") ?? ""
             }), async () => await bridge("read_animation_states"));
           case "create":
-            return await bridge("create_animation");
+            return await editorOrEngine("create_animation", "writes");
           case "add_track":
-            return await bridge("add_animation_track");
+            return await editorOrEngine("add_animation_track", "writes");
           case "add_state":
-            return await bridge("add_animation_state");
+            return await editorOrEngine("add_animation_state", "writes");
           default:
-            return await bridge("connect_animation_states");
+            return await editorOrEngine("connect_animation_states", "writes");
         }
       case "script_edit":
         return await this.handleRenameSymbol(args);
@@ -48038,6 +48058,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
+    const began = Date.now();
     const classes = await this.rebuildClassCache(project.value.path);
     if (!classes.ok) {
       return this.answer(classes);
@@ -48111,6 +48132,7 @@ class GodotServer {
       await untilGone([run.process.pid]);
     }
     await run.settled;
+    const tookMs = Date.now() - began;
     const notCompiled = stopped.for ?? run.log.all.map((entry) => autoloadNotCompiled(entry, autoloaded)).find((found) => found !== null) ?? null;
     const reportsDir = join32(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
@@ -48200,6 +48222,7 @@ class GodotServer {
               passed: false,
               verdict,
               tests: 0,
+              tookMs,
               exitCode,
               exitSignal: run.exitSignal ?? undefined,
               hung,
@@ -48257,6 +48280,7 @@ class GodotServer {
       errors: report.errors,
       skipped: report.skipped,
       time: report.time,
+      tookMs,
       failed,
       failedWithoutDetail: briefed > 0 ? briefed : undefined,
       hookFailures: hookFailures.length > 0 ? hookFailures : undefined,
@@ -49363,7 +49387,7 @@ class GodotServer {
     if (!asked.ok) {
       return asked.response;
     }
-    if (exported === null && !sceneToRun && !hasMainScene(project.value.file)) {
+    if (exported === null && !sceneToRun && mainSceneOf(project.value.file) === null) {
       return this.createErrorResponse("The project sets no main scene, so there is nothing to run.", [
         "Pass scene to run one scene",
         "Choose the main scene with project_settings set_main_scene"
@@ -49440,6 +49464,7 @@ class GodotServer {
       alsoRunning: stranded.length === 0 ? undefined : stranded.map((one) => one.pid),
       pid: started.pid,
       executable: exported?.ok === true ? exported.relativePath : undefined,
+      scene: exported !== null ? undefined : sceneArgument === null ? mainSceneOf(project.value.file) : `res://${sceneArgument}`,
       arguments: cmdArgs,
       argsNote: engineFlagsNote(given.value),
       transcript: started.transcript,
@@ -53360,9 +53385,9 @@ init_setup();
 init_tool_definitions();
 init_tool_reference();
 import { existsSync as existsSync14, mkdirSync as mkdirSync5, readdirSync as readdirSync9, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename as basename6, dirname as dirname8, join as join14 } from "node:path";
+import { basename as basename6, dirname as dirname8, join as join15 } from "node:path";
 var SKILL_NAME = "gdharness";
-var SHARED_SKILLS = join14(".agents", "skills");
+var SHARED_SKILLS = join15(".agents", "skills");
 function skillMarkdown(version) {
   return `---
 name: ${SKILL_NAME}
@@ -53587,27 +53612,27 @@ what they report while starting comes back under \`engine_messages_before_operat
 function skillFiles(version) {
   return new Map([
     ["SKILL.md", skillMarkdown(version)],
-    [join14("references", "tools.md"), renderToolsMarkdown()]
+    [join15("references", "tools.md"), renderToolsMarkdown()]
   ]);
 }
 function skillDirectories(harnesses, projectPath, exists) {
-  const directories = [join14(projectPath, SHARED_SKILLS, SKILL_NAME)];
+  const directories = [join15(projectPath, SHARED_SKILLS, SKILL_NAME)];
   for (const harness of harnesses) {
     if (harness.skills === undefined) {
       continue;
     }
-    const own = join14(projectPath, harness.skills.dir);
-    if ((!harness.skills.shared || exists(own)) && !directories.includes(join14(own, SKILL_NAME))) {
-      directories.push(join14(own, SKILL_NAME));
+    const own = join15(projectPath, harness.skills.dir);
+    if ((!harness.skills.shared || exists(own)) && !directories.includes(join15(own, SKILL_NAME))) {
+      directories.push(join15(own, SKILL_NAME));
     }
   }
   return directories;
 }
 function everySkillDirectory(projectPath, harnesses) {
-  const directories = new Set([join14(projectPath, SHARED_SKILLS, SKILL_NAME)]);
+  const directories = new Set([join15(projectPath, SHARED_SKILLS, SKILL_NAME)]);
   for (const harness of harnesses) {
     if (harness.skills !== undefined) {
-      directories.add(join14(projectPath, harness.skills.dir, SKILL_NAME));
+      directories.add(join15(projectPath, harness.skills.dir, SKILL_NAME));
     }
   }
   return [...directories];
@@ -53624,7 +53649,7 @@ function removeSkill(directories, projectPath) {
   return removed;
 }
 function pruneEmpty(directory, projectPath) {
-  const shared = join14(projectPath, ".agents");
+  const shared = join15(projectPath, ".agents");
   let path = directory;
   while (path !== projectPath && (basename6(path) === "skills" || path === shared)) {
     if (readdirSync9(path).length > 0) {
@@ -53640,7 +53665,7 @@ function writeSkill(directories, version) {
     const replaced = existsSync14(directory);
     rmSync6(directory, { recursive: true, force: true });
     for (const [name, contents] of files) {
-      const path = join14(directory, name);
+      const path = join15(directory, name);
       mkdirSync5(dirname8(path), { recursive: true });
       writeFileSync7(path, contents, "utf8");
     }
@@ -53650,13 +53675,13 @@ function writeSkill(directories, version) {
 
 // src/version.ts
 import { readFileSync as readFileSync12 } from "node:fs";
-import { dirname as dirname9, join as join15 } from "node:path";
+import { dirname as dirname9, join as join16 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getLocalVersion() {
   const currentDirectory = dirname9(fileURLToPath2(import.meta.url));
   const packageCandidates = [
-    join15(currentDirectory, "..", "package.json"),
-    join15(currentDirectory, "..", "..", "package.json")
+    join16(currentDirectory, "..", "package.json"),
+    join16(currentDirectory, "..", "..", "package.json")
   ];
   for (const packagePath of packageCandidates) {
     try {