gdharness 1.3.65 → 1.3.67

package/build/cli.js

@@ -2003,9 +2003,6 @@ function nonEmpty(value) {
 function keptSlotsOf(count) {
   return Math.max(2, Math.floor(count / 4));
 }
-function reservedSlotOf(count) {
-  return count - Math.max(1, count - keptSlotsOf(count)) >= 2 ? count - 1 : null;
-}
 function slotWaiters(directory) {
   const marks = join6(directory, WAITING_FOLDER);
   let names;
@@ -2072,8 +2069,20 @@ class SlotLine {
     return { ...holder, ...this.game ? { game: true } : {}, taker: this.taker, since: this.since / 1000 };
   }
   ahead(waiters) {
-    const own = this.mark ?? "￿";
-    return waiters.filter((one) => one.mark !== this.mark && (one.since < this.since || one.since === this.since && one.mark < own)).toSorted((a, b) => a.since - b.since || (a.mark < b.mark ? -1 : 1));
+    const now = this.clock();
+    const young = (taker, game, since) => taker === "other" && (game || now - since < ONE_OFF_AGED_MS) ? 1 : 0;
+    const own = {
+      group: young(this.taker, this.game, this.since),
+      since: this.since,
+      mark: this.mark ?? "￿"
+    };
+    const placeOf = (one) => ({
+      group: young(one.taker, one.game, one.since),
+      since: one.since,
+      mark: one.mark
+    });
+    const before = (a, b) => a.group - b.group || a.since - b.since || (a.mark < b.mark ? -1 : a.mark > b.mark ? 1 : 0);
+    return waiters.filter((one) => one.mark !== this.mark && before(placeOf(one), own) < 0).toSorted((a, b) => before(placeOf(a), placeOf(b)));
   }
   admitted(numbers, theirs) {
     const now = this.clock();
@@ -2085,7 +2094,7 @@ class SlotLine {
   }
 }
 function gamesKeptOf(kept) {
-  return Math.max(0, Math.min(Math.floor(kept / 2), kept - GATE_KEPT - 1));
+  return Math.max(0, Math.min(Math.floor(kept / 2), kept - 1));
 }
 function slotsDrawnOn(count, taker, queue) {
   const gated = Math.max(1, count - keptSlotsOf(count));
@@ -2094,14 +2103,35 @@ function slotsDrawnOn(count, taker, queue) {
   }
   const every = Array.from({ length: count }, (_, slot) => count - 1 - slot);
   const kept = every.slice(0, count - gated);
+  if (taker === "tier") {
+    return { numbers: [...every.slice(count - gated), ...kept] };
+  }
   if (taker === "timing" || queue === "none" || kept.length === 0) {
     return { numbers: every };
   }
-  if (taker === "tier") {
-    const reserve = reservedSlotOf(count);
-    return { numbers: [...kept].reverse().filter((slot) => slot !== reserve), limit: "tier" };
+  if (queue === "spare") {
+    return { numbers: [...kept, ...every.slice(count - gated)] };
   }
-  return { numbers: kept.slice(0, Math.max(1, kept.length - GATE_KEPT)), limit: "kept" };
+  return { numbers: kept, limit: "kept" };
+}
+function spareSaid(content, now) {
+  let said;
+  try {
+    said = JSON.parse(content ?? "");
+  } catch {
+    return 0;
+  }
+  if (!isRecord(said)) {
+    return 0;
+  }
+  const { spare, written } = said;
+  if (typeof spare !== "number" || !Number.isInteger(spare) || typeof written !== "number") {
+    return 0;
+  }
+  return now - written > SPARE_STALE_MS ? 0 : Math.max(0, spare);
+}
+function forAGame(queue, game) {
+  return game && queue === "spare" ? "queued" : queue;
 }
 function inAGate(env = process4.env) {
   return nonEmpty(env[SHARE_VARIABLE]) !== undefined && nonEmpty(env[SHARE_COUNT_VARIABLE]) !== undefined;
@@ -2294,10 +2324,8 @@ class EngineSlots {
     const aged = taker === "other" && !game && waitedMs >= ONE_OFF_AGED_MS;
     let queue;
     const queued = async () => queue ??= await this.gateQueue();
-    this.drawn = slotsDrawnOn(this.count, taker, taker === "gate" || taker === "timing" || aged ? "none" : await queued());
+    this.drawn = slotsDrawnOn(this.count, taker, taker === "other" && !aged ? forAGame(await queued(), game) : "none");
     if (game && this.drawn.limit === "kept") {
-      const reserve = reservedSlotOf(this.count);
-      this.drawn = { ...this.drawn, numbers: this.drawn.numbers.filter((slot) => slot !== reserve) };
       const kept = this.count - Math.max(1, this.count - keptSlotsOf(this.count));
       const games = await this.heldByGames(Array.from({ length: kept }, (_, at) => this.count - kept + at));
       if (games.length >= gamesKeptOf(kept)) {
@@ -2353,12 +2381,11 @@ class EngineSlots {
       return new Map;
     }
     const now = Date.now();
-    const reserve = reservedSlotOf(this.count);
     const drawn = [];
     for (const one of ahead) {
       const aged = one.taker === "other" && !one.game && now - one.since >= ONE_OFF_AGED_MS;
-      const theirs = slotsDrawnOn(this.count, one.taker, one.taker === "gate" || one.taker === "timing" || aged ? "none" : await queued());
-      drawn.push(one.game && theirs.limit === "kept" ? theirs.numbers.filter((slot) => slot !== reserve) : theirs.numbers);
+      const theirs = slotsDrawnOn(this.count, one.taker, one.taker === "other" && !aged ? forAGame(await queued(), one.game) : "none");
+      drawn.push(theirs.numbers);
     }
     return new Map([...slotsClaimed(drawn, open)].map(([slot, at]) => [slot, ahead[at]?.mark ?? ""]));
   }
@@ -2433,7 +2460,12 @@ class EngineSlots {
         live = "queued";
       }
     }
-    return live;
+    return live === "queued" && await this.spare() > 0 ? "spare" : live;
+  }
+  async spare() {
+    const path = join6(this.directory, SPARE_FILE);
+    const said = spareSaid(readWhole(path), Date.now());
+    return said > 0 && !await this.free(path) ? said : 0;
   }
   holders() {
     const found = [];
@@ -2654,7 +2686,7 @@ function slotWaitSaid(waitedMs, count, directory, holders = [], drawn = { number
   const named = holdersNamed(taking, holders);
   const waiting = `${so}: ${slots}`;
   const back = `the engine starts when ${taking === 1 ? "it" : "one"} is given back`;
-  const starts = drawn.limit === "kept" || drawn.limit === "tier" || drawn.limit === "games" ? `${back} or no gate is queued` : back;
+  const starts = drawn.limit === "kept" || drawn.limit === "games" ? `${back} or no gate is queued` : back;
   const said = named.length === 0 ? `${waiting}, by a gate or another tool, and ${starts}.` : taking === 1 ? `${waiting}, by ${named.join(", ")}, and ${starts}.` : `${waiting}: ${listed(named)}. ${starts.charAt(0).toUpperCase()}${starts.slice(1)}.`;
   return `${said}${leftSaid(drawn)}`;
 }
@@ -2674,9 +2706,6 @@ function slotsSaid(taking, count, directory, limit) {
   if (limit === "gate") {
     return `${taking === 1 ? "the one engine slot" : `the ${String(taking)} engine slots`} of the ${String(count)} ${where} a gate's engines draw on`;
   }
-  if (limit === "tier") {
-    return `${taking === 1 ? "the one engine slot" : `the ${String(taking)} engine slots`} of the ${String(count)} ${where} a gate's own steps take while a gate is queued`;
-  }
   if (limit === "games") {
     return `${taking === 1 ? "the one engine slot" : `the ${String(taking)} engine slots`} of the ${String(count)} ${where} that games editor_run started may hold while a gate is queued, the rest kept for short calls,`;
   }
@@ -2743,7 +2772,7 @@ async function inASlot(body) {
     held.release();
   }
 }
-var HELD_VARIABLE = "GODOT_ENGINE_HELD", SLOTS_VARIABLE = "GODOT_ENGINE_SLOTS", SLOT_COUNT_VARIABLE = "GODOT_ENGINE_SLOT_COUNT", PROCESSORS_A_SLOT = 2, START_TOLERANCE_MS = 2000, UNWRITTEN_MS = 1e4, SLOT_LOOK_MS = 1000, SLOT_SETTLE_MS = 50, WAIT_SAID_MS = 20000, COMMAND_WAIT_SAID_MS = 2000, START_READ_MS = 1e4, WAITING_FOLDER = "waiting", QUEUED_FOLDER = "queued", SHARE_VARIABLE = "GODOT_ENGINE_SHARE", SHARE_COUNT_VARIABLE = "GODOT_ENGINE_SHARE_COUNT", GATE_KEPT = 1, ONE_OFF_AGED_MS = 120000, SLOT_YIELD_MS = 5000, MEMORY_TAKER = "memory", TIMED_VARIABLE = "GODOT_ENGINE_TIMED", TIER_VARIABLE = "GODOT_ENGINE_TIER", SEATED_SUFFIX = ".seated", waitsMarked = 0, ENGINE_PID_LOOK_MS = 100, ours, saidTo, takenBy;
+var HELD_VARIABLE = "GODOT_ENGINE_HELD", SLOTS_VARIABLE = "GODOT_ENGINE_SLOTS", SLOT_COUNT_VARIABLE = "GODOT_ENGINE_SLOT_COUNT", PROCESSORS_A_SLOT = 2, START_TOLERANCE_MS = 2000, UNWRITTEN_MS = 1e4, SLOT_LOOK_MS = 1000, SLOT_SETTLE_MS = 50, WAIT_SAID_MS = 20000, COMMAND_WAIT_SAID_MS = 2000, START_READ_MS = 1e4, WAITING_FOLDER = "waiting", QUEUED_FOLDER = "queued", SHARE_VARIABLE = "GODOT_ENGINE_SHARE", SHARE_COUNT_VARIABLE = "GODOT_ENGINE_SHARE_COUNT", ONE_OFF_AGED_MS = 120000, SLOT_YIELD_MS = 5000, MEMORY_TAKER = "memory", TIMED_VARIABLE = "GODOT_ENGINE_TIMED", TIER_VARIABLE = "GODOT_ENGINE_TIER", SEATED_SUFFIX = ".seated", SPARE_FILE = "spare.json", SPARE_STALE_MS = 1e4, waitsMarked = 0, ENGINE_PID_LOOK_MS = 100, ours, saidTo, takenBy;
 var init_engine_slots = __esm(() => {
   init_alive();
   init_cache_home();
@@ -13081,13 +13110,17 @@ function crashIn(lines) {
   const at = trimmed.findIndex((line) => CRASH_HEADER.test(line));
   const said = trimmed.some((line) => line.includes(QUEUE_OVERFLOW_LINE));
   if (at === -1) {
-    return said ? { signal: "", overflowed: true } : null;
+    return said ? { reported: false, signal: undefined, overflowed: true } : null;
   }
   const report = trimmed.slice(at);
   const build = report.map((line) => CRASH_BUILD.exec(line)?.[1]).find((commit) => commit !== undefined);
   const frames = build === undefined ? undefined : QUEUE_OVERFLOW_FRAMES.get(build);
   const framed = frames?.every((frame) => report.some((line) => line.includes(`(${frame})`))) === true;
-  return { signal: CRASH_HEADER.exec(trimmed[at] ?? "")?.[1] ?? "", overflowed: said || framed };
+  return { reported: true, signal: CRASH_HEADER.exec(trimmed[at] ?? "")?.[1], overflowed: said || framed };
+}
+function crashSaid(crashed, during) {
+  const signal = crashed.signal === undefined ? "" : `, its crash handler reporting signal ${crashed.signal}`;
+  return `the engine crashed${during}${signal}`;
 }
 function whileRunning(running) {
   if (running === null) {
@@ -13115,10 +13148,10 @@ function judgeEngine(printed, handed, end) {
     faults.push(end.ended);
   } else if (end.code !== 0 && !explained) {
     const free = end.freeBytes === undefined ? "" : `, with ${(end.freeBytes / 1024 ** 3).toFixed(1)} GB of memory free as it ended`;
-    faults.push(crashed !== null && crashed.signal !== "" ? `the engine crashed${whileRunning(printed.running)}, its crash handler reporting signal ${crashed.signal}${free}` : end.code === null ? `the engine was ended by ${end.signal ?? "a signal"}${free}` : `the engine exited ${exitNamed(end.code)}${free}`);
+    faults.push(crashed?.reported === true ? `${crashSaid(crashed, whileRunning(printed.running))}${free}` : end.code === null ? `the engine was ended by ${end.signal ?? "a signal"}${free}` : `the engine exited ${exitNamed(end.code)}${free}`);
   }
   if (crashed?.overflowed === true) {
-    faults.push(`the engine's call queue overflowed${whileRunning(printed.running)}: something queued deferred calls without end within one frame, most often a layout that changes the size it is laid out from in a deferred handler, so the frame never ends${crashed.signal === "" ? "" : ", and the engine crashed reporting the overflow"}`);
+    faults.push(`the engine's call queue overflowed${whileRunning(printed.running)}: something queued deferred calls without end within one frame, most often a layout that changes the size it is laid out from in a deferred handler, so the frame never ends${crashed.reported ? ", and the engine crashed reporting the overflow" : ""}`);
   }
   if (printed.lines.every((line) => line.trim() === "")) {
     faults.push("the engine printed nothing at all");
@@ -13250,7 +13283,7 @@ function judgeCompile(printed, end) {
   if (end.ended !== null) {
     faults.push(end.ended);
   } else if (end.code !== 0) {
-    faults.push(crashed !== null && crashed.signal !== "" ? `the engine crashed, its crash handler reporting signal ${crashed.signal}` : end.code === null ? `the engine was ended by ${end.signal ?? "a signal"}` : `the engine exited ${exitNamed(end.code)}`);
+    faults.push(crashed?.reported === true ? crashSaid(crashed, "") : end.code === null ? `the engine was ended by ${end.signal ?? "a signal"}` : `the engine exited ${exitNamed(end.code)}`);
   }
   if (!printed.lines.some((line) => line.trim() === COMPILED_SAID)) {
     faults.push("it never said it had compiled them");
@@ -13390,7 +13423,7 @@ var init_suite_judge = __esm(() => {
     [105, "gdUnit4's code for scripts that did not compile"]
   ]);
   GODOT_EXITS = new Set([1, 255]);
-  CRASH_HEADER = /^(?:CrashHandlerException|handle_crash): Program crashed with signal (\d+)/;
+  CRASH_HEADER = /^(?:CrashHandlerException|handle_crash): Program crashed(?: with signal (\d+))?$/;
   CRASH_BUILD = /^Engine version: .*\(([0-9a-f]{40})\)$/;
   QUEUE_OVERFLOW_FRAMES = new Map([
     ["ed1daf0bf001b61586d9930840f2f1394092c079", ["main+3e1082a", "main+3e0f4aa"]]
@@ -13969,11 +14002,14 @@ function runArguments(options) {
   }
   return args;
 }
-function editorArguments(projectPath, ports, logFile, hidden, silent) {
+function editorArguments(projectPath, ports, logFile, hidden, silent, platform = process.platform) {
+  const headless = hidden && platform !== "win32";
+  const windowed = hidden && !headless;
   return [
     "-e",
-    ...hidden ? ["--headless"] : [],
-    ...silent && !hidden ? ["--audio-driver", "Dummy"] : [],
+    ...headless ? ["--headless"] : [],
+    ...windowed ? hiddenWindowFlags([], false) : [],
+    ...(silent || hidden) && !headless ? ["--audio-driver", "Dummy"] : [],
     "--path",
     projectPath,
     "--lsp-port",
@@ -13981,12 +14017,13 @@ function editorArguments(projectPath, ports, logFile, hidden, silent) {
     "--dap-port",
     String(ports.dap),
     "--log-file",
-    logFile
+    logFile,
+    ...windowed ? ["--", HIDDEN_EDITOR_MARK] : []
   ];
 }
 function startedAs(commandLine) {
   const words = commandLineWords(commandLine);
-  const hidden = words.includes("--headless");
+  const hidden = words.includes("--headless") || words.includes(HIDDEN_EDITOR_MARK);
   const driver = words.indexOf("--audio-driver");
   return { hidden, silent: hidden || driver >= 0 && words[driver + 1] === "Dummy" };
 }
@@ -14035,7 +14072,7 @@ function environmentFor2(options, variables = process.env) {
   const base = options.savesIn === undefined ? { ...variables } : userDataIn(options.savesIn, variables);
   return { ...base, ...options.env, GDHARNESS_RUNTIME_DIR: options.runtimeDirectory };
 }
-var HIDDEN_WINDOW_FPS = 60, ENGINE_FLAGS, VALUE_KIND, SET_BY_ARGUMENT, OPENED_BY_A_SERVER = "GDHARNESS_OPENED_BY_A_SERVER", EDITOR_PID_VARIABLE = "GDHARNESS_EDITOR_PID", RESERVED_VARIABLE_PREFIX = "GDHARNESS_", SAVES_NOT_MOVED_NOTE = "On macOS the engine reads user:// off HOME and ignores the variables that move it elsewhere, measured on Godot 4.7.2, so this run wrote its saves where the player keeps theirs. A suite that saves a game has written into the same folder as the copy being played, and one that tidies up after itself may have removed real saves.";
+var HIDDEN_WINDOW_FPS = 60, ENGINE_FLAGS, VALUE_KIND, SET_BY_ARGUMENT, HIDDEN_EDITOR_MARK = "--gdharness-hidden", OPENED_BY_A_SERVER = "GDHARNESS_OPENED_BY_A_SERVER", EDITOR_PID_VARIABLE = "GDHARNESS_EDITOR_PID", RESERVED_VARIABLE_PREFIX = "GDHARNESS_", SAVES_NOT_MOVED_NOTE = "On macOS the engine reads user:// off HOME and ignores the variables that move it elsewhere, measured on Godot 4.7.2, so this run wrote its saves where the player keeps theirs. A suite that saves a game has written into the same folder as the copy being played, and one that tidies up after itself may have removed real saves.";
 var init_launch = __esm(() => {
   ENGINE_FLAGS = Object.freeze({
     "--verbose": "none",
@@ -14452,7 +14489,7 @@ function answersTo(entry, severity, contains) {
 var HEADLINE, CRASH, GDUNIT_CASE, CRASH_FILLER, COLOUR_CODE, STREAMS, ADMITTED, LOCATION2, FRAME, LONGEST_CYCLE = 64;
 var init_game_log = __esm(() => {
   HEADLINE = /^(USER )?(SCRIPT ERROR|SHADER ERROR|ERROR|WARNING):\s?(.*)$/;
-  CRASH = /^(?:CrashHandlerException|handle_crash): Program crashed with signal \d+/;
+  CRASH = /^(?:CrashHandlerException|handle_crash): Program crashed(?: with signal \d+)?\s*$/;
   GDUNIT_CASE = /^\s+res:\/\/.+?\.(?:gd|cs) > .+? (?:STARTED|PASSED|FAILED|ERROR|SKIPPED|FLAKY)(?:\s|$)/;
   CRASH_FILLER = /^(?:=+|-- END OF .* BACKTRACE --|\[\d+\] .* - no debug info in .*)$/;
   COLOUR_CODE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
@@ -15475,6 +15512,7 @@ var init_scratch = __esm(() => {
   KINDS = [
     "answers",
     "desktop",
+    "editor-capture",
     "export",
     "import",
     "params",
@@ -19461,19 +19499,19 @@ var init_tool_definitions = __esm(() => {
     {
       name: "editor_launch",
       title: "Open, restart or close the editor, or bind its debug adapter again",
-      description: "Opens the Godot editor on a project, or restarts or closes the one already connected, or binds its debug adapter again. close saves open scenes, quits the editor and waits for its process to go, which is the only way to end a hidden one short of killing it. An editor this server opened that has not connected yet has nothing of this server's to save, so close stops its process instead. open answers once the process has started, and the editor dials in after its import. A call needing the editor made before then waits for the one this server opened, for as long as a restart waits, and is refused naming it if it has not arrived. open refuses while an editor of the project is already running and has not reached this server, naming its pid, rather than putting a second on the project. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it headless instead and, on Windows, on a desktop of its own, where the games it plays go too. A hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one. It saves open scenes on the way out. An editor a server opened is started again by the server, hidden or visible and silent or not as it was started unless hidden or silent says otherwise, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. Godot tries each server port once, as the editor starts, so a restart binds a debug adapter that came back without its port again, in the editor that came back. rebind does the same for the connected editor without restarting it, whoever opened it. A debug session open on the adapter ends with it and is opened again by the next debug call. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so in editor_status rather than waiting for an editor that is not coming, and open finishes it. An open is refused when the editor it would start could never reach this server. Those are a project other than the one this server serves (its editor dials that project's own server), a project without the gdharness editor addon installed and enabled, and a project whose editor a restart is already bringing back.",
+      description: "Opens the Godot editor on a project, or restarts or closes the one already connected, or binds its debug adapter again. close saves open scenes, quits the editor and waits for its process to go, which is the only way to end a hidden one short of killing it. An editor this server opened that has not connected yet has nothing of this server's to save, so close stops its process instead. open answers once the process has started, and the editor dials in after its import. A call needing the editor made before then waits for the one this server opened, for as long as a restart waits, and is refused naming it if it has not arrived. open refuses while an editor of the project is already running and has not reached this server, naming its pid, rather than putting a second on the project. The editor is an ordinary visible one on the desktop in use, and on Windows it is shown without being activated, so opening or reopening it does not take the keyboard from whatever the user is typing in. hidden: true opens it out of sight instead. On Windows it gets a desktop of its own, shared by the games it plays, and still draws its views for editor_capture. On Linux and macOS it is headless, so editor_capture refuses it. A hidden editor serves the bridge, the language server and the debug adapter as a visible one does. A game a visible editor plays opens as a window on the desktop in use. An editor goes on serving the addon it read at startup, so restart is what puts a gdharness upgrade into effect, and nothing else here restarts one. It saves open scenes on the way out. An editor a server opened is started again by the server, hidden or visible and silent or not as it was started unless hidden or silent says otherwise, once the old one has gone: it waits 90 seconds for that, or GDHARNESS_EDITOR_RESTART_TIMEOUT_MS, and an old editor still running after it is not replaced, since the new one would find its ports held. One opened by hand restarts itself, which only one with a window can do, because the engine hands back none of the arguments it was started with. Godot tries each server port once, as the editor starts, so a restart binds a debug adapter that came back without its port again, in the editor that came back. rebind does the same for the connected editor without restarting it, whoever opened it. A debug session open on the adapter ends with it and is opened again by the next debug call. editor_status says which editor is connected and whether it is holding an old addon. Opening a project is a save and so is closing one, which is the part that is not obvious from outside: the editor imports the project on open and writes project.godot back, and Godot writes only what differs from its own defaults, so a key named deliberately at its default value is dropped either way. A restart of an editor this server opened is a quit and then a launch, and this server can be ended between them, usually by the reconnect the restart was being taken for: the editor is gone and nothing replaces it. That is written down before the quit, so the next server says so in editor_status rather than waiting for an editor that is not coming, and open finishes it. An open is refused when the editor it would start could never reach this server. Those are a project other than the one this server serves (its editor dials that project's own server), a project without the gdharness editor addon installed and enabled, and a project whose editor a restart is already bringing back.",
       answer: "close answers settingsDropped, naming what its save took out of project.godot and left out when it took nothing, and settingsNote when the file could not be read to tell. An editor stopped before it connected is answered with beforeConnecting. close and restart name under savedScenes the open scenes that had unsaved changes and were saved on the way out, an empty list when none had. A scene that would not save refuses the close or restart and leaves the editor running. Both answer tookMs, how long the editor took to go or to come back. restart answers with the version that came back, and hidden, whether it came back with no window, and says under settingsDropped which keys its save dropped, because it waits for the editor to return. An open cannot, since it answers as soon as the process exists and the save happens during the import minutes later, so editor_status carries that reading once the editor has connected. Nothing else will say a key went until something depends on one. A restart answers lspListening and dapListening once the editor's servers are up. When either came back without its port, serversSaid gives the lines the editor's log panel has about its servers, the one place Godot says why a port would not bind, and when it was the debug adapter, which is bound again in the editor that came back, debugAdapterRebound says whether that took. Neither is there when both came up. Godot clears that panel whenever a game is played, unless its run/output/always_clear_output_on_play setting is off, so after a play the lines from the editor's own start are gone. rebind answers rebound, with lspListening, dapListening and serversSaid, the lines that rebind made the panel print. A restart that a server's end interrupted shows as restartInterrupted in editor_status, and the open that finishes it says so under finishesRestart.",
       parameters: {
         projectPath: { ...PROJECT_PATH, ops: ["open"] },
         hidden: {
           type: "boolean",
           ops: ["open", "restart"],
-          description: "Open the editor headless and, on Windows, on a desktop of its own, so no window of it or of the games it plays appears. Default false on open: one visible editor, shown without taking the focus. On restart only for an editor a server opened, where the default is how the editor being replaced was started, read from its process. One whose start cannot be read is left running and refused until hidden is passed. One opened by hand comes back as it was, so hidden is refused there."
+          description: "Open the editor out of sight, with the games it plays: on a desktop of its own on Windows, and headless elsewhere. Default false on open: one visible editor, shown without taking the focus. On restart it applies only to an editor a server opened. The default there is how the replaced editor was started, read from its process. One whose start cannot be read is left running and refused until hidden is passed. One opened by hand comes back as it was, so hidden is refused there."
         },
         silent: {
           type: "boolean",
           ops: ["open", "restart"],
-          description: "Open the editor with no sound out of the machine, started with --audio-driver Dummy, so a tool script, a preview or a scene playing in its viewport is heard by nobody. Default true on open, and on restart how the editor being replaced was started: pass false to hear it. The answer's arguments are what the editor was started with. The editor hands no audio driver to a game it plays, so editor_run's own silent decides that game's sound. A hidden editor is headless and silent either way, so its arguments carry no --audio-driver. On restart only for an editor a server opened. One opened by hand comes back as it was."
+          description: "Open the editor with no sound out of the machine, started with --audio-driver Dummy, so a tool script, a preview or a scene playing in its viewport is heard by nobody. Default true on open, and on restart how the editor being replaced was started: pass false to hear it. The answer's arguments are what the editor was started with. The editor hands no audio driver to a game it plays, so editor_run's own silent decides that game's sound. A hidden editor is silent whatever silent says. A headless editor has no sound to turn off, so its arguments show no --audio-driver. On restart only for an editor a server opened. One opened by hand comes back as it was."
         }
       },
       requires: [],
@@ -19714,7 +19752,7 @@ var init_tool_definitions = __esm(() => {
       title: "Editor status",
       effect: "read",
       description: "Whether the editor addon is connected, which Godot answers, whether the editor is playing something, and which games with the runtime addon are reachable, of this project and of every other on the machine. Read connected with mayYetConnect: the editor dials this server and backs off between tries, so for the first half-minute after a server starts false means not reached yet as often as no editor. mayYetConnect true is worth waiting out, false is final, and editorCannotConnect, restartInterrupted, restartUnderway, closedHere and editorsNotYetConnected say why. An editor that has connected and not yet greeted reports nothing about itself, and every other call made in that window waits up to ten seconds for it to settle. playingInEditor null means unanswered rather than nothing playing: processActive and runtimes do not depend on the editor answering. game.run names the run editor_output and editor_run stop answer for, and stays named after it ends. addonIsStale, on a connected editor and on each running game (absent with neither), says it runs addon code other than what this server ships, and staleNote says which half moves: the project, by a gdharness upgrade it spells out to run in a shell, the editor by a restart, or this server by a reconnect. A false editor.lspListening or editor.dapListening comes with serversNote: editor_launch rebind binds the debug adapter again in place, and editor_launch restart the language server. editor.scan says whether the editor is scanning, which editor_run waits out before starting a game. A game announced in a protocol this server does not speak is listed under unreadable, during an upgrade that moves the protocol, until the halves match.",
-      answer: "projectIs, when present, is the gdharness version of the addons in the project, which differs from this server's (project_info says which of the two to move), and configIs, when present, the version the project's MCP config starts, which differs from this server's, so the next connection runs that one. server names this server: its pid, its version, and lifecycleLog, the file every gdharness server of the user appends a line to when it starts, when its client first names itself, when it replaces another server of its project, and when it ends, with why it ended (the client closing its end as stdin:end, a signal by name, superseded with the successor's pid, an uncaught exception or rejection with its stack, or the exit code) and the calls it was answering then. The parent's command line follows on its own line a few seconds after the start. A server killed without warning writes no ended line, and on Windows every kill is that, so a started line with no ended line after it is a server something killed. " + "runtimeConnected counts the games of the project this server serves on this release's runtime addon, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath, and userDir, the directory its user:// is, where its saves and settings are read. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. Its play says which play the editor is on: play.play counts the plays that editor has started since it opened, whoever started them, and play.editorPid is the editor, so two reads with different pairs are two plays even when both say playing. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it. It stays named after the run ends, beside processActive false, so editor_output can still read what that run printed. It is null when there is no run at all. startedAt says when it began, and endedAt when it ended, wherever something saw the end: a run adopted from a note another server wrote can have ended hours before this server started. editor.lspListening and editor.dapListening say whether anything accepts connections on the ports the editor names, lspPort and dapPort: Godot binds each once, as the editor starts, and reports a failure only in the log panel of the editor itself, so a false comes with serversNote: editor_launch rebind binds the debug adapter again in place, and editor_launch restart the language server. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. editor.openScenes lists the scenes open in the editor's tabs, leaving out a tab of a scene never saved, editor.editedScene the one it is showing (null when none is, or when that scene was never saved), and editor.unsavedScenes those with changes not yet written to disk, where an empty entry is a scene never saved. All three come with scan and are absent when it is null. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout. For the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself. A game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say). addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs the gdharness upgrade command, spelled out to run in a shell, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. A runtime_* call to such a game is refused with the staleNote and not sent. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out. False is an editor that is not there. False beside editorCannotConnect is a project without the gdharness editor addon installed or enabled, where no editor can ever dial in, however young the server or whichever editor is open. Its remedies say how to install or enable it. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for. editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. Any editor of this project running and not yet connected, whoever opened it, makes it true as well and is named under editorsNotYetConnected with its pid and start time, so a restart a reconnect interrupted after its launch is not read as nothing being there. settingsDropped appears here once when the editor this server opened saved project.godot on its way in and took a key out of it, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. A stale editor is asked nothing but to quit: every other call to it is refused with staleNote, which names editor_launch restart, the upgrade command or a reconnect. port is the one the editor bridge is on. When that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds. bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it. startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and from the socket opening until its greeting and that read are done, identifying is true and connected false. One started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window. serverVersion is the gdharness version of this server. bridgeAvailable says the editor bridge is listening. When it failed to start, startupError gives the error, and retryingBridge is true while this server tries again. announcedAt is the file where this server told editors of its project which port to dial. connectedAt is when the editor connected, and lastPongAt when it last answered this server's keep-alive ping. addonDigest is a hash of the editor addon's code, which addonIsStale compares with what this server ships. debugPort is the port of the editor's remote debugger, the one games it plays connect to. openedByAServer says a gdharness server started this editor, syncsBreakpoints that it keeps its breakpoints when a debug session opens, which Godot otherwise clears, and hidden that it runs headless with no window anybody can see. pendingRequests counts the requests sent to the editor and not yet answered, and queuedResources the files with writes waiting behind another write to the same file.",
+      answer: "projectIs, when present, is the gdharness version of the addons in the project, which differs from this server's (project_info says which of the two to move), and configIs, when present, the version the project's MCP config starts, which differs from this server's, so the next connection runs that one. server names this server: its pid, its version, and lifecycleLog, the file every gdharness server of the user appends a line to when it starts, when its client first names itself, when it replaces another server of its project, and when it ends, with why it ended (the client closing its end as stdin:end, a signal by name, superseded with the successor's pid, an uncaught exception or rejection with its stack, or the exit code) and the calls it was answering then. The parent's command line follows on its own line a few seconds after the start. A server killed without warning writes no ended line, and on Windows every kill is that, so a started line with no ended line after it is a server something killed. " + "runtimeConnected counts the games of the project this server serves on this release's runtime addon, and runtimes lists every game on the machine with ofThisProject saying which is which, since a game of another project is reached only by naming its projectPath, and userDir, the directory its user:// is, where its saves and settings are read. playingInEditor is null when the editor was not asked or did not answer, which is not the same as a no: with no editor connected there is nobody to ask, and an editor that does not serve the question is given a moment and then left. A game can be playing while this is null, so read it as unanswered rather than as nothing playing, and use processActive and runtimes, which come from elsewhere and do not depend on the editor answering. Its play says which play the editor is on: play.play counts the plays that editor has started since it opened, whoever started them, and play.editorPid is the editor, so two reads with different pairs are two plays even when both say playing. game.run names the run processActive is about, the one editor_output and editor_run stop answer for: its pid, its project, and adopted true when this server read it back from another server rather than starting it. It stays named after the run ends, beside processActive false, so editor_output can still read what that run printed. It is null when there is no run at all. startedAt says when it began, and endedAt when it ended, wherever something saw the end: a run adopted from a note another server wrote can have ended hours before this server started. editor.lspListening and editor.dapListening say whether anything accepts connections on the ports the editor names, lspPort and dapPort: Godot binds each once, as the editor starts, and reports a failure only in the log panel of the editor itself, so a false comes with serversNote: editor_launch rebind binds the debug adapter again in place, and editor_launch restart the language server. editor.scan says whether the editor is scanning or importing and how many milliseconds ago its last scan finished (finishedMsAgo), or is null when it did not answer: the editor rewrites the class cache just after a scan, and editor_run waits that out before starting a game, saying so under waitedForEditorScanMs. editor.openScenes lists the scenes open in the editor's tabs, leaving out a tab of a scene never saved, editor.editedScene the one it is showing (null when none is, or when that scene was never saved), and editor.unsavedScenes those with changes not yet written to disk, where an empty entry is a scene never saved. All three come with scan and are absent when it is null. Each game under runtimes is pinged with a short wait, so one held at a breakpoint is listed as unreachable rather than making this call wait out the runtime timeout. For the run this server is reporting on, heldAt says whether that is what it is, with the same three answers editor_output gives. A game the editor played announces the editor under editorPid, and so does whatever that game started for itself. A game some other server started announces none, which is how the two are told apart when both are running from one project. Each game also says which runtime addon it loaded, under addonVersion (null when it cannot say). addonIsStale is true when that code is not what this server ships, and staleNote says whether the project needs the gdharness upgrade command, spelled out to run in a shell, the game a restart, or this server a reconnect. A second checkout of a project, such as a git worktree, carries addons of its own and is where this shows. A runtime_* call to such a game is refused with the staleNote and not sent. When connected is false, mayYetConnect says whether that is final: the editor dials this server rather than the other way round and backs off between tries, so for the first half-minute after a server starts, false means \"not reached yet\" as often as it means \"no editor\". True is worth waiting out. False is an editor that is not there. False beside editorCannotConnect is a project without the gdharness editor addon installed or enabled, where no editor can ever dial in, however young the server or whichever editor is open. Its remedies say how to install or enable it. False beside restartInterrupted is one that an editor_launch restart on a previous server asked to quit, where the launch half never ran because that server was ended in between, usually by the reconnect the restart was taken for. editor_launch open finishes it. True beside restartUnderway is a restart still in progress, its server alive and within the wait for the old editor to go: the editor is coming, and opening another would put two on one project. listeningSince is when this server took the bridge port, which is what that window is measured from and what a caller wanting its own window should read. An editor this server opened counts for as long as its process lives, however far past that window the import runs, and awaitingLaunchedEditor names its pid so the two reasons for true are told apart. Any editor of this project running and not yet connected, whoever opened it, makes it true as well and is named under editorsNotYetConnected with its pid and start time, so a restart a reconnect interrupted after its launch is not read as nothing being there. settingsDropped appears here once when the editor this server opened saved project.godot on its way in and took a key out of it, which is the same reading editor_launch restart makes in its own answer. A game that has announced itself in a protocol this server does not speak is listed under unreadable rather than left out, with the protocol it speaks and whether the server or the addon is the older half. This happens during an upgrade that moves the runtime protocol, which most do not: installing replaces the addon on disk as soon as the pin moves, while a server that is already running stays on the version it started with, so the two speak different protocols until the server is reconnected. Those games are real and running, but no tool here can reach them until the halves match, so runtimes stays empty and runtimeConnected stays false. An upgrade that leaves the protocol alone opens no such window and this list stays empty through it. addonIsStale is decided by the code of the editor addons rather than their version, so an editor started before an upgrade that left that code alone reports the older addonVersion, is not stale, and addonNote says so: it needs no restart. A stale editor is asked nothing but to quit: every other call to it is refused with staleNote, which names editor_launch restart, the upgrade command or a reconnect. port is the one the editor bridge is on. When that is not the one this server was configured with, portWanted names the configured one and portNote says why it moved and, when it was the server this one replaced, which pid kept it. A server replacing another of its project that holds the configured port waits for it to stand down and takes the port over, which takes a few seconds. bridgeHandover says so while it waits, and it moves only if that server has not let go within the wait. An editor that has connected and not yet greeted, which lasts a frame and longer while it imports, reports nothing about itself: greeting says so, addonIsStale is absent rather than guessed, and a restart asked then waits for the greeting to learn who opened it. startedByAnEditor is an editor another editor started, by Godot's own restart or the project manager, which has none of the arguments a server gave the one before it. startedByAnEditorNote says what that costs. An engine run that loads the editor addon to do one job and quit, such as a gate's godot --headless --import, an export or a script, is not taken as the editor: a process that greets without a server's mark has its command line read first, and from the socket opening until its greeting and that read are done, identifying is true and connected false. One started with such an option is turned away, and turnedAway names the last one, its pid and the option. Every other call made while an editor is arriving, before its greeting or while it is looked up, waits up to ten seconds for it to settle rather than acting on connected as it reads in that window. serverVersion is the gdharness version of this server. bridgeAvailable says the editor bridge is listening. When it failed to start, startupError gives the error, and retryingBridge is true while this server tries again. announcedAt is the file where this server told editors of its project which port to dial. connectedAt is when the editor connected, and lastPongAt when it last answered this server's keep-alive ping. addonDigest is a hash of the editor addon's code, which addonIsStale compares with what this server ships. debugPort is the port of the editor's remote debugger, the one games it plays connect to. openedByAServer says a gdharness server started this editor, syncsBreakpoints that it keeps its breakpoints when a debug session opens, which Godot otherwise clears, and hidden that it runs with no window anybody can see. pendingRequests counts the requests sent to the editor and not yet answered, and queuedResources the files with writes waiting behind another write to the same file.",
       parameters: {},
       requires: []
     },
@@ -19744,6 +19782,41 @@ var init_tool_definitions = __esm(() => {
       },
       requires: ["projectPath"]
     },
+    {
+      name: "editor_capture",
+      title: "Capture the editor's view of a scene",
+      effect: "read",
+      description: "A picture of a scene as the editor's 2D or 3D view draws it, including what its @tool scripts draw under Engine.is_editor_hint(). No game and no headless engine runs that branch, so runtime_capture cannot show it. The editor opens the scene, shows its 2D or 3D view for a few frames and captures it. It then returns to the scene and view it showed before, and closes the scene again if it was not open. The view is the editor's own, at its zoom and scroll for that scene, and in 3D with its grid and gizmos. A scene open with unsaved changes is captured as the editor holds it. Other calls to the editor wait for the capture. Needs a connected editor that draws: a visible one, or a hidden one on Windows. A hidden editor on Linux or macOS is headless and is refused.",
+      answer: "The picture, with its size in pixels and which view drew it. When width or height scaled the picture, it also gives the size the view drew at. A scene with unsaved changes in the editor says so.",
+      parameters: {
+        projectPath: PROJECT_PATH,
+        scenePath: SCENE_PATH,
+        view: {
+          type: "string",
+          enum: ["2d", "3d"],
+          description: "Which of the editor's views draws the scene. Default 3d for a scene whose root is a Node3D, and 2d otherwise."
+        },
+        width: {
+          type: "integer",
+          minimum: 1,
+          description: "Scale the picture to this width. Given alone, the height keeps the picture's proportions."
+        },
+        height: {
+          type: "integer",
+          minimum: 1,
+          description: "Scale the picture to this height. Given alone, the width keeps the picture's proportions."
+        },
+        outputPath: {
+          type: "string",
+          description: "Also save the picture as a lossless PNG at this absolute path. The answer says where. Refused unless it ends in .png, its directory exists, it is outside the project, and no file is there already."
+        },
+        inline: {
+          type: "boolean",
+          description: "Send the picture back in the answer. Default true, as a JPEG when that is smaller than the PNG and the picture has no transparency. false sends none and needs outputPath."
+        }
+      },
+      requires: ["projectPath", "scenePath"]
+    },
     {
       name: "editor_classes",
       title: "Engine classes",
@@ -51071,9 +51144,15 @@ function selectTests(projectPath, asked, given) {
         return { ok: false, reason: `${said}: none of them declares a func test_ at the top level.` };
       }
       const written = declared.map((one) => `${nameOf(one.suite)}:${one.test}`);
-      const close = nearest(suiteNamed === null ? test : `${nameOf(suiteNamed)}:${test}`, [
-        ...new Set(suiteNamed === null ? declared.map((one) => one.test) : written)
-      ]);
+      const bare = (name) => name.replace(/^test_/, "");
+      const inSuite = suiteNamed === null ? declared : declared.filter((one) => one.suite === suitePath || nameOf(one.suite) === suiteNamed);
+      const spell = (one) => suiteNamed === null ? one.test : `${nameOf(one.suite)}:${one.test}`;
+      const close = [
+        ...new Set([
+          ...nearest(bare(test), [...new Set(inSuite.map((one) => bare(one.test)))]).flatMap((name) => inSuite.filter((one) => bare(one.test) === name).map(spell)),
+          ...suiteNamed === null ? [] : declared.filter((one) => one.test === test).map(spell)
+        ])
+      ];
       return {
         ok: false,
         reason: close.length > 0 ? `${said}. The nearest ${close.length === 1 ? "is" : "are"} ${close.join(", ")}.` : `${said}. The cases there are ${written.slice(0, 12).join(", ")}${written.length > 12 ? `, and ${written.length - 12} more` : ""}.`
@@ -51096,27 +51175,109 @@ var init_test_selection = __esm(() => {
   CASE_AFTER_SCRIPT = /^(.*\.gd):(\w+)$/;
 });
 
+// src/write-turns.ts
+import { createHash as createHash8 } from "node:crypto";
+import { closeSync as closeSync6, mkdirSync as mkdirSync23, openSync as openSync7, readFileSync as readFileSync41, rmSync as rmSync21, statSync as statSync20, writeSync as writeSync5 } from "node:fs";
+import { join as join45, relative as relative10 } from "node:path";
+import process18 from "node:process";
+import { setTimeout as delay8 } from "node:timers/promises";
+function writeLockOf(projectPath, file) {
+  const named = relative10(projectPath, file).split("\\").join("/");
+  const key = process18.platform === "win32" ? named.toLowerCase() : named;
+  const hash = createHash8("sha256").update(key).digest("hex").slice(0, 16);
+  return join45(projectPath, ".godot", WRITES_FOLDER, `${hash}.lock`);
+}
+async function inTurnFor(projectPath, file, write) {
+  const lock = writeLockOf(projectPath, file);
+  mkdirSync23(join45(projectPath, ".godot", WRITES_FOLDER), { recursive: true });
+  const holder = JSON.stringify({ pid: process18.pid, started: await ownStart(), file });
+  const starts = new Map;
+  while (!made(lock, holder) && !await takenOver(lock, holder, starts)) {
+    await delay8(TURN_LOOK_MS);
+  }
+  try {
+    return await write();
+  } finally {
+    removeWhole(lock);
+  }
+}
+function made(path, content) {
+  let file;
+  try {
+    file = openSync7(path, "wx");
+  } catch {
+    return false;
+  }
+  try {
+    writeSync5(file, content);
+  } finally {
+    closeSync6(file);
+  }
+  return true;
+}
+async function takenOver(lock, holder, starts) {
+  if (!await gone2(lock, starts)) {
+    return false;
+  }
+  const steal = `${lock}.steal`;
+  if (!made(steal, holder)) {
+    try {
+      if (Date.now() - statSync20(steal).mtimeMs > UNWRITTEN_MS) {
+        rmSync21(steal, { force: true });
+      }
+    } catch {}
+    return false;
+  }
+  try {
+    return await gone2(lock, starts) && removeWhole(lock) && made(lock, holder);
+  } finally {
+    rmSync21(steal, { force: true });
+  }
+}
+async function gone2(lock, starts) {
+  let content;
+  let writtenAt;
+  try {
+    content = readFileSync41(lock, "utf8");
+    writtenAt = statSync20(lock).mtimeMs;
+  } catch {
+    return false;
+  }
+  const pid = holderOf(content)?.pid;
+  if (pid !== undefined && !starts.has(pid) && alive(pid)) {
+    starts.set(pid, (await startTimesOf([pid])).get(pid));
+  }
+  return lockIsFree(content, writtenAt, Date.now(), alive, (asked) => starts.get(asked));
+}
+var WRITES_FOLDER = "gdharness-writes", TURN_LOOK_MS = 100;
+var init_write_turns = __esm(() => {
+  init_alive();
+  init_engine_slots();
+  init_process_children();
+  init_whole_file();
+});
+
 // src/server.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import {
   appendFileSync as appendFileSync2,
-  closeSync as closeSync6,
+  closeSync as closeSync7,
   constants,
   copyFileSync as copyFileSync2,
   existsSync as existsSync36,
   fstatSync as fstatSync3,
-  mkdirSync as mkdirSync23,
-  openSync as openSync7,
+  mkdirSync as mkdirSync24,
+  openSync as openSync8,
   readdirSync as readdirSync21,
-  readFileSync as readFileSync41,
+  readFileSync as readFileSync42,
   readSync as readSync4,
   realpathSync as realpathSync7,
   rmdirSync as rmdirSync2,
-  statSync as statSync20,
+  statSync as statSync21,
   writeFileSync as writeFileSync24
 } from "node:fs";
-import { basename as basename14, dirname as dirname25, extname as extname6, isAbsolute as isAbsolute9, join as join45, normalize as normalize2, relative as relative10 } from "node:path";
-import { setTimeout as delay8 } from "node:timers/promises";
+import { basename as basename14, dirname as dirname25, extname as extname6, isAbsolute as isAbsolute9, join as join46, normalize as normalize2, relative as relative11 } from "node:path";
+import { setTimeout as delay9 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 function editorRestartTimeoutMs() {
   return waitFromEnv("GDHARNESS_EDITOR_RESTART_TIMEOUT_MS", 90000);
@@ -51129,9 +51290,9 @@ function greetingWaitMs() {
   return waitFromEnv("GDHARNESS_GREETING_WAIT_MS", 1e4);
 }
 function pictureToSend(pngPath, jpegPath) {
-  const png = readFileSync41(pngPath);
+  const png = readFileSync42(pngPath);
   const beside = pngPath.replace(/\.png$/, ".jpg");
-  const jpeg = jpegPath !== undefined && normalize2(jpegPath) === normalize2(beside) && existsSync36(beside) ? readFileSync41(beside) : null;
+  const jpeg = jpegPath !== undefined && normalize2(jpegPath) === normalize2(beside) && existsSync36(beside) ? readFileSync42(beside) : null;
   const sent = jpeg !== null && jpeg.length < png.length ? jpeg : png;
   return {
     data: sent.toString("base64"),
@@ -51175,7 +51336,7 @@ function writtenFileRefusal(path, rule) {
   if (!existsSync36(directory)) {
     return `${argument}'s directory ${dirname25(path)} does not exist. ${whatOpening} creates no directories.`;
   }
-  const where = join45(directory, basename14(path));
+  const where = join46(directory, basename14(path));
   const inside = rule.projects.find((project) => project !== "" && isWithinRoot(realAsFarAsItExists(project), where));
   if (inside !== undefined) {
     return `${argument} ${path} is inside the project at ${inside}. ${whatOpening} is saved outside it, so it never becomes part of the game.`;
@@ -51271,7 +51432,7 @@ function keptGameRequest(tool, op, args) {
   }
 }
 function projectSpelling(projectPath, absolutePath) {
-  return `res://${relative10(realAsFarAsItExists(projectPath), realAsFarAsItExists(absolutePath)).replaceAll("\\", "/")}`;
+  return `res://${relative11(realAsFarAsItExists(projectPath), realAsFarAsItExists(absolutePath)).replaceAll("\\", "/")}`;
 }
 function whichGame(args) {
   return { projectPath: args["projectPath"], pid: args["pid"] };
@@ -51402,7 +51563,7 @@ async function untilGone(pids, withinMs = stopWaitMs()) {
   const gone = () => pids.every((pid) => !alive(pid));
   const deadline = Date.now() + withinMs;
   while (!gone() && Date.now() < deadline) {
-    await delay8(50);
+    await delay9(50);
   }
   return gone();
 }
@@ -51606,7 +51767,7 @@ function endedToStartThis(ended) {
   return ` ${which} was ended to start this one. Its output is no longer what editor_output answers about.`;
 }
 function lineNothingStopsOn(absolutePath, relativePath, line) {
-  const text = readFileSync41(absolutePath, "utf8");
+  const text = readFileSync42(absolutePath, "utf8");
   const lines = text === "" ? 0 : text.split(`
 `).length - (text.endsWith(`
 `) ? 1 : 0);
@@ -51814,7 +51975,7 @@ function notRunNote(notRun, failFast) {
 function presetsIn(projectPath) {
   let text;
   try {
-    text = readFileSync41(join45(projectPath, "export_presets.cfg"), "utf8");
+    text = readFileSync42(join46(projectPath, "export_presets.cfg"), "utf8");
   } catch {
     return null;
   }
@@ -51921,7 +52082,7 @@ function filesIn(folder) {
   try {
     for (const entry of readdirSync21(folder, { withFileTypes: true })) {
       if (entry.isFile()) {
-        found.set(entry.name, statSync20(join45(folder, entry.name)).mtimeMs);
+        found.set(entry.name, statSync21(join46(folder, entry.name)).mtimeMs);
       }
     }
   } catch {}
@@ -51961,7 +52122,7 @@ function unsavedInEditorNote(scripts) {
   return `${listed} ${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 (!existsSync36(join45(projectPath, "project.godot"))) {
+  if (!existsSync36(join46(projectPath, "project.godot"))) {
     return null;
   }
   const report = inspectProject(projectPath);
@@ -51989,8 +52150,8 @@ function rewriteBusNamed(projectPath, from, to) {
   const giving = [`bus = &"${quoted(from)}"`, `bus = "${quoted(from)}"`];
   const rewritten = [];
   for (const file of projectFiles(projectPath, [".tscn", ".tres"])) {
-    const absolute = join45(projectPath, file);
-    const lines = readFileSync41(absolute, "utf8").split(`
+    const absolute = join46(projectPath, file);
+    const lines = readFileSync42(absolute, "utf8").split(`
 `);
     const at = [];
     const after = lines.map((line, index) => {
@@ -52009,7 +52170,7 @@ function rewriteBusNamed(projectPath, from, to) {
   }
   const namedInScripts = [];
   for (const file of projectFiles(projectPath, [".gd"])) {
-    readFileSync41(join45(projectPath, file), "utf8").split(`
+    readFileSync42(join46(projectPath, file), "utf8").split(`
 `).forEach((line, index) => {
       if (line.includes(`"${from}"`)) {
         namedInScripts.push({ file: `res://${file}`, line: index + 1, text: line.trim() });
@@ -52300,7 +52461,7 @@ function profileFrameFunctions(projectPath) {
   let projectGodot = null;
   if (projectPath !== null) {
     try {
-      projectGodot = readFileSync41(join45(projectPath, "project.godot"), "utf8");
+      projectGodot = readFileSync42(join46(projectPath, "project.godot"), "utf8");
     } catch {}
   }
   return frameFunctionsFor(queuedMessagesOf(projectGodot));
@@ -52324,7 +52485,7 @@ function projectSourceOf(projectPath) {
       let source = null;
       if (inside.ok) {
         try {
-          source = readFileSync41(inside.absolutePath, "utf8");
+          source = readFileSync42(inside.absolutePath, "utf8");
         } catch {}
       }
       read.set(script, source);
@@ -52496,7 +52657,7 @@ function foldedEntriesAnswer(log, floor = "warning") {
 }
 function gdUnitFailsOnScriptErrors(projectPath) {
   try {
-    return settingKeys(readFileSync41(join45(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
+    return settingKeys(readFileSync42(join46(projectPath, "project.godot"), "utf8")).get("gdunit4/report/godot/script_error") !== false;
   } catch {
     return true;
   }
@@ -52511,7 +52672,7 @@ function uncaughtNote(uncaught) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync36(join45(projectPath, wanted))) {
+  if (wanted === "" || existsSync36(join46(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -52534,7 +52695,7 @@ function windowNoteFor(needing, sharing) {
   return `${named(needing)} ${one ? "needs" : "need"} a window, as gdharness test reads ${one ? "it" : "them"}, so the run had one: the engine ran without --headless, at the size project.godot gives its viewport, with no sound${process.platform === "win32" ? ", on a desktop of its own, where its window neither shows nor takes the keyboard" : ""}. ${why}${shared}`;
 }
 function testPathsIn(projectPath, given, argument = "path") {
-  const defaults = TEST_DIRECTORIES.filter((directory) => existsSync36(join45(projectPath, directory)));
+  const defaults = TEST_DIRECTORIES.filter((directory) => existsSync36(join46(projectPath, directory)));
   const entries = given === undefined || given === null || given === "" ? defaults.length > 0 ? defaults : TEST_DIRECTORIES : given;
   const listed = Array.isArray(entries) ? entries : [entries];
   if (listed.length === 0) {
@@ -52637,17 +52798,17 @@ function asWarning(raised) {
 }
 function isDirectory(path) {
   try {
-    return statSync20(path).isDirectory();
+    return statSync21(path).isDirectory();
   } catch {
     return false;
   }
 }
 function mainSceneOf(projectFile) {
-  const scene = parseProjectGodot(readFileSync41(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync42(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "" ? scene : null;
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync41(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync42(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function ownArguments(params) {
@@ -52679,7 +52840,7 @@ function unheldNote(changed) {
 class GodotServer {
   stdio = null;
   locator = new GodotLocator;
-  operationsScript = join45(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join46(__dirname2, "godot", "operations", "godot_operations.gd");
   exportOptionsRead = new Map;
   heldWhilePending = new Set;
   evaluatedWhilePending = new Set;
@@ -52838,7 +52999,7 @@ class GodotServer {
         taken = true;
         this.logDebug(`Took port ${wanted} over from pid ${announced.pid}`);
       } catch {
-        await delay8(HANDOVER_POLL_MS);
+        await delay9(HANDOVER_POLL_MS);
       }
     }
     this.notHandedOverBy = taken ? null : announced.pid;
@@ -52969,7 +53130,7 @@ class GodotServer {
   }
   noteTheStart() {
     const cwd = process.cwd();
-    const mcpJson = join45(cwd, ".mcp.json");
+    const mcpJson = join46(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", {
@@ -53118,7 +53279,7 @@ class GodotServer {
         return checked.response;
       }
       const project = args["projectPath"];
-      if (typeof project === "string" && existsSync36(join45(project, "project.godot"))) {
+      if (typeof project === "string" && existsSync36(join46(project, "project.godot"))) {
         this.lastProjectPath = project;
       }
       this.updates.refresh();
@@ -53161,7 +53322,7 @@ class GodotServer {
     let notSaved;
     try {
       savedAt = answer.content.map((item, index) => {
-        const file = join45(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
+        const file = join46(directory, item.type === "text" ? `${stem}-${index}.txt` : `${stem}-${index}.${item.mimeType.split("/")[1] ?? "bin"}`);
         writeFileSync24(file, item.type === "text" ? item.text : Buffer.from(item.data, "base64"));
         return file;
       });
@@ -53625,6 +53786,8 @@ class GodotServer {
         return await this.handleEditorStatus();
       case "editor_rescan":
         return await this.handleRescanFilesystem(args);
+      case "editor_capture":
+        return await this.handleEditorCapture(args);
       case "runtime_inspect": {
         const patience = readPositiveNumber(args, "timeoutMs") ?? this.runtimeTimeoutMs();
         switch (op) {
@@ -53858,7 +54021,7 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join45(path, "project.godot");
+    const file = join46(path, "project.godot");
     if (!existsSync36(file)) {
       return {
         ok: false,
@@ -54608,7 +54771,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync41(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync42(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -54762,7 +54925,7 @@ class GodotServer {
       const platform = presetPlatform(project.value.path, preset);
       if (platform !== null) {
         const known = await this.exportOptions(platform, {
-          presetsFile: join45(project.value.path, "export_presets.cfg"),
+          presetsFile: join46(project.value.path, "export_presets.cfg"),
           preset,
           asked: options
         });
@@ -54813,7 +54976,7 @@ ${platform}`;
     }
     const empty = scratchDirectory("export");
     try {
-      writeFileSync24(join45(empty, "project.godot"), `config_version=5
+      writeFileSync24(join46(empty, "project.godot"), `config_version=5
 `);
       const outcome = await runOperation({ godotPath: engine.value, script: this.operationsScript, debug: DEBUG_MODE, editor: true }, "export_options", { platform, ...standing }, empty);
       const options = outcome.ok ? outcome.payload["options"] : undefined;
@@ -54852,7 +55015,7 @@ ${platform}`;
     }
     const folder = dirname25(output.absolutePath);
     try {
-      mkdirSync23(folder, { recursive: true });
+      mkdirSync24(folder, { recursive: true });
     } catch (error) {
       return this.createErrorResponse(`Cannot create ${dirname25(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
@@ -54870,7 +55033,7 @@ ${platform}`;
     const exportArgs = [
       "--headless",
       "--log-file",
-      join45(exportLogs, "engine.log"),
+      join46(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       pack ? "--export-pack" : debug ? "--export-debug" : "--export-release",
@@ -54878,7 +55041,7 @@ ${platform}`;
       output.absolutePath
     ];
     this.logDebug(`Exporting: ${engine.value} ${exportArgs.join(" ")}`);
-    const writtenAt = () => existsSync36(output.absolutePath) ? statSync20(output.absolutePath).mtimeMs : null;
+    const writtenAt = () => existsSync36(output.absolutePath) ? statSync21(output.absolutePath).mtimeMs : null;
     const caches = editorCacheDirectory(engine.value);
     const exportOnce = async () => {
       const before = writtenAt();
@@ -54908,7 +55071,7 @@ ${platform}`;
       return this.createErrorResponse(`Export could not be run: ${ending.failure ?? "the engine gave no exit status"}`);
     }
     const beside = writtenBeside(listedBefore, filesIn(folder), basename14(output.absolutePath), dirname25(output.relativePath).replaceAll("\\", "/"));
-    return exportAnswer(ending, { preset, outputPath: output.relativePath, debug, ...pack ? { pack } : {} }, before, writtenAt(), beside, docCacheNote, existsSync36(output.absolutePath) ? statSync20(output.absolutePath).size : null, importedFirstAnswer(imported));
+    return exportAnswer(ending, { preset, outputPath: output.relativePath, debug, ...pack ? { pack } : {} }, before, writtenAt(), beside, docCacheNote, existsSync36(output.absolutePath) ? statSync21(output.absolutePath).size : null, importedFirstAnswer(imported));
   }
   reportTestProgress(log) {
     const progress = callProgress();
@@ -54969,7 +55132,7 @@ ${platform}`;
     if (movie !== null) {
       return this.createErrorResponse(movie);
     }
-    const missing = paths.value.filter((path) => !existsSync36(join45(project.value.path, path.slice("res://".length))));
+    const missing = paths.value.filter((path) => !existsSync36(join46(project.value.path, path.slice("res://".length))));
     const scripts = new ProjectScripts(project.value.path);
     const present = paths.value.filter((path) => !missing.includes(path));
     const asked = scripts.searchedAsTold(present);
@@ -55061,10 +55224,10 @@ ${platform}`;
     const ignored = readStringArray(args, "ignore") ?? [];
     const declaredUnder = ignored.length === 0 ? [] : asked.flatMap((path) => path.endsWith(".gd") ? scripts.suite(path) ?? [] : scripts.suitesUnder([path]));
     const userData = scratchDirectory("tests");
-    const suitesFile = join45(userData, "suites.txt");
-    const skippingFile = join45(userData, "skipping.txt");
-    const engineLog = join45(userData, "engine.log");
-    const expectedFile = join45(userData, "expected.json");
+    const suitesFile = join46(userData, "suites.txt");
+    const skippingFile = join46(userData, "skipping.txt");
+    const engineLog = join46(userData, "engine.log");
+    const expectedFile = join46(userData, "expected.json");
     writeFileSync24(suitesFile, `${(selection.value?.suites ?? asked).join(`
 `)}
 `);
@@ -55105,11 +55268,11 @@ ${platform}`;
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? TEST_TIMEOUT_MS;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
     const helperFiles = {
-      spec: join45(userData, "spec"),
-      pid: join45(userData, "pid"),
-      error: join45(userData, "error"),
-      stop: join45(userData, "stop"),
-      step: join45(userData, "step")
+      spec: join46(userData, "spec"),
+      pid: join46(userData, "pid"),
+      error: join46(userData, "error"),
+      stop: join46(userData, "stop"),
+      step: join46(userData, "step")
     };
     const onDesktop = windowed && process.platform === "win32";
     const run = await this.spawnGame(engine.value, cmdArgs, userDataIn(userData), onDesktop ? { directory: project.value.path, files: helperFiles } : undefined);
@@ -55163,7 +55326,7 @@ ${platform}`;
     await run.settled;
     const helperFailed = onDesktop ? helperFailure(helperFiles.error) ?? (existsSync36(helperFiles.pid) ? null : `it never started, and ${helperStep(helperFiles.step)}`) : null;
     if (helperFailed !== null) {
-      discard(join45(project.value.path, ".godot", ...ours.split("/")), userData);
+      discard(join46(project.value.path, ".godot", ...ours.split("/")), userData);
       return this.createErrorResponse(`No tests ran: ${named(needing)} ${needing.length === 1 ? "needs" : "need"} a window, and the engine could not be started on a desktop of its own: ${helperFailed}`);
     }
     const endedAt = Date.now();
@@ -55174,16 +55337,16 @@ ${platform}`;
       engine: endedAt - importedAt
     };
     const notCompiled = stopped.for ?? run.log.all.map((entry) => autoloadNotCompiled(entry, autoloaded)).find((found) => found !== null) ?? null;
-    const reportsDir = join45(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join46(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
-    const casePrinted = withNestedErrors(readRun(existsSync36(engineLog) ? readFileSync41(engineLog, "utf8") : ""), run.log.all);
+    const casePrinted = withNestedErrors(readRun(existsSync36(engineLog) ? readFileSync42(engineLog, "utf8") : ""), run.log.all);
     const declaredErrors = readExpected(expectedFile);
     try {
       const written = existsSync36(reportsDir) && notCompiled === null ? readdirSync21(reportsDir).filter((name) => name.startsWith("report_")).toSorted((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync41(join45(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync42(join46(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -55596,7 +55759,7 @@ ${error.text}`;
     const scripts = projectFiles(projectPath, [".gd"]).map((script) => `res://${script}`);
     const wanted = `res://${relativePath}`;
     const folder = dirname25(relativePath.replaceAll("\\", "/"));
-    const inFolder = join45(projectPath, folder);
+    const inFolder = join46(projectPath, folder);
     const beside = existsSync36(inFolder) ? readdirSync21(inFolder, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => `res://${folder === "." ? "" : `${folder}/`}${entry.name}`) : [];
     return this.createErrorResponse(withNearestFiles(`Script file does not exist: ${wanted}`, wanted, scripts, beside));
   }
@@ -55729,7 +55892,7 @@ ${error.text}`;
         return null;
       }
       try {
-        return readFileSync41(contained.absolutePath, "utf8");
+        return readFileSync42(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -55823,7 +55986,7 @@ ${error.text}`;
       return null;
     }
     try {
-      return readFileSync41(contained.absolutePath, "utf8");
+      return readFileSync42(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -55997,7 +56160,7 @@ ${error.text}`;
       ...Array.isArray(stack) ? {
         stack: stack.map((frame) => ({
           ...frame,
-          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join45(projectPath, frame["script"].slice("res://".length)) } : {}
+          ...projectPath !== "" && typeof frame["script"] === "string" && frame["script"].startsWith("res://") ? { path: join46(projectPath, frame["script"].slice("res://".length)) } : {}
         }))
       } : {}
     });
@@ -56121,7 +56284,7 @@ ${error.text}`;
     try {
       const askedAt = Date.now();
       const asked = this.godotBridge.invokeTool("playing_status", {}, { counted: false });
-      const answer = await Promise.race([asked, delay8(PLAYING_STATUS_MS).then(() => null)]);
+      const answer = await Promise.race([asked, delay9(PLAYING_STATUS_MS).then(() => null)]);
       if (answer === null) {
         this.logDebug(`playing_status did not answer within ${PLAYING_STATUS_MS}ms`);
         asked.then(() => {
@@ -56146,7 +56309,7 @@ ${error.text}`;
     try {
       const answer = await Promise.race([
         this.godotBridge.invokeTool("scan_status", {}, { counted: false }),
-        delay8(PLAYING_STATUS_MS).then(() => null)
+        delay9(PLAYING_STATUS_MS).then(() => null)
       ]);
       if (answer === null) {
         return null;
@@ -56288,7 +56451,7 @@ ${error.text}`;
       if (answer.serversNote === undefined || adapterFailed || Date.now() >= deadline) {
         return answer;
       }
-      await delay8(500);
+      await delay9(500);
     }
   }
   async rebindTheDebugAdapter(servers) {
@@ -56342,7 +56505,7 @@ ${error.text}`;
       return null;
     }
     try {
-      return settingKeys(readFileSync41(join45(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync42(join46(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -56549,7 +56712,7 @@ ${error.text}`;
       if (Date.now() >= deadline) {
         return false;
       }
-      await delay8(250);
+      await delay9(250);
     }
   }
   async handleLaunchEditor(args) {
@@ -56687,7 +56850,7 @@ ${error.text}`;
     if (!paths.ok) {
       return refused(paths.reason, PATH_SOLUTIONS);
     }
-    const missing = paths.value.filter((path) => !existsSync36(join45(projectPath, path.slice("res://".length))));
+    const missing = paths.value.filter((path) => !existsSync36(join46(projectPath, path.slice("res://".length))));
     if (missing.length > 0) {
       return refused(`Nothing at ${missing.join(" and ")} in the project at ${projectPath}.`, PATH_SOLUTIONS);
     }
@@ -56860,7 +57023,7 @@ ${error.text}`;
   }
   async runtimeUp(projectPath, before, budget, withArgs) {
     const budgetMs = budget.ms;
-    if (!existsSync36(join45(projectPath, RUNTIME_SCRIPT))) {
+    if (!existsSync36(join46(projectPath, RUNTIME_SCRIPT))) {
       return runtimeVerdict(null, {
         addon: false,
         budgetMs,
@@ -56963,7 +57126,7 @@ ${error.text}`;
     }
     let announcedAt;
     try {
-      announcedAt = statSync20(endpoint.file).mtimeMs;
+      announcedAt = statSync21(endpoint.file).mtimeMs;
     } catch {
       return;
     }
@@ -57023,7 +57186,7 @@ ${error.text}`;
       stepFrom = now;
     };
     const transcript = openTranscript(startedAt);
-    closeSync6(transcript.fd);
+    closeSync7(transcript.fd);
     step("transcript");
     const playAnswer = asParams(JSON.parse(answer.content[0]?.text ?? "{}"));
     const which = playOf(playAnswer);
@@ -57124,7 +57287,7 @@ ${error.text}`;
     }
     let handle;
     try {
-      handle = openSync7(game.errorReport, "r");
+      handle = openSync8(game.errorReport, "r");
     } catch {
       return;
     }
@@ -57158,7 +57321,7 @@ ${error.text}`;
         game.log.append("stderr", reported);
       }
     } finally {
-      closeSync6(handle);
+      closeSync7(handle);
     }
   }
   announcedPidNamedBy(run, line) {
@@ -57178,7 +57341,7 @@ ${error.text}`;
       return 0;
     }
     try {
-      return reportAlreadyInTranscript(readFileSync41(game.transcript), readFileSync41(report));
+      return reportAlreadyInTranscript(readFileSync42(game.transcript), readFileSync42(report));
     } catch (error) {
       this.logDebug(`Could not compare a picked-up run's report with its transcript: ${errorMessage(error)}`);
       return 0;
@@ -57201,7 +57364,7 @@ ${error.text}`;
       if (Date.now() >= deadline) {
         return false;
       }
-      await delay8(100);
+      await delay9(100);
     }
   }
   async endActiveGame(reason, going, graceful) {
@@ -57465,7 +57628,7 @@ ${error.text}`;
     const slot = await slotForCall(true);
     const startedAt = Date.now();
     const transcript = openTranscript(startedAt);
-    closeSync6(transcript.fd);
+    closeSync7(transcript.fd);
     const profile = profiled ? profilePath(startedAt) : undefined;
     const gameEnv = onTheSlot(profiled ? { ...env ?? process.env, [PROFILE_FROM_START]: "1" } : env ?? process.env, slot.lock);
     let launched;
@@ -57525,7 +57688,7 @@ ${error.text}`;
     }
     let handle;
     try {
-      handle = openSync7(game.transcript, "r");
+      handle = openSync8(game.transcript, "r");
     } catch {
       return;
     }
@@ -57539,7 +57702,7 @@ ${error.text}`;
       game.readOffset += read;
       game.log.append("transcript", buffer.subarray(0, read));
     } finally {
-      closeSync6(handle);
+      closeSync7(handle);
     }
   }
   async pickUpWhatTheEditorIsPlaying() {
@@ -57936,7 +58099,7 @@ ${error.text}`;
     };
     const going = await this.runStillGoing(run);
     const projectPath = run.projectPath;
-    const projectGone = projectPath !== null && !existsSync36(join45(projectPath, "project.godot"));
+    const projectGone = projectPath !== null && !existsSync36(join46(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"]);
     }
@@ -58094,7 +58257,7 @@ ${error.text}`;
           return true;
         }
       }
-      await delay8(100);
+      await delay9(100);
     }
     return false;
   }
@@ -58124,7 +58287,7 @@ ${error.text}`;
           break;
         }
       }
-      await delay8(RUN_POLL_MS);
+      await delay9(RUN_POLL_MS);
     }
     if (!await this.runStillGoing(run)) {
       return await this.handleGetDebugOutput(args);
@@ -58186,7 +58349,7 @@ ${error.text}`;
       if (Date.now() >= until) {
         return false;
       }
-      await delay8(50);
+      await delay9(50);
     }
   }
   async handleEditorConsole(args) {
@@ -58343,7 +58506,7 @@ ${error.text}`;
       notes.push(endedWithoutACode({
         throughEditor: run.throughEditor,
         announced: announced !== undefined || run.announcedPid !== undefined,
-        couldAnnounce: run.projectPath !== null && existsSync36(join45(run.projectPath, RUNTIME_SCRIPT)),
+        couldAnnounce: run.projectPath !== null && existsSync36(join46(run.projectPath, RUNTIME_SCRIPT)),
         endedHere: typeof run.endedHere === "string",
         pickedUp: run.pickedUp === true
       }));
@@ -58601,6 +58764,66 @@ ${error.text}`;
       return error instanceof BridgeTimeout;
     }
   }
+  async handleEditorCapture(args) {
+    const projectPath = readNonEmptyString(args, "projectPath") ?? "";
+    const saveTo = readNonEmptyString(args, "outputPath") ?? null;
+    const sendsThePicture = readBoolean(args, "inline") !== false;
+    if (!sendsThePicture && saveTo === null) {
+      return this.createErrorResponse("inline: false sends no picture back, so it needs outputPath to save one to.", [
+        "Pass outputPath, an absolute path ending in .png outside the project",
+        "Or leave inline out to have the picture sent"
+      ]);
+    }
+    if (saveTo !== null) {
+      const refusal = captureDestinationRefusal(saveTo, [
+        ...projectPath === "" ? [] : [projectPath],
+        ...this.ownProject === null ? [] : [this.ownProject]
+      ]);
+      if (refusal !== null) {
+        return this.createErrorResponse(refusal);
+      }
+    }
+    const folder = scratchDirectory("editor-capture");
+    const picture = join46(folder, "capture.png");
+    try {
+      const asked = await this.handleViaBridge("capture_editor_view", { ...args, output_path: picture }, "editor_capture");
+      if (asked.isError === true) {
+        return asked;
+      }
+      const payload = asParams(JSON.parse(asked.content[0]?.text ?? "{}"));
+      const returned = readString(payload, "path");
+      if (readString(payload, "type") !== "screenshot_file" || returned === undefined) {
+        return this.createErrorResponse(`The editor answered a capture with ${JSON.stringify(payload)}`);
+      }
+      if (normalize2(returned) !== normalize2(picture)) {
+        return this.createErrorResponse(`Rejected capture file path outside the managed capture path: '${returned}'`);
+      }
+      if (saveTo !== null) {
+        try {
+          copyFileSync2(picture, saveTo, constants.COPYFILE_EXCL);
+        } catch (error) {
+          return this.createErrorResponse(`The capture was taken and could not be saved at ${saveTo}: ${errorMessage(error)}`);
+        }
+      }
+      const sent = sendsThePicture ? pictureToSend(picture, readString(payload, "jpegPath")) : null;
+      const view = readString(payload, "view") === "3d" ? "3D" : "2D";
+      const drawnAt = payload["drawnAt"];
+      const scaled = isRecord(drawnAt) ? `, scaled from ${String(drawnAt["width"])}x${String(drawnAt["height"])}` : "";
+      const unsaved = payload["unsavedInEditor"] === true ? ". The picture includes the scene's unsaved changes in the editor" : "";
+      const how = sent === null ? ". Not sent, as inline: false asked" : sent.mimeType === "image/jpeg" ? `. Sent as JPEG, ${kilobytes(sent.bytes)} against the PNG's ${kilobytes(sent.pngBytes)}${saveTo === null ? "" : ", and the saved PNG is lossless"}` : "";
+      return {
+        content: [
+          {
+            type: "text",
+            text: `The editor's ${view} view of ${readString(payload, "scenePath") ?? "the scene"}: ${String(readNumber(payload, "width") ?? 0)}x${String(readNumber(payload, "height") ?? 0)} png${scaled}${unsaved}${saveTo === null ? "" : `. Saved to ${saveTo}`}${how}`
+          },
+          ...sent === null ? [] : [{ type: "image", data: sent.data, mimeType: sent.mimeType }]
+        ]
+      };
+    } finally {
+      discard(folder);
+    }
+  }
   async handleRescanFilesystem(args) {
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 30000;
     const started = Date.now();
@@ -59416,17 +59639,25 @@ ${error.text}`;
         ]);
       }
     }
-    const declaring = declaredButUncached(projectPath, typeName);
-    if (declaring !== null) {
-      const rebuilt = await this.rebuildClassCache(projectPath);
-      if (!rebuilt.ok) {
-        return this.answer(rebuilt);
+    const run = async () => {
+      const declaring = declaredButUncached(projectPath, typeName);
+      if (declaring !== null) {
+        const rebuilt = await this.rebuildClassCache(projectPath);
+        if (!rebuilt.ok) {
+          return this.answer(rebuilt);
+        }
       }
-    }
-    const outcome = await this.operation("run_editor_tool", { command, arguments: contained.value }, projectPath);
-    if (!outcome.ok) {
-      return this.answer(outcome);
-    }
+      const outcome = await this.operation("run_editor_tool", { command, arguments: contained.value }, projectPath);
+      if (!outcome.ok) {
+        return this.answer(outcome);
+      }
+      return this.headlessAnswer(outcome, effect, typeName, declaring);
+    };
+    const written = readNonEmptyString(contained.value, "scenePath") ?? readNonEmptyString(contained.value, "resourcePath");
+    const target = effect === "writes" && written !== undefined ? resolveWithinProject(projectPath, written) : null;
+    return target?.ok === true ? await inTurnFor(projectPath, target.absolutePath, run) : await run();
+  }
+  headlessAnswer(outcome, effect, typeName, declaring) {
     return this.jsonTextResponse({
       ...outcome.payload,
       ...declaring === null ? {} : {
@@ -59685,7 +59916,7 @@ ${error.text}`;
     }
     const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const declared = new RegExp(`^\\s*(?:@\\w+(?:\\([^)]*\\))?\\s+)*class_name\\s+${escaped}\\b`, "m");
-    if (declared.test(readFileSync41(scriptPath, "utf8"))) {
+    if (declared.test(readFileSync42(scriptPath, "utf8"))) {
       return null;
     }
     const checked = await this.classesTheEditorCannotSee(args);
@@ -59883,7 +60114,7 @@ ${error.text}`;
   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) || !existsSync36(join45(project, RUNTIME_SCRIPT)) || !await this.runStillGoing(run)) {
+    if (run === null || project === null || run.announcedPid !== undefined || run.projectPath !== null && !isSameDirectory(run.projectPath, project) || !existsSync36(join46(project, RUNTIME_SCRIPT)) || !await this.runStillGoing(run)) {
       return null;
     }
     const already = runtimesAnnounced().running;
@@ -59892,7 +60123,7 @@ ${error.text}`;
         return !run.announcedBefore.has(one.pid);
       }
       try {
-        return statSync20(one.file).mtimeMs >= run.startedAt;
+        return statSync21(one.file).mtimeMs >= run.startedAt;
       } catch {
         return false;
       }
@@ -59993,7 +60224,7 @@ ${error.text}`;
       return this.createErrorResponse(staleNote);
     }
     const screenshotDir = expectsScreenshot ? scratchDirectory("runtime-screenshot") : null;
-    const screenshotPath = screenshotDir ? join45(screenshotDir, "capture.png") : null;
+    const screenshotPath = screenshotDir ? join46(screenshotDir, "capture.png") : null;
     const refused = (message) => this.createErrorResponse(message);
     const onGame = {
       pid: choice.endpoint.pid,
@@ -60266,6 +60497,7 @@ var init_server = __esm(() => {
   init_tool_definitions();
   init_tool_reference();
   init_update_check();
+  init_write_turns();
   TYPE_ARGUMENTS = {
     add_node: "nodeType",
     create_resource: "resourceType",
@@ -60338,7 +60570,7 @@ init_bridge_announce();
 init_engine_launch();
 init_engine_slots();
 import { existsSync as existsSync37 } from "node:fs";
-import { dirname as dirname26, join as join46, resolve as resolve16 } from "node:path";
+import { dirname as dirname26, join as join47, resolve as resolve16 } from "node:path";
 
 // src/error-mode.ts
 import process8 from "node:process";
@@ -60688,6 +60920,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | End a game of the project that no server is holding | \`editor_run stop\` with its \`pid\` from \`editor_status\` \`runtimes\`, never a process kill by hand: it is ended only when it announced itself for the project and its command line is the project's engine run |
 | Play a game without touching the player's saves | \`editor_run start\` with \`savesIn\`, a directory for this run's \`user://\`: the editor plays with its own environment, so a run given one is started by the server, and the answer says under \`savesNote\` when the platform ignores it |
 | A picture, for a person who asked to see one | \`runtime_capture\` |
+| What a scene's @tool scripts draw in the editor | \`editor_capture\`, the editor's own 2D or 3D view of the scene. No game runs their editor branch |
 
 These need the runtime autoload, which \`gdharness setup\` registers. \`runtime_capture\` needs a
 window and refuses headless rather than handing back the last frame anything drew. On Windows a
@@ -62609,7 +62842,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve16(named ?? ".");
-  if (!existsSync37(join46(projectPath, "project.godot"))) {
+  if (!existsSync37(join47(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot. Run from the project directory, or name it on the command line.`);
   }
   return projectPath;
@@ -62673,7 +62906,7 @@ async function registerRuntime(godot, projectPath) {
   }
   const path = (named ?? "").replace(/^res:\/\//, "");
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync37(join46(projectPath, path))) {
+  if (!existsSync37(join47(projectPath, path))) {
     console.log("  that file is not in this project, so it boots with a missing script");
   }
   console.log(`  ${useTheShippedLoader(RUNTIME_AUTOLOAD.name, path)}`);