gdharness 1.2.36 → 1.2.38

package/build/index.js

@@ -3365,17 +3365,18 @@ import {
   closeSync as closeSync3,
   constants,
   copyFileSync,
-  existsSync as existsSync20,
+  existsSync as existsSync21,
   fstatSync,
   mkdirSync as mkdirSync15,
   openSync as openSync4,
-  readdirSync as readdirSync11,
+  readdirSync as readdirSync12,
   readFileSync as readFileSync24,
   readSync as readSync2,
   rmdirSync as rmdirSync2,
-  statSync as statSync12
+  statSync as statSync13,
+  writeFileSync as writeFileSync16
 } from "node:fs";
-import { basename as basename7, dirname as dirname18, extname as extname4, isAbsolute as isAbsolute4, join as join26, normalize as normalize2, relative as relative5 } from "node:path";
+import { basename as basename8, dirname as dirname19, extname as extname4, isAbsolute as isAbsolute5, join as join27, normalize as normalize2, relative as relative5 } from "node:path";
 import { setTimeout as delay5 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 
@@ -28537,19 +28538,11 @@ function dictionary(entries) {
   return Object.assign(emptyRecord(), entries);
 }
 
-// src/editor-log.ts
-import {
-  closeSync as closeSync2,
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync7,
-  openSync as openSync2,
-  readFileSync as readFileSync12,
-  readSync,
-  rmSync as rmSync6,
-  statSync as statSync5,
-  writeFileSync as writeFileSync8
-} from "node:fs";
-import { dirname as dirname7, join as join11 } from "node:path";
+// src/doc-cache.ts
+import { existsSync as existsSync7, readdirSync as readdirSync3, statSync as statSync5 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { basename as basename2, dirname as dirname7, isAbsolute as isAbsolute3, join as join11 } from "node:path";
+import process7 from "node:process";
 
 // src/game-log.ts
 import { StringDecoder } from "node:string_decoder";
@@ -28757,6 +28750,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;
   }
@@ -28790,12 +28786,131 @@ function answersTo(entry, severity, contains) {
   return [entry.text, ...entry.detail].some((line) => line.toLowerCase().includes(needle));
 }
 
+// src/engine-run.ts
+function runEngine(executable, args, options = {}) {
+  return new Promise((resolve) => {
+    const log = new GameLog;
+    let failure = null;
+    const signal = callSignal();
+    const child = spawnHidden(executable, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      ...signal === undefined ? {} : { signal }
+    });
+    child.stdout.on("data", (chunk) => {
+      log.append("stdout", chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      log.append("stderr", chunk);
+    });
+    const { timeout } = options;
+    const timer = timeout === undefined ? undefined : setTimeout(() => {
+      failure ??= `it ran past its ${timeout.said}`;
+      child.kill();
+    }, timeout.ms);
+    child.on("error", (error) => {
+      failure ??= error.name === "AbortError" ? "the call was cancelled" : `it could not be started: ${error.message}`;
+    });
+    child.on("close", (code, closedBy) => {
+      clearTimeout(timer);
+      log.finish();
+      const started = child.pid !== undefined;
+      resolve({ log, exitCode: started ? code : null, exitSignal: closedBy, failure });
+    });
+  });
+}
+var 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"]
+]);
+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 ? exitCodeText(run.exitCode) : `ended by ${run.exitSignal}`;
+}
+
+// src/doc-cache.ts
+var CACHE_FILE = /^editor_doc_cache-\d+\.\d+\.res$/;
+function editorCacheDirectory(godotPath, platform = process7.platform, env = process7.env, home = homedir2()) {
+  const beside = dirname7(godotPath);
+  const bundle = platform === "darwin" && basename2(beside) === "MacOS" && basename2(dirname7(beside)) === "Contents" ? dirname7(dirname7(dirname7(beside))) : null;
+  for (const folder of bundle === null ? [beside] : [beside, bundle]) {
+    if (existsSync7(join11(folder, "._sc_")) || existsSync7(join11(folder, "_sc_"))) {
+      return join11(folder, "editor_data", "cache");
+    }
+  }
+  if (platform === "win32") {
+    const set = (name) => env[name] === "" ? undefined : env[name];
+    return join11(set("LOCALAPPDATA") ?? set("TEMP") ?? join11(home, "AppData", "Local"), "Godot");
+  }
+  if (platform === "darwin") {
+    return join11(home, "Library", "Caches", "Godot");
+  }
+  const xdg = env["XDG_CACHE_HOME"];
+  return join11(xdg !== undefined && isAbsolute3(xdg) ? xdg : join11(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(join11(directory, name), statSync5(join11(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.";
+}
+
 // src/editor-log.ts
+import {
+  closeSync as closeSync2,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync7,
+  openSync as openSync2,
+  readFileSync as readFileSync12,
+  readSync,
+  rmSync as rmSync6,
+  statSync as statSync6,
+  writeFileSync as writeFileSync8
+} from "node:fs";
+import { dirname as dirname8, join as join12 } from "node:path";
 function editorLogPath(projectPath) {
-  return join11(projectPath, ".godot", "gdharness-editor.log");
+  return join12(projectPath, ".godot", "gdharness-editor.log");
 }
 function editorLogNotePath(projectPath) {
-  return join11(projectPath, ".godot", "gdharness-editor.json");
+  return join12(projectPath, ".godot", "gdharness-editor.json");
 }
 function readEditorLogNote(projectPath) {
   try {
@@ -28810,7 +28925,7 @@ function readEditorLogNote(projectPath) {
 function clearEditorLog(projectPath) {
   try {
     const path = editorLogPath(projectPath);
-    mkdirSync7(dirname7(path), { recursive: true });
+    mkdirSync7(dirname8(path), { recursive: true });
     rmSync6(path, { force: true });
     rmSync6(editorLogNotePath(projectPath), { force: true });
   } catch {}
@@ -28818,7 +28933,7 @@ function clearEditorLog(projectPath) {
 function writeEditorLogNote(projectPath, pid) {
   try {
     const path = editorLogNotePath(projectPath);
-    mkdirSync7(dirname7(path), { recursive: true });
+    mkdirSync7(dirname8(path), { recursive: true });
     writeFileSync8(path, JSON.stringify({ pid, startedAt: new Date().toISOString() }, null, 2), "utf8");
   } catch {}
 }
@@ -28840,7 +28955,7 @@ function editorConsole(projectPath, editorPid, openedByAServer) {
     return { kind: "older server", notedPid: noted?.pid ?? null };
   }
   const path = editorLogPath(projectPath);
-  if (!existsSync7(path)) {
+  if (!existsSync8(path)) {
     return { kind: "not written" };
   }
   const log = new GameLog;
@@ -28899,7 +29014,7 @@ function foldProgress(text) {
 }
 var MOST_CONSOLE_BYTES = 8 * 1024 * 1024;
 function theFirstOf(path) {
-  const whole = statSync5(path).size;
+  const whole = statSync6(path).size;
   if (whole <= MOST_CONSOLE_BYTES) {
     return { text: readFileSync12(path, "utf8") };
   }
@@ -29056,60 +29171,21 @@ function linesBefore(entries, at, collapsed, wanted) {
   return found.reverse();
 }
 
-// src/engine-run.ts
-function runEngine(executable, args, options = {}) {
-  return new Promise((resolve) => {
-    const log = new GameLog;
-    let failure = null;
-    const signal = callSignal();
-    const child = spawnHidden(executable, args, {
-      stdio: ["ignore", "pipe", "pipe"],
-      ...signal === undefined ? {} : { signal }
-    });
-    child.stdout.on("data", (chunk) => {
-      log.append("stdout", chunk);
-    });
-    child.stderr.on("data", (chunk) => {
-      log.append("stderr", chunk);
-    });
-    const { timeout } = options;
-    const timer = timeout === undefined ? undefined : setTimeout(() => {
-      failure ??= `it ran past its ${timeout.said}`;
-      child.kill();
-    }, timeout.ms);
-    child.on("error", (error) => {
-      failure ??= error.name === "AbortError" ? "the call was cancelled" : `it could not be started: ${error.message}`;
-    });
-    child.on("close", (code, closedBy) => {
-      clearTimeout(timer);
-      log.finish();
-      const started = child.pid !== undefined;
-      resolve({ log, exitCode: started ? code : null, exitSignal: closedBy, failure });
-    });
-  });
-}
-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}`;
-}
-
 // src/file-move.ts
 import {
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   mkdirSync as mkdirSync10,
-  readdirSync as readdirSync5,
+  readdirSync as readdirSync6,
   readFileSync as readFileSync16,
   renameSync as renameSync3,
-  statSync as statSync6,
+  statSync as statSync7,
   writeFileSync as writeFileSync11
 } from "node:fs";
-import { basename as basename3, dirname as dirname11, extname as extname3, join as join15, relative as relative4 } from "node:path";
+import { basename as basename4, dirname as dirname12, extname as extname3, join as join16, relative as relative4 } from "node:path";
 
 // src/project-scan.ts
-import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync13 } from "node:fs";
-import { extname, join as join12 } from "node:path";
+import { existsSync as existsSync9, readdirSync as readdirSync4, readFileSync as readFileSync13 } from "node:fs";
+import { extname, join as join13 } from "node:path";
 var SKIPPED = new Set(["node_modules"]);
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
@@ -29119,10 +29195,10 @@ function steppedOver(directory) {
   return gdignored(directory) || installedByUs(directory);
 }
 function gdignored(directory) {
-  return existsSync8(join12(directory, ".gdignore"));
+  return existsSync9(join13(directory, ".gdignore"));
 }
 function installedByUs(directory) {
-  return existsSync8(join12(directory, VERSION_MARKER));
+  return existsSync9(join13(directory, VERSION_MARKER));
 }
 var SCENE_EXTENSIONS = new Set(["tscn", "scn"]);
 var ASSET_EXTENSIONS = new Set([
@@ -29161,12 +29237,12 @@ function projectStructure(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync3(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join12(directory, entry.name));
+        visit(join13(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (SCENE_EXTENSIONS.has(extension)) {
@@ -29190,13 +29266,13 @@ function projectFiles(projectPath, extensions) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync3(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join12(directory, entry.name), spelled);
+        visit(join13(directory, entry.name), spelled);
       } else if (entry.isFile() && extensions.includes(extname(entry.name).toLowerCase())) {
         found.push(spelled);
       }
@@ -29212,20 +29288,20 @@ function scriptsWithoutUid(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync3(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join12(directory, entry.name), spelled);
+        visit(join13(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync8(join12(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync9(join13(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -29253,11 +29329,11 @@ function projectTexts(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync3(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
-      const absolute = join12(directory, entry.name);
+      const absolute = join13(directory, entry.name);
       const spelled = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
         visit(absolute, `${spelled}/`);
@@ -29283,11 +29359,11 @@ function ignoredTexts(projectPath) {
       return;
     }
     const under = ignored || gdignored(directory);
-    for (const entry of readdirSync3(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
-      const absolute = join12(directory, entry.name);
+      const absolute = join13(directory, entry.name);
       const spelled = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
         visit(absolute, `${spelled}/`, under);
@@ -29320,14 +29396,14 @@ function searchProject(projectPath, options) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync3(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
       if (full()) {
         return;
       }
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join12(directory, entry.name);
+      const entryPath = join13(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -29366,8 +29442,8 @@ function searchProject(projectPath, options) {
 }
 
 // src/rename.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync14, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname8, posix as posix2 } from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync8, readFileSync as readFileSync14, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname9, posix as posix2 } from "node:path";
 class Script {
   path;
   text;
@@ -30096,21 +30172,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 && existsSync9(rewrite.writeTo)) {
+    if (rewrite.writeTo !== rewrite.absolute && existsSync10(rewrite.writeTo)) {
       throw new Error(`${rewrite.writeTo} already exists; nothing was written`);
     }
   }
   const done = [];
   try {
     for (const rewrite of rewrites) {
-      mkdirSync8(dirname8(rewrite.writeTo), { recursive: true });
+      mkdirSync8(dirname9(rewrite.writeTo), { recursive: true });
       const staging = `${rewrite.writeTo}.gdharness-rename`;
       writeFileSync9(staging, rewrite.after, "utf8");
       renameSync2(staging, rewrite.writeTo);
       let movedUid = false;
       if (rewrite.writeTo !== rewrite.absolute) {
         unlinkSync2(rewrite.absolute);
-        if (existsSync9(`${rewrite.absolute}.uid`)) {
+        if (existsSync10(`${rewrite.absolute}.uid`)) {
           renameSync2(`${rewrite.absolute}.uid`, `${rewrite.writeTo}.uid`);
           movedUid = true;
         }
@@ -30134,14 +30210,14 @@ function applyRewrites(rewrites) {
 }
 
 // src/rename-symbol.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync9, readdirSync as readdirSync4, realpathSync as realpathSync4, rmSync as rmSync7, writeFileSync as writeFileSync10 } from "node:fs";
-import { basename as basename2, dirname as dirname10, join as join14, relative as relative3, resolve as resolve5 } from "node:path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, readdirSync as readdirSync5, realpathSync as realpathSync4, rmSync as rmSync7, writeFileSync as writeFileSync10 } from "node:fs";
+import { basename as basename3, dirname as dirname11, join as join15, relative as relative3, resolve as resolve5 } from "node:path";
 
 // src/lsp_client.ts
-import { existsSync as existsSync10, realpathSync as realpathSync2 } from "node:fs";
+import { existsSync as existsSync11, realpathSync as realpathSync2 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
 import { createConnection as createConnection3 } from "node:net";
-import { dirname as dirname9, join as join13, resolve as resolve3 } from "node:path";
+import { dirname as dirname10, join as join14, resolve as resolve3 } from "node:path";
 import { setTimeout as delay4 } from "node:timers/promises";
 import { fileURLToPath, pathToFileURL } from "node:url";
 var DEFAULT_LSP_PORT = 6005;
@@ -30339,7 +30415,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname9(resolve3(filePath));
+    const rootPath = this.rootPath ?? dirname10(resolve3(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params, timeoutMs = this.timeouts.requestMs) {
@@ -30912,7 +30988,7 @@ async function resolveLSPPaths(projectPathValue, scriptPathValue) {
   } catch {
     throw new ArgumentRefusal(`Project path does not exist: ${requestedProjectPath}`);
   }
-  if (!existsSync10(join13(projectPath, "project.godot"))) {
+  if (!existsSync11(join14(projectPath, "project.godot"))) {
     throw new ArgumentRefusal(`Not a Godot project: ${projectPath}. Point projectPath at the directory holding project.godot.`);
   }
   const contained = resolveWithinProject(projectPath, scriptPathValue);
@@ -31287,13 +31363,13 @@ function onDiskSpelling(path) {
   let at = resolve5(path);
   for (;; ) {
     try {
-      return join14(realpathSync4.native(at), ...missing.reverse());
+      return join15(realpathSync4.native(at), ...missing.reverse());
     } catch {
-      const parent = dirname10(at);
+      const parent = dirname11(at);
       if (parent === at) {
         return resolve5(path);
       }
-      missing.push(basename2(at));
+      missing.push(basename3(at));
       at = parent;
     }
   }
@@ -31340,7 +31416,7 @@ async function renameSymbol(request, services) {
         reason: `newScriptPath must be a .gd path inside the project, and ${request.newScriptPath} is not.`
       };
     }
-    if (existsSync11(request.newScriptPath)) {
+    if (existsSync12(request.newScriptPath)) {
       return { ok: false, reason: `${moveTo} already exists, so the script cannot be moved there.` };
     }
   }
@@ -31516,7 +31592,7 @@ async function renameSymbol(request, services) {
       scripts,
       moves: new Map([[declaringPath, moveTo]]),
       named: [declaringPath],
-      exists: (path) => existsSync11(`${projectPath}/${path.slice("res://".length)}`)
+      exists: (path) => existsSync12(`${projectPath}/${path.slice("res://".length)}`)
     }, plan);
   }
   plan = mentionIgnored(plan, ignoredTexts(projectPath), symbol, moveTo === null ? [] : [declaringPath]);
@@ -31717,15 +31793,15 @@ ${mention.kind}`;
 var LEFT_ALONE_ANSWER_LINES = 300;
 var detailWrites = 0;
 function writeLeftAloneDetail(projectPath, symbol, detail) {
-  const directory = join14(projectPath, ".godot", "gdharness-renames");
+  const directory = join15(projectPath, ".godot", "gdharness-renames");
   mkdirSync9(directory, { recursive: true });
   detailWrites += 1;
-  const path = join14(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
+  const path = join15(directory, `${String(Date.now())}-${String(detailWrites).padStart(6, "0")}-${String(process.pid)}-${symbol}.json`);
   writeFileSync10(path, `${JSON.stringify(detail, null, 2)}
 `, "utf8");
-  const kept = readdirSync4(directory).filter((name) => name.endsWith(".json")).sort().reverse();
+  const kept = readdirSync5(directory).filter((name) => name.endsWith(".json")).sort().reverse();
   for (const old of kept.slice(10)) {
-    rmSync7(join14(directory, old), { force: true });
+    rmSync7(join15(directory, old), { force: true });
   }
   return path;
 }
@@ -31750,15 +31826,15 @@ function summaryOf(edits, mentions, rewrites, left) {
 // src/file-move.ts
 var SIDECARS = [".uid", ".import"];
 function filesUnder(directory) {
-  return readdirSync5(directory, { withFileTypes: true }).flatMap((entry) => {
-    const path = join15(directory, entry.name);
+  return readdirSync6(directory, { withFileTypes: true }).flatMap((entry) => {
+    const path = join16(directory, entry.name);
     return entry.isDirectory() ? filesUnder(path) : [path];
   });
 }
 function sameFile(one, other) {
   try {
-    const a = statSync6(one);
-    const b = statSync6(other);
+    const a = statSync7(one);
+    const b = statSync7(other);
     return a.ino === b.ino && a.dev === b.dev;
   } catch {
     return false;
@@ -31772,8 +31848,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 = join15(directory, step);
-      if (existsSync12(join15(directory, ".gdignore"))) {
+      directory = join16(directory, step);
+      if (existsSync13(join16(directory, ".gdignore"))) {
         return `${path} is under a directory holding a .gdignore, which the engine does not load`;
       }
     }
@@ -31785,21 +31861,21 @@ function installedAddonOf(projectPath, path) {
   if (steps[0] !== "addons" || steps[1] === undefined) {
     return null;
   }
-  return existsSync12(join15(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
+  return existsSync13(join16(projectPath, "addons", steps[1], VERSION_MARKER)) ? `res://addons/${steps[1]}` : null;
 }
 function binaryResources(projectPath) {
   const found = [];
   const visit = (directory, prefix) => {
-    if (existsSync12(join15(directory, ".gdignore"))) {
+    if (existsSync13(join16(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 = `${prefix}${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join15(directory, entry.name), `${path}/`);
+        visit(join16(directory, entry.name), `${path}/`);
       } else if (/\.(scn|res)$/i.test(entry.name)) {
         found.push(path);
       }
@@ -31809,7 +31885,7 @@ function binaryResources(projectPath) {
   return found;
 }
 function targetPathOf(projectPath, absolute) {
-  const inside = relative4(onDiskSpelling(projectPath), join15(onDiskSpelling(dirname11(absolute)), basename3(absolute)));
+  const inside = relative4(onDiskSpelling(projectPath), join16(onDiskSpelling(dirname12(absolute)), basename4(absolute)));
   if (inside === "" || inside.startsWith("..") || /^[A-Za-z]:/.test(inside)) {
     return null;
   }
@@ -31827,13 +31903,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 (!existsSync12(absoluteFrom)) {
+  if (!existsSync13(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 = statSync6(absoluteFrom).isDirectory();
+  const isDirectory = statSync7(absoluteFrom).isDirectory();
   if (from === "res://project.godot") {
     return {
       ok: false,
@@ -31856,7 +31932,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   if (isDirectory && to.startsWith(`${from}/`)) {
     return { ok: false, reason: `${from} cannot be moved into itself.` };
   }
-  if (existsSync12(absoluteTo) && !sameFile(absoluteFrom, absoluteTo)) {
+  if (existsSync13(absoluteTo) && !sameFile(absoluteFrom, absoluteTo)) {
     return { ok: false, reason: `${to} already exists, so nothing was moved there.` };
   }
   const unseen = unseenByTheEngine(projectPath, to);
@@ -31864,7 +31940,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 && existsSync12(join15(projectPath, path.slice("res://".length))));
+    const owner = SIDECARS.map((sidecar) => from.endsWith(sidecar) ? from.slice(0, -sidecar.length) : null).find((path) => path !== null && existsSync13(join16(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.` };
     }
@@ -31886,7 +31962,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   } else {
     moves.set(from, to);
     for (const sidecar of SIDECARS) {
-      if (existsSync12(`${absoluteFrom}${sidecar}`)) {
+      if (existsSync13(`${absoluteFrom}${sidecar}`)) {
         moves.set(`${from}${sidecar}`, `${to}${sidecar}`);
       }
     }
@@ -31898,12 +31974,12 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
     scripts,
     moves,
     named: [from],
-    exists: (path) => existsSync12(join15(projectPath, path.slice("res://".length)))
+    exists: (path) => existsSync13(join16(projectPath, path.slice("res://".length)))
   }, { edits: [], mentions: [] });
   plan = mentionIgnored(plan, ignoredTexts(projectPath), null, [from]);
   const binaries = [];
   for (const path of binaryResources(projectPath)) {
-    const bytes = readFileSync16(join15(projectPath, path.slice("res://".length)));
+    const bytes = readFileSync16(join16(projectPath, path.slice("res://".length)));
     const names = [...moves.keys()].find((moving) => bytes.includes(moving));
     if (names !== undefined) {
       binaries.push({
@@ -31922,7 +31998,7 @@ function planFileMove(projectPath, absoluteFrom, absoluteTo) {
   }));
   const left = leftAloneReport(mentions);
   const rewrites = rewritesOf(plan, texts, null);
-  const absoluteOf = (path) => join15(projectPath, path.slice("res://".length));
+  const absoluteOf = (path) => join16(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);
@@ -31969,19 +32045,19 @@ function applyFileMove(outcome) {
     }
   }
   for (const file of outcome.moved) {
-    if (!existsSync12(file.absoluteFrom)) {
+    if (!existsSync13(file.absoluteFrom)) {
       throw new Error(`${file.from} is gone from disk; nothing was written`);
     }
     if (file.text !== null && readFileSync16(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 (existsSync12(file.absoluteTo) && !sameFile(file.absoluteFrom, file.absoluteTo)) {
+    if (existsSync13(file.absoluteTo) && !sameFile(file.absoluteFrom, file.absoluteTo)) {
       throw new Error(`${file.to} already exists; nothing was written`);
     }
   }
   const undo = [];
   const rename = (source, target) => {
-    mkdirSync10(dirname11(target), { recursive: true });
+    mkdirSync10(dirname12(target), { recursive: true });
     renameSync3(source, target);
     undo.push(() => {
       renameSync3(target, source);
@@ -32704,27 +32780,27 @@ function getDefaultBridge(ownProject = null) {
 }
 
 // src/godot-path.ts
-import { existsSync as existsSync14 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 import { normalize } from "node:path";
 
 // src/detection.ts
-import { existsSync as existsSync13, readdirSync as readdirSync6, statSync as statSync7 } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join as join16 } from "node:path";
+import { existsSync as existsSync14, readdirSync as readdirSync7, statSync as statSync8 } from "node:fs";
+import { homedir as homedir3 } from "node:os";
+import { join as join17 } from "node:path";
 function resolveHomeDirectory() {
   try {
-    return homedir2();
+    return homedir3();
   } catch {
     return "";
   }
 }
 function scanDirectoryForGodotBinaries(directory, platform) {
-  if (!directory || !existsSync13(directory)) {
+  if (!directory || !existsSync14(directory)) {
     return [];
   }
   let entries;
   try {
-    entries = readdirSync6(directory);
+    entries = readdirSync7(directory);
   } catch {
     return [];
   }
@@ -32734,16 +32810,16 @@ function scanDirectoryForGodotBinaries(directory, platform) {
     if (!pattern.test(name)) {
       continue;
     }
-    const fullPath = join16(directory, name);
+    const fullPath = join17(directory, name);
     try {
-      const stat = statSync7(fullPath);
+      const stat = statSync8(fullPath);
       if (stat.isFile()) {
         matches.push({ name, mtime: stat.mtimeMs });
       }
     } catch {}
   }
   matches.sort((a, b) => b.mtime - a.mtime);
-  return matches.map((m) => join16(directory, m.name));
+  return matches.map((m) => join17(directory, m.name));
 }
 function conventionalPaths(platform, home) {
   const paths = ["godot"];
@@ -32844,7 +32920,7 @@ class GodotLocator {
       return known;
     }
     let reason;
-    if (path !== "godot" && !existsSync14(path)) {
+    if (path !== "godot" && !existsSync15(path)) {
       reason = "does not exist";
     } else {
       try {
@@ -32860,12 +32936,12 @@ class GodotLocator {
 }
 
 // src/headless.ts
-import { existsSync as existsSync18, readFileSync as readFileSync19, realpathSync as realpathSync5, writeFileSync as writeFileSync13 } from "node:fs";
-import { dirname as dirname13, join as join20 } from "node:path";
+import { existsSync as existsSync19, readFileSync as readFileSync19, realpathSync as realpathSync5, writeFileSync as writeFileSync13 } from "node:fs";
+import { dirname as dirname14, join as join21 } from "node:path";
 
 // src/library-copies.ts
-import { existsSync as existsSync15, readdirSync as readdirSync7, readFileSync as readFileSync17, renameSync as renameSync4, unlinkSync as unlinkSync3 } from "node:fs";
-import { basename as basename4, dirname as dirname12, isAbsolute as isAbsolute3, join as join17 } from "node:path";
+import { existsSync as existsSync16, readdirSync as readdirSync8, readFileSync as readFileSync17, renameSync as renameSync4, unlinkSync as unlinkSync3 } from "node:fs";
+import { basename as basename5, dirname as dirname13, isAbsolute as isAbsolute4, join as join18 } from "node:path";
 function freeLibraryCopies(projectPath, platform = process.platform) {
   const setAside = [];
   const swept = [];
@@ -32873,26 +32949,26 @@ function freeLibraryCopies(projectPath, platform = process.platform) {
     return { setAside, swept };
   }
   for (const library of windowsLibraries(projectPath)) {
-    const folder = dirname12(library);
-    const copy = `~${basename4(library)}`;
-    if (existsSync15(join17(folder, copy))) {
-      const aside = join17(folder, `${copy}.aside-${process.pid}-${Date.now()}`);
+    const folder = dirname13(library);
+    const copy = `~${basename5(library)}`;
+    if (existsSync16(join18(folder, copy))) {
+      const aside = join18(folder, `${copy}.aside-${process.pid}-${Date.now()}`);
       try {
-        renameSync4(join17(folder, copy), aside);
+        renameSync4(join18(folder, copy), aside);
         setAside.push(aside);
       } catch {}
     }
     let names;
     try {
-      names = readdirSync7(folder);
+      names = readdirSync8(folder);
     } catch {
       continue;
     }
     for (const name of names) {
       if (name.length > copy.length && name.toLowerCase().startsWith(copy.toLowerCase())) {
         try {
-          unlinkSync3(join17(folder, name));
-          swept.push(join17(folder, name));
+          unlinkSync3(join18(folder, name));
+          swept.push(join18(folder, name));
         } catch {}
       }
     }
@@ -32900,7 +32976,7 @@ function freeLibraryCopies(projectPath, platform = process.platform) {
   return { setAside, swept };
 }
 function windowsLibraries(projectPath) {
-  const listed = readOrNull(join17(projectPath, ".godot", "extension_list.cfg"));
+  const listed = readOrNull(join18(projectPath, ".godot", "extension_list.cfg"));
   if (listed === null) {
     return [];
   }
@@ -32919,7 +32995,7 @@ function windowsLibraries(projectPath) {
         continue;
       }
       const named = inLibraries ? /^\s*windows[\w.]*\s*=\s*"([^"]+)"/.exec(row)?.[1] : undefined;
-      const library = named === undefined ? null : resolveResource(projectPath, dirname12(manifest), named);
+      const library = named === undefined ? null : resolveResource(projectPath, dirname13(manifest), named);
       if (library !== null) {
         libraries.add(library);
       }
@@ -32932,9 +33008,9 @@ function resolveResource(projectPath, relativeTo, path) {
     return null;
   }
   if (path.startsWith("res://")) {
-    return join17(projectPath, path.slice("res://".length));
+    return join18(projectPath, path.slice("res://".length));
   }
-  return isAbsolute3(path) ? path : join17(relativeTo, path);
+  return isAbsolute4(path) ? path : join18(relativeTo, path);
 }
 function readOrNull(path) {
   try {
@@ -32946,34 +33022,35 @@ function readOrNull(path) {
 
 // src/reimport.ts
 import { createHash as createHash3 } from "node:crypto";
-import { existsSync as existsSync16, readFileSync as readFileSync18, rmSync as rmSync8, statSync as statSync8, utimesSync, writeFileSync as writeFileSync12 } from "node:fs";
-import { basename as basename5, join as join18 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync18, rmSync as rmSync8, statSync as statSync9, utimesSync, writeFileSync as writeFileSync12 } from "node:fs";
+import { basename as basename6, join as join19 } from "node:path";
 function forceNextImport(projectPath, resourcePath) {
   const relative = resourcePath.replace(/^res:\/\//, "");
-  const sidecar = join18(projectPath, `${relative}.import`);
-  if (!existsSync16(sidecar)) {
+  const sidecar = join19(projectPath, `${relative}.import`);
+  if (!existsSync17(sidecar)) {
     return;
   }
-  const { atime, mtimeMs } = statSync8(sidecar);
+  const { atime, mtimeMs } = statSync9(sidecar);
   writeFileSync12(sidecar, readFileSync18(sidecar, "utf8").replace(/^valid=false\r?\n/m, ""));
   utimesSync(sidecar, atime, new Date(mtimeMs + 2000));
   rmSync8(importRecord(projectPath, resourcePath), { force: true });
 }
 function importRecord(projectPath, resourcePath) {
   const digest = createHash3("md5").update(resourcePath).digest("hex");
-  return join18(projectPath, ".godot", "imported", `${basename5(resourcePath)}-${digest}.md5`);
+  return join19(projectPath, ".godot", "imported", `${basename6(resourcePath)}-${digest}.md5`);
 }
 
 // src/scratch.ts
-import { existsSync as existsSync17, mkdtempSync as mkdtempSync2, readdirSync as readdirSync8, rmSync as rmSync9 } from "node:fs";
+import { existsSync as existsSync18, mkdtempSync as mkdtempSync2, readdirSync as readdirSync9, rmSync as rmSync9 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { join as join19 } from "node:path";
-import process7 from "node:process";
+import { join as join20 } from "node:path";
+import process8 from "node:process";
 var SWEPT = { recursive: true, force: true };
 var AGAIN_AFTER_MS = [250, 500, 1000, 2000, 4000, 8000, 16000];
 var waiting = new Set;
 var atExit = new Set;
 var KINDS = [
+  "answers",
   "desktop",
   "export",
   "import",
@@ -32982,12 +33059,12 @@ var KINDS = [
   "tests"
 ];
 function scratchDirectory(kind) {
-  return mkdtempSync2(join19(tmpdir5(), `gdharness-${kind}-${process7.pid}-`));
+  return mkdtempSync2(join20(tmpdir5(), `gdharness-${kind}-${process8.pid}-`));
 }
 function sweepAbandonedScratch(directory = tmpdir5()) {
   let entries;
   try {
-    entries = readdirSync8(directory);
+    entries = readdirSync9(directory);
   } catch {
     return;
   }
@@ -32998,7 +33075,7 @@ function sweepAbandonedScratch(directory = tmpdir5()) {
       continue;
     }
     try {
-      remove(join19(directory, entry));
+      remove(join20(directory, entry));
     } catch {}
   }
 }
@@ -33036,7 +33113,7 @@ function tryAgain(path, attempt) {
     lastTryOnExit();
   }
   const after = AGAIN_AFTER_MS[attempt];
-  if (after === undefined || !existsSync17(path)) {
+  if (after === undefined || !existsSync18(path)) {
     waiting.delete(path);
     if (after === undefined) {
       atExit.add(path);
@@ -33058,7 +33135,7 @@ function lastTryOnExit() {
     return;
   }
   lastTryWatched = true;
-  process7.once("exit", () => {
+  process8.once("exit", () => {
     for (const path of [...waiting, ...atExit]) {
       try {
         remove(path);
@@ -33078,8 +33155,14 @@ function snakeCased(params) {
 }
 function engineExtras(outcome) {
   const after = outcome.afterAnswerMessages ?? [];
+  const before = outcome.beforeOperationMessages ?? [];
   return {
     ...outcome.messages.length > 0 ? { engine_messages: outcome.messages } : {},
+    ...before.length > 0 ? {
+      engine_messages_before_operation: before,
+      engine_messages_before_operation_note: BEFORE_OPERATION_NOTE
+    } : {},
+    ...outcome.beforeOperationOmitted === undefined ? {} : { engine_messages_before_operation_omitted: outcome.beforeOperationOmitted },
     ...outcome.messagesOmitted === undefined ? {} : { engine_messages_omitted: outcome.messagesOmitted },
     ...after.length > 0 ? { engine_messages_after_answer: after, engine_messages_after_answer_note: AFTER_ANSWER_NOTE } : {},
     ...outcome.afterAnswerOmitted === undefined ? {} : { engine_messages_after_answer_omitted: outcome.afterAnswerOmitted },
@@ -33087,8 +33170,11 @@ function engineExtras(outcome) {
   };
 }
 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.";
+var 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.";
 var OWN_ERROR = "[ERROR] ";
 var ANSWERED = "[gdharness] answered";
+var WAITING = "[gdharness] waiting for the autoloads";
+var BEGUN = "[gdharness] begun";
 var MESSAGES_KEPT = 200;
 var ERRORS_NAMED = 3;
 function problemsIn(log) {
@@ -33127,7 +33213,7 @@ function refusalsIn(log) {
 }
 function scriptFault(problems, script) {
   const spelled = (path) => `(${path.replaceAll("\\", "/").toLowerCase()}/`;
-  const directories = [...new Set([spelled(dirname13(script)), spelled(resolvedOr(dirname13(script)))])];
+  const directories = [...new Set([spelled(dirname14(script)), spelled(resolvedOr(dirname14(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));
@@ -33165,26 +33251,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",
-      join20(logDir, "engine.log"),
+      join21(logDir, "engine.log"),
       "--path",
       projectPath,
       "--import"
@@ -33193,24 +33286,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 = join20(paramsDir, `${operation}.json`);
-  const answerFile = join20(paramsDir, "answer.json");
+  const paramsFile = join21(paramsDir, `${operation}.json`);
+  const answerFile = join21(paramsDir, "answer.json");
   writeFileSync13(paramsFile, JSON.stringify(snakeCased(params)), "utf8");
   const args = [
     "--headless",
     "--log-file",
-    join20(paramsDir, "engine.log"),
+    join21(paramsDir, "engine.log"),
     "--path",
     projectPath,
     "--script",
@@ -33229,12 +33324,22 @@ async function runOperation(engine, operation, params, projectPath) {
     discard(paramsDir);
   }
   const everything = ran.log.everything();
-  const answered = everything.findIndex((entry) => entry.source === "stderr" && entry.text === ANSWERED);
-  const problems = problemsAmong(answered === -1 ? everything : everything.slice(0, answered));
+  const marked = (text) => everything.findIndex((entry) => entry.source === "stderr" && entry.text === text);
+  const answered = marked(ANSWERED);
+  const waiting = marked(WAITING);
+  const begun = marked(BEGUN);
+  const ended = answered === -1 ? everything.length : answered;
+  const problems = waiting === -1 ? problemsAmong(everything.slice(0, ended)) : problemsAmong([
+    ...everything.slice(0, waiting),
+    ...begun === -1 ? [] : everything.slice(begun + 1, ended)
+  ]);
+  const startup = waiting === -1 ? [] : problemsAmong(everything.slice(waiting + 1, begun === -1 ? ended : begun));
   const after = answered === -1 ? [] : problemsAmong(everything.slice(answered + 1));
   const afterAnswered = {
     ...after.length === 0 ? {} : { afterAnswerMessages: after.slice(-MESSAGES_KEPT) },
-    ...after.length > MESSAGES_KEPT ? { afterAnswerOmitted: after.length - MESSAGES_KEPT } : {}
+    ...after.length > MESSAGES_KEPT ? { afterAnswerOmitted: after.length - MESSAGES_KEPT } : {},
+    ...startup.length === 0 ? {} : { beforeOperationMessages: startup.slice(-MESSAGES_KEPT) },
+    ...startup.length > MESSAGES_KEPT ? { beforeOperationOmitted: startup.length - MESSAGES_KEPT } : {}
   };
   if (answer.kind === "unreadable") {
     return {
@@ -33245,6 +33350,14 @@ async function runOperation(engine, operation, params, projectPath) {
     };
   }
   if (answer.kind === "none") {
+    if (waiting !== -1 && begun === -1) {
+      return {
+        ok: false,
+        message: `${operation} never ran: the engine ended (${howItEnded(ran)}) while it started the project's ` + `autoloads, which this operation waits for. The last it reported: ${reason(ran.log, startup)}`,
+        ...reported2(problems),
+        ...afterAnswered
+      };
+    }
     const refusals = refusalsIn(ran.log);
     if (refusals.length > 0) {
       const said = new Set(refusals.map((entry) => entry.index));
@@ -33280,7 +33393,7 @@ async function runOperation(engine, operation, params, projectPath) {
   };
 }
 function answerIn(file) {
-  if (!existsSync18(file)) {
+  if (!existsSync19(file)) {
     return { kind: "none" };
   }
   const text = readFileSync19(file, "utf8");
@@ -33686,6 +33799,31 @@ ${note}`;
     return detail === entry.detail ? entry : { ...entry, detail };
   });
 }
+var MOST_REPORTS_SHOWN = 20;
+var LONGEST_DETAIL = 20000;
+function shortened(detail) {
+  if (detail === null || detail.length <= LONGEST_DETAIL) {
+    return detail;
+  }
+  return `${detail.slice(0, LONGEST_DETAIL)}
+[${detail.length - LONGEST_DETAIL} more characters left out]`;
+}
+function foldedReports(reports) {
+  const first = new Map;
+  for (const report of reports) {
+    const key = JSON.stringify([report.kind, report.message, report.detail]);
+    const seen = first.get(key);
+    if (seen === undefined) {
+      first.set(key, { report, times: 1 });
+    } else {
+      seen.times += 1;
+    }
+  }
+  return [...first.values()].map(({ report, times }) => {
+    const kept = { ...report, detail: shortened(report.detail) };
+    return times === 1 ? kept : { ...kept, times };
+  });
+}
 function failedCases(report, printed) {
   const cases = report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ entry, path: suite.path })));
   const read = withActualsPrinted(cases.flatMap(({ entry }) => entry.reports), printed);
@@ -33693,6 +33831,8 @@ function failedCases(report, printed) {
   return cases.map(({ entry, path }) => {
     const reports = read.slice(next, next + entry.reports.length);
     next += entry.reports.length;
+    const folded = foldedReports(reports);
+    const shown = folded.slice(0, MOST_REPORTS_SHOWN);
     return {
       suite: entry.suite,
       name: entry.name,
@@ -33700,11 +33840,34 @@ function failedCases(report, printed) {
       time: entry.time,
       path,
       message: reports[0]?.message ?? null,
-      detail: reports[0]?.detail ?? null,
-      ...reports.length > 1 ? { reports } : {}
+      detail: shortened(reports[0]?.detail ?? null),
+      ...reports.length > 1 ? { reports: shown, reportCount: reports.length } : {},
+      ...folded.length > shown.length ? { reportsLeftOut: folded.length - shown.length } : {}
     };
   });
 }
+function failedWithin(failed, budget) {
+  const sizes = failed.map((entry) => JSON.stringify(entry).length);
+  const smallestFirst = sizes.map((_, index) => index).sort((a, b) => (sizes[a] ?? 0) - (sizes[b] ?? 0));
+  const whole = new Set;
+  let spent = 0;
+  for (const index of smallestFirst) {
+    const size = sizes[index] ?? 0;
+    if (spent + size > budget) {
+      break;
+    }
+    spent += size;
+    whole.add(index);
+  }
+  const kept = failed.map((entry, index) => {
+    if (whole.has(index)) {
+      return entry;
+    }
+    const { detail: _detail, reports: _reports, reportsLeftOut: _left, ...named } = entry;
+    return { ...named, message: entry.message?.slice(0, 500) ?? null, detail: null };
+  });
+  return { failed: kept, briefed: failed.length - whole.size };
+}
 var MASKED_BRACKET = "[lb]";
 function masked(expected, actual) {
   const allSpelled = (value) => !PRINTED_DICTIONARY.test(value) && value.split("[").length === value.split(MASKED_BRACKET).length;
@@ -33856,26 +34019,26 @@ function askTheKeeper(address, line, withinMs) {
 }
 
 // src/lifecycle-log.ts
-import { appendFileSync, mkdirSync as mkdirSync11, renameSync as renameSync5, statSync as statSync9 } from "node:fs";
-import { dirname as dirname14, join as join21 } from "node:path";
-import process8 from "node:process";
+import { appendFileSync, mkdirSync as mkdirSync11, renameSync as renameSync5, statSync as statSync10 } from "node:fs";
+import { dirname as dirname15, join as join22 } from "node:path";
+import process9 from "node:process";
 function lifecycleLogPath() {
-  return join21(runtimeDirectory(), "servers.log");
+  return join22(runtimeDirectory(), "servers.log");
 }
 var LIFECYCLE_LOG_LIMIT = 1e6;
 function writeLifecycle(event, fields = {}) {
   const path = lifecycleLogPath();
   try {
-    mkdirSync11(dirname14(path), { recursive: true });
-    if ((statSync9(path, { throwIfNoEntry: false })?.size ?? 0) > LIFECYCLE_LOG_LIMIT) {
+    mkdirSync11(dirname15(path), { recursive: true });
+    if ((statSync10(path, { throwIfNoEntry: false })?.size ?? 0) > LIFECYCLE_LOG_LIMIT) {
       try {
         renameSync5(path, `${path}.1`);
       } catch {}
     }
     const line = {
       at: new Date().toISOString(),
-      pid: process8.pid,
-      ppid: process8.ppid,
+      pid: process9.pid,
+      ppid: process9.ppid,
       version: SERVER_VERSION,
       event
     };
@@ -34164,14 +34327,14 @@ function setupPromptHandlers(server) {
 
 // src/restart-note.ts
 import { mkdirSync as mkdirSync12, readFileSync as readFileSync20, rmSync as rmSync10, writeFileSync as writeFileSync14 } from "node:fs";
-import { dirname as dirname15, join as join22 } from "node:path";
+import { dirname as dirname16, join as join23 } from "node:path";
 function restartNotePath(projectPath) {
-  return join22(projectPath, ".godot", "gdharness-restart.json");
+  return join23(projectPath, ".godot", "gdharness-restart.json");
 }
 function noteRestartBegun(note) {
   const path = restartNotePath(note.projectPath);
   try {
-    mkdirSync12(dirname15(path), { recursive: true });
+    mkdirSync12(dirname16(path), { recursive: true });
     writeFileSync14(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
@@ -34203,23 +34366,23 @@ function restartSettled(projectPath) {
 
 // src/run-record.ts
 import { createHash as createHash4 } from "node:crypto";
-import { mkdirSync as mkdirSync13, openSync as openSync3, readdirSync as readdirSync9, readFileSync as readFileSync21, realpathSync as realpathSync6, rmSync as rmSync11, statSync as statSync10 } from "node:fs";
-import { basename as basename6, dirname as dirname16, join as join23, resolve as resolve6 } from "node:path";
+import { mkdirSync as mkdirSync13, openSync as openSync3, readdirSync as readdirSync10, readFileSync as readFileSync21, realpathSync as realpathSync6, rmSync as rmSync11, statSync as statSync11 } from "node:fs";
+import { basename as basename7, dirname as dirname17, join as join24, resolve as resolve6 } from "node:path";
 function runsDirectory() {
-  return join23(runtimeDirectory(), "runs");
+  return join24(runtimeDirectory(), "runs");
 }
 function realAsFarAsItExists(path) {
   const missing = [];
   let at = path;
   for (;; ) {
     try {
-      return join23(realpathSync6.native(at), ...missing);
+      return join24(realpathSync6.native(at), ...missing);
     } catch {
-      const parent = dirname16(at);
+      const parent = dirname17(at);
       if (parent === at) {
         return path;
       }
-      missing.unshift(basename6(at));
+      missing.unshift(basename7(at));
       at = parent;
     }
   }
@@ -34230,10 +34393,10 @@ function projectKey(projectPath) {
   return createHash4("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join23(directory, "runs", `note-${projectKey(projectPath)}.json`);
+  return join24(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function latestRunPath(servedBy, directory = runtimeDirectory()) {
-  return join23(directory, "runs", `latest-${projectKey(servedBy)}.json`);
+  return join24(directory, "runs", `latest-${projectKey(servedBy)}.json`);
 }
 function writeLatestRun(servedBy, latest) {
   try {
@@ -34259,17 +34422,20 @@ function readLatestRun(servedBy, directory = runtimeDirectory()) {
 var SHARED_NOTE = "run.json";
 function openTranscript(startedAt) {
   mkdirSync13(runsDirectory(), { recursive: true });
-  const path = join23(runsDirectory(), `run-${startedAt}.log`);
+  const path = join24(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync3(path, "a") };
 }
 function profilePath(startedAt) {
-  return join23(runsDirectory(), `run-${startedAt}.profile.json`);
+  return join24(runsDirectory(), `run-${startedAt}.profile.json`);
+}
+function profileMarkPath(startedAt) {
+  return join24(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 join23(directory, "runs", `editor-${projectKey(projectPath)}.json`);
+  return join24(directory, "runs", `editor-${projectKey(projectPath)}.json`);
 }
 function writeEditorRunNote(note) {
   mkdirSync13(runsDirectory(), { recursive: true });
@@ -34280,7 +34446,7 @@ function writeEditorRunNote(note) {
 }
 function readEditorRunNote(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join23(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(editorNotePath(projectPath, directory)) ?? editorNoteAt(join24(directory, "runs", "editor-run.json"));
     if (note !== null && isSameDirectory(note.projectPath, projectPath)) {
       return note;
     }
@@ -34314,7 +34480,7 @@ function readRunRecord(projectPath) {
     if (own !== null) {
       return own;
     }
-    const shared = recordAt(join23(directory, "runs", SHARED_NOTE));
+    const shared = recordAt(join24(directory, "runs", SHARED_NOTE));
     if (shared !== null && shared.projectPath !== "" && isSameDirectory(shared.projectPath, projectPath)) {
       return shared;
     }
@@ -34326,13 +34492,13 @@ function everyRunRecord() {
   for (const directory of runtimeDirectories()) {
     let entries;
     try {
-      entries = readdirSync9(join23(directory, "runs"));
+      entries = readdirSync10(join24(directory, "runs"));
     } catch {
       continue;
     }
     for (const entry of entries) {
       if (entry === SHARED_NOTE || entry.startsWith("note-") && entry.endsWith(".json")) {
-        const record = recordAt(join23(directory, "runs", entry));
+        const record = recordAt(join24(directory, "runs", entry));
         if (record !== null) {
           found.push(record);
         }
@@ -34502,7 +34668,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 : basename6(record.command);
+  const engine = record.command === undefined ? null : basename7(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)) {
@@ -34541,7 +34707,7 @@ function judgeAnnouncedGame(running, projectPath, announcedAt) {
 }
 function clearRunRecord(projectPath) {
   for (const directory of runtimeDirectories()) {
-    const shared = join23(directory, "runs", SHARED_NOTE);
+    const shared = join24(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] : []]) {
@@ -34553,7 +34719,7 @@ function clearRunRecord(projectPath) {
 }
 function ageMs(path, now) {
   try {
-    return now - statSync10(path).mtimeMs;
+    return now - statSync11(path).mtimeMs;
   } catch {
     return 0;
   }
@@ -34562,20 +34728,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 = readdirSync9(directory);
+    entries = readdirSync10(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 = join23(directory, entry);
+    const path = join24(directory, entry);
     if (kept.has(path) || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -34586,7 +34753,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
 }
 
 // src/script-origins.ts
-import { join as join24 } from "node:path";
+import { join as join25 } from "node:path";
 var UNRESOLVED = /Could not resolve class "([A-Za-z_][A-Za-z0-9_]*)", because of a parser error/;
 function unresolvedClassIn(message) {
   return UNRESOLVED.exec(message)?.[1] ?? null;
@@ -34642,7 +34809,7 @@ function checkWithEngine(godotPath, projectPath) {
       const ran = await runEngine(godotPath, [
         "--headless",
         "--log-file",
-        join24(logDir, "engine.log"),
+        join25(logDir, "engine.log"),
         "--path",
         projectPath,
         "--check-only",
@@ -34736,6 +34903,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(readFileSync22(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);
@@ -34899,6 +35112,8 @@ var SCENE_PATH = {
   type: "string",
   description: 'Scene file inside the project, such as "scenes/main.tscn" or "res://scenes/main.tscn".'
 };
+var WITHOUT_AN_EDITOR = "Through the editor when one serves the project; with none, a headless engine runs the editor's own tool and the answer says so under writtenBy, or readBy for a read. That engine runs every script of the file, where the editor runs only tool scripts, so what a script changes as the file loads or as a property is set is put back before anything is saved, and a file where that cannot be done, such as a scene whose script does not compile, is refused and nothing is written. An editor of the project that is running and has not reached this server is waited for rather than written around.";
+var WHOLE_NUMBERS = 'A whole number of 2^53 or more, such as a 64-bit seed or a resource uid, is written as its digits, {"_type": "int", "value": "9007199254740993"}, the form a read answers with: a JSON number that large can arrive as a neighbour of the one sent, so sent as a number it is refused.';
 var SCRIPT_PATH = {
   type: "string",
   description: 'Script file inside the project, such as "scripts/player.gd".'
@@ -34911,7 +35126,7 @@ var NODE_PATH = {
 };
 var PROPERTIES = {
   type: "object",
-  description: 'Properties to set, keyed by Godot property name. Vectors, colours and the like may be written as {"x": 1, "y": 2} or tagged {"_type": "Vector2", "x": 1, "y": 2}, which is the form a read answers with, so a value read off one node can be written straight to another. A key may also be a colon path into one of the components of a vector, a colour, a rectangle or a transform, as GDScript names them, so one axis is written alone: "position:x", "modulate:a", "region_rect:size:y"; a component the value does not have is refused, naming the ones it has. A property holding a node takes the path to it from the node being set, such as "../Player". Each value is read back once set, and one the engine changed or refused is refused with what it holds.',
+  description: `Properties to set, keyed by Godot property name. Vectors, colours and the like may be written as {"x": 1, "y": 2} or tagged {"_type": "Vector2", "x": 1, "y": 2}, which is the form a read answers with, so a value read off one node can be written straight to another. A key may also be a colon path into one of the components of a vector, a colour, a rectangle or a transform, as GDScript names them, so one axis is written alone: "position:x", "modulate:a", "region_rect:size:y"; a component the value does not have is refused, naming the ones it has. A property holding a node takes the path to it from the node being set, such as "../Player". Each value is read back once set, and one the engine changed or refused is refused with what it holds. ${WHOLE_NUMBERS}`,
   additionalProperties: true
 };
 var XY = {
@@ -34955,7 +35170,10 @@ var SCRIPT_MODIFICATIONS = {
       name: { type: "string" },
       params: { type: "string", description: 'Functions and signals: the parameter list, "delta: float".' },
       returnType: { type: "string", description: "Functions: the return type." },
-      body: { type: "string", description: "Functions: the body." },
+      body: {
+        type: "string",
+        description: "Functions: the body, its lines separated by \\n. Indent shared by every line is taken off and one tab put on, so it can be written indented or not."
+      },
       varType: {
         type: "string",
         description: "Variables and constants: the type annotation; without one, the type the value evaluates to."
@@ -35058,7 +35276,7 @@ var TOOL_SPECS = [
   {
     name: "project_settings",
     title: "Project settings",
-    description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, one on an addon from before this, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. add_input_action on an action that exists, one of the engine's ui_ actions included, replaces its events and deadzone, and answers was_new false with what it held under old_events and old_deadzone. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. Every write keeps the sections and keys of project.godot in the order the file had them, so a change touches only its own lines. get answers exists, true for any setting the engine knows, and at_default, true when the value is the engine's own default and so has no line in project.godot. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
+    description: "Reads or writes project.godot: settings, autoloads, the main scene, input actions, plugins and audio buses. A write with an editor open on the project is handed to the editor, which takes the settings the write changed or names from the file (named under editorAdopted), including a setting the file already held, since the editor can hold another value after the file was put back, or reloads the bus layout, so it answers the new values and does not save the old ones back over them. editorNote is an editor that could not take the write, one on an addon from before this, which still holds the old values until editor_launch restart. An enabled plugin's code still loads on the editor's next start. set answers old_value and new_value, with was_new true when project.godot did not set the setting before, and was_default true when what it held was the engine's own default, which old_value then is. add_input_action on an action that exists, one of the engine's ui_ actions included, replaces its events and deadzone, and answers was_new false with what it held under old_events and old_deadzone. A set of the value the setting already holds, in the same type, writes nothing and answers unchanged true and saved false. Every write keeps the sections and keys of project.godot in the order the file had them, so a change moves no other line; the save is the engine's, and like the editor's it writes Godot's header and config/features into a file that lacks them. get answers exists, true for any setting the engine knows, and at_default, true when the value is the engine's own default and so has no line in project.godot. Each setting under prefix carries at_default too, so a family read separates what the project sets from the engine's defaults; it is absent for a setting the engine registers no default for, such as an input action the project added, which only the project can have set.",
     parameters: {
       projectPath: PROJECT_PATH2,
       setting: {
@@ -35236,24 +35454,32 @@ var TOOL_SPECS = [
     description: "The import pipeline: what needs importing, how a resource is imported, reimports, UIDs, and the global class list the editor and the engine read.",
     parameters: {
       projectPath: PROJECT_PATH2,
-      resourcePath: RESOURCE_PATH,
+      resourcePath: { ...RESOURCE_PATH, ops: ["status", "options", "set_options", "uid", "reimport"] },
       includeUpToDate: {
         type: "boolean",
+        ops: ["status"],
         description: "status: list resources that are current as well. Default false."
       },
       options: {
         type: "object",
+        ops: ["set_options"],
         description: `set_options: import options keyed as the .import file spells them, {"compress/mode": 1}. A dictionary option whose keys are numbers, a font's opentype_features or any option already holding number keys, takes them written as strings of digits, and opentype_features also takes an OpenType tag by its four-letter name: {"opentype_features": {"liga": 0}} turns ligatures off. Both are written as the numbers the engine reads.`,
         additionalProperties: true
       },
       reimport: {
         type: "boolean",
+        ops: ["set_options"],
         description: "set_options: reimport afterwards, answered under reimport as project_import reimport answers. Default true."
       },
-      force: { type: "boolean", description: "reimport: reimport even what is current. Default false." },
+      force: {
+        type: "boolean",
+        ops: ["reimport"],
+        description: "reimport: reimport even what is current. Default false."
+      },
       timeoutMs: {
         type: "integer",
         minimum: 1,
+        ops: ["reimport", "set_options"],
         description: "reimport, set_options: how long to wait for the editor to finish reimporting. Default 300000."
       }
     },
@@ -35331,7 +35557,7 @@ var TOOL_SPECS = [
     name: "project_test",
     title: "Run tests",
     effect: "additive",
-    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Each entry under failed carries its first report as message and detail, and, when it has more than one, every report under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. A client that sends a progress token is told as each suite finishes, and at least every twenty seconds through a long one, so an idle limit does not end a long tier. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
+    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Each entry under failed carries its first report as message and detail, and, when it has more than one, its reports under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. Identical reports fold into one with times, at most twenty different ones are kept (reportsLeftOut counts the rest), and past about a megabyte the largest cases keep only their first message (failedWithoutDetail). failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. A client that sends a progress token is told as each suite finishes, and at least every twenty seconds through a long one, so an idle limit does not end a long tier. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
     parameters: {
       projectPath: PROJECT_PATH2,
       path: {
@@ -35368,14 +35594,14 @@ var TOOL_SPECS = [
   {
     name: "scene_create",
     title: "Create or save a scene",
-    description: "Creates a scene file where none is, saves one, or saves a copy under a new path. A save of a scene open in the editor saves the editor's copy, unsaved changes included. Needs the editor connected.",
+    description: `Creates a scene file where none is, saves one, or saves a copy under a new path. A save of a scene open in the editor saves the editor's copy, unsaved changes included. ${WITHOUT_AN_EDITOR}`,
     parameters: {
       projectPath: PROJECT_PATH2,
       scenePath: SCENE_PATH,
       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",
@@ -35413,29 +35639,32 @@ var TOOL_SPECS = [
   {
     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. set with name 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. Needs the editor connected.",
+    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_PATH2,
       scenePath: SCENE_PATH,
-      nodePath: NODE_PATH,
+      nodePath: { ...NODE_PATH, ops: ["get", "set", "duplicate", "reparent", "delete", "set_tilemap_cells"] },
       parentNodePath: {
         type: "string",
+        ops: ["add", "duplicate"],
         description: "add: where the node goes. Default the root. duplicate: where the copy goes."
       },
       nodeType: {
         type: "string",
-        description: 'add: the node class, such as "CharacterBody2D". Give this or instancePath.'
+        ops: ["add"],
+        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",
         ops: ["add"],
         description: `add: a scene to instance as the new node instead of a class, such as "ui/panel.tscn". It is saved as an instance of that file, the way the editor's Instantiate Child Scene saves one, so changes to that scene reach it; properties set its root. A scene that is the target or instances it is refused.`
       },
-      nodeName: { type: "string", description: "add: the new node's name." },
-      properties: PROPERTIES,
-      newName: { type: "string", description: "duplicate: the copy's name." },
+      nodeName: { type: "string", ops: ["add"], description: "add: the new node's name." },
+      properties: { ...PROPERTIES, ops: ["add", "set"] },
+      newName: { type: "string", ops: ["duplicate"], description: "duplicate: the copy's name." },
       newParentPath: {
         type: "string",
+        ops: ["reparent"],
         description: "reparent: the new parent, which may be the one it has, to move it among its siblings."
       },
       index: {
@@ -35446,13 +35675,15 @@ var TOOL_SPECS = [
       },
       includeDefaults: {
         type: "boolean",
+        ops: ["get"],
         description: "get: include properties still at their default. Default false."
       },
       layer: {
         type: "number",
+        ops: ["set_tilemap_cells"],
         description: "set_tilemap_cells: the layer of a TileMap. Default 0. A TileMapLayer is one layer."
       },
-      cells: TILEMAP_CELLS
+      cells: { ...TILEMAP_CELLS, ops: ["set_tilemap_cells"] }
     },
     requires: ["projectPath", "scenePath"],
     operations: {
@@ -35492,16 +35723,32 @@ var TOOL_SPECS = [
   {
     name: "scene_signal",
     title: "Scene signals",
-    description: "Signal connections in a scene file. Each connection answers with its flags as the number and as flagNames; persist is on every connection, since a scene saves no other kind. A connect of a pair already connected says alreadyConnected, with flagsBefore when it changed the flags. Needs the editor connected.",
+    description: `Signal connections in a scene file. Each connection answers with its flags as the number and as flagNames; persist is on every connection, since a scene saves no other kind. A connect of a pair already connected says alreadyConnected, with flagsBefore when it changed the flags. ${WITHOUT_AN_EDITOR}`,
     parameters: {
       projectPath: PROJECT_PATH2,
       scenePath: SCENE_PATH,
-      sourceNodePath: { type: "string", description: "The node that emits." },
-      signalName: { type: "string", description: 'The signal it emits, such as "pressed".' },
-      targetNodePath: { type: "string", description: "The node whose method is called." },
-      methodName: { type: "string", description: "The method on that node, called when it emits." },
-      flags: { type: "number", description: "connect: Object.ConnectFlags, such as 1 for deferred." },
-      nodePath: { type: "string", description: "list: only connections involving this node." }
+      sourceNodePath: { type: "string", ops: ["connect", "disconnect"], description: "The node that emits." },
+      signalName: {
+        type: "string",
+        ops: ["connect", "disconnect"],
+        description: 'The signal it emits, such as "pressed".'
+      },
+      targetNodePath: {
+        type: "string",
+        ops: ["connect", "disconnect"],
+        description: "The node whose method is called."
+      },
+      methodName: {
+        type: "string",
+        ops: ["connect", "disconnect"],
+        description: "The method on that node, called when it emits."
+      },
+      flags: {
+        type: "number",
+        ops: ["connect"],
+        description: "connect: Object.ConnectFlags, such as 1 for deferred."
+      },
+      nodePath: { type: "string", ops: ["list"], description: "list: only connections involving this node." }
     },
     requires: ["projectPath", "scenePath"],
     operations: {
@@ -35626,18 +35873,28 @@ var TOOL_SPECS = [
     parameters: {
       projectPath: PROJECT_PATH2,
       scriptPath: SCRIPT_PATH,
-      className: { type: "string", description: "create: a class_name for the script. Not with content." },
-      extends: { type: "string", description: "create: the base class. Default Node. Not with content." },
+      className: {
+        type: "string",
+        ops: ["create"],
+        description: "create: a class_name for the script. Not with content."
+      },
+      extends: {
+        type: "string",
+        ops: ["create"],
+        description: "create: the base class. Default Node. Not with content."
+      },
       content: {
         type: "string",
+        ops: ["create"],
         description: "create: the whole file, written as given, instead of a template, className and extends."
       },
       template: {
         type: "string",
         enum: ["singleton", "state_machine", "component", "resource"],
+        ops: ["create"],
         description: "create: a starting shape."
       },
-      modifications: SCRIPT_MODIFICATIONS,
+      modifications: { ...SCRIPT_MODIFICATIONS, ops: ["modify"] },
       symbol: {
         type: "string",
         ops: ["rename"],
@@ -35675,16 +35932,19 @@ var TOOL_SPECS = [
       scriptPath: SCRIPT_PATH,
       includeInherited: {
         type: "boolean",
+        ops: ["structure"],
         description: "structure: also list what the script inherits, walking extends through the project's other scripts. Each such member carries inherited_from, the file declaring it, and the answer gains inherits_from, the chain that was walked. A name the script overrides is listed at both its lines rather than once. A native base is not walked, since it declares nothing in a file: editor_classes info answers for those. Default false."
       },
       line: {
         type: "integer",
         minimum: 1,
+        ops: ["completion", "hover"],
         description: "completion, hover: the line, counted from 1 as the editor shows it."
       },
       character: {
         type: "integer",
         minimum: 1,
+        ops: ["completion", "hover"],
         description: "completion, hover: the column, counted from 1 as the editor shows it, with a tab counted as one. symbols gives each name at the line and column hover is asked at."
       }
     },
@@ -35692,7 +35952,7 @@ var TOOL_SPECS = [
     operations: {
       structure: {
         effect: "read",
-        summary: "functions, variables, signals, class_name and extends, read from the file, and dependencies: the paths it loads or preloads as written, then the scripts declaring each project class_name its code uses, which classes_used names with the class",
+        summary: "functions, variables, signals, class_name and extends, read from the file, and dependencies: the paths it loads or preloads as written, then the scripts declaring each project class_name its code uses, which classes_used names with the class; autoloads_used names each autoload the code uses by its global name, with the autoload's script, which the project loads rather than this script, so it is not under dependencies",
         requires: []
       },
       symbols: {
@@ -35727,7 +35987,7 @@ var TOOL_SPECS = [
   {
     name: "resource_edit",
     title: "Edit resources",
-    description: 'Resource files: read one, create any ClassDB resource as .tres, change one, write a shader, build a TileSet, or set a Theme colour or font size. A material is a create with resourceType StandardMaterial3D, ShaderMaterial or CanvasItemMaterial. read answers with the properties the file sets, in the form modify takes, and a Theme lists its items there as "Button/colors/font_color". move takes any file of the project, a script or an image as much as a resource, or a directory, and works from the files, so it needs no editor; one serving the project is brought up to it as after a move in its own FileSystem dock, its open scenes and cached resources named for the new paths and the project settings the move rewrote taken from the file. read needs no editor either: with none serving the project, a headless engine reads the file. The ops that write a resource need the editor connected.',
+    description: 'Resource files: read one, create any ClassDB resource as .tres, change one, write a shader, build a TileSet, or set a Theme colour or font size. A material is a create with resourceType StandardMaterial3D, ShaderMaterial or CanvasItemMaterial. read answers with the properties the file sets, in the form modify takes, and a Theme lists its items there as "Button/colors/font_color". move takes any file of the project, a script or an image as much as a resource, or a directory, and works from the files, so it needs no editor; one serving the project is brought up to it as after a move in its own FileSystem dock, its open scenes and cached resources named for the new paths and the project settings the move rewrote taken from the file. read needs no editor either: with none serving the project, a headless engine reads the file. The ops that write a resource go through the editor when one serves the project; with none, a headless engine runs the tool the editor would and the answer says so under writtenBy. That engine runs the script of the resource, where the editor runs only tool scripts, so what a script changes as the file loads or as a property is set is put back before the save, and a resource where that cannot be done is refused and the file left as it was.',
     parameters: {
       projectPath: PROJECT_PATH2,
       resourcePath: {
@@ -35737,7 +35997,7 @@ var TOOL_SPECS = [
       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: {
@@ -35931,6 +36191,17 @@ var TOOL_SPECS = [
         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,
@@ -35982,7 +36253,7 @@ var TOOL_SPECS = [
         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"
   },
   {
@@ -36078,9 +36349,10 @@ var TOOL_SPECS = [
     description: "The engine's ClassDB: find classes, read one in full, or walk an inheritance tree.",
     parameters: {
       projectPath: PROJECT_PATH2,
-      filter: { type: "string", description: "query: a substring of the class name." },
+      filter: { type: "string", ops: ["query"], description: "query: a substring of the class name." },
       category: {
         type: "string",
+        ops: ["query"],
         enum: [
           "node",
           "node2d",
@@ -36097,9 +36369,21 @@ var TOOL_SPECS = [
         ],
         description: "query: limit to one family."
       },
-      instantiableOnly: { type: "boolean", description: "query: leave out abstract classes. Default false." },
-      className: { type: "string", description: "info, inheritance: the class." },
-      includeInherited: { type: "boolean", description: "info: include inherited members. Default false." },
+      instantiableOnly: {
+        type: "boolean",
+        ops: ["query"],
+        description: "query: leave out abstract classes. Default false."
+      },
+      className: {
+        type: "string",
+        ops: ["info", "inheritance"],
+        description: "info, inheritance: the class."
+      },
+      includeInherited: {
+        type: "boolean",
+        ops: ["info"],
+        description: "info: include inherited members. Default false."
+      },
       member: {
         type: "string",
         ops: ["info"],
@@ -36253,7 +36537,7 @@ var TOOL_SPECS = [
       value: {
         ops: ["set"],
         blank: true,
-        description: `set: the value, fitted to the property's type. A number the property would have to cut is refused rather than truncated: a fraction into an int, a number other than 0 or 1 into a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent, a fraction into one holding an int included. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
+        description: `set: the value, fitted to the property's type. ${WHOLE_NUMBERS} A number the property would have to cut is refused rather than truncated: a fraction into an int, a number other than 0 or 1 into a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}, which is the form a read answers with. "" writes an empty string. A property typed as or holding an object takes a path naming one the game holds, the way call's args do, and holds that instance, or null, which the text null also means, to empty it. One declared as Variant or untyped takes anything, as the engine does: a value of the kind it holds is fitted to it, an int staying an int, and any other is stored as sent, a fraction into one holding an int included. A typed list or map, such as Array[int] or Dictionary[String, int], takes a JSON list or object with each element fitted to its element type, and an element that cannot become one is refused by its index or key, as is an object of another script than the one the list holds, whether or not that script has a class_name.`
       },
       method: {
         type: "string",
@@ -36263,7 +36547,7 @@ var TOOL_SPECS = [
       args: {
         type: "array",
         ops: ["call"],
-        description: `call: the arguments, fitted to the method's parameter types. A number a parameter would have to cut is refused rather than truncated: a fraction for an int, a number other than 0 or 1 for a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
+        description: `call: the arguments, fitted to the method's parameter types. An RID is passed as the {"_type": "RID", "id": ...} a read answers it with, such as a viewport's for RenderingServer's render timing. ${WHOLE_NUMBERS} A number a parameter would have to cut is refused rather than truncated: a fraction for an int, a number other than 0 or 1 for a bool. A vector, colour or the like may be written as its fields, {"x": 140, "y": 300}, or tagged, {"_type": "Vector2", "x": 140, "y": 300}. A parameter typed as an object takes a path naming one the game holds and is handed that instance: a colon path read from nodePath, "_game:run:wares:3", or one starting at a node, "/root/Main/Hud" or "/root/Main:_game:run". A path that reaches no object, or an object of another class than the parameter declares, is refused, and so are too few or too many arguments. The engine names a parameter typed as a script class without class_name by the class the script extends, so an object of that class with another script passes that check and the engine refuses the call: the answer says the method did not run, with the engine's reason. A parameter typed as a list or map, such as Array[int] or Array[Gear], is built from a JSON list or object element by element, objects named by their paths. The method itself takes its arguments here only: brackets on it holding arguments are refused.`
       },
       properties: {
         type: ["boolean", "array"],
@@ -36767,16 +37051,16 @@ function serverInstructions() {
 import { createHash as createHash5 } from "node:crypto";
 import {
   cpSync,
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync14,
-  readdirSync as readdirSync10,
+  readdirSync as readdirSync11,
   readFileSync as readFileSync23,
   rmdirSync,
   rmSync as rmSync12,
-  statSync as statSync11,
+  statSync as statSync12,
   writeFileSync as writeFileSync15
 } from "node:fs";
-import { dirname as dirname17, join as join25 } from "node:path";
+import { dirname as dirname18, join as join26 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
 var EDITOR_PLUGINS = ["gdharness_editor", "auto_reload"];
@@ -36795,13 +37079,13 @@ function runtimeAddonDigest(from = shippedAddonsDirectory()) {
 function addonsDigest(names, from) {
   const hash = createHash5("sha256");
   const walk = (directory, relative) => {
-    for (const name of readdirSync10(directory).sort()) {
+    for (const name of readdirSync11(directory).sort()) {
       if (name === VERSION_MARKER || name === DIGEST_MARKER) {
         continue;
       }
-      const path = join25(directory, name);
+      const path = join26(directory, name);
       const inside = `${relative}/${name}`;
-      if (statSync11(path).isDirectory()) {
+      if (statSync12(path).isDirectory()) {
         walk(path, inside);
       } else {
         hash.update(`${inside}
@@ -36813,7 +37097,7 @@ function addonsDigest(names, from) {
     }
   };
   for (const name of names) {
-    walk(join25(from, name), name);
+    walk(join26(from, name), name);
   }
   return hash.digest("hex");
 }
@@ -36846,19 +37130,19 @@ function installedRuntimeDigest(projectPath) {
   return digestMarker(projectPath, RUNTIME_ADDON);
 }
 function digestMarker(projectPath, addon) {
-  const marker = join25(projectPath, "addons", addon, DIGEST_MARKER);
-  if (!existsSync19(marker)) {
+  const marker = join26(projectPath, "addons", addon, DIGEST_MARKER);
+  if (!existsSync20(marker)) {
     return null;
   }
   const said = readFileSync23(marker, "utf8").trim();
   return said === "" ? null : said;
 }
 function shippedAddonsDirectory() {
-  return join25(dirname17(fileURLToPath3(import.meta.url)), "godot", "addons");
+  return join26(dirname18(fileURLToPath3(import.meta.url)), "godot", "addons");
 }
 function installedAddonVersion(projectPath) {
-  const marker = join25(projectPath, "addons", ADDONS[0], VERSION_MARKER);
-  if (!existsSync19(marker)) {
+  const marker = join26(projectPath, "addons", ADDONS[0], VERSION_MARKER);
+  if (!existsSync20(marker)) {
     return null;
   }
   const said = readFileSync23(marker, "utf8").trim();
@@ -36872,7 +37156,7 @@ function loaderAmong(projectPath, named) {
     }
     let source = null;
     try {
-      source = readFileSync23(join25(projectPath, path), "utf8");
+      source = readFileSync23(join26(projectPath, path), "utf8");
     } catch {}
     if (source?.includes(RUNTIME_AUTOLOAD.path)) {
       return { name: entry, path, exists: true };
@@ -36914,10 +37198,10 @@ function enabledPlugins(settings) {
 function inspectProject(projectPath) {
   const problems = [];
   const addons = ADDONS.map((name) => {
-    const directory = join25(projectPath, "addons", name);
-    const marker = join25(directory, VERSION_MARKER);
-    const installed = existsSync19(directory);
-    const version = existsSync19(marker) ? readFileSync23(marker, "utf8").trim() : null;
+    const directory = join26(projectPath, "addons", name);
+    const marker = join26(directory, VERSION_MARKER);
+    const installed = existsSync20(directory);
+    const version = existsSync20(marker) ? readFileSync23(marker, "utf8").trim() : null;
     const current = version === SERVER_VERSION;
     if (!installed) {
       problems.push(`addons/${name} is not installed; run gdharness setup`);
@@ -36926,7 +37210,7 @@ function inspectProject(projectPath) {
     }
     return { name, installed, version, current };
   });
-  const settings = parseProjectGodot(readFileSync23(join25(projectPath, "project.godot"), "utf8"));
+  const settings = parseProjectGodot(readFileSync23(join26(projectPath, "project.godot"), "utf8"));
   const pluginsEnabled = enabledPlugins(settings);
   for (const name of EDITOR_PLUGINS) {
     if (!pluginsEnabled.includes(name)) {
@@ -36942,7 +37226,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 (!existsSync19(join25(projectPath, path))) {
+    if (!existsSync20(join26(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`);
       }
@@ -36992,7 +37276,9 @@ function argumentShape(schema) {
 // src/server.ts
 var UPDATE_NOTICE_EVERY = 500;
 var FEEDBACK_NOTICE_EVERY = 250;
-var __dirname2 = dirname18(fileURLToPath4(import.meta.url));
+var FAILED_BUDGET = 1e6;
+var ANSWER_BUDGET = 4000000;
+var __dirname2 = dirname19(fileURLToPath4(import.meta.url));
 var PARENT_ASKED_AFTER_MS = 5000;
 function editorRestartTimeoutMs() {
   return waitFromEnv("GDHARNESS_EDITOR_RESTART_TIMEOUT_MS", 90000);
@@ -37024,22 +37310,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(dirname18(path));
-  if (!existsSync20(directory)) {
-    return `${named}'s directory ${dirname18(path)} does not exist; ${what} creates no directories.`;
+  const directory = realPathOr(dirname19(path));
+  if (!existsSync21(directory)) {
+    return `${named}'s directory ${dirname19(path)} does not exist; ${what} creates no directories.`;
   }
-  const where = join26(directory, basename7(path));
+  const where = join27(directory, basename8(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) => existsSync20(file));
+  const taken = rule.writes(where).find((file) => existsSync21(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.`;
   }
@@ -37150,7 +37436,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";
@@ -37263,7 +37549,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) {
@@ -37601,7 +37887,7 @@ function notRunNote(notRun, failFast) {
 function exportPresetRefusal(projectPath, preset) {
   let text;
   try {
-    text = readFileSync24(join26(projectPath, "export_presets.cfg"), "utf8");
+    text = readFileSync24(join27(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.`;
   }
@@ -37623,7 +37909,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);
@@ -37640,6 +37926,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) {
@@ -37664,9 +37951,9 @@ function writtenBeside(before, after, output, within) {
 function filesIn(folder) {
   const found = new Map;
   try {
-    for (const entry of readdirSync11(folder, { withFileTypes: true })) {
+    for (const entry of readdirSync12(folder, { withFileTypes: true })) {
       if (entry.isFile()) {
-        found.set(entry.name, statSync12(join26(folder, entry.name)).mtimeMs);
+        found.set(entry.name, statSync13(join27(folder, entry.name)).mtimeMs);
       }
     }
   } catch {}
@@ -37700,7 +37987,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 (!existsSync20(join26(projectPath, "project.godot"))) {
+  if (!existsSync21(join27(projectPath, "project.godot"))) {
     return null;
   }
   const report = inspectProject(projectPath);
@@ -37988,7 +38275,7 @@ function profileFrameFunctions(projectPath) {
   let projectGodot = null;
   if (projectPath !== null) {
     try {
-      projectGodot = readFileSync24(join26(projectPath, "project.godot"), "utf8");
+      projectGodot = readFileSync24(join27(projectPath, "project.godot"), "utf8");
     } catch {}
   }
   return frameFunctionsFor(queuedMessagesOf(projectGodot));
@@ -38166,7 +38453,7 @@ function foldedEntriesAnswer(log, floor = "warning") {
 var ERROR_ASSERT = "GdUnitGodotErrorAssertImpl.gd";
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync24(join26(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync24(join27(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -38181,13 +38468,13 @@ function uncaughtNote(uncaught) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync20(join26(projectPath, wanted))) {
+  if (wanted === "" || existsSync21(join27(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
   let near = [];
   try {
-    near = readdirSync11(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 = readdirSync12(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 "";
   }
@@ -38279,23 +38566,23 @@ function engineChecked(why) {
 var EXTERNAL_MEMBER = 'Could not resolve external class member "';
 function isDirectory(path) {
   try {
-    return statSync12(path).isDirectory();
+    return statSync13(path).isDirectory();
   } catch {
     return false;
   }
 }
 function scriptsUnder(directory, prefix) {
-  if (existsSync20(join26(directory, ".gdignore"))) {
+  if (existsSync21(join27(directory, ".gdignore"))) {
     return [];
   }
   const found = [];
-  for (const entry of readdirSync11(directory, { withFileTypes: true }).sort((a, b) => a.name < b.name ? -1 : 1)) {
+  for (const entry of readdirSync12(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(join26(directory, entry.name), path));
+      found.push(...scriptsUnder(join27(directory, entry.name), path));
     } else if (entry.isFile() && entry.name.endsWith(".gd")) {
       found.push(path);
     }
@@ -38311,7 +38598,7 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync24(join26(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
+    return readFileSync24(join27(projectPath, RUNTIME_AUTOLOAD.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
@@ -38337,7 +38624,7 @@ var STATIC_LIST_HINT = { ttlMs: 5 * 60000, cacheScope: "private" };
 class GodotServer {
   stdio = null;
   locator = new GodotLocator;
-  operationsScript = join26(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join27(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -38364,6 +38651,7 @@ class GodotServer {
   inFlight = new Map;
   callsOnGames = new Set;
   callsTaken = 0;
+  answersDirectory;
   clientNoted = null;
   parentCommand = null;
   endNoted = false;
@@ -38597,14 +38885,14 @@ class GodotServer {
   }
   noteTheStart() {
     const cwd = process.cwd();
-    const mcpJson = join26(cwd, ".mcp.json");
+    const mcpJson = join27(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: existsSync20(mcpJson) ? mcpJson : null
+      mcpJson: existsSync21(mcpJson) ? mcpJson : null
     });
     if (predecessor !== null) {
       writeLifecycle("replaced", { project: this.ownProject, predecessor });
@@ -38745,7 +39033,7 @@ class GodotServer {
         return checked.response;
       }
       const named = args["projectPath"];
-      if (typeof named === "string" && existsSync20(join26(named, "project.godot"))) {
+      if (typeof named === "string" && existsSync21(join27(named, "project.godot"))) {
         this.lastProjectPath = named;
       }
       this.updates.refresh();
@@ -38762,12 +39050,66 @@ class GodotServer {
       this.inFlight.set(call, { tool: spec.name, op: checked.op ?? "", startedAt: Date.now() });
       try {
         const answer = await withCallSignal(ctx.mcpReq.signal, () => this.answered(spec.name, checked.op ?? "", args), progress);
-        return this.withFeedbackNotice(this.withUpdateNotice(answer));
+        return this.withinTheClientsLimit(spec.name, this.withFeedbackNotice(this.withUpdateNotice(answer)));
       } finally {
         this.inFlight.delete(call);
       }
     });
   }
+  withinTheClientsLimit(tool, answer) {
+    const sizeOf = (item) => item.type === "text" ? Buffer.byteLength(item.text) : item.data.length;
+    const bytes = answer.content.reduce((sum, item) => sum + sizeOf(item), 0);
+    if (bytes <= ANSWER_BUDGET) {
+      return answer;
+    }
+    this.answersDirectory ??= scratchDirectory("answers");
+    const directory = this.answersDirectory;
+    const stem = `${tool}-${Date.now()}`;
+    let savedAt;
+    let notSaved;
+    try {
+      savedAt = answer.content.map((item, index) => {
+        const file = join27(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
+        writeFileSync16(file, item.type === "text" ? item.text : Buffer.from(item.data, "base64"));
+        return file;
+      });
+    } catch (error) {
+      notSaved = errorMessage(error);
+    }
+    const first = answer.content[0];
+    let parsed = null;
+    try {
+      parsed = first?.type === "text" ? JSON.parse(first.text) : null;
+    } catch {}
+    const small = {};
+    const leftOut = [];
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      for (const [key, value] of Object.entries(parsed)) {
+        if (JSON.stringify(value).length <= 2000) {
+          small[key] = value;
+        } else {
+          leftOut.push(key);
+        }
+      }
+    }
+    return {
+      ...answer,
+      content: [
+        {
+          type: "text",
+          text: answerJson({
+            ...small,
+            answerTooLarge: {
+              bytes,
+              savedAt,
+              leftOut: leftOut.length > 0 ? leftOut : undefined,
+              note: savedAt === undefined ? `The answer was ${bytes} bytes, past the ${ANSWER_BUDGET} this server sends in one message (Claude Code closes the connection past 16 MB), and writing it to a file failed: ${notSaved ?? "no reason given"}. The fields of its top level that are short are kept here.` : `The answer was ${bytes} bytes, past the ${ANSWER_BUDGET} this server sends in one message (Claude Code closes the connection past 16 MB), so it was written whole to savedAt; read it from there. The fields of its top level that are short are kept here. The files are removed once this server has stopped.`
+            }
+          })
+        }
+      ]
+    };
+  }
   async answered(tool, op, args) {
     try {
       return await this.dispatch(tool, op, args);
@@ -39019,6 +39361,7 @@ class GodotServer {
       const contained = this.containProjectFiles({ ...arguments_, ...extra });
       return contained.ok ? await this.handleViaBridge(command, contained.value, op === "" ? tool : `${tool} ${op}`) : contained.response;
     };
+    const editorOrEngine = async (command, effect, extra = {}) => await this.editorOrEngine(command, { ...arguments_, ...extra }, `${tool} ${op}`, effect);
     switch (tool) {
       case "project_info":
         return await this.handleProjectInfo(args);
@@ -39031,7 +39374,7 @@ class GodotServer {
       case "project_test":
         return await this.handleRunTests(args);
       case "scene_create":
-        return op === "create" ? await bridge("create_scene") : await bridge("save_scene");
+        return op === "create" ? await editorOrEngine("create_scene", "writes") : await editorOrEngine("save_scene", "writes");
       case "scene_tree":
         return await this.readFromFile(args, "scenePath", "read_scene_tree", (file) => ({
           scenePath: file,
@@ -39041,28 +39384,28 @@ class GodotServer {
       case "scene_node":
         switch (op) {
           case "add":
-            return await bridge("add_node");
+            return await editorOrEngine("add_node", "writes");
           case "get":
-            return await bridge("get_node_properties");
+            return await editorOrEngine("get_node_properties", "reads");
           case "set":
-            return await bridge("set_node_properties");
+            return await editorOrEngine("set_node_properties", "writes");
           case "duplicate":
-            return await bridge("duplicate_node", { parentPath: args["parentNodePath"] });
+            return await editorOrEngine("duplicate_node", "writes", { parentPath: args["parentNodePath"] });
           case "reparent":
-            return await bridge("reparent_node");
+            return await editorOrEngine("reparent_node", "writes");
           case "delete":
-            return await bridge("delete_node");
+            return await editorOrEngine("delete_node", "writes");
           default:
-            return await bridge("set_tilemap_cells", { tilemapNodePath: args["nodePath"] });
+            return await editorOrEngine("set_tilemap_cells", "writes", { tilemapNodePath: args["nodePath"] });
         }
       case "scene_signal":
         switch (op) {
           case "connect":
-            return await bridge("connect_signal");
+            return await editorOrEngine("connect_signal", "writes");
           case "disconnect":
-            return await bridge("disconnect_signal");
+            return await editorOrEngine("disconnect_signal", "writes");
           default:
-            return await bridge("list_connections");
+            return await editorOrEngine("list_connections", "reads");
         }
       case "scene_animation":
         switch (op) {
@@ -39113,17 +39456,17 @@ class GodotServer {
             }), async () => await bridge("read_resource", kept));
           }
           case "create":
-            return await bridge("create_resource");
+            return await editorOrEngine("create_resource", "writes");
           case "modify":
-            return await bridge("modify_resource");
+            return await editorOrEngine("modify_resource", "writes");
           case "create_shader":
-            return await bridge("create_shader", { shaderPath: args["resourcePath"] });
+            return await editorOrEngine("create_shader", "writes", { shaderPath: args["resourcePath"] });
           case "create_tileset":
-            return await bridge("create_tileset", { tilesetPath: args["resourcePath"] });
+            return await editorOrEngine("create_tileset", "writes", { tilesetPath: args["resourcePath"] });
           case "set_theme_color":
-            return await bridge("set_theme_color", { themePath: args["resourcePath"] });
+            return await editorOrEngine("set_theme_color", "writes", { themePath: args["resourcePath"] });
           default:
-            return await bridge("set_theme_font_size", { themePath: args["resourcePath"] });
+            return await editorOrEngine("set_theme_font_size", "writes", { themePath: args["resourcePath"] });
         }
       case "editor_launch":
         if (op === "close") {
@@ -39344,8 +39687,8 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join26(path, "project.godot");
-    if (!existsSync20(file)) {
+    const file = join27(path, "project.godot");
+    if (!existsSync21(file)) {
       return {
         ok: false,
         response: this.createErrorResponse(`Not a Godot project: ${path}`, [
@@ -39391,7 +39734,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}".`, [
@@ -39650,7 +39993,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));
   }
@@ -39889,6 +40233,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) {
@@ -39989,6 +40336,10 @@ class GodotServer {
     if (unknown.length > 0) {
       return this.createErrorResponse(`project_info cannot include ${unknown.join(", ")}. Sections: ${Object.keys(PROJECT_INFO_SECTIONS2).join(", ")}.`);
     }
+    const forValidation = ["preset", "detail"].filter((name) => args[name] !== undefined);
+    if (forValidation.length > 0 && !include.includes("validation")) {
+      return this.createErrorResponse(`${forValidation.join(" and ")} ${forValidation.length === 1 ? "is" : "are"} read only by the validation section, which this call does not include: add "validation" to include, or leave ${forValidation.length === 1 ? "it" : "them"} out.`);
+    }
     const project = this.project(args);
     if (!project.ok) {
       return project.response;
@@ -40001,7 +40352,7 @@ class GodotServer {
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
-      name: typeof name === "string" && name !== "" ? name : basename7(project.value.path),
+      name: typeof name === "string" && name !== "" ? name : basename8(project.value.path),
       path: project.value.path,
       mainScene: typeof mainScene === "string" && mainScene !== "" ? mainScene : null,
       godotVersion: await this.godotVersion(engine.value),
@@ -40084,18 +40435,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname18(output.absolutePath);
+    const folder = dirname19(output.absolutePath);
     try {
       mkdirSync15(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname18(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname19(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
     const exportLogs = scratchDirectory("export");
     const exportArgs = [
       "--headless",
       "--log-file",
-      join26(exportLogs, "engine.log"),
+      join27(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -40103,24 +40454,37 @@ class GodotServer {
       output.absolutePath
     ];
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
-    const writtenAt = () => existsSync20(output.absolutePath) ? statSync12(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 = () => existsSync21(output.absolutePath) ? statSync13(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), basename7(output.absolutePath), dirname18(output.relativePath).replaceAll("\\", "/"));
-    return exportAnswer(ending, { preset, outputPath: output.relativePath, debug }, before, writtenAt(), beside);
+    const beside = writtenBeside(listedBefore, filesIn(folder), basename8(output.absolutePath), dirname19(output.relativePath).replaceAll("\\", "/"));
+    return exportAnswer(ending, { preset, outputPath: output.relativePath, debug }, before, writtenAt(), beside, docCacheNote);
   }
   reportTestProgress(log) {
     const progress = callProgress();
@@ -40173,10 +40537,10 @@ class GodotServer {
     if (movie !== null) {
       return this.createErrorResponse(movie);
     }
-    const missing = paths.value.filter((path) => !existsSync20(join26(project.value.path, path.slice("res://".length))));
+    const missing = paths.value.filter((path) => !existsSync21(join27(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 = !existsSync20(join26(project.value.path, runner));
+    const noRunner = !existsSync21(join27(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}` : "";
@@ -40267,21 +40631,21 @@ class GodotServer {
       await untilGone([run.process.pid]);
     }
     await run.settled;
-    const reportsDir = join26(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join27(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
-      const written = existsSync20(reportsDir) ? readdirSync11(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
+      const written = existsSync21(reportsDir) ? readdirSync12(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(readFileSync24(join26(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync24(join27(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
     } finally {
       discard(reportsDir, userData);
       try {
-        rmdirSync2(dirname18(reportsDir));
+        rmdirSync2(dirname19(reportsDir));
       } catch {}
     }
     const engineEntries = foldedRepeats(run.log.select({
@@ -40313,7 +40677,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] ?? "")}`;
@@ -40373,7 +40737,7 @@ class GodotServer {
         isError: true
       };
     }
-    const failed = failedCases(report, Buffer.concat(console2).toString("utf8"));
+    const { failed, briefed } = failedWithin(failedCases(report, Buffer.concat(console2).toString("utf8")), FAILED_BUDGET);
     const orphans = orphansPrinted(said);
     const leftBehind = new Map(orphans.suites.map((suite) => [suite.path, suite.orphans]));
     const orphansIn = (path) => path === null ? 0 : leftBehind.get(path) ?? 0;
@@ -40413,6 +40777,7 @@ class GodotServer {
       skipped: report.skipped,
       time: report.time,
       failed,
+      failedWithoutDetail: briefed > 0 ? briefed : undefined,
       hookFailures: hookFailures.length > 0 ? hookFailures : undefined,
       uncaughtScriptErrors: uncaughtFolded.length > 0 ? uncaughtFolded : undefined,
       warnings: warnings.length > 0 ? warnings : undefined,
@@ -40424,6 +40789,7 @@ class GodotServer {
       ...scanned,
       note: [
         missingNote,
+        briefed > 0 ? `${briefed} of the ${failed.length} failing cases, those with the largest reports, are named with their first message only, since their reports would have made the answer too large to deliver; pass one case's suite path to see its reports.` : undefined,
         notApplied.length > 0 ? "An ignore entry named a case that ran all the same: gdUnit4 leaves a case out only as suite_name:test_name, and reads an entry with no colon as a suite name or a piece of a suite path. ignoreNotApplied gives the form for each case that ran." : undefined,
         uncaughtNote(uncaught),
         ranAs.startsWith("warnings") && warnings.length === 0 ? "gdUnit4 exits 101 for orphan nodes when nothing failed, and this run printed no count of them: orphan reporting may be off in the project settings." : notRunNote(notRun, readBoolean(args, "failFast") === true)
@@ -40587,7 +40953,11 @@ class GodotServer {
     };
   }
   markedIfStale(answer) {
-    return markIfStale(answer, this.godotBridge.getStatus().addonVersion, SERVER_VERSION, this.godotBridge.getStatus().addonDigest, shippedEditorDigest(), this.editorCodeOnDisk());
+    const status = this.godotBridge.getStatus();
+    if (!hasSaidWhoItIs(status)) {
+      return answer;
+    }
+    return markIfStale(answer, status.addonVersion, SERVER_VERSION, status.addonDigest, shippedEditorDigest(), this.editorCodeOnDisk());
   }
   async diagnosticsOf(args) {
     const waited = await this.waitForTheEditorOpenedHere(args, []);
@@ -40634,7 +41004,7 @@ class GodotServer {
     const cached = cachedClasses(projectPath);
     const sourceOf = (resourcePath) => {
       const contained = resolveWithinProject(projectPath, resourcePath);
-      if (!contained.ok || !existsSync20(contained.absolutePath)) {
+      if (!contained.ok || !existsSync21(contained.absolutePath)) {
         return null;
       }
       try {
@@ -40728,7 +41098,7 @@ class GodotServer {
   }
   sourceOfClass(projectPath, resourcePath) {
     const contained = resolveWithinProject(projectPath, resourcePath);
-    if (!contained.ok || !existsSync20(contained.absolutePath)) {
+    if (!contained.ok || !existsSync21(contained.absolutePath)) {
       return null;
     }
     try {
@@ -40890,7 +41260,7 @@ class GodotServer {
       ...Array.isArray(stack) ? {
         stack: stack.map((frame) => ({
           ...frame,
-          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join26(projectPath, frame["script"].slice("res://".length)) } : {}
+          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join27(projectPath, frame["script"].slice("res://".length)) } : {}
         }))
       } : {}
     });
@@ -41169,7 +41539,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync24(join26(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync24(join27(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -41408,7 +41778,7 @@ class GodotServer {
       return;
     }
     const connected = this.godotBridge.isConnected() ? this.godotBridge.getStatus().editorPid : undefined;
-    const pids = editorsOfProjectIn(tree, projectPath).filter((pid) => pid !== connected);
+    const pids = editorsOfProjectIn(tree, projectPath).filter((pid) => pid !== connected && alive(pid));
     const started = await startTimesOf(pids);
     return pids.map((pid) => {
       const at = started.get(pid) ?? tree.get(pid)?.startedAt;
@@ -41606,7 +41976,7 @@ class GodotServer {
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync20(join26(projectPath, RUNTIME_AUTOLOAD.path))) {
+    if (!existsSync21(join27(projectPath, RUNTIME_AUTOLOAD.path))) {
       return runtimeVerdict(null, {
         addon: false,
         budgetMs,
@@ -41692,7 +42062,7 @@ class GodotServer {
     }
     let announcedAt;
     try {
-      announcedAt = statSync12(endpoint.file).mtimeMs;
+      announcedAt = statSync13(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -42582,9 +42952,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 && !existsSync20(join26(projectPath, "project.godot"));
+    const projectGone = projectPath !== null && !existsSync21(join27(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"]);
     }
@@ -42594,7 +42968,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) {
@@ -42607,15 +42981,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;
@@ -42637,12 +43012,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"]);
@@ -42665,13 +43041,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;
@@ -42872,7 +43305,7 @@ class GodotServer {
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync20(join26(run.projectPath, RUNTIME_AUTOLOAD.path)),
+        couldAnnounce: run.projectPath !== null && existsSync21(join27(run.projectPath, RUNTIME_AUTOLOAD.path)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -43502,7 +43935,7 @@ class GodotServer {
     if (!scriptPath.ok) {
       return this.createErrorResponse(scriptPath.reason);
     }
-    if (!existsSync20(scriptPath.absolutePath)) {
+    if (!existsSync21(scriptPath.absolutePath)) {
       return this.createErrorResponse(`Script file does not exist: ${scriptPath.absolutePath}`);
     }
     const asked = readNonEmptyString(args, "newScriptPath");
@@ -43647,6 +44080,45 @@ class GodotServer {
       ...engineExtras(outcome)
     });
   }
+  async editorOrEngine(command, args, askedAs, effect) {
+    const contained = this.containProjectFiles(args);
+    if (!contained.ok) {
+      return contained.response;
+    }
+    const project = this.project(contained.value);
+    if (!project.ok) {
+      return project.response;
+    }
+    const projectPath = project.value.path;
+    const waited = await this.waitForTheEditorOpenedHere(contained.value, []);
+    if (this.editorHasOpen(projectPath)) {
+      return await this.handleViaBridge(command, contained.value, askedAs);
+    }
+    if (effect === "writes") {
+      if (waited !== null) {
+        return waited;
+      }
+      const arriving = await this.editorsNotYetConnected(projectPath);
+      if (arriving !== undefined && arriving.length > 0) {
+        const named = arriving.map((one) => `pid ${one.pid}`).join(", ");
+        return this.createErrorResponse(`${askedAs} was not run: an editor of this project is running (${named}) and has not reached this server, and saving a scene or resource it holds would put back what a write made around it.`, [
+          "editor_status names it under editorsNotYetConnected and says when it has connected; the write then goes through it",
+          `If it never connects it is not reaching this server: end ${arriving.length === 1 ? "that pid" : "those pids"} and ask again`
+        ]);
+      }
+    }
+    const outcome = await this.operation("run_editor_tool", { command, arguments: contained.value }, projectPath);
+    if (!outcome.ok) {
+      return this.answer(outcome);
+    }
+    return this.jsonTextResponse({
+      ...outcome.payload,
+      ...effect === "reads" ? {
+        readBy: "a headless engine, since no editor serves this project; unsaved changes in an editor are not seen"
+      } : { writtenBy: "a headless engine, since no editor serves this project" },
+      ...engineExtras(outcome)
+    });
+  }
   async handleMoveFile(given) {
     const project = this.project(given);
     if (!project.ok) {
@@ -44045,7 +44517,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) || !existsSync20(join26(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync21(join27(project, RUNTIME_AUTOLOAD.path)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -44054,7 +44526,7 @@ class GodotServer {
         return !run.announcedBefore.has(one.pid);
       }
       try {
-        return statSync12(one.file).mtimeMs >= run.startedAt;
+        return statSync13(one.file).mtimeMs >= run.startedAt;
       } catch {
         return false;
       }
@@ -44135,7 +44607,7 @@ class GodotServer {
       }
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join26(screenshotDir, "capture.png") : null;
+    const screenshotPath = screenshotDir ? join27(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}