gdharness 1.2.37 → 1.2.38

package/build/cli.js

@@ -8181,6 +8181,9 @@ class GameLog {
   count(severity) {
     return this.entries.filter((entry) => entry.severity === severity).length;
   }
+  crashReport() {
+    return this.entries.find((entry) => CRASH.test(entry.text));
+  }
   everything() {
     return this.entries;
   }
@@ -8260,21 +8263,98 @@ function runEngine(executable, args, options = {}) {
     });
   });
 }
+function exitCodeText(code) {
+  if (code === null) {
+    return "exit code unknown";
+  }
+  if (code < 3221225472) {
+    return `exit code ${code}`;
+  }
+  const hex = `0x${code.toString(16).toUpperCase()}`;
+  return `exit code ${hex}, ${WINDOWS_STATUSES.get(code) ?? "a Windows error status"}`;
+}
 function howItEnded(run) {
   if (run.failure !== null) {
     return run.exitSignal === null ? run.failure : `ended by ${run.exitSignal}, because ${run.failure}`;
   }
-  return run.exitSignal === null ? `exit code ${run.exitCode ?? "unknown"}` : `ended by ${run.exitSignal}`;
+  return run.exitSignal === null ? exitCodeText(run.exitCode) : `ended by ${run.exitSignal}`;
 }
+var WINDOWS_STATUSES;
 var init_engine_run = __esm(() => {
   init_call_signal();
   init_game_log();
   init_spawn();
+  WINDOWS_STATUSES = new Map([
+    [3221225477, "an access violation, so it crashed"],
+    [3221225501, "an illegal instruction, so it crashed"],
+    [3221225620, "an integer division by zero, so it crashed"],
+    [3221225725, "a stack overflow, so it crashed"],
+    [3221225781, "a library it needs was not found, so it never started"],
+    [3221225786, "its console was closed or sent Ctrl+C"],
+    [3221226356, "a corrupted heap, so it crashed"],
+    [3221226505, "a stack buffer overrun or a fast fail, so it crashed"]
+  ]);
 });
 
-// src/library-copies.ts
-import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync3, renameSync, unlinkSync } from "node:fs";
+// src/doc-cache.ts
+import { existsSync as existsSync5, readdirSync as readdirSync3, statSync as statSync4 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
 import { basename as basename3, dirname as dirname4, isAbsolute as isAbsolute2, join as join5 } from "node:path";
+import process5 from "node:process";
+function editorCacheDirectory(godotPath, platform = process5.platform, env = process5.env, home = homedir3()) {
+  const beside = dirname4(godotPath);
+  const bundle = platform === "darwin" && basename3(beside) === "MacOS" && basename3(dirname4(beside)) === "Contents" ? dirname4(dirname4(dirname4(beside))) : null;
+  for (const folder of bundle === null ? [beside] : [beside, bundle]) {
+    if (existsSync5(join5(folder, "._sc_")) || existsSync5(join5(folder, "_sc_"))) {
+      return join5(folder, "editor_data", "cache");
+    }
+  }
+  if (platform === "win32") {
+    const set = (name) => env[name] === "" ? undefined : env[name];
+    return join5(set("LOCALAPPDATA") ?? set("TEMP") ?? join5(home, "AppData", "Local"), "Godot");
+  }
+  if (platform === "darwin") {
+    return join5(home, "Library", "Caches", "Godot");
+  }
+  const xdg = env["XDG_CACHE_HOME"];
+  return join5(xdg !== undefined && isAbsolute2(xdg) ? xdg : join5(home, ".cache"), "godot");
+}
+function docCachesWritten(directory) {
+  const written = new Map;
+  let names;
+  try {
+    names = readdirSync3(directory);
+  } catch {
+    return written;
+  }
+  for (const name of names.filter((one) => CACHE_FILE.test(one))) {
+    try {
+      written.set(join5(directory, name), statSync4(join5(directory, name)).mtimeMs);
+    } catch {}
+  }
+  return written;
+}
+function docCacheCrash(ran, before, after, what) {
+  const report = ran.log.crashReport();
+  if (ran.exitCode === 0 && ran.exitSignal === null && report === undefined || ran.failure !== null) {
+    return null;
+  }
+  const rewritten = [...after].find(([path, at]) => before.get(path) !== at)?.[0];
+  if (rewritten === undefined) {
+    return null;
+  }
+  const said = report === undefined ? "" : `, and its crash handler printed "${report.text}"`;
+  return `The first ${what} ended badly (${howItEnded(ran)}${said}) after rebuilding the editor's class reference ` + `cache, ${rewritten}. Godot crashes as an import or an export exits when it finds that cache ` + "stale, which it is whenever another build of the same minor version wrote it last, such as 4.7.1 " + `beside 4.7.2, and the crashing run writes a fresh one. So the ${what} was run again, and this answer ` + "is from that second run.";
+}
+var CACHE_FILE;
+var init_doc_cache = __esm(() => {
+  init_engine_run();
+  CACHE_FILE = /^editor_doc_cache-\d+\.\d+\.res$/;
+});
+
+// src/library-copies.ts
+import { existsSync as existsSync6, readdirSync as readdirSync4, readFileSync as readFileSync3, renameSync, unlinkSync } from "node:fs";
+import { basename as basename4, dirname as dirname5, isAbsolute as isAbsolute3, join as join6 } from "node:path";
 function freeLibraryCopies(projectPath, platform = process.platform) {
   const setAside = [];
   const swept = [];
@@ -8282,26 +8362,26 @@ function freeLibraryCopies(projectPath, platform = process.platform) {
     return { setAside, swept };
   }
   for (const library of windowsLibraries(projectPath)) {
-    const folder = dirname4(library);
-    const copy = `~${basename3(library)}`;
-    if (existsSync5(join5(folder, copy))) {
-      const aside = join5(folder, `${copy}.aside-${process.pid}-${Date.now()}`);
+    const folder = dirname5(library);
+    const copy = `~${basename4(library)}`;
+    if (existsSync6(join6(folder, copy))) {
+      const aside = join6(folder, `${copy}.aside-${process.pid}-${Date.now()}`);
       try {
-        renameSync(join5(folder, copy), aside);
+        renameSync(join6(folder, copy), aside);
         setAside.push(aside);
       } catch {}
     }
     let names;
     try {
-      names = readdirSync3(folder);
+      names = readdirSync4(folder);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.length > copy.length && name.toLowerCase().startsWith(copy.toLowerCase())) {
         try {
-          unlinkSync(join5(folder, name));
-          swept.push(join5(folder, name));
+          unlinkSync(join6(folder, name));
+          swept.push(join6(folder, name));
         } catch {}
       }
     }
@@ -8309,7 +8389,7 @@ function freeLibraryCopies(projectPath, platform = process.platform) {
   return { setAside, swept };
 }
 function windowsLibraries(projectPath) {
-  const listed = readOrNull(join5(projectPath, ".godot", "extension_list.cfg"));
+  const listed = readOrNull(join6(projectPath, ".godot", "extension_list.cfg"));
   if (listed === null) {
     return [];
   }
@@ -8328,7 +8408,7 @@ function windowsLibraries(projectPath) {
         continue;
       }
       const named = inLibraries ? /^\s*windows[\w.]*\s*=\s*"([^"]+)"/.exec(row)?.[1] : undefined;
-      const library = named === undefined ? null : resolveResource(projectPath, dirname4(manifest), named);
+      const library = named === undefined ? null : resolveResource(projectPath, dirname5(manifest), named);
       if (library !== null) {
         libraries.add(library);
       }
@@ -8341,9 +8421,9 @@ function resolveResource(projectPath, relativeTo, path) {
     return null;
   }
   if (path.startsWith("res://")) {
-    return join5(projectPath, path.slice("res://".length));
+    return join6(projectPath, path.slice("res://".length));
   }
-  return isAbsolute2(path) ? path : join5(relativeTo, path);
+  return isAbsolute3(path) ? path : join6(relativeTo, path);
 }
 function readOrNull(path) {
   try {
@@ -8356,33 +8436,33 @@ var init_library_copies = () => {};
 
 // src/reimport.ts
 import { createHash } from "node:crypto";
-import { existsSync as existsSync6, readFileSync as readFileSync4, rmSync as rmSync3, statSync as statSync4, utimesSync, writeFileSync as writeFileSync3 } from "node:fs";
-import { basename as basename4, join as join6 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync4, rmSync as rmSync3, statSync as statSync5, utimesSync, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename5, join as join7 } from "node:path";
 function forceNextImport(projectPath, resourcePath) {
   const relative = resourcePath.replace(/^res:\/\//, "");
-  const sidecar = join6(projectPath, `${relative}.import`);
-  if (!existsSync6(sidecar)) {
+  const sidecar = join7(projectPath, `${relative}.import`);
+  if (!existsSync7(sidecar)) {
     return;
   }
-  const { atime, mtimeMs } = statSync4(sidecar);
+  const { atime, mtimeMs } = statSync5(sidecar);
   writeFileSync3(sidecar, readFileSync4(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
   utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
   rmSync3(importRecord(projectPath, resourcePath), { force: true });
 }
 function importRecord(projectPath, resourcePath) {
   const digest = createHash("md5").update(resourcePath).digest("hex");
-  return join6(projectPath, ".godot", "imported", `${basename4(resourcePath)}-${digest}.md5`);
+  return join7(projectPath, ".godot", "imported", `${basename5(resourcePath)}-${digest}.md5`);
 }
 var init_reimport = () => {};
 
 // src/alive.ts
-import process5 from "node:process";
+import process6 from "node:process";
 function alive(pid) {
   if (pid === undefined || pid === null) {
     return false;
   }
   try {
-    process5.kill(pid, 0);
+    process6.kill(pid, 0);
     return true;
   } catch (error) {
     return error.code === "EPERM";
@@ -8391,17 +8471,17 @@ function alive(pid) {
 var init_alive = () => {};
 
 // src/scratch.ts
-import { existsSync as existsSync7, mkdtempSync, readdirSync as readdirSync4, rmSync as rmSync4 } from "node:fs";
+import { existsSync as existsSync8, mkdtempSync, readdirSync as readdirSync5, rmSync as rmSync4 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join7 } from "node:path";
-import process6 from "node:process";
+import { join as join8 } from "node:path";
+import process7 from "node:process";
 function scratchDirectory(kind) {
-  return mkdtempSync(join7(tmpdir2(), `gdharness-${kind}-${process6.pid}-`));
+  return mkdtempSync(join8(tmpdir2(), `gdharness-${kind}-${process7.pid}-`));
 }
 function sweepAbandonedScratch(directory = tmpdir2()) {
   let entries;
   try {
-    entries = readdirSync4(directory);
+    entries = readdirSync5(directory);
   } catch {
     return;
   }
@@ -8412,7 +8492,7 @@ function sweepAbandonedScratch(directory = tmpdir2()) {
       continue;
     }
     try {
-      remove(join7(directory, entry));
+      remove(join8(directory, entry));
     } catch {}
   }
 }
@@ -8450,7 +8530,7 @@ function tryAgain(path, attempt) {
     lastTryOnExit();
   }
   const after = AGAIN_AFTER_MS[attempt];
-  if (after === undefined || !existsSync7(path)) {
+  if (after === undefined || !existsSync8(path)) {
     waiting.delete(path);
     if (after === undefined) {
       atExit.add(path);
@@ -8471,7 +8551,7 @@ function lastTryOnExit() {
     return;
   }
   lastTryWatched = true;
-  process6.once("exit", () => {
+  process7.once("exit", () => {
     for (const path of [...waiting, ...atExit]) {
       try {
         remove(path);
@@ -8498,8 +8578,8 @@ var init_scratch = __esm(() => {
 });
 
 // src/headless.ts
-import { existsSync as existsSync8, readFileSync as readFileSync5, realpathSync as realpathSync2, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname5, join as join8 } from "node:path";
+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)) {
@@ -8560,7 +8640,7 @@ function refusalsIn(log) {
 }
 function scriptFault(problems, script) {
   const spelled = (path) => `(${path.replaceAll("\\", "/").toLowerCase()}/`;
-  const directories = [...new Set([spelled(dirname5(script)), spelled(resolvedOr(dirname5(script)))])];
+  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));
@@ -8598,26 +8678,33 @@ async function runImport(godotPath, projectPath, options = {}) {
   };
   const first = await pass();
   const collided = librariesNotCopied(first.messages);
-  if (collided.length === 0) {
+  const crash = first.docCacheNote;
+  if (collided.length === 0 && crash === undefined) {
     return first;
   }
-  const second = await pass();
+  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,
-    librariesRetried: collided,
-    ...still.length === 0 ? {} : { librariesNotLoaded: still },
-    extensionNote: extensionRetryNote(collided, still)
+    ...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",
-      join8(logDir, "engine.log"),
+      join9(logDir, "engine.log"),
       "--path",
       projectPath,
       "--import"
@@ -8626,24 +8713,26 @@ async function importOnce(godotPath, projectPath) {
     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) };
+    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)
+    ...reported2(problems),
+    ...crash === null ? {} : { docCacheNote: crash }
   };
 }
 async function runOperation(engine, operation, params, projectPath) {
   const paramsDir = scratchDirectory("params");
-  const paramsFile = join8(paramsDir, `${operation}.json`);
-  const answerFile = join8(paramsDir, "answer.json");
+  const paramsFile = join9(paramsDir, `${operation}.json`);
+  const answerFile = join9(paramsDir, "answer.json");
   writeFileSync4(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join8(paramsDir, "engine.log"),
+    join9(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -8731,7 +8820,7 @@ async function runOperation(engine, operation, params, projectPath) {
   };
 }
 function answerIn(file) {
-  if (!existsSync8(file)) {
+  if (!existsSync9(file)) {
     return { kind: "none" };
   }
   const text = readFileSync5(file, "utf8");
@@ -8747,6 +8836,7 @@ function answerIn(file) {
 }
 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();
@@ -8754,9 +8844,9 @@ var init_headless = __esm(() => {
 });
 
 // src/update-check.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
-import { homedir as homedir3, tmpdir as tmpdir3 } from "node:os";
-import { join as join9 } from "node:path";
+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`;
 }
@@ -8776,27 +8866,27 @@ function cacheDirectory(environment) {
     const value = environment[name];
     return value !== undefined && value !== "" ? value : null;
   };
-  const home = set("HOME") ?? homedir3();
+  const home = set("HOME") ?? homedir4();
   if (process.platform === "win32") {
-    return join9(set("LOCALAPPDATA") ?? home, "gdharness");
+    return join10(set("LOCALAPPDATA") ?? home, "gdharness");
   }
   if (process.platform === "darwin") {
-    return join9(home, "Library", "Caches", "gdharness");
+    return join10(home, "Library", "Caches", "gdharness");
   }
-  return join9(set("XDG_CACHE_HOME") ?? join9(home, ".cache"), "gdharness");
+  return join10(set("XDG_CACHE_HOME") ?? join10(home, ".cache"), "gdharness");
 }
 function cacheFile(environment = process.env) {
   try {
     const directory = cacheDirectory(environment);
     mkdirSync3(directory, { recursive: true, mode: 448 });
-    return join9(directory, "update-check.json");
+    return join10(directory, "update-check.json");
   } catch {
-    return join9(tmpdir3(), "gdharness-update-check.json");
+    return join10(tmpdir3(), "gdharness-update-check.json");
   }
 }
 function readCache(path) {
   try {
-    if (!existsSync9(path)) {
+    if (!existsSync10(path)) {
       return null;
     }
     const parsed = JSON.parse(readFileSync6(path, "utf8"));
@@ -9031,7 +9121,7 @@ var init_server_version = __esm(() => {
 
 // src/issues.ts
 import { createHash as createHash2 } from "node:crypto";
-import process7 from "node:process";
+import process8 from "node:process";
 function feedbackNotice(every) {
   return JSON.stringify({
     gdharness_feedback: {
@@ -9042,9 +9132,9 @@ function feedbackNotice(every) {
   }, null, 2);
 }
 function runtime() {
-  const versions = process7.versions;
+  const versions = process8.versions;
   const bun = versions["bun"];
-  return bun === undefined ? `node ${process7.versions.node}` : `bun ${bun}`;
+  return bun === undefined ? `node ${process8.versions.node}` : `bun ${bun}`;
 }
 function defectSignature(where, message) {
   const normalised = `${where}
@@ -9056,7 +9146,7 @@ function facts(where, message, godotVersion) {
     ["Where", where],
     ["Error", message],
     ["Version", `gdharness ${SERVER_VERSION}`],
-    ["Runtime", `${runtime()}, ${process7.platform} ${process7.arch}`],
+    ["Runtime", `${runtime()}, ${process8.platform} ${process8.arch}`],
     ["Godot", godotVersion ?? "not known at the point this failed"],
     ["Signature", defectSignature(where, message)]
   ];
@@ -9066,7 +9156,7 @@ function filledTemplate(where, message, godotVersion) {
     `**gdharness version**: ${SERVER_VERSION}`,
     `**Godot version**: ${godotVersion ?? ""}`,
     `**Bun version**: ${runtime()}`,
-    `**OS**: ${process7.platform} ${process7.arch}`,
+    `**OS**: ${process8.platform} ${process8.arch}`,
     "**MCP client**:",
     "",
     "## What you did",
@@ -9806,8 +9896,8 @@ var init_gdscript_source = __esm(() => {
 });
 
 // src/class-cache.ts
-import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync8, statSync as statSync5 } from "node:fs";
-import { join as join10, posix } from "node:path";
+import { existsSync as existsSync11, readdirSync as readdirSync6, readFileSync as readFileSync8, statSync as statSync6 } from "node:fs";
+import { join as join11, posix } from "node:path";
 function isToolScript(source) {
   return TOOL.test(codeOf(source));
 }
@@ -9823,14 +9913,14 @@ function declaredClasses(projectPath) {
 }
 function eachScript(projectPath, each) {
   const visit = (directory, prefix) => {
-    if (existsSync10(join10(directory, ".gdignore"))) {
+    if (existsSync11(join11(directory, ".gdignore"))) {
       return;
     }
-    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const path = join10(directory, entry.name);
+      const path = join11(directory, entry.name);
       if (entry.isDirectory()) {
         visit(path, `${prefix}${entry.name}/`);
       } else if (entry.isFile() && entry.name.endsWith(".gd")) {
@@ -9856,8 +9946,8 @@ function scriptsNaming(projectPath, classes) {
   return naming.sort((a, b) => a.script.localeCompare(b.script));
 }
 function cachedClasses(projectPath) {
-  const cache = join10(projectPath, ".godot", "global_script_class_cache.cfg");
-  if (!existsSync10(cache)) {
+  const cache = join11(projectPath, ".godot", "global_script_class_cache.cfg");
+  if (!existsSync11(cache)) {
     return null;
   }
   const listed = new Map;
@@ -10127,9 +10217,9 @@ 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 = join10(projectPath, ".godot", "global_script_class_cache.cfg");
+  const cache = join11(projectPath, ".godot", "global_script_class_cache.cfg");
   try {
-    return statSync5(cache).mtimeMs;
+    return statSync6(cache).mtimeMs;
   } catch {
     return null;
   }
@@ -10141,14 +10231,14 @@ function declaredSince(projectPath, paths, names, since) {
       return false;
     }
     try {
-      return statSync5(join10(projectPath, path.slice("res://".length))).mtimeMs > since;
+      return statSync6(join11(projectPath, path.slice("res://".length))).mtimeMs > since;
     } catch {
       return false;
     }
   });
 }
 function cachedAtMissingPaths(cached, projectPath) {
-  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync10(join10(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
+  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync11(join11(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);
@@ -10173,8 +10263,8 @@ var init_class_cache = __esm(() => {
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync11, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "node:fs";
-import { extname, join as join11 } from "node:path";
+import { existsSync as existsSync12, readdirSync as readdirSync7, readFileSync as readFileSync9 } from "node:fs";
+import { extname, join as join12 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
@@ -10182,10 +10272,10 @@ function steppedOver(directory) {
   return gdignored(directory) || installedByUs(directory);
 }
 function gdignored(directory) {
-  return existsSync11(join11(directory, ".gdignore"));
+  return existsSync12(join12(directory, ".gdignore"));
 }
 function installedByUs(directory) {
-  return existsSync11(join11(directory, VERSION_MARKER));
+  return existsSync12(join12(directory, VERSION_MARKER));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -10193,12 +10283,12 @@ function projectStructure(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join11(directory, entry.name));
+        visit(join12(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (SCENE_EXTENSIONS.has(extension)) {
@@ -10222,13 +10312,13 @@ function projectFiles(projectPath, extensions) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join11(directory, entry.name), spelled);
+        visit(join12(directory, entry.name), spelled);
       } else if (entry.isFile() && extensions.includes(extname(entry.name).toLowerCase())) {
         found.push(spelled);
       }
@@ -10243,20 +10333,20 @@ function scriptsWithoutUid(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join11(directory, entry.name), spelled);
+        visit(join12(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync11(join11(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync12(join12(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -10273,11 +10363,11 @@ function projectTexts(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
-      const absolute = join11(directory, entry.name);
+      const absolute = join12(directory, entry.name);
       const spelled = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
         visit(absolute, `${spelled}/`);
@@ -10303,11 +10393,11 @@ function ignoredTexts(projectPath) {
       return;
     }
     const under = ignored || gdignored(directory);
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
-      const absolute = join11(directory, entry.name);
+      const absolute = join12(directory, entry.name);
       const spelled = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
         visit(absolute, `${spelled}/`, under);
@@ -10340,14 +10430,14 @@ function searchProject(projectPath, options) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync6(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(directory, { withFileTypes: true })) {
       if (full()) {
         return;
       }
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join11(directory, entry.name);
+      const entryPath = join12(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -10792,16 +10882,16 @@ function readParams(params, key) {
 import { createHash as createHash3 } from "node:crypto";
 import {
   cpSync,
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync4,
-  readdirSync as readdirSync7,
+  readdirSync as readdirSync8,
   readFileSync as readFileSync11,
   rmdirSync,
   rmSync as rmSync5,
-  statSync as statSync6,
+  statSync as statSync7,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname6, join as join12 } from "node:path";
+import { dirname as dirname7, join as join13 } from "node:path";
 import { fileURLToPath } from "node:url";
 function editorAddonDigest(from = shippedAddonsDirectory()) {
   return addonsDigest(EDITOR_PLUGINS, from);
@@ -10812,13 +10902,13 @@ function runtimeAddonDigest(from = shippedAddonsDirectory()) {
 function addonsDigest(names, from) {
   const hash = createHash3("sha256");
   const walk = (directory, relative) => {
-    for (const name of readdirSync7(directory).sort()) {
+    for (const name of readdirSync8(directory).sort()) {
       if (name === VERSION_MARKER || name === DIGEST_MARKER) {
         continue;
       }
-      const path = join12(directory, name);
+      const path = join13(directory, name);
       const inside = `${relative}/${name}`;
-      if (statSync6(path).isDirectory()) {
+      if (statSync7(path).isDirectory()) {
         walk(path, inside);
       } else {
         hash.update(`${inside}
@@ -10830,7 +10920,7 @@ function addonsDigest(names, from) {
     }
   };
   for (const name of names) {
-    walk(join12(from, name), name);
+    walk(join13(from, name), name);
   }
   return hash.digest("hex");
 }
@@ -10861,44 +10951,44 @@ function installedRuntimeDigest(projectPath) {
   return digestMarker(projectPath, RUNTIME_ADDON);
 }
 function digestMarker(projectPath, addon) {
-  const marker = join12(projectPath, "addons", addon, DIGEST_MARKER);
-  if (!existsSync12(marker)) {
+  const marker = join13(projectPath, "addons", addon, DIGEST_MARKER);
+  if (!existsSync13(marker)) {
     return null;
   }
   const said = readFileSync11(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function shippedAddonsDirectory() {
-  return join12(dirname6(fileURLToPath(import.meta.url)), "godot", "addons");
+  return join13(dirname7(fileURLToPath(import.meta.url)), "godot", "addons");
 }
 function shippedOperationsScript() {
-  return join12(dirname6(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
+  return join13(dirname7(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
 }
 function installAddons(projectPath, from = shippedAddonsDirectory()) {
   const installed = [];
   for (const name of ADDONS) {
-    const source = join12(from, name);
-    if (!existsSync12(join12(source, name === RUNTIME_ADDON ? "runtime_autoload.gd" : "plugin.cfg"))) {
+    const source = join13(from, name);
+    if (!existsSync13(join13(source, name === RUNTIME_ADDON ? "runtime_autoload.gd" : "plugin.cfg"))) {
       throw new Error(`The package holds no ${name} addon at ${source}.`);
     }
-    const target = join12(projectPath, "addons", name);
-    const replaced = existsSync12(target);
+    const target = join13(projectPath, "addons", name);
+    const replaced = existsSync13(target);
     rmSync5(target, { recursive: true, force: true });
-    mkdirSync4(dirname6(target), { recursive: true });
+    mkdirSync4(dirname7(target), { recursive: true });
     cpSync(source, target, { recursive: true });
-    writeFileSync6(join12(target, VERSION_MARKER), `${SERVER_VERSION}
+    writeFileSync6(join13(target, VERSION_MARKER), `${SERVER_VERSION}
 `);
     installed.push({ name, path: target, replaced });
   }
-  writeFileSync6(join12(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
+  writeFileSync6(join13(projectPath, "addons", ADDONS[0], DIGEST_MARKER), `${editorAddonDigest(from)}
 `);
-  writeFileSync6(join12(projectPath, "addons", RUNTIME_ADDON, DIGEST_MARKER), `${runtimeAddonDigest(from)}
+  writeFileSync6(join13(projectPath, "addons", RUNTIME_ADDON, DIGEST_MARKER), `${runtimeAddonDigest(from)}
 `);
   return installed;
 }
 function installedAddonVersion(projectPath) {
-  const marker = join12(projectPath, "addons", ADDONS[0], VERSION_MARKER);
-  if (!existsSync12(marker)) {
+  const marker = join13(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  if (!existsSync13(marker)) {
     return null;
   }
   const said = readFileSync11(marker, "utf8").trim();
@@ -10907,14 +10997,14 @@ function installedAddonVersion(projectPath) {
 function removeAddons(projectPath) {
   const removed = [];
   for (const name of ADDONS) {
-    const target = join12(projectPath, "addons", name);
-    if (existsSync12(target)) {
+    const target = join13(projectPath, "addons", name);
+    if (existsSync13(target)) {
       rmSync5(target, { recursive: true, force: true });
       removed.push(target);
     }
   }
-  const addons = join12(projectPath, "addons");
-  if (removed.length > 0 && existsSync12(addons) && readdirSync7(addons).length === 0) {
+  const addons = join13(projectPath, "addons");
+  if (removed.length > 0 && existsSync13(addons) && readdirSync8(addons).length === 0) {
     rmdirSync(addons);
     removed.push(addons);
   }
@@ -10948,7 +11038,7 @@ function loaderAmong(projectPath, named) {
     }
     let source = null;
     try {
-      source = readFileSync11(join12(projectPath, path), "utf8");
+      source = readFileSync11(join13(projectPath, path), "utf8");
     } catch {}
     if (source?.includes(RUNTIME_AUTOLOAD.path)) {
       return { name: entry, path, exists: true };
@@ -10990,10 +11080,10 @@ function enabledPlugins(settings) {
 function inspectProject(projectPath) {
   const problems = [];
   const addons = ADDONS.map((name) => {
-    const directory = join12(projectPath, "addons", name);
-    const marker = join12(directory, VERSION_MARKER);
-    const installed = existsSync12(directory);
-    const version = existsSync12(marker) ? readFileSync11(marker, "utf8").trim() : null;
+    const directory = join13(projectPath, "addons", name);
+    const marker = join13(directory, VERSION_MARKER);
+    const installed = existsSync13(directory);
+    const version = existsSync13(marker) ? readFileSync11(marker, "utf8").trim() : null;
     const current = version === SERVER_VERSION;
     if (!installed) {
       problems.push(`addons/${name} is not installed; run gdharness setup`);
@@ -11002,7 +11092,7 @@ function inspectProject(projectPath) {
     }
     return { name, installed, version, current };
   });
-  const settings = parseProjectGodot(readFileSync11(join12(projectPath, "project.godot"), "utf8"));
+  const settings = parseProjectGodot(readFileSync11(join13(projectPath, "project.godot"), "utf8"));
   const pluginsEnabled = enabledPlugins(settings);
   for (const name of EDITOR_PLUGINS) {
     if (!pluginsEnabled.includes(name)) {
@@ -11018,7 +11108,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 (!existsSync12(join12(projectPath, path))) {
+    if (!existsSync13(join13(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`);
       }
@@ -11679,7 +11769,7 @@ var init_tool_definitions = __esm(() => {
         rootNodeType: {
           type: "string",
           ops: ["create"],
-          description: "create: the root node class. Default Node."
+          description: "create: the root node class, an engine class or a class_name a project script declares, which the root is made as with that script attached. Default Node."
         },
         rootNodeName: {
           type: "string",
@@ -11717,7 +11807,7 @@ var init_tool_definitions = __esm(() => {
     {
       name: "scene_node",
       title: "Scene nodes",
-      description: `One node in a scene file: add, read, set, duplicate, reparent or delete it, or paint TileMap cells. Any ClassDB node type can be added, so a NavigationRegion2D, an AnimationTree or a Camera3D is an add with that nodeType and its properties, and another scene is instanced by an add with instancePath. A set with properties {"name": "Boss"} renames a node. A property holding a Resource takes the res:// path of one, so a texture, a material or a theme is a set like any other. A write is refused while the editor holds unsaved changes to the scene, and for a node that belongs to a scene this one instances or inherits. ${WITHOUT_AN_EDITOR}`,
+      description: `One node in a scene file: add, read, set, duplicate, reparent or delete it, or paint TileMap cells. Any ClassDB node type or script class can be added, so a NavigationRegion2D, an AnimationTree or a Camera3D is an add with that nodeType and its properties, and another scene is instanced by an add with instancePath. A set with properties {"name": "Boss"} renames a node. A property holding a Resource takes the res:// path of one, so a texture, a material or a theme is a set like any other. A write is refused while the editor holds unsaved changes to the scene, and for a node that belongs to a scene this one instances or inherits. ${WITHOUT_AN_EDITOR}`,
       parameters: {
         projectPath: PROJECT_PATH,
         scenePath: SCENE_PATH,
@@ -11730,7 +11820,7 @@ var init_tool_definitions = __esm(() => {
         nodeType: {
           type: "string",
           ops: ["add"],
-          description: 'add: the node class, such as "CharacterBody2D". Give this or instancePath.'
+          description: 'add: the node class, such as "CharacterBody2D", or a class_name a project script declares, which the node is made as with that script attached. Give this or instancePath.'
         },
         instancePath: {
           type: "string",
@@ -12075,7 +12165,7 @@ var init_tool_definitions = __esm(() => {
         resourceType: {
           type: "string",
           ops: ["create"],
-          description: 'create: the resource class, such as "PhysicsMaterial" or "StandardMaterial3D".'
+          description: 'create: the resource class, such as "PhysicsMaterial" or "StandardMaterial3D", or a class_name a project script declares, which the resource is made as with that script attached.'
         },
         properties: { ...PROPERTIES, ops: ["create", "modify"] },
         script: {
@@ -12269,6 +12359,17 @@ var init_tool_definitions = __esm(() => {
           ops: ["profile"],
           description: "profile: also answer, under callers, where the project's scripts name this function in code: its name, or Class.name for the functions of one class. Each place has its script, line, the named function it is written in (within), whether the function is called there or passed on as a Callable (called), and the profile's calls, self and total milliseconds for the function it is in, those taking the most time first, forty at most. Found by name in the source, since the engine's profiler records nothing about who made a call, so a method of the same name on another class is listed too, except, when Class.name was asked, one called through another class of the project by name or through a parameter, local or class variable declared as one, and a call made through a string is not. A parameter, local or class variable of the same name is not the function and is not listed. A property's get or set block, which the profile names Class.@name_getter or Class.@name_setter, is asked about by that name or by the property's: the places are where the property is named, each saying instead of called whether it writes the property (access write), which runs the set block, or reads it (access read), which runs the get block, and the rows are both blocks'. Inside the property's own blocks its name is the value stored, which the engine reads and writes without running them, so those lines are not places."
         },
+        mark: {
+          type: "boolean",
+          ops: ["profile"],
+          description: `profile: answer as usual and set the run's mark at these totals, so a later profile with since: "mark" answers for one action, a press or a commit, apart from the boot and everything before it. The mark is kept beside the run's profile, so a server that replaces this one reads it too, and setting it again moves it. Given with since, the answer counts from the mark before it moves, which times one span after another. Default false.`
+        },
+        since: {
+          type: "string",
+          enum: ["mark"],
+          ops: ["profile"],
+          description: 'profile: "mark" answers only what was added after the mark that mark: true set in this run: per function the calls and self and total milliseconds since it, with the functions that added no call left out, frames and coveredMs since it, and callersOf read off the same difference. Refused when no mark was set in this run, or when the profile holds less than it did at the mark, which is a profiler started again since.'
+        },
         limit: {
           type: "integer",
           minimum: 1,
@@ -12320,7 +12421,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. 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. 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.",
+      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. 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. 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"
     },
     {
@@ -32796,7 +32897,7 @@ var init_ajvProvider_CEoC__sr = __esm(() => {
 });
 
 // node_modules/@modelcontextprotocol/server/dist/shimsNode.mjs
-import process9 from "node:process";
+import process10 from "node:process";
 var init_shimsNode = __esm(() => {
   init_ajvProvider_CEoC__sr();
 });
@@ -34610,7 +34711,7 @@ var swallowsErrorsAfterClose, StdioServerTransport = class {
   _readBuffer;
   _started = false;
   _closed = false;
-  constructor(_stdin = process9.stdin, _stdout = process9.stdout, options) {
+  constructor(_stdin = process10.stdin, _stdout = process10.stdout, options) {
     this._stdin = _stdin;
     this._stdout = _stdout;
     this._readBuffer = new ReadBuffer({ maxBufferSize: options?.maxBufferSize });
@@ -34799,10 +34900,10 @@ var init_stdio = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync14, readdirSync as readdirSync9, readFileSync as readFileSync13, statSync as statSync7, unlinkSync as unlinkSync2 } from "node:fs";
+import { existsSync as existsSync15, readdirSync as readdirSync10, readFileSync as readFileSync13, statSync as statSync8, unlinkSync as unlinkSync2 } from "node:fs";
 import { createConnection } from "node:net";
 import { tmpdir as tmpdir4 } from "node:os";
-import { dirname as dirname9, join as join15, resolve as resolve4 } from "node:path";
+import { dirname as dirname10, join as join16, 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);
@@ -34810,20 +34911,20 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join15(perUser ?? tmpdir4(), "gdharness");
+  return join16(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(join15(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+    candidates.push(join16(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 = join15(directory, `runtime-${pid}.log`);
-    if (existsSync14(path)) {
+    const path = join16(directory, `runtime-${pid}.log`);
+    if (existsSync15(path)) {
       return path;
     }
   }
@@ -34871,7 +34972,7 @@ function parseAnnouncement(file, pid) {
   };
   let announcedAt;
   try {
-    announcedAt = statSync7(file).mtimeMs;
+    announcedAt = statSync8(file).mtimeMs;
   } catch {}
   const when = announcedAt === undefined ? {} : { announcedAt };
   if (protocol !== RUNTIME_PROTOCOL) {
@@ -34963,29 +35064,29 @@ function strangersAmong(candidates, now, startTimes = startTimesOf) {
   }).map((one) => one.file));
 }
 function announcedIn(directory) {
-  if (!existsSync14(directory)) {
+  if (!existsSync15(directory)) {
     return [];
   }
   const found = [];
   const candidates = [];
   const entries = [];
-  for (const entry of readdirSync9(directory)) {
+  for (const entry of readdirSync10(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
-      sweepErrorReport(join15(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      sweepErrorReport(join16(directory, entry), Number.parseInt(report[1] ?? "", 10));
       continue;
     }
     const match = ANNOUNCEMENT_PATTERN.exec(entry);
     if (!match) {
       continue;
     }
-    const file = join15(directory, entry);
+    const file = join16(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const running = alive(pid);
     entries.push({ file, pid, running });
     if (running) {
       try {
-        candidates.push({ file, pid, writtenAt: statSync7(file).mtimeMs });
+        candidates.push({ file, pid, writtenAt: statSync8(file).mtimeMs });
       } catch {}
     }
   }
@@ -35007,16 +35108,16 @@ function announcedIn(directory) {
     found.push(announced);
   }
   const held = new Set(entries.map((one) => one.file));
-  const here = join15(directory, ".");
+  const here = join16(directory, ".");
   for (const file of verdicts.keys()) {
-    if (dirname9(file) === here && !held.has(file)) {
+    if (dirname10(file) === here && !held.has(file)) {
       verdicts.delete(file);
     }
   }
   return found;
 }
 async function announcementEnded(pid, directories = runtimeDirectories()) {
-  const files = directories.map((directory) => join15(directory, `runtime-${pid}.json`)).filter((file) => existsSync14(file));
+  const files = directories.map((directory) => join16(directory, `runtime-${pid}.json`)).filter((file) => existsSync15(file));
   const first = files[0];
   if (first === undefined) {
     return;
@@ -35042,7 +35143,7 @@ function sweepErrorReport(path, pid, now = Date.now()) {
     return;
   }
   try {
-    if (now - statSync7(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
+    if (now - statSync8(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
       unlinkSync2(path);
     }
   } catch {}
@@ -35318,9 +35419,9 @@ var init_runtime_client = __esm(() => {
 
 // src/boot-note.ts
 import { mkdirSync as mkdirSync6, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname10, join as join16 } from "node:path";
+import { dirname as dirname11, join as join17 } from "node:path";
 function bootNotePath(projectPath) {
-  return join16(projectPath, ".godot", "gdharness-boot.json");
+  return join17(projectPath, ".godot", "gdharness-boot.json");
 }
 function readScenes(projectPath) {
   try {
@@ -35340,7 +35441,7 @@ function readBootNote(projectPath, scene) {
 function writeBootNote(projectPath, scene, announcedAfterMs) {
   try {
     const path = bootNotePath(projectPath);
-    mkdirSync6(dirname10(path), { recursive: true });
+    mkdirSync6(dirname11(path), { recursive: true });
     const scenes = {
       ...readScenes(projectPath),
       [scene]: {
@@ -35367,9 +35468,9 @@ var init_boot_note = __esm(() => {
 
 // src/breakpoint-note.ts
 import { mkdirSync as mkdirSync7, readFileSync as readFileSync15, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname11, isAbsolute as isAbsolute3, join as join17, relative as relative3 } from "node:path";
+import { dirname as dirname12, isAbsolute as isAbsolute4, join as join18, relative as relative3 } from "node:path";
 function breakpointNotePath(projectPath) {
-  return join17(projectPath, ".godot", "gdharness-breakpoints.json");
+  return join18(projectPath, ".godot", "gdharness-breakpoints.json");
 }
 function writeBreakpointNote(projectPath, held) {
   const path = breakpointNotePath(projectPath);
@@ -35386,7 +35487,7 @@ function writeBreakpointNote(projectPath, held) {
         lines: [...one.lines]
       }))
     };
-    mkdirSync7(dirname11(path), { recursive: true });
+    mkdirSync7(dirname12(path), { recursive: true });
     writeFileSync9(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
@@ -35405,12 +35506,12 @@ function readBreakpointNote(projectPath) {
         continue;
       }
       const { script, lines: listed } = entry;
-      if (typeof script !== "string" || isAbsolute3(script) || script.split("/").includes("..")) {
+      if (typeof script !== "string" || isAbsolute4(script) || script.split("/").includes("..")) {
         continue;
       }
       const lines = Array.isArray(listed) ? listed.filter((line) => Number.isInteger(line) && line > 0) : [];
       if (lines.length > 0) {
-        held.push({ scriptPath: realPathOr(join17(projectPath, script)), lines });
+        held.push({ scriptPath: realPathOr(join18(projectPath, script)), lines });
       }
     }
     return held;
@@ -35420,7 +35521,7 @@ function readBreakpointNote(projectPath) {
 }
 function withinProject(projectPath, scriptPath) {
   const rel = relative3(projectPath, scriptPath);
-  return rel !== "" && !rel.startsWith("..") && !isAbsolute3(rel);
+  return rel !== "" && !rel.startsWith("..") && !isAbsolute4(rel);
 }
 var init_breakpoint_note = __esm(() => {
   init_errors();
@@ -35460,9 +35561,9 @@ var init_whole_file = __esm(() => {
 
 // src/class-note.ts
 import { mkdirSync as mkdirSync8, readFileSync as readFileSync16 } from "node:fs";
-import { dirname as dirname12, join as join18 } from "node:path";
+import { dirname as dirname13, join as join19 } from "node:path";
 function classNotePath(projectPath) {
-  return join18(projectPath, ".godot", "gdharness-classes.json");
+  return join19(projectPath, ".godot", "gdharness-classes.json");
 }
 function readClassNote(projectPath) {
   try {
@@ -35496,7 +35597,7 @@ function unfinishedScanIn(value) {
 function writeClassNote(projectPath, note) {
   const path = classNotePath(projectPath);
   try {
-    mkdirSync8(dirname12(path), { recursive: true });
+    mkdirSync8(dirname13(path), { recursive: true });
   } catch {
     return;
   }
@@ -35508,11 +35609,11 @@ var init_class_note = __esm(() => {
 });
 
 // src/config-pin.ts
-import { existsSync as existsSync15, readFileSync as readFileSync17 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync16, readFileSync as readFileSync17 } from "node:fs";
+import { join as join20 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join19(projectPath, ".mcp.json");
-  if (!existsSync15(config)) {
+  const config = join20(projectPath, ".mcp.json");
+  if (!existsSync16(config)) {
     return [];
   }
   let text;
@@ -35538,22 +35639,22 @@ var init_config_pin = __esm(() => {
 });
 
 // src/cut-test-run.ts
-import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync18, rmSync as rmSync9, writeFileSync as writeFileSync11 } from "node:fs";
-import { dirname as dirname13, join as join20 } from "node:path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync9, readFileSync as readFileSync18, rmSync as rmSync9, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname14, join as join21 } from "node:path";
 function keptAt(projectPath) {
-  return join20(projectPath, ".godot", "gdharness-reports", "cut-run.json");
+  return join21(projectPath, ".godot", "gdharness-reports", "cut-run.json");
 }
 function keepCutTestRun(projectPath, run) {
   const path = keptAt(projectPath);
   try {
-    mkdirSync9(dirname13(path), { recursive: true });
+    mkdirSync9(dirname14(path), { recursive: true });
     writeFileSync11(path, `${JSON.stringify(run, null, 2)}
 `, "utf8");
   } catch {}
 }
 function takeCutTestRun(projectPath) {
   const path = keptAt(projectPath);
-  if (!existsSync16(path)) {
+  if (!existsSync17(path)) {
     return null;
   }
   try {
@@ -36370,27 +36471,27 @@ var init_dap_client = __esm(() => {
 import { createHash as createHash4 } from "node:crypto";
 import {
   closeSync,
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   mkdtempSync as mkdtempSync2,
   openSync,
   readFileSync as readFileSync19,
   rmSync as rmSync10,
-  statSync as statSync8,
+  statSync as statSync9,
   writeFileSync as writeFileSync12,
   writeSync
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 function helperAssembly(directory = tmpdir5()) {
-  return join21(directory, `gdharness-desktop-${DIGEST}.dll`);
+  return join22(directory, `gdharness-desktop-${DIGEST}.dll`);
 }
 async function ensureHelperCompiled(directory = tmpdir5(), budgetMs = HELPER_COMPILE_MS, wait = true) {
   const assembly = helperAssembly(directory);
   const lock = `${assembly}.compiling`;
   const until = Date.now() + budgetMs;
   while (Date.now() < until) {
-    if (existsSync17(assembly)) {
+    if (existsSync18(assembly)) {
       return null;
     }
     let mine = false;
@@ -36409,7 +36510,7 @@ async function ensureHelperCompiled(directory = tmpdir5(), budgetMs = HELPER_COM
     }
     try {
       const holder = Number(readFileSync19(lock, "utf8").trim());
-      const old = Date.now() - statSync8(lock).mtimeMs > budgetMs;
+      const old = Date.now() - statSync9(lock).mtimeMs > budgetMs;
       if (old || Number.isInteger(holder) && holder > 0 && !alive(holder)) {
         rmSync10(lock, { force: true });
         continue;
@@ -36423,8 +36524,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(join21(directory, "gdharness-desktop-source-"));
-  const source = join21(scratch, "helper.cs");
+  const scratch = mkdtempSync2(join22(directory, "gdharness-desktop-source-"));
+  const source = join22(scratch, "helper.cs");
   writeFileSync12(source, SOURCE, "utf8");
   const literal = (path) => `'${path.replaceAll("'", "''")}'`;
   const script = [
@@ -36462,7 +36563,7 @@ async function compileHelper(directory, assembly, budgetMs) {
       });
       compiler.once("close", (code) => {
         clearTimeout(timer);
-        resolve(existsSync17(assembly) ? null : `Windows PowerShell could not compile it${code === null ? " in time" : ""}: ${complained.trim() || `exit code ${String(code)}`}`);
+        resolve(existsSync18(assembly) ? null : `Windows PowerShell could not compile it${code === null ? " in time" : ""}: ${complained.trim() || `exit code ${String(code)}`}`);
       });
     });
   } finally {
@@ -36629,21 +36730,21 @@ var init_desktop = __esm(() => {
 // src/editor-log.ts
 import {
   closeSync as closeSync2,
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   mkdirSync as mkdirSync10,
   openSync as openSync2,
   readFileSync as readFileSync20,
   readSync,
   rmSync as rmSync11,
-  statSync as statSync9,
+  statSync as statSync10,
   writeFileSync as writeFileSync13
 } from "node:fs";
-import { dirname as dirname14, join as join22 } from "node:path";
+import { dirname as dirname15, join as join23 } from "node:path";
 function editorLogPath(projectPath) {
-  return join22(projectPath, ".godot", "gdharness-editor.log");
+  return join23(projectPath, ".godot", "gdharness-editor.log");
 }
 function editorLogNotePath(projectPath) {
-  return join22(projectPath, ".godot", "gdharness-editor.json");
+  return join23(projectPath, ".godot", "gdharness-editor.json");
 }
 function readEditorLogNote(projectPath) {
   try {
@@ -36658,7 +36759,7 @@ function readEditorLogNote(projectPath) {
 function clearEditorLog(projectPath) {
   try {
     const path = editorLogPath(projectPath);
-    mkdirSync10(dirname14(path), { recursive: true });
+    mkdirSync10(dirname15(path), { recursive: true });
     rmSync11(path, { force: true });
     rmSync11(editorLogNotePath(projectPath), { force: true });
   } catch {}
@@ -36666,7 +36767,7 @@ function clearEditorLog(projectPath) {
 function writeEditorLogNote(projectPath, pid) {
   try {
     const path = editorLogNotePath(projectPath);
-    mkdirSync10(dirname14(path), { recursive: true });
+    mkdirSync10(dirname15(path), { recursive: true });
     writeFileSync13(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
@@ -36688,7 +36789,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
     return { kind: "older server", notedPid: noted?.pid ?? null };
   }
   const path = editorLogPath(projectPath);
-  if (!existsSync18(path)) {
+  if (!existsSync19(path)) {
     return { kind: "not written" };
   }
   const log = new GameLog;
@@ -36744,7 +36845,7 @@ function foldProgress(text) {
 `);
 }
 function theFirstOf(path) {
-  const whole = statSync9(path).size;
+  const whole = statSync10(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
     return { text: readFileSync20(path, "utf8") };
   }
@@ -36907,8 +37008,8 @@ var init_editor_log = __esm(() => {
 });
 
 // src/rename.ts
-import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync21, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync14 } from "node:fs";
-import { dirname as dirname15, posix as posix2 } from "node:path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync11, readFileSync as readFileSync21, renameSync as renameSync3, unlinkSync as unlinkSync3, writeFileSync as writeFileSync14 } from "node:fs";
+import { dirname as dirname16, posix as posix2 } from "node:path";
 
 class Script {
   path;
@@ -37616,21 +37717,21 @@ function applyRewrites(rewrites) {
     if (now !== rewrite.before) {
       throw new Error(`${rewrite.path} changed on disk while the rename was being worked out; nothing was written`);
     }
-    if (rewrite.writeTo !== rewrite.absolute && existsSync19(rewrite.writeTo)) {
+    if (rewrite.writeTo !== rewrite.absolute && existsSync20(rewrite.writeTo)) {
       throw new Error(`${rewrite.writeTo} already exists; nothing was written`);
     }
   }
   const done = [];
   try {
     for (const rewrite of rewrites) {
-      mkdirSync11(dirname15(rewrite.writeTo), { recursive: true });
+      mkdirSync11(dirname16(rewrite.writeTo), { recursive: true });
       const staging = `${rewrite.writeTo}.gdharness-rename`;
       writeFileSync14(staging, rewrite.after, "utf8");
       renameSync3(staging, rewrite.writeTo);
       let movedUid = false;
       if (rewrite.writeTo !== rewrite.absolute) {
         unlinkSync3(rewrite.absolute);
-        if (existsSync19(`${rewrite.absolute}.uid`)) {
+        if (existsSync20(`${rewrite.absolute}.uid`)) {
           renameSync3(`${rewrite.absolute}.uid`, `${rewrite.writeTo}.uid`);
           movedUid = true;
         }
@@ -37676,10 +37777,10 @@ var init_rename = __esm(() => {
 });
 
 // src/lsp_client.ts
-import { existsSync as existsSync20, realpathSync as realpathSync4 } from "node:fs";
+import { existsSync as existsSync21, realpathSync as realpathSync4 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname16, join as join23, resolve as resolve5 } from "node:path";
+import { dirname as dirname17, join as join24, resolve as resolve5 } from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function initializeTimeoutMs() {
@@ -37841,7 +37942,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname16(resolve5(filePath));
+    const rootPath = this.rootPath ?? dirname17(resolve5(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params, timeoutMs = this.timeouts.requestMs) {
@@ -38357,7 +38458,7 @@ async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   } catch {
     throw new ArgumentRefusal(`Project path does not exist: ${requestedProjectPath}`);
   }
-  if (!existsSync20(join23(projectPath, "project.godot"))) {
+  if (!existsSync21(join24(projectPath, "project.godot"))) {
     throw new ArgumentRefusal(`Not a Godot project: ${projectPath}. Point projectPath at the directory holding project.godot.`);
   }
   const contained = resolveWithinProject(projectPath, scriptPathValue);
@@ -38517,8 +38618,8 @@ var init_lsp_client = __esm(() => {
 });
 
 // src/rename-symbol.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync12, readdirSync as readdirSync10, realpathSync as realpathSync5, rmSync as rmSync12, writeFileSync as writeFileSync15 } from "node:fs";
-import { basename as basename6, dirname as dirname17, join as join24, relative as relative4, resolve as resolve6 } from "node:path";
+import { existsSync as existsSync22, 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 join25, 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)) {
@@ -38531,13 +38632,13 @@ function onDiskSpelling(path) {
   let at = resolve6(path);
   for (;; ) {
     try {
-      return join24(realpathSync5.native(at), ...missing.reverse());
+      return join25(realpathSync5.native(at), ...missing.reverse());
     } catch {
-      const parent = dirname17(at);
+      const parent = dirname18(at);
       if (parent === at) {
         return resolve6(path);
       }
-      missing.push(basename6(at));
+      missing.push(basename7(at));
       at = parent;
     }
   }
@@ -38584,7 +38685,7 @@ async function renameSymbol(request, services) {
         reason: `newScriptPath must be a .gd path inside the project, and ${request.newScriptPath} is not.`
       };
     }
-    if (existsSync21(request.newScriptPath)) {
+    if (existsSync22(request.newScriptPath)) {
       return { ok: false, reason: `${moveTo} already exists, so the script cannot be moved there.` };
     }
   }
@@ -38760,7 +38861,7 @@ async function renameSymbol(request, services) {
       scripts,
       moves: new Map([[declaringPath, moveTo]]),
       named: [declaringPath],
-      exists: (path) => existsSync21(`${projectPath}/${path.slice("res://".length)}`)
+      exists: (path) => existsSync22(`${projectPath}/${path.slice("res://".length)}`)
     }, plan);
   }
   plan = mentionIgnored(plan, ignoredTexts(projectPath), symbol, moveTo === null ? [] : [declaringPath]);
@@ -38959,15 +39060,15 @@ ${mention.kind}`;
   };
 }
 function writeLeftAloneDetail(projectPath, symbol, detail) {
-  const directory = join24(projectPath, ".godot", "gdharness-renames");
+  const directory = join25(projectPath, ".godot", "gdharness-renames");
   mkdirSync12(directory, { recursive: true });
   detailWrites += 1;
-  const path = join24(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
+  const path = join25(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
   writeFileSync15(path, `${JSON.stringify(detail, null, 2)}
 `, "utf8");
-  const kept = readdirSync10(directory).filter((name) => name.endsWith(".json")).sort().reverse();
+  const kept = readdirSync11(directory).filter((name) => name.endsWith(".json")).sort().reverse();
   for (const old of kept.slice(10)) {
-    rmSync12(join24(directory, old), { force: true });
+    rmSync12(join25(directory, old), { force: true });
   }
   return path;
 }
@@ -39008,25 +39109,25 @@ var init_rename_symbol = __esm(() => {
 
 // src/file-move.ts
 import {
-  existsSync as existsSync22,
+  existsSync as existsSync23,
   mkdirSync as mkdirSync13,
-  readdirSync as readdirSync11,
+  readdirSync as readdirSync12,
   readFileSync as readFileSync22,
   renameSync as renameSync4,
-  statSync as statSync10,
+  statSync as statSync11,
   writeFileSync as writeFileSync16
 } from "node:fs";
-import { basename as basename7, dirname as dirname18, extname as extname3, join as join25, relative as relative5 } from "node:path";
+import { basename as basename8, dirname as dirname19, extname as extname3, join as join26, relative as relative5 } from "node:path";
 function filesUnder(directory) {
-  return readdirSync11(directory, { withFileTypes: true }).flatMap((entry) => {
-    const path = join25(directory, entry.name);
+  return readdirSync12(directory, { withFileTypes: true }).flatMap((entry) => {
+    const path = join26(directory, entry.name);
     return entry.isDirectory() ? filesUnder(path) : [path];
   });
 }
 function sameFile(one, other) {
   try {
-    const a = statSync10(one);
-    const b = statSync10(other);
+    const a = statSync11(one);
+    const b = statSync11(other);
     return a.ino === b.ino && a.dev === b.dev;
   } catch {
     return false;
@@ -39040,8 +39141,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 = join25(directory, step);
-      if (existsSync22(join25(directory, ".gdignore"))) {
+      directory = join26(directory, step);
+      if (existsSync23(join26(directory, ".gdignore"))) {
         return `${path} is under a directory holding a .gdignore, which the engine does not load`;
       }
     }
@@ -39053,21 +39154,21 @@ function installedAddonOf(projectPath, path) {
   if (steps[0] !== "addons" || steps[1] === undefined) {
     return null;
   }
-  return existsSync22(join25(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
+  return existsSync23(join26(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
 }
 function binaryResources(projectPath) {
   const found = [];
   const visit = (directory, prefix) => {
-    if (existsSync22(join25(directory, ".gdignore"))) {
+    if (existsSync23(join26(directory, ".gdignore"))) {
       return;
     }
-    for (const entry of readdirSync11(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync12(directory, { withFileTypes: true })) {
       if (entry.name.startsWith(".")) {
         continue;
       }
       const path = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join25(directory, entry.name), `${path}/`);
+        visit(join26(directory, entry.name), `${path}/`);
       } else if (/\.(scn|res)$/i.test(entry.name)) {
         found.push(path);
       }
@@ -39077,7 +39178,7 @@ function binaryResources(projectPath) {
   return found;
 }
 function targetPathOf(projectPath, absolute) {
-  const inside = relative5(onDiskSpelling(projectPath), join25(onDiskSpelling(dirname18(absolute)), basename7(absolute)));
+  const inside = relative5(onDiskSpelling(projectPath), join26(onDiskSpelling(dirname19(absolute)), basename8(absolute)));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
     return null;
   }
@@ -39095,13 +39196,13 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   if (to === null) {
     return { ok: false, reason: `newPath must be a path inside the project, and ${absoluteTo} is not.` };
   }
-  if (!existsSync22(absoluteFrom)) {
+  if (!existsSync23(absoluteFrom)) {
     return { ok: false, reason: `There is nothing at ${from} to move.` };
   }
   if (from === to) {
     return { ok: false, reason: `${from} is already there; nothing to move.` };
   }
-  const isDirectory = statSync10(absoluteFrom).isDirectory();
+  const isDirectory = statSync11(absoluteFrom).isDirectory();
   if (from === "res://project.godot") {
     return {
       ok: false,
@@ -39124,7 +39225,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   if (isDirectory && to.startsWith(`${from}/`)) {
     return { ok: false, reason: `${from} cannot be moved into itself.` };
   }
-  if (existsSync22(absoluteTo) && !sameFile(absoluteFrom, absoluteTo)) {
+  if (existsSync23(absoluteTo) && !sameFile(absoluteFrom, absoluteTo)) {
     return { ok: false, reason: `${to} already exists, so nothing was moved there.` };
   }
   const unseen = unseenByTheEngine(projectPath, to);
@@ -39132,7 +39233,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 && existsSync22(join25(projectPath, path.slice("res://".length))));
+    const owner = SIDECARS.map((sidecar) => from.endsWith(sidecar) ? from.slice(0, -sidecar.length) : null).find((path) => path !== null && existsSync23(join26(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.` };
     }
@@ -39154,7 +39255,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   } else {
     moves.set(from, to);
     for (const sidecar of SIDECARS) {
-      if (existsSync22(`${absoluteFrom}${sidecar}`)) {
+      if (existsSync23(`${absoluteFrom}${sidecar}`)) {
         moves.set(`${from}${sidecar}`, `${to}${sidecar}`);
       }
     }
@@ -39166,12 +39267,12 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
     scripts,
     moves,
     named: [from],
-    exists: (path) => existsSync22(join25(projectPath, path.slice("res://".length)))
+    exists: (path) => existsSync23(join26(projectPath, path.slice("res://".length)))
   }, { edits: [], mentions: [] });
   plan = mentionIgnored(plan, ignoredTexts(projectPath), null, [from]);
   const binaries = [];
   for (const path of binaryResources(projectPath)) {
-    const bytes = readFileSync22(join25(projectPath, path.slice("res://".length)));
+    const bytes = readFileSync22(join26(projectPath, path.slice("res://".length)));
     const names = [...moves.keys()].find((moving) => bytes.includes(moving));
     if (names !== undefined) {
       binaries.push({
@@ -39190,7 +39291,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   }));
   const left = leftAloneReport(mentions);
   const rewrites = rewritesOf(plan, texts, null);
-  const absoluteOf = (path) => join25(projectPath, path.slice("res://".length));
+  const absoluteOf = (path) => join26(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);
@@ -39237,19 +39338,19 @@ function applyFileMove(outcome) {
     }
   }
   for (const file of outcome.moved) {
-    if (!existsSync22(file.absoluteFrom)) {
+    if (!existsSync23(file.absoluteFrom)) {
       throw new Error(`${file.from} is gone from disk; nothing was written`);
     }
     if (file.text !== null && readFileSync22(file.absoluteFrom, "utf8") !== file.text.before) {
       throw new Error(`${file.from} changed on disk while the move was being worked out; nothing was written`);
     }
-    if (existsSync22(file.absoluteTo) && !sameFile(file.absoluteFrom, file.absoluteTo)) {
+    if (existsSync23(file.absoluteTo) && !sameFile(file.absoluteFrom, file.absoluteTo)) {
       throw new Error(`${file.to} already exists; nothing was written`);
     }
   }
   const undo = [];
   const rename = (source, target) => {
-    mkdirSync13(dirname18(target), { recursive: true });
+    mkdirSync13(dirname19(target), { recursive: true });
     renameSync4(source, target);
     undo.push(() => {
       renameSync4(target, source);
@@ -43435,25 +43536,25 @@ var DEBUG_PREFIX = "debug ";
 var init_keeper_channel = () => {};
 
 // src/lifecycle-log.ts
-import { appendFileSync, mkdirSync as mkdirSync14, renameSync as renameSync5, statSync as statSync11 } from "node:fs";
-import { dirname as dirname19, join as join26 } from "node:path";
-import process10 from "node:process";
+import { appendFileSync, mkdirSync as mkdirSync14, renameSync as renameSync5, statSync as statSync12 } from "node:fs";
+import { dirname as dirname20, join as join27 } from "node:path";
+import process11 from "node:process";
 function lifecycleLogPath() {
-  return join26(runtimeDirectory(), "servers.log");
+  return join27(runtimeDirectory(), "servers.log");
 }
 function writeLifecycle(event, fields = {}) {
   const path = lifecycleLogPath();
   try {
-    mkdirSync14(dirname19(path), { recursive: true });
-    if ((statSync11(path, { throwIfNoEntry: false })?.size ?? 0) > LIFECYCLE_LOG_LIMIT) {
+    mkdirSync14(dirname20(path), { recursive: true });
+    if ((statSync12(path, { throwIfNoEntry: false })?.size ?? 0) > LIFECYCLE_LOG_LIMIT) {
       try {
         renameSync5(path, `${path}.1`);
       } catch {}
     }
     const line = {
       at: new Date().toISOString(),
-      pid: process10.pid,
-      ppid: process10.ppid,
+      pid: process11.pid,
+      ppid: process11.ppid,
       version: SERVER_VERSION,
       event
     };
@@ -43760,14 +43861,14 @@ var init_prompts = __esm(() => {
 
 // src/restart-note.ts
 import { mkdirSync as mkdirSync15, readFileSync as readFileSync23, rmSync as rmSync13, writeFileSync as writeFileSync17 } from "node:fs";
-import { dirname as dirname20, join as join27 } from "node:path";
+import { dirname as dirname21, join as join28 } from "node:path";
 function restartNotePath(projectPath) {
-  return join27(projectPath, ".godot", "gdharness-restart.json");
+  return join28(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync15(dirname20(path), { recursive: true });
+    mkdirSync15(dirname21(path), { recursive: true });
     writeFileSync17(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
@@ -43802,23 +43903,23 @@ 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 readdirSync12, readFileSync as readFileSync24, realpathSync as realpathSync6, rmSync as rmSync14, statSync as statSync12 } from "node:fs";
-import { basename as basename8, dirname as dirname21, join as join28, resolve as resolve7 } from "node:path";
+import { mkdirSync as mkdirSync16, openSync as openSync3, readdirSync as readdirSync13, readFileSync as readFileSync24, realpathSync as realpathSync6, rmSync as rmSync14, statSync as statSync13 } from "node:fs";
+import { basename as basename9, dirname as dirname22, join as join29, resolve as resolve7 } from "node:path";
 function runsDirectory() {
-  return join28(runtimeDirectory(), "runs");
+  return join29(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join28(realpathSync6.native(at), ...missing);
+      return join29(realpathSync6.native(at), ...missing);
     } catch {
-      const parent = dirname21(at);
+      const parent = dirname22(at);
       if (parent === at) {
         return path;
       }
-      missing.unshift(basename8(at));
+      missing.unshift(basename9(at));
       at = parent;
     }
   }
@@ -43829,10 +43930,10 @@ function projectKey(projectPath) {
   return createHash5("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join28(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join29(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function latestRunPath(servedBy, directory = runtimeDirectory()) {
-  return join28(directory, "runs", `latest-${projectKey(servedBy)}.json`);
+  return join29(directory, "runs", `latest-${projectKey(servedBy)}.json`);
 }
 function writeLatestRun(servedBy, latest) {
   try {
@@ -43857,17 +43958,20 @@ function readLatestRun(servedBy, directory = runtimeDirectory()) {
 }
 function openTranscript(startedAt) {
   mkdirSync16(runsDirectory(), { recursive: true });
-  const path = join28(runsDirectory(), `run-${startedAt}.log`);
+  const path = join29(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync3(path, "a") };
 }
 function profilePath(startedAt) {
-  return join28(runsDirectory(), `run-${startedAt}.profile.json`);
+  return join29(runsDirectory(), `run-${startedAt}.profile.json`);
+}
+function profileMarkPath(startedAt) {
+  return join29(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 join28(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join29(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
   mkdirSync16(runsDirectory(), { recursive: true });
@@ -43878,7 +43982,7 @@ function writeEditorRunNote(note) {
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join28(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join29(directory, "runs", "editor-run.json"));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -43912,7 +44016,7 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join28(directory, "runs", SHARED_NOTE));
+    const shared = recordAt(join29(directory, "runs", SHARED_NOTE));
     if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
       return shared;
     }
@@ -43924,13 +44028,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync12(join28(directory, "runs"));
+      entries = readdirSync13(join29(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join28(directory, "runs", entry));
+        const record = recordAt(join29(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -44099,7 +44203,7 @@ function whyNotTheRun(record, running, needed) {
   if (after > SAME_RUN_WINDOW_MS) {
     return `that process started ${Math.round(after / 1000)} seconds after the run had`;
   }
-  const engine = record.command === undefined ? null : basename8(record.command);
+  const engine = record.command === undefined ? null : basename9(record.command);
   const said = process.platform === "win32" ? running.text.toLowerCase() : running.text;
   const wanted = engine === null || process.platform !== "win32" ? engine : engine.toLowerCase();
   if (wanted !== null && !said.includes(wanted)) {
@@ -44138,7 +44242,7 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join28(directory, "runs", SHARED_NOTE);
+    const shared = join29(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] : []]) {
@@ -44150,7 +44254,7 @@ function clearRunRecord(projectPath) {
 }
 function ageMs(path, now) {
   try {
-    return now - statSync12(path).mtimeMs;
+    return now - statSync13(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -44159,20 +44263,21 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
   const directory = runsDirectory();
   const kept = new Set(everyRunRecord().flatMap((record) => [
     record.transcript,
+    profileMarkPath(record.startedAt),
     ...record.profile === undefined ? [] : [record.profile]
   ]));
   let entries;
   try {
-    entries = readdirSync12(directory);
+    entries = readdirSync13(directory);
   } catch {
     return;
   }
   for (const entry of entries) {
-    const transcript = entry.startsWith("run-") && (entry.endsWith(".log") || entry.endsWith(".profile.json"));
+    const transcript = entry.startsWith("run-") && (entry.endsWith(".log") || entry.endsWith(".profile.json") || entry.endsWith(".profile-mark.json"));
     if (!transcript && !entry.endsWith(".partial")) {
       continue;
     }
-    const path = join28(directory, entry);
+    const path = join29(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -44193,7 +44298,7 @@ var init_run_record = __esm(() => {
 });
 
 // src/script-origins.ts
-import { join as join29 } from "node:path";
+import { join as join30 } from "node:path";
 function unresolvedClassIn(message) {
   return UNRESOLVED.exec(message)?.[1] ?? null;
 }
@@ -44246,7 +44351,7 @@ function checkWithEngine(godotPath, projectPath) {
       const ran = await runEngine(godotPath, [
         "--headless",
         "--log-file",
-        join29(logDir, "engine.log"),
+        join30(logDir, "engine.log"),
         "--path",
         projectPath,
         "--check-only",
@@ -44339,6 +44444,52 @@ function isCalibration(signature) {
   const parts = signatureParts(signature);
   return parts.script.endsWith(RUNTIME_SCRIPT) && (parts.function === PROFILER_PROBE || parts.function === PROFILER_CALIBRATOR);
 }
+function writeProfileMark(path, mark) {
+  return writeWhole(path, JSON.stringify(mark));
+}
+function readProfileMark(path) {
+  try {
+    const parsed = JSON.parse(readFileSync25(path, "utf8"));
+    return typeof parsed === "object" && typeof parsed.totals === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function totalsSince(now, mark) {
+  if (now.frames < mark.frames || now.startedAt !== mark.startedAt) {
+    return null;
+  }
+  let shrunk = 0;
+  const functions = {};
+  for (const [signature, sum] of Object.entries(now.functions)) {
+    const before = mark.functions[signature];
+    if (isCalibration(signature) || before === undefined) {
+      functions[signature] = sum;
+      continue;
+    }
+    const added = {
+      calls: sum.calls - before.calls,
+      selfSeconds: sum.selfSeconds - before.selfSeconds,
+      totalSeconds: sum.totalSeconds - before.totalSeconds
+    };
+    if (added.calls < 0 || added.selfSeconds < 0 || added.totalSeconds < 0) {
+      shrunk += 1;
+    } else if (added.calls > 0) {
+      functions[signature] = added;
+    }
+  }
+  shrunk += Object.keys(mark.functions).filter((signature) => now.functions[signature] === undefined && (mark.functions[signature]?.calls ?? 0) > 0).length;
+  return {
+    totals: {
+      ...now,
+      frames: now.frames - mark.frames,
+      unreadable: Math.max(0, now.unreadable - mark.unreadable),
+      ...now.cappedFrames === undefined ? {} : { cappedFrames: Math.max(0, now.cappedFrames - (mark.cappedFrames ?? 0)) },
+      functions
+    },
+    shrunk
+  };
+}
 function perCallCostOf(totals) {
   for (const [signature, sum] of Object.entries(totals.functions)) {
     const parts = signatureParts(signature);
@@ -44471,18 +44622,18 @@ import {
   closeSync as closeSync3,
   constants,
   copyFileSync,
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   fstatSync,
   mkdirSync as mkdirSync17,
   openSync as openSync4,
-  readdirSync as readdirSync13,
+  readdirSync as readdirSync14,
   readFileSync as readFileSync26,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
-  statSync as statSync13,
+  statSync as statSync14,
   writeFileSync as writeFileSync18
 } from "node:fs";
-import { basename as basename9, dirname as dirname22, extname as extname4, isAbsolute as isAbsolute4, join as join30, normalize as normalize2, relative as relative6 } from "node:path";
+import { basename as basename10, dirname as dirname23, extname as extname4, isAbsolute as isAbsolute5, join as join31, normalize as normalize2, relative as relative6 } from "node:path";
 import { setTimeout as delay5 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function editorRestartTimeoutMs() {
@@ -44512,22 +44663,22 @@ function writtenFileRefusal(path, rule) {
   if (/^(res|user):\/\//.test(path)) {
     return `${named} ${path} is a Godot path; ${what} is saved outside the project, at an absolute path on this machine.`;
   }
-  if (!isAbsolute4(path)) {
+  if (!isAbsolute5(path)) {
     return `${named} ${path} is not absolute; name the whole path, so where it is written does not depend on this server's directory.`;
   }
   if (!rule.extensions.includes(extname4(path).toLowerCase())) {
     return `${named} ${path} does not end in ${rule.extensions.join(" or ")}, which is what ${what} is.`;
   }
-  const directory = realPathOr(dirname22(path));
-  if (!existsSync23(directory)) {
-    return `${named}'s directory ${dirname22(path)} does not exist; ${what} creates no directories.`;
+  const directory = realPathOr(dirname23(path));
+  if (!existsSync24(directory)) {
+    return `${named}'s directory ${dirname23(path)} does not exist; ${what} creates no directories.`;
   }
-  const where = join30(directory, basename9(path));
+  const where = join31(directory, basename10(path));
   const inside = rule.projects.find((project) => project !== "" && isWithinRoot(realPathOr(project), where));
   if (inside !== undefined) {
     return `${named} ${path} is inside the project at ${inside}; ${what} is saved outside it, so it never becomes part of the game.`;
   }
-  const taken = rule.writes(where).find((file) => existsSync23(file));
+  const taken = rule.writes(where).find((file) => existsSync24(file));
   if (taken !== undefined) {
     return taken === where ? `${named} ${path} already exists; ${what} is not written over a file. Name a new one.` : `${named} ${path} would write ${taken}, which already exists; ${what} is not written over a file. Name a new one.`;
   }
@@ -44636,7 +44787,7 @@ function exited(run) {
   return run.exitCode !== null || run.exitSignal !== null;
 }
 function howItExited(run) {
-  return run.exitSignal === null ? `exit code ${run.exitCode ?? "unknown"}` : `ended by ${run.exitSignal}, with no exit code`;
+  return run.exitSignal === null ? exitCodeText(run.exitCode) : `ended by ${run.exitSignal}, with no exit code`;
 }
 function errorsUnread(run) {
   return run.throughEditor && typeof run.errorReport !== "string";
@@ -44744,7 +44895,7 @@ function endedWithoutACode(run) {
 function ourRunEnded(run, now) {
   const which = `${run.throughEditor ? "played in the editor" : "started"}${run.pid === null ? "" : ` (pid ${run.pid})`}`;
   const when = run.endedAt === undefined ? "" : ` ${Math.max(0, Math.round((now - run.endedAt) / 1000))}s ago`;
-  const how = run.endedThrough === "close" ? "this server asked it to close" : run.endedThrough === "keeper" ? "this server ended it through the keeper holding it" : run.endedThrough === "signal" ? "this server signalled it" : run.endedThrough === "editor" ? "this server asked the editor to stop it" : run.exitCode !== null ? `it exited by itself with code ${run.exitCode}` : run.exitSignal === null ? "it is no longer running" : `it was ended by ${run.exitSignal}`;
+  const how = run.endedThrough === "close" ? "this server asked it to close" : run.endedThrough === "keeper" ? "this server ended it through the keeper holding it" : run.endedThrough === "signal" ? "this server signalled it" : run.endedThrough === "editor" ? "this server asked the editor to stop it" : run.exitCode !== null ? `it exited by itself with ${exitCodeText(run.exitCode)}` : run.exitSignal === null ? "it is no longer running" : `it was ended by ${run.exitSignal}`;
   return `No game with the runtime addon is running: the game this server ${which} ended${when}, and ${how}. editor_output has what it printed, and editor_run start runs it again.`;
 }
 function stopVerdict(stop) {
@@ -45063,7 +45214,7 @@ function notRunNote(notRun, failFast) {
 function exportPresetRefusal(projectPath, preset) {
   let text;
   try {
-    text = readFileSync26(join30(projectPath, "export_presets.cfg"), "utf8");
+    text = readFileSync26(join31(projectPath, "export_presets.cfg"), "utf8");
   } catch {
     return `This project has no export_presets.cfg, so it has no preset '${preset}' to export with. project_export add_preset writes one, as the editor's Project > Export does.`;
   }
@@ -45085,7 +45236,7 @@ function exportPresetRefusal(projectPath, preset) {
   }
   return names.length === 0 ? `export_presets.cfg names no preset, so there is no '${preset}' to export with. project_export add_preset adds one.` : `This project has no export preset named '${preset}'. Its presets are ${names.map((name) => `'${name}'`).join(", ")}.`;
 }
-function exportAnswer(ending, asked, before, after, beside = []) {
+function exportAnswer(ending, asked, before, after, beside = [], docCacheNote = null) {
   const { log } = ending;
   const written = after !== null && after !== before;
   const notCopied = librariesNotCopied(log.all);
@@ -45102,6 +45253,7 @@ function exportAnswer(ending, asked, before, after, beside = []) {
       librariesNotLoaded: notCopied,
       extensionNote: `The export could not load ${notCopied.join(" and ")}: on Windows an engine running as the editor, which an export is, loads a GDExtension from a ~ copy beside the library, and another engine on this project held that copy: it could not be moved aside before the export, or another engine made a new one in between. Export again once that engine has loaded or exited.`
     },
+    ...docCacheNote === null ? {} : { docCacheNote },
     ...foldedEntriesAnswer(log)
   };
   if (verdict.exported) {
@@ -45126,9 +45278,9 @@ function writtenBeside(before, after, output, within) {
 function filesIn(folder) {
   const found = new Map;
   try {
-    for (const entry of readdirSync13(folder, { withFileTypes: true })) {
+    for (const entry of readdirSync14(folder, { withFileTypes: true })) {
       if (entry.isFile()) {
-        found.set(entry.name, statSync13(join30(folder, entry.name)).mtimeMs);
+        found.set(entry.name, statSync14(join31(folder, entry.name)).mtimeMs);
       }
     }
   } catch {}
@@ -45158,7 +45310,7 @@ function unsavedInEditorNote(scripts) {
   return `${named} ${one ? "is" : "are"} open in the editor's script ${one ? "tab" : "tabs"} with unsaved edits, and saving ${one ? "that tab" : "them"} there writes ${one ? "its" : "their"} text over what was written here: close ${one ? "it" : "them"} without saving, or save first and edit again.`;
 }
 function editorAddonMissing(projectPath) {
-  if (!existsSync23(join30(projectPath, "project.godot"))) {
+  if (!existsSync24(join31(projectPath, "project.godot"))) {
     return null;
   }
   const report = inspectProject(projectPath);
@@ -45396,7 +45548,7 @@ function profileFrameFunctions(projectPath) {
   let projectGodot = null;
   if (projectPath !== null) {
     try {
-      projectGodot = readFileSync26(join30(projectPath, "project.godot"), "utf8");
+      projectGodot = readFileSync26(join31(projectPath, "project.godot"), "utf8");
     } catch {}
   }
   return frameFunctionsFor(queuedMessagesOf(projectGodot));
@@ -45570,7 +45722,7 @@ function foldedEntriesAnswer(log, floor = "warning") {
 }
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync26(join30(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync26(join31(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -45585,13 +45737,13 @@ function uncaughtNote(uncaught) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync23(join30(projectPath, wanted))) {
+  if (wanted === "" || existsSync24(join31(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
   let near = [];
   try {
-    near = readdirSync13(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
+    near = readdirSync14(projectPath, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.toLowerCase() !== root).map((entry) => entry.name).filter((name) => name.toLowerCase().startsWith("test") || root.startsWith(name.toLowerCase()));
   } catch {
     return "";
   }
@@ -45682,23 +45834,23 @@ function engineChecked(why) {
 }
 function isDirectory(path) {
   try {
-    return statSync13(path).isDirectory();
+    return statSync14(path).isDirectory();
   } catch {
     return false;
   }
 }
 function scriptsUnder(directory, prefix) {
-  if (existsSync23(join30(directory, ".gdignore"))) {
+  if (existsSync24(join31(directory, ".gdignore"))) {
     return [];
   }
   const found = [];
-  for (const entry of readdirSync13(directory, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
+  for (const entry of readdirSync14(directory, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
     if (entry.name.startsWith(".")) {
       continue;
     }
     const path = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
     if (entry.isDirectory()) {
-      found.push(...scriptsUnder(join30(directory, entry.name), path));
+      found.push(...scriptsUnder(join31(directory, entry.name), path));
     } else if (entry.isFile() && entry.name.endsWith(".gd")) {
       found.push(path);
     }
@@ -45714,7 +45866,7 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync26(join30(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync26(join31(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
@@ -45739,7 +45891,7 @@ function needsItsOwnProcess(asked) {
 class GodotServer {
   stdio = null;
   locator = new GodotLocator;
-  operationsScript = join30(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join31(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -46000,14 +46152,14 @@ class GodotServer {
   }
   noteTheStart() {
     const cwd = process.cwd();
-    const mcpJson = join30(cwd, ".mcp.json");
+    const mcpJson = join31(cwd, ".mcp.json");
     const announced = this.ownProject === null ? null : readAnnouncement(announcementPath(this.ownProject));
     const predecessor = announced !== null && announced.pid !== process.pid && alive(announced.pid) ? announced.pid : null;
     writeLifecycle("started", {
       argv: process.argv.slice(1),
       cwd,
       project: this.ownProject,
-      mcpJson: existsSync23(mcpJson) ? mcpJson : null
+      mcpJson: existsSync24(mcpJson) ? mcpJson : null
     });
     if (predecessor !== null) {
       writeLifecycle("replaced", { project: this.ownProject, predecessor });
@@ -46148,7 +46300,7 @@ class GodotServer {
         return checked.response;
       }
       const named = args["projectPath"];
-      if (typeof named === "string" && existsSync23(join30(named, "project.godot"))) {
+      if (typeof named === "string" && existsSync24(join31(named, "project.godot"))) {
         this.lastProjectPath = named;
       }
       this.updates.refresh();
@@ -46184,7 +46336,7 @@ class GodotServer {
     let notSaved;
     try {
       savedAt = answer.content.map((item, index) => {
-        const file = join30(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
+        const file = join31(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
         writeFileSync18(file, item.type === "text" ? item.text : Buffer.from(item.data, "base64"));
         return file;
       });
@@ -46802,8 +46954,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join30(path, "project.godot");
-    if (!existsSync23(file)) {
+    const file = join31(path, "project.godot");
+    if (!existsSync24(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -46849,7 +47001,7 @@ class GodotServer {
   }
   runEnvironment(args) {
     const savesIn = readNonEmptyString(args, "savesIn");
-    if (savesIn !== undefined && !isAbsolute4(savesIn)) {
+    if (savesIn !== undefined && !isAbsolute5(savesIn)) {
       return {
         ok: false,
         response: this.createErrorResponse(`savesIn must be an absolute path, not "${savesIn}".`, [
@@ -47108,7 +47260,8 @@ class GodotServer {
         uidsCreated: given,
         stillWithoutUid: after,
         note: uidsLeftNote(after.length),
-        ...imported.extensionNote === undefined ? {} : { extensionNote: imported.extensionNote }
+        ...imported.extensionNote === undefined ? {} : { extensionNote: imported.extensionNote },
+        ...imported.docCacheNote === undefined ? {} : { docCacheNote: imported.docCacheNote }
       }
     }, scanned));
   }
@@ -47347,6 +47500,9 @@ class GodotServer {
       if (imported.extensionNote !== undefined) {
         extra["extensionNote"] = imported.extensionNote;
       }
+      if (imported.docCacheNote !== undefined) {
+        extra["docCacheNote"] = imported.docCacheNote;
+      }
     }
     const after = await this.operation("get_import_status", statusAsk, projectPath);
     if (!after.ok) {
@@ -47463,7 +47619,7 @@ class GodotServer {
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
-      name: typeof name === "string" && name !== "" ? name : basename9(project.value.path),
+      name: typeof name === "string" && name !== "" ? name : basename10(project.value.path),
       path: project.value.path,
       mainScene: typeof mainScene === "string" && mainScene !== "" ? mainScene : null,
       godotVersion: await this.godotVersion(engine.value),
@@ -47546,18 +47702,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname22(output.absolutePath);
+    const folder = dirname23(output.absolutePath);
     try {
       mkdirSync17(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname22(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname23(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
     const exportLogs = scratchDirectory("export");
     const exportArgs = [
       "--headless",
       "--log-file",
-      join30(exportLogs, "engine.log"),
+      join31(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -47565,24 +47721,37 @@ class GodotServer {
       output.absolutePath
     ];
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
-    const writtenAt = () => existsSync23(output.absolutePath) ? statSync13(output.absolutePath).mtimeMs : null;
-    const before = writtenAt();
-    const listedBefore = filesIn(folder);
-    const freed = freeLibraryCopies(project.value.path);
-    if (freed.setAside.length > 0 || freed.swept.length > 0) {
-      this.logDebug(`Before the export: set aside ${freed.setAside.join(", ")}; swept ${freed.swept.join(", ")}`);
-    }
-    let ending;
+    const writtenAt = () => existsSync24(output.absolutePath) ? statSync14(output.absolutePath).mtimeMs : null;
+    const caches = editorCacheDirectory(engine.value);
+    const exportOnce = async () => {
+      const before = writtenAt();
+      const listedBefore = filesIn(folder);
+      const cachesBefore = docCachesWritten(caches);
+      const freed = freeLibraryCopies(project.value.path);
+      if (freed.setAside.length > 0 || freed.swept.length > 0) {
+        this.logDebug(`Before the export: set aside ${freed.setAside.join(", ")}; swept ${freed.swept.join(", ")}`);
+      }
+      const ending = await runEngine(engine.value, exportArgs, {
+        timeout: { ms: 300000, said: "five minutes" }
+      });
+      const crash = docCacheCrash(ending, cachesBefore, docCachesWritten(caches), "export");
+      return { ending, before, listedBefore, crash };
+    };
+    let run;
+    let docCacheNote;
     try {
-      ending = await runEngine(engine.value, exportArgs, { timeout: { ms: 300000, said: "five minutes" } });
+      const first = await exportOnce();
+      docCacheNote = first.crash;
+      run = first.crash === null ? first : await exportOnce();
     } finally {
       discard(exportLogs);
     }
+    const { ending, before, listedBefore } = run;
     if (ending.exitSignal === null && ending.exitCode === null) {
       return this.createErrorResponse(`Export could not be run: ${ending.failure ?? "the engine gave no exit status"}`);
     }
-    const beside = writtenBeside(listedBefore, filesIn(folder), basename9(output.absolutePath), dirname22(output.relativePath).replaceAll("\\", "/"));
-    return exportAnswer(ending, { preset, outputPath: output.relativePath, debug }, before, writtenAt(), beside);
+    const beside = writtenBeside(listedBefore, filesIn(folder), basename10(output.absolutePath), dirname23(output.relativePath).replaceAll("\\", "/"));
+    return exportAnswer(ending, { preset, outputPath: output.relativePath, debug }, before, writtenAt(), beside, docCacheNote);
   }
   reportTestProgress(log) {
     const progress = callProgress();
@@ -47635,10 +47804,10 @@ class GodotServer {
     if (movie !== null) {
       return this.createErrorResponse(movie);
     }
-    const missing = paths.value.filter((path) => !existsSync23(join30(project.value.path, path.slice("res://".length))));
+    const missing = paths.value.filter((path) => !existsSync24(join31(project.value.path, path.slice("res://".length))));
     const asked = paths.value.filter((path) => !missing.includes(path));
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    const noRunner = !existsSync23(join30(project.value.path, runner));
+    const noRunner = !existsSync24(join31(project.value.path, runner));
     if (asked.length === 0) {
       const verdict = `nothing at ${missing.join(" and ")}`;
       const andNoRunner = noRunner ? `, and gdUnit4 is not installed in this project: no ${runner}` : "";
@@ -47729,21 +47898,21 @@ class GodotServer {
       await untilGone([run.process.pid]);
     }
     await run.settled;
-    const reportsDir = join30(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join31(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync23(reportsDir) ? readdirSync13(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync24(reportsDir) ? readdirSync14(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync26(join30(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync26(join31(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
       discard(reportsDir, userData);
       try {
-        rmdirSync2(dirname22(reportsDir));
+        rmdirSync2(dirname23(reportsDir));
       } catch {}
     }
     const engineEntries = foldedRepeats(run.log.select({
@@ -47775,7 +47944,7 @@ class GodotServer {
     const declaring = printedErrors.some((error) => unresolvedClassIn(error.message) !== null) ? await originsOf(printedErrors, declaredClasses(project.value.path), checkWithEngine(engine.value, project.value.path)) : { origins: [], unconfirmed: [] };
     const scriptErrors = [...declaring.origins, ...printedErrors];
     const brokenScripts = new Set(scriptErrors.map((error) => error.path)).size;
-    const ranAs = cutShort !== null ? cutShort.verdict : nothingRan ?? (brokenScripts > 0 ? `script errors in ${brokenScripts === 1 ? "one script" : `${brokenScripts} scripts`}, so no suite ran` : undefined) ?? (uncaught.length > 0 ? `${uncaught.length === 1 ? "one script error" : `${uncaught.length} script errors`} that failed no case` : undefined) ?? (exitCode === null ? undefined : verdicts[exitCode]) ?? (run.exitSignal === null ? `exit ${exitCode ?? "unknown"}` : howItExited(run));
+    const ranAs = cutShort !== null ? cutShort.verdict : nothingRan ?? (brokenScripts > 0 ? `script errors in ${brokenScripts === 1 ? "one script" : `${brokenScripts} scripts`}, so no suite ran` : undefined) ?? (uncaught.length > 0 ? `${uncaught.length === 1 ? "one script error" : `${uncaught.length} script errors`} that failed no case` : undefined) ?? (exitCode === null ? undefined : verdicts[exitCode]) ?? howItExited(run);
     const nothingAt = missing.join(" and ");
     const verdict = missing.length === 0 ? ranAs : `${ranAs}; nothing at ${nothingAt}`;
     const missingNote = missing.length === 0 ? undefined : `Nothing at ${nothingAt}, so ${missing.length === 1 ? "it was" : "they were"} left out and only ${asked.join(", ")} ran; a run of fewer paths than were asked for is not called a pass.${elsewhereIn(project.value.path, missing[0] ?? "")}`;
@@ -48102,7 +48271,7 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const sourceOf = (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync23(contained.absolutePath)) {
+      if (!contained.ok || !existsSync24(contained.absolutePath)) {
         return null;
       }
       try {
@@ -48196,7 +48365,7 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync23(contained.absolutePath)) {
+    if (!contained.ok || !existsSync24(contained.absolutePath)) {
       return null;
     }
     try {
@@ -48358,7 +48527,7 @@ class GodotServer {
       ...Array.isArray(stack) ? {
         stack: stack.map((frame) => ({
           ...frame,
-          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join30(projectPath, frame["script"].slice("res://".length)) } : {}
+          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join31(projectPath, frame["script"].slice("res://".length)) } : {}
         }))
       } : {}
     });
@@ -48637,7 +48806,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync26(join30(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync26(join31(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -49074,7 +49243,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync23(join30(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync24(join31(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, {
         addon: false,
         budgetMs,
@@ -49160,7 +49329,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync13(endpoint.file).mtimeMs;
+      announcedAt = statSync14(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -50050,9 +50219,13 @@ class GodotServer {
     if (callersName !== undefined && !callersName.replace(/@([^.@]+)_(?:getter|setter)$/, "$1").split(".").every(isIdentifier)) {
       return this.createErrorResponse(`callersOf takes a function's name, or Class.name for the functions of one class, and ${JSON.stringify(callersName)} is neither.`, ["editor_run profile names each function as it answers; pass one of those"]);
     }
+    const asked = {
+      mark: readBoolean(args, "mark") === true,
+      since: readString(args, "since") === "mark"
+    };
     const going = await this.runStillGoing(run);
     const projectPath = run.projectPath;
-    const projectGone = projectPath !== null && !existsSync23(join30(projectPath, "project.godot"));
+    const projectGone = projectPath !== null && !existsSync24(join31(projectPath, "project.godot"));
     if (projectGone && callersName !== undefined) {
       return this.createErrorResponse(`callersOf reads the project's scripts, and the run's project at ${projectPath} has no project.godot any more.`, ["editor_run profile without callersOf answers with the profile itself"]);
     }
@@ -50062,7 +50235,7 @@ class GodotServer {
       ...callersName === undefined ? {} : { callersOf: { name: callersName, scripts: () => projectScripts(projectPath) } }
     };
     if (run.throughEditor) {
-      return await this.profileOfThePlayedGame(going, projectPath, fromProject, limit);
+      return await this.profileOfThePlayedGame(run, going, fromProject, limit, asked);
     }
     const path = run.profile;
     if (path === undefined) {
@@ -50075,15 +50248,16 @@ class GodotServer {
       ]);
     }
     const totals = file.connected ? file : null;
-    return this.jsonTextResponse(profileAnswer({
+    return this.profileReply(run, {
       through: "gdharness",
       running: going,
       totals,
       coveredMs: totals?.lastFrameAt == null ? 0 : totals.lastFrameAt - totals.startedAt,
       ...fromProject
-    }, limit));
+    }, limit, asked);
   }
-  async profileOfThePlayedGame(going, projectPath, fromProject, limit) {
+  async profileOfThePlayedGame(run, going, fromProject, limit, asked) {
+    const { projectPath } = run;
     const read = await this.handleViaBridge("profile_read", {});
     if (read.isError === true) {
       return read;
@@ -50105,12 +50279,13 @@ class GodotServer {
         return this.createErrorResponse("The editor says it is playing and has no debugger session for the game, so there is nothing to switch the profiler on in yet.", ["Ask again in a moment, once the game is up"]);
       }
       const on = await this.firstProfiledFrame();
+      const unmarked = asked.mark || asked.since ? " Nothing was marked, and nothing is counted from a mark: the profile begins now, so an answer without since covers the same span." : "";
       return this.jsonTextResponse({
         through: "editor",
         running: true,
         started: true,
         functions: [],
-        note: on ? "The profiler was switched on now, for the game the editor is playing, and its first frame has arrived, so it covers what the game does from here on. Ask again for the functions; editor_run start with profile: true covers a game from its start." : `The profiler was switched on for the game the editor is playing, and no frame of it had arrived ${PROFILER_ON_MS}ms later: what the game does before the first one is not counted. Ask again for the functions; editor_run start with profile: true covers a game from its start.`
+        note: on ? `The profiler was switched on now, for the game the editor is playing, and its first frame has arrived, so it covers what the game does from here on. Ask again for the functions; editor_run start with profile: true covers a game from its start.${unmarked}` : `The profiler was switched on for the game the editor is playing, and no frame of it had arrived ${PROFILER_ON_MS}ms later: what the game does before the first one is not counted. Ask again for the functions; editor_run start with profile: true covers a game from its start.${unmarked}`
       });
     }
     const functions = asParams(held["functions"]);
@@ -50133,13 +50308,70 @@ class GodotServer {
         ];
       }))
     } : null;
-    return this.jsonTextResponse(profileAnswer({
+    return this.profileReply(run, {
       through: "editor",
       running: going,
       totals,
       coveredMs: readNonNegativeNumber(held, "coveredMs") ?? 0,
       ...fromProject
-    }, limit));
+    }, limit, asked);
+  }
+  profileReply(run, reading, limit, asked) {
+    const markPath = profileMarkPath(run.startedAt);
+    const now = Date.now();
+    let shown = reading;
+    const lead = [];
+    let sinceFields = {};
+    if (asked.since) {
+      const mark = readProfileMark(markPath);
+      if (mark === null || mark.runStartedAt !== run.startedAt || mark.projectPath !== run.projectPath) {
+        return this.createErrorResponse("No mark has been set in this run, so there is nothing to count from.", ["editor_run profile with mark: true sets one at the totals it answers with"]);
+      }
+      const added = reading.totals === null ? null : totalsSince(reading.totals, mark.totals);
+      if (added === null) {
+        return this.createErrorResponse("The profile holds less than it did at the mark, so the profiler was started again since, and what it holds now cannot be counted from the mark.", ["editor_run profile with mark: true sets a mark in the profile as it is now"]);
+      }
+      shown = {
+        ...reading,
+        totals: added.totals,
+        coveredMs: Math.max(0, reading.coveredMs - mark.coveredMs)
+      };
+      const ago = now - mark.takenAt;
+      sinceFields = {
+        since: "mark",
+        markSetMsAgo: ago,
+        ...added.shrunk > 0 ? { lessThanAtMark: added.shrunk } : {}
+      };
+      lead.push(`Counted from the mark set ${ago}ms ago: each function's calls and milliseconds are what it added after the mark, frames and coveredMs are those since it, and a function that added no call is left out.`);
+      if (added.shrunk > 0) {
+        const one = added.shrunk === 1;
+        lead.push(`${one ? "One function reads" : `${added.shrunk} functions read`} less than at the mark and ${one ? "is" : "are"} left out, counted under lessThanAtMark: the engine's own totals arrived after the mark and replaced the frames' sum, and capped totals leave out the functions with the least time.`);
+      }
+    }
+    if (asked.mark) {
+      if (reading.totals === null) {
+        return this.createErrorResponse("There is nothing to mark yet: the game has not connected to the profiler.", ["Ask again in a moment, once the game is up"]);
+      }
+      const mark = {
+        takenAt: now,
+        projectPath: run.projectPath,
+        runStartedAt: run.startedAt,
+        coveredMs: reading.coveredMs,
+        totals: reading.totals
+      };
+      if (!writeProfileMark(markPath, mark)) {
+        return this.createErrorResponse(`The mark could not be written to ${markPath}, so none is set.`);
+      }
+      lead.push(asked.since ? 'The mark is moved to the totals as they are now, so the next since: "mark" counts from here.' : 'The mark is set at these totals: editor_run profile with since: "mark" answers only what is added after it.');
+    }
+    const answer = profileAnswer(shown, limit);
+    const note = [...lead, ...typeof answer["note"] === "string" ? [answer["note"]] : []].join(" ");
+    return this.jsonTextResponse({
+      ...answer,
+      ...sinceFields,
+      ...asked.mark ? { marked: true } : {},
+      note: note === "" ? undefined : note
+    });
   }
   async firstProfiledFrame() {
     const deadline = Date.now() + PROFILER_ON_MS;
@@ -50340,7 +50572,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync23(join30(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync24(join31(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -50970,7 +51202,7 @@ class GodotServer {
     if (!scriptPath.ok) {
       return this.createErrorResponse(scriptPath.reason);
     }
-    if (!existsSync23(scriptPath.absolutePath)) {
+    if (!existsSync24(scriptPath.absolutePath)) {
       return this.createErrorResponse(`Script file does not exist: ${scriptPath.absolutePath}`);
     }
     const asked = readNonEmptyString(args, "newScriptPath");
@@ -51552,7 +51784,7 @@ class GodotServer {
   async ownRunOnItsWay(projectPath, budgetMs) {
     const run = await this.currentRun();
     const project = projectPath ?? run?.projectPath ?? null;
-    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync23(join30(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync24(join31(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -51561,7 +51793,7 @@ class GodotServer {
         return !run.announcedBefore.has(one.pid);
       }
       try {
-        return statSync13(one.file).mtimeMs >= run.startedAt;
+        return statSync14(one.file).mtimeMs >= run.startedAt;
       } catch {
         return false;
       }
@@ -51642,7 +51874,7 @@ class GodotServer {
       }
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join30(screenshotDir, "capture.png") : null;
+    const screenshotPath = screenshotDir ? join31(screenshotDir, "capture.png") : null;
     const staleNote = this.runtimeStaleNote(choice.endpoint);
     const stale = staleNote === undefined ? {} : { addonIsStale: true, staleNote };
     const refused = (message) => this.createErrorResponse(staleNote === undefined ? message : `${message}
@@ -51839,6 +52071,7 @@ var init_server = __esm(() => {
   init_cut_test_run();
   init_dap_client();
   init_desktop();
+  init_doc_cache();
   init_editor_log();
   init_engine_run();
   init_errors();
@@ -51881,7 +52114,7 @@ var init_server = __esm(() => {
   init_tool_definitions();
   init_tool_reference();
   init_update_check();
-  __dirname2 = dirname22(fileURLToPath5(import.meta.url));
+  __dirname2 = dirname23(fileURLToPath5(import.meta.url));
   KEEPER_DEBUG_MS = PAUSE_MS + STEP_MS + 2 * READ_MS;
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   LONGEST_BOOT_NOTED_MS = 5 * 60000;
@@ -51941,8 +52174,8 @@ var init_server = __esm(() => {
 init_bridge_announce();
 init_errors();
 init_godot_path();
-import { existsSync as existsSync24 } from "node:fs";
-import { join as join31, resolve as resolve8 } from "node:path";
+import { existsSync as existsSync25 } from "node:fs";
+import { join as join32, resolve as resolve8 } from "node:path";
 
 // src/harnesses.ts
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync2 } from "node:fs";
@@ -52877,10 +53110,10 @@ init_issues();
 init_paths();
 
 // src/prompt.ts
-import process8 from "node:process";
+import process9 from "node:process";
 import { createInterface } from "node:readline/promises";
 function interactive() {
-  return process8.stdin.isTTY && process8.stdout.isTTY;
+  return process9.stdin.isTTY && process9.stdout.isTTY;
 }
 
 class Ask {
@@ -52889,7 +53122,7 @@ class Ask {
     if (!interactive()) {
       return fallback;
     }
-    this.line ??= createInterface({ input: process8.stdin, output: process8.stdout });
+    this.line ??= createInterface({ input: process9.stdin, output: process9.stdout });
     const answer = (await this.line.question(`${question} ${fallback ? "[Y/n]" : "[y/N]"} `)).trim();
     return answer === "" ? fallback : answer.toLowerCase().startsWith("y");
   }
@@ -52907,10 +53140,10 @@ init_setup();
 init_setup();
 init_tool_definitions();
 init_tool_reference();
-import { existsSync as existsSync13, mkdirSync as mkdirSync5, readdirSync as readdirSync8, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
-import { basename as basename5, dirname as dirname7, join as join13 } from "node:path";
+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";
 var SKILL_NAME = "gdharness";
-var SHARED_SKILLS = join13(".agents", "skills");
+var SHARED_SKILLS = join14(".agents", "skills");
 function skillMarkdown(version) {
   return `---
 name: ${SKILL_NAME}
@@ -52997,7 +53230,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | What every label on a screen says | \`runtime_inspect tree\` with \`properties\` naming \`text\`, which reads it off every node that has one; \`includeProperties\` is every stored property of every node and ran to seventy-six thousand characters for one row |
 | Whether this engine has a method or property, and what it takes | \`editor_classes info\` with \`member\`, which answers that one member and which class declares it rather than the whole class |
 | Wait for a run to finish | \`editor_run wait\`, never a sleep or a shell loop on the pid: it answers as \`editor_output\` does, once the run is over |
-| Find which GDScript makes a run slow | \`editor_run start\` with \`profile\` set, then \`editor_run profile\`: the engine's own script profiler, per function with calls and self and total milliseconds, by self time, never \`Time.get_ticks_usec()\` laps edited into the game. A scene that does its work in \`_ready\` and quits is covered whole when the runtime autoload is registered, and a game the editor is already playing is profiled from the moment it is asked. \`callersOf\` names where the project's scripts call one function, each place with its function's numbers, since the engine records no callers |
+| Find which GDScript makes a run slow | \`editor_run start\` with \`profile\` set, then \`editor_run profile\`: the engine's own script profiler, per function with calls and self and total milliseconds, by self time, never \`Time.get_ticks_usec()\` laps edited into the game. A scene that does its work in \`_ready\` and quits is covered whole when the runtime autoload is registered, and a game the editor is already playing is profiled from the moment it is asked. For one action, a press or a commit, set \`mark\` on a profile before it and pass \`since: "mark"\` after it, which answers only what the action added. \`callersOf\` names where the project's scripts call one function, each place with its function's numbers, since the engine records no callers |
 | End a bench and the workers it opened | \`editor_run stop\` with \`andChildren\`, never a process listing by scene name: it ends every process under the run's, to any depth, that is a game of the project, announced as one or the project's engine run with \`--path\` on it, names them under \`endedChildren\` with what identified each, and leaves and names any other |
 | End a game of the project that no server is holding | \`editor_run stop\` with its \`pid\` from \`editor_status\` \`runtimes\`, never a process kill by hand: it is ended only when it announced itself for the project and its command line is the project's engine run |
 | Play a game without touching the player's saves | \`editor_run start\` with \`savesIn\`, a directory for this run's \`user://\`: the editor plays with its own environment, so a run given one is started by the server, and the answer says under \`savesNote\` when the platform ignores it |
@@ -53135,27 +53368,27 @@ what they report while starting comes back under \`engine_messages_before_operat
 function skillFiles(version) {
   return new Map([
     ["SKILL.md", skillMarkdown(version)],
-    [join13("references", "tools.md"), renderToolsMarkdown()]
+    [join14("references", "tools.md"), renderToolsMarkdown()]
   ]);
 }
 function skillDirectories(harnesses, projectPath, exists) {
-  const directories = [join13(projectPath, SHARED_SKILLS, SKILL_NAME)];
+  const directories = [join14(projectPath, SHARED_SKILLS, SKILL_NAME)];
   for (const harness of harnesses) {
     if (harness.skills === undefined) {
       continue;
     }
-    const own = join13(projectPath, harness.skills.dir);
-    if ((!harness.skills.shared || exists(own)) && !directories.includes(join13(own, SKILL_NAME))) {
-      directories.push(join13(own, SKILL_NAME));
+    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));
     }
   }
   return directories;
 }
 function everySkillDirectory(projectPath, harnesses) {
-  const directories = new Set([join13(projectPath, SHARED_SKILLS, SKILL_NAME)]);
+  const directories = new Set([join14(projectPath, SHARED_SKILLS, SKILL_NAME)]);
   for (const harness of harnesses) {
     if (harness.skills !== undefined) {
-      directories.add(join13(projectPath, harness.skills.dir, SKILL_NAME));
+      directories.add(join14(projectPath, harness.skills.dir, SKILL_NAME));
     }
   }
   return [...directories];
@@ -53163,33 +53396,33 @@ function everySkillDirectory(projectPath, harnesses) {
 function removeSkill(directories, projectPath) {
   const removed = [];
   for (const directory of directories) {
-    if (existsSync13(directory)) {
+    if (existsSync14(directory)) {
       rmSync6(directory, { recursive: true, force: true });
-      pruneEmpty(dirname7(directory), projectPath);
+      pruneEmpty(dirname8(directory), projectPath);
       removed.push(directory);
     }
   }
   return removed;
 }
 function pruneEmpty(directory, projectPath) {
-  const shared = join13(projectPath, ".agents");
+  const shared = join14(projectPath, ".agents");
   let path = directory;
-  while (path !== projectPath && (basename5(path) === "skills" || path === shared)) {
-    if (readdirSync8(path).length > 0) {
+  while (path !== projectPath && (basename6(path) === "skills" || path === shared)) {
+    if (readdirSync9(path).length > 0) {
       return;
     }
     rmSync6(path, { recursive: true, force: true });
-    path = dirname7(path);
+    path = dirname8(path);
   }
 }
 function writeSkill(directories, version) {
   const files = skillFiles(version);
   return directories.map((directory) => {
-    const replaced = existsSync13(directory);
+    const replaced = existsSync14(directory);
     rmSync6(directory, { recursive: true, force: true });
     for (const [name, contents] of files) {
-      const path = join13(directory, name);
-      mkdirSync5(dirname7(path), { recursive: true });
+      const path = join14(directory, name);
+      mkdirSync5(dirname8(path), { recursive: true });
       writeFileSync7(path, contents, "utf8");
     }
     return { path: directory, replaced };
@@ -53198,13 +53431,13 @@ function writeSkill(directories, version) {
 
 // src/version.ts
 import { readFileSync as readFileSync12 } from "node:fs";
-import { dirname as dirname8, join as join14 } from "node:path";
+import { dirname as dirname9, join as join15 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getLocalVersion() {
-  const currentDirectory = dirname8(fileURLToPath2(import.meta.url));
+  const currentDirectory = dirname9(fileURLToPath2(import.meta.url));
   const packageCandidates = [
-    join14(currentDirectory, "..", "package.json"),
-    join14(currentDirectory, "..", "..", "package.json")
+    join15(currentDirectory, "..", "package.json"),
+    join15(currentDirectory, "..", "..", "package.json")
   ];
   for (const packagePath of packageCandidates) {
     try {
@@ -53226,7 +53459,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve8(named ?? ".");
-  if (!existsSync24(join31(projectPath, "project.godot"))) {
+  if (!existsSync25(join32(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -53271,7 +53504,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync24(join31(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync25(join32(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }
@@ -53403,7 +53636,7 @@ async function setup() {
       console.log("no harness configured; name one yourself, and gdharness harnesses lists them all");
     }
     if (!args.includes("--no-skill")) {
-      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync24);
+      const directories = skillDirectories(chosen.harnesses, projectPath, existsSync25);
       for (const written of writeSkill(directories, getLocalVersion())) {
         console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
       }
@@ -53517,7 +53750,7 @@ async function upgrade() {
       moved.push(took.from);
     }
   }
-  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync24), version)) {
+  for (const written of writeSkill(skillDirectories(already, projectPath, existsSync25), version)) {
     console.log(`skill: ${written.replaced ? "replaced" : "written"} ${written.path}`);
   }
   console.log(`