gdharness 1.0.1 → 1.0.3

package/build/cli.js

@@ -7673,6 +7673,9 @@ function cacheWrittenAt(projectPath) {
     return null;
   }
 }
+function cachedAtMissingPaths(cached, projectPath) {
+  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync6(join6(projectPath, path.slice("res://".length)))).map(([name]) => name).sort();
+}
 function staleAgainst(cached, projectPath) {
   return [...declaredClasses(projectPath)].filter(([name, path]) => cached.get(name) !== path).map(([name]) => name);
 }
@@ -16084,7 +16087,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_rescan",
-      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. Needs the editor connected.",
+      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
       parameters: {
         projectPath: PROJECT_PATH,
         timeoutMs: { type: "number", description: "How long to wait for the scan. Default 30000." },
@@ -16120,12 +16123,20 @@ var init_tool_definitions = __esm(() => {
         },
         instantiableOnly: { type: "boolean", description: "query: leave out abstract classes. Default false." },
         className: { type: "string", description: "info, inheritance: the class." },
-        includeInherited: { type: "boolean", description: "info: include inherited members. Default false." }
+        includeInherited: { type: "boolean", description: "info: include inherited members. Default false." },
+        member: {
+          type: "string",
+          ops: ["info"],
+          description: 'info: one member by name, a method, property, signal, enum or constant, with its signature and which class declares it, looked for on the class and every ancestor. The whole of Control is seventy thousand characters; the question "does this engine have it, and what does it take" is this. A name nothing declares is refused with the members whose names contain it.'
+        }
       },
       requires: ["projectPath"],
       operations: {
         query: { summary: "classes matching a filter or category", requires: [] },
-        info: { summary: "methods, properties, signals and enums of one class", requires: ["className"] },
+        info: {
+          summary: "methods, properties, signals and enums of one class, or one member of it by name",
+          requires: ["className"]
+        },
         inheritance: { summary: "ancestors and descendants of one class", requires: ["className"] }
       },
       defaultOperation: "query"
@@ -16144,13 +16155,19 @@ var init_tool_definitions = __esm(() => {
         property: {
           type: "string",
           ops: ["property", "find"],
-          description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A negative number counts from the end. A step that is not there is named, and says what was there instead.'
+          description: 'property: which one to read. find: read this one off every node matched, so a panel of labels is one call rather than one per label. Colons read through what a node holds, "_game:clock:speed", which is where a game keeps what is worth asking about. A number or a key steps into a list or a map, "_game:run:roster:0:traits", which is how the lists a game keeps its state in are walked: a roster, a board, an in-tray. A negative number counts from the end. A step written as a call, "get_viewport():gui_get_focus_owner()", calls a method that takes no arguments and walks into what it returned, which is how a question only a method answers is read in one call: which control holds the focus in the viewport this one is in. A step that is not there is named, and says what was there instead.'
         },
         depth: { type: "number", ops: ["tree"], description: "tree: levels to descend. Default 3." },
         includeProperties: {
           type: "boolean",
           ops: ["tree"],
-          description: "tree: include each node's properties. Default false."
+          description: "tree: include every stored property of each node. Default false, and one row of a form answered seventy-six thousand characters with it; properties names the few that are wanted."
+        },
+        properties: {
+          type: "array",
+          items: { type: "string" },
+          ops: ["tree"],
+          description: "tree: the properties to read off each node, by name, so the text of every label and button under a panel is one call: a node that has not got one leaves it out. Colons read through what a node holds, as property does for find."
         },
         className: {
           type: "string",
@@ -16219,7 +16236,7 @@ var init_tool_definitions = __esm(() => {
         property: {
           type: "string",
           ops: ["set"],
-          description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end. The answer reads back off the same holder, so a write a typed container refused shows as an unchanged value.'
+          description: 'set: which one to write. Colons write through what a node holds, "_game:run:day", and a number or a key steps into a list or a map on the way, "_game:run:roster:0:name", a negative number counting from the end, and a step written as a call, "get_viewport():gui_embed_subwindows", walks through what a method taking no arguments returned. The answer reads back off the same holder, so a write a typed container refused shows as an unchanged value.'
         },
         value: {
           ops: ["set"],
@@ -16229,7 +16246,7 @@ var init_tool_definitions = __esm(() => {
         method: {
           type: "string",
           ops: ["call"],
-          description: 'call: which one to call. Colons call through what a node holds, "_game:run:advance", the same way a property is written through them, and a list or a map is stepped into by index or key, "_game:run:roster:0:retire".'
+          description: 'call: which one to call. Colons call through what a node holds, "_game:run:advance", the same way a property is written through them, a list or a map is stepped into by index or key, "_game:run:roster:0:retire", and a step written as a call walks through what a method taking no arguments returned, "get_viewport():gui_get_focus_owner".'
         },
         args: {
           type: "array",
@@ -16289,7 +16306,7 @@ var init_tool_definitions = __esm(() => {
         pressed: {
           type: "boolean",
           ops: ["action", "key", "mouse_click"],
-          description: "action, key: leave it out and the press is a whole one, down and up a frame apart. true holds it down, false lets go of one being held. mouse_click is one raw event, so it is down unless you say false."
+          description: "action, key: leave it out and the press is a whole one, down and up a frame apart. true holds it down, false lets go of one being held. mouse_click is one raw event, so it is down unless you say false; a wheel button down is a whole step, since a wheel is never held."
         },
         strength: { type: "number", ops: ["action"], description: "action: 0 to 1. Default 1." },
         keycode: {
@@ -16339,7 +16356,7 @@ var init_tool_definitions = __esm(() => {
         relativeX: {
           type: "number",
           ops: ["mouse_motion"],
-          description: "mouse_motion: the movement the event carries. Left out, it is the distance from where the pointer last was, which is what a control that drags reads; give it to send a motion the position does not show."
+          description: "mouse_motion: the movement the event carries. Left out, it is the distance from where the last injected pointer event put the pointer, and none for the first; that is what a control that drags reads. Give it to send a motion the position does not show."
         },
         relativeY: {
           type: "number",
@@ -16359,7 +16376,7 @@ var init_tool_definitions = __esm(() => {
         },
         action: { summary: "press an action, or hold it", requires: ["action"] },
         key: {
-          summary: "press a key, or hold it. Not for a menu a click has opened: an OptionButton or PopupMenu pops up as a window of its own that a key sent to the game never reaches, so an arrow moves nothing in it and Enter closes it with nothing chosen. choose is what selects there",
+          summary: "press a key, or hold it. Not for a menu a click has opened: an OptionButton or PopupMenu pops up as a window of its own that a key sent to the game never reaches, so an arrow moves nothing in it and Enter closes it with nothing chosen. choose is what selects there. The limit is that menu's own navigation, not windows in general: an embedded dialog whose owner reads keys in _input gets them, and a binding catcher up in one takes the key first time",
           requires: ["keycode"]
         },
         text: {
@@ -16367,11 +16384,11 @@ var init_tool_definitions = __esm(() => {
           requires: ["text"]
         },
         mouse_click: {
-          summary: "one mouse button event at a position, carrying the buttons held once it has happened. A drag is a press held with pressed true, motions, and a release with pressed false",
+          summary: "one mouse button event at a position, carrying the buttons held once it has happened. A drag is a press held with pressed true, motions, and a release with pressed false. A wheel button is a whole step, press and release together as a mouse sends one, and the answer says released: a lone wheel press holds the viewport on the control that took it, so every click after it lands there",
           requires: ["x", "y"]
         },
         mouse_motion: {
-          summary: "move the mouse to a position, carrying the distance from where it last was unless relativeX and relativeY say otherwise, and the buttons held, so a control that drags moves under a run of these between a held mouse_click and its release",
+          summary: "move the mouse to a position, carrying the distance from where the last injected event put it unless relativeX and relativeY say otherwise, and the buttons held, so a control that drags moves under a run of these between a held mouse_click and its release",
           requires: ["x", "y"]
         }
       }
@@ -16389,12 +16406,21 @@ var init_tool_definitions = __esm(() => {
         },
         nodePath: { type: "string", ops: ["signal", "until"], description: "signal, until: the node." },
         signal: { type: "string", ops: ["signal"], description: "signal: the signal name." },
-        property: { type: "string", ops: ["until"], description: "until: the property name." },
+        property: {
+          type: "string",
+          ops: ["until"],
+          description: 'until: the property name, or a colon path through what the node holds, "_game:run:day", read the way runtime_inspect property reads one, a step written as a call included. Walked again on every frame, so a holder the game replaces while the wait is on is followed.'
+        },
         value: { ops: ["until"], description: "until: the value to wait for, fitted to the property's type." },
         says: {
           type: "string",
           ops: ["until"],
-          description: "until: wait for these words to appear anywhere under nodePath instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, hidden nodes included; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property."
+          description: "until: wait for these words to appear anywhere under nodePath instead of for a property, which is how a panel that rebuilds its labels is waited on at all: the labels are named afresh each redraw and the panel is what stays put. Case-insensitive, part of a line, on a node the player can see unless includeHidden says otherwise; a label with a line break is matched with the break in the words, and a backslash followed by n counts as one. Instead of, not as well as: a call carrying this and a property is refused, because they ask about different things and answering one of them silently is how a caller watches a screen believing they are watching a property."
+        },
+        includeHidden: {
+          type: "boolean",
+          ops: ["until"],
+          description: "until, with says: count words on a hidden node too. Default false, since a wait for words is a wait for them to be shown: a button that exists hidden through a whole animation carries its words the whole time and satisfied the wait at once, and every wait on that screen fell back to counting frames."
         },
         timeoutMs: {
           type: "number",
@@ -36440,18 +36466,59 @@ var init_lsp_client = __esm(() => {
 });
 
 // src/process-children.ts
-import { execFile as execFile5 } from "node:child_process";
+import { execFile as execFile5, execFileSync, spawnSync as spawnSync2 } from "node:child_process";
 import { basename as basename2 } from "node:path";
 import { promisify as promisify5 } from "node:util";
+function startTimesOf(pids) {
+  const began = new Map;
+  if (pids.length === 0) {
+    return began;
+  }
+  try {
+    if (process.platform === "win32") {
+      const filter = pids.map((pid) => `ProcessId=${pid}`).join(" OR ");
+      const said = execFileSync("powershell", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Get-CimInstance Win32_Process -Filter "${filter}" | ForEach-Object { "$($_.ProcessId) $(([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds())" }`
+      ], { encoding: "utf8", timeout: ASK_TIMEOUT_MS, windowsHide: true });
+      for (const line of said.split(`
+`)) {
+        const found = /^\s*(\d+)\s+(\d+)\s*$/.exec(line);
+        if (found?.[1] !== undefined && found[2] !== undefined) {
+          began.set(Number(found[1]), Number(found[2]));
+        }
+      }
+      return began;
+    }
+    const said = spawnSync2("ps", ["-p", pids.join(","), "-o", "pid=,lstart="], {
+      encoding: "utf8",
+      timeout: ASK_TIMEOUT_MS,
+      env: { ...process.env, LC_ALL: "C" }
+    }).stdout;
+    for (const line of said.split(`
+`)) {
+      const found = /^\s*(\d+)\s+(.+)$/.exec(line);
+      const at = Date.parse(found?.[2]?.trim() ?? "");
+      if (found?.[1] !== undefined && !Number.isNaN(at)) {
+        began.set(Number(found[1]), at);
+      }
+    }
+  } catch {}
+  return began;
+}
 async function processTree() {
   try {
-    const printed = process.platform === "win32" ? await askWindows() : await askPosix();
-    return parseProcessTable(printed);
+    if (process.platform === "win32") {
+      return parseProcessTable(await askWindows(), true);
+    }
+    return parseProcessTable(await askPosix());
   } catch {
     return;
   }
 }
-function parseProcessTable(printed) {
+function parseProcessTable(printed, started = false) {
   const tree = new Map;
   for (const line of printed.split(/\r?\n/)) {
     const fields = /^\s*(\d+)\s+(\d+)(?:\s+(.*))?$/.exec(line);
@@ -36460,16 +36527,38 @@ function parseProcessTable(printed) {
     }
     const pid = Number(fields[1]);
     const parent = Number(fields[2]);
-    if (pid > 0) {
-      tree.set(pid, { parent, command: (fields[3] ?? "").trim() });
+    const rest = (fields[3] ?? "").trim();
+    if (pid <= 0) {
+      continue;
+    }
+    if (!started) {
+      tree.set(pid, { parent, command: rest });
+      continue;
     }
+    const timed = /^(\d+)(?:\s+(.*))?$/.exec(rest);
+    if (timed === null) {
+      continue;
+    }
+    const began = Number(timed[1]);
+    tree.set(pid, { parent, command: (timed[2] ?? "").trim(), ...began > 0 ? { startedAt: began } : {} });
   }
   return tree;
 }
+function linked(tree, child, parent) {
+  const from = tree.get(child);
+  const to = tree.get(parent);
+  if (from === undefined || from.parent !== parent) {
+    return false;
+  }
+  if (from.startedAt === undefined || to?.startedAt === undefined) {
+    return true;
+  }
+  return from.startedAt >= to.startedAt;
+}
 function childrenIn(tree, pid) {
   const children = [];
-  for (const [child, listed] of tree) {
-    if (listed.parent === pid) {
+  for (const child of tree.keys()) {
+    if (linked(tree, child, pid)) {
       children.push(child);
     }
   }
@@ -36497,13 +36586,15 @@ function descendantsIn(tree, pid) {
 function ancestorsIn(tree, pid, root) {
   const chain = [];
   const seen = new Set([pid]);
+  let child = pid;
   let parent = tree.get(pid)?.parent;
-  while (parent !== undefined && !seen.has(parent)) {
+  while (parent !== undefined && !seen.has(parent) && linked(tree, child, parent)) {
     chain.push(parent);
     if (parent === root) {
       break;
     }
     seen.add(parent);
+    child = parent;
     parent = tree.get(parent)?.parent;
   }
   return chain;
@@ -36559,7 +36650,7 @@ async function askWindows() {
     "-NoProfile",
     "-NonInteractive",
     "-Command",
-    'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId) $($_.CommandLine)" }'
+    'Get-CimInstance Win32_Process | ForEach-Object { $began = 0; if ($_.CreationDate) { $began = ([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds() }; "$($_.ProcessId) $($_.ParentProcessId) $began $($_.CommandLine)" }'
   ], { timeout: ASK_TIMEOUT_MS, windowsHide: true, maxBuffer: 16 * 1024 * 1024 });
   return stdout;
 }
@@ -36791,7 +36882,7 @@ var init_restart_note = __esm(() => {
 import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync15, statSync as statSync3, unlinkSync } from "node:fs";
 import { createConnection as createConnection3 } from "node:net";
 import { tmpdir as tmpdir4 } from "node:os";
-import { join as join17, resolve as resolve4 } from "node:path";
+import { dirname as dirname11, join as join17, resolve as resolve4 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
@@ -36900,11 +36991,31 @@ function announcedAndGone(projectPath) {
   const wanted = resolve4(projectPath);
   return gone.filter((one) => one.noticedAt >= since && resolve4(one.project) === wanted);
 }
+function strangersAmong(candidates, now, startTimes = startTimesOf) {
+  const toJudge = candidates.filter((one) => {
+    if (now - one.writtenAt < JUDGED_AFTER_MS) {
+      return false;
+    }
+    const known = verdicts.get(one.file);
+    return known === undefined || known.writtenAt !== one.writtenAt || !known.stranger && now - known.judgedAt > CONFIRMED_FOR_MS;
+  });
+  if (toJudge.length > 0) {
+    const began = startTimes(toJudge.map((one) => one.pid));
+    for (const one of toJudge) {
+      const at = began.get(one.pid);
+      const stranger = at !== undefined && at - one.writtenAt > STARTED_AFTER_ANNOUNCING_MS;
+      verdicts.set(one.file, { writtenAt: one.writtenAt, judgedAt: now, stranger });
+    }
+  }
+  return new Set(candidates.filter((one) => verdicts.get(one.file)?.stranger === true).map((one) => one.file));
+}
 function announcedIn(directory) {
   if (!existsSync13(directory)) {
     return [];
   }
   const found = [];
+  const candidates = [];
+  const entries = [];
   for (const entry of readdirSync5(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
@@ -36918,20 +37029,59 @@ function announcedIn(directory) {
     const file = join17(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const alive = processAlive(pid);
-    const announced = alive ? parseAnnouncement(file, pid) : { kind: "rubbish" };
+    entries.push({ file, pid, alive });
+    if (alive) {
+      try {
+        candidates.push({ file, pid, writtenAt: statSync3(file).mtimeMs });
+      } catch {}
+    }
+  }
+  const strangers = strangersAmong(candidates, Date.now());
+  for (const { file, pid, alive } of entries) {
+    const announced = alive && !strangers.has(file) ? parseAnnouncement(file, pid) : { kind: "rubbish" };
     if (announced.kind === "rubbish") {
-      if (!alive) {
+      if (!alive || strangers.has(file)) {
         wentAway(file, pid);
       }
       try {
         unlinkSync(file);
       } catch {}
+      verdicts.delete(file);
       continue;
     }
     found.push(announced);
   }
+  const held = new Set(entries.map((one) => one.file));
+  const here = join17(directory, ".");
+  for (const file of verdicts.keys()) {
+    if (dirname11(file) === here && !held.has(file)) {
+      verdicts.delete(file);
+    }
+  }
   return found;
 }
+async function announcementEnded(pid, directories = runtimeDirectories()) {
+  const files = directories.map((directory) => join17(directory, `runtime-${pid}.json`)).filter((file) => existsSync13(file));
+  const first = files[0];
+  if (first === undefined) {
+    return;
+  }
+  const until = Date.now() + ENDED_WITHIN_MS;
+  while (processAlive(pid)) {
+    const left = until - Date.now();
+    if (left <= 0) {
+      return;
+    }
+    await delay2(Math.min(LOOK_EVERY_MS, left));
+  }
+  wentAway(first, pid);
+  for (const file of files) {
+    try {
+      unlinkSync(file);
+    } catch {}
+    verdicts.delete(file);
+  }
+}
 function sweepErrorReport(path, pid, now = Date.now()) {
   if (processAlive(pid)) {
     return;
@@ -37112,16 +37262,18 @@ function runtimeRequest(endpoint, command, params, timeoutMs) {
     });
   });
 }
-var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1;
+var RUNTIME_PROTOCOL = 2, ANNOUNCEMENT_PATTERN, ERROR_REPORT_PATTERN, ERROR_REPORT_KEEP_MS, GONE_WINDOW_MS = 120000, GONE_KEPT = 32, gone, STARTED_AFTER_ANNOUNCING_MS = 2000, CONFIRMED_FOR_MS = 60000, JUDGED_AFTER_MS = 60000, verdicts, ENDED_WITHIN_MS = 3000, LOOK_EVERY_MS = 50, ANNOUNCE_BUDGET_MS = 5000, nextRequestId = 1;
 var init_runtime_client = __esm(() => {
+  init_process_children();
   ANNOUNCEMENT_PATTERN = /^runtime-(\d+)\.json$/;
   ERROR_REPORT_PATTERN = /^runtime-(\d+)\.log$/;
   ERROR_REPORT_KEEP_MS = 60 * 60 * 1000;
   gone = [];
+  verdicts = new Map;
 });
 
 // src/run-record.ts
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 import { mkdirSync as mkdirSync9, openSync, readdirSync as readdirSync6, readFileSync as readFileSync16, rmSync as rmSync9, statSync as statSync4, writeFileSync as writeFileSync11 } from "node:fs";
 import { basename as basename3, join as join18 } from "node:path";
 function runsDirectory() {
@@ -37247,7 +37399,7 @@ function runningAs(pid) {
       const raw = readFileSync16(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
-    const args = execFileSync("ps", ["-p", String(pid), "-o", "args="], {
+    const args = execFileSync2("ps", ["-p", String(pid), "-o", "args="], {
       encoding: "utf8",
       timeout: 15000
     }).trim();
@@ -37259,20 +37411,14 @@ function runningAs(pid) {
 function listeningPid(port) {
   try {
     if (process.platform === "win32") {
-      const said = execFileSync("powershell", [
-        "-NoProfile",
-        "-NonInteractive",
-        "-Command",
-        `(Get-NetTCPConnection -State Listen -LocalPort ${port} -ErrorAction SilentlyContinue | Select-Object -First 1).OwningProcess`
-      ], { encoding: "utf8", timeout: 15000 }).trim();
-      return /^\d+$/.test(said) ? Number(said) : null;
+      return listeningPidInNetstat(execFileSync2("netstat", ["-ano"], { encoding: "utf8", timeout: 15000 }), port);
     }
     for (const [command, args, pattern] of [
       ["lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], /^(\d+)/],
       ["ss", ["-ltnpH", `sport = :${port}`], /pid=(\d+)/]
     ]) {
       try {
-        const said = execFileSync(command, [...args], { encoding: "utf8", timeout: 15000 }).trim();
+        const said = execFileSync2(command, [...args], { encoding: "utf8", timeout: 15000 }).trim();
         const found = pattern.exec(said);
         if (found?.[1] !== undefined) {
           return Number(found[1]);
@@ -37284,9 +37430,22 @@ function listeningPid(port) {
     return null;
   }
 }
+function listeningPidInNetstat(printed, port) {
+  for (const line of printed.split(/\r?\n/)) {
+    const fields = /^\s*TCP\s+(\S+)\s+\S+\s+LISTENING\s+(\d+)\s*$/i.exec(line);
+    if (fields === null) {
+      continue;
+    }
+    const local = fields[1] ?? "";
+    if (Number(local.slice(local.lastIndexOf(":") + 1)) === port) {
+      return Number(fields[2]);
+    }
+  }
+  return null;
+}
 function windowsCommandLine(pid) {
   try {
-    const answer = execFileSync("powershell", [
+    const answer = execFileSync2("powershell", [
       "-NoProfile",
       "-NonInteractive",
       "-Command",
@@ -37304,7 +37463,7 @@ function startedAt(pid, windowsAnswer) {
     return Number.isNaN(when) ? null : when;
   }
   try {
-    const said = execFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
+    const said = execFileSync2("ps", ["-p", String(pid), "-o", "lstart="], {
       encoding: "utf8",
       timeout: 15000
     }).trim();
@@ -37316,7 +37475,7 @@ function startedAt(pid, windowsAnswer) {
 }
 function windowsImage(pid) {
   try {
-    const csv = execFileSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+    const csv = execFileSync2("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
       encoding: "utf8",
       timeout: 15000,
       windowsHide: true
@@ -37419,7 +37578,7 @@ import {
   readSync
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename4, dirname as dirname11, join as join19, normalize as normalize3, relative as relative3 } from "node:path";
+import { basename as basename4, dirname as dirname12, join as join19, normalize as normalize3, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import { promisify as promisify7 } from "node:util";
@@ -37458,13 +37617,16 @@ function stillRunning(run) {
   }
   return true;
 }
-function runIsUp(run, editorSays) {
+function runIsUp(run, editorSays, now = Date.now()) {
   if (run?.throughEditor !== true) {
     return stillRunning(run);
   }
   if (run.announcedPid !== undefined && !alive(run.announcedPid)) {
     return false;
   }
+  if (editorSays === false && run.seenPlaying !== true && now - run.startedAt < PLAY_STARTS_WITHIN_MS) {
+    return true;
+  }
   return editorSays ?? stillRunning(run);
 }
 function endedPreviousRun(ended) {
@@ -37538,10 +37700,11 @@ function runtimeVerdict(endpoint, after) {
       heldAt: after.heldAt
     };
   }
+  const state = after.playingSeen === false ? "the editor has not yet reported the game as playing, which a restarted editor does not until its scan is over" : "the game is still running";
   return {
     listening: false,
     mayYetAnnounce: after.running,
-    note: after.running ? `nothing announced itself within ${after.budgetMs}ms and the game is still running, so it may announce a moment from now: editor_status says whether it has, and editor_run start takes runtimeWaitMs to wait longer than this${after.withArgs ? ", which a run carrying its own arguments may well need, since whatever they ask the game to do before its first frame is inside this wait" : ""}` : `nothing announced itself within ${after.budgetMs}ms and the game is no longer running, so nothing is going to: editor_output has what it printed on the way down`,
+    note: after.running ? `nothing announced itself within ${after.budgetMs}ms and ${state}, so it may announce a moment from now: editor_status says whether it has, and editor_run start takes runtimeWaitMs to wait longer than this${after.withArgs ? ", which a run carrying its own arguments may well need, since whatever they ask the game to do before its first frame is inside this wait" : ""}` : `nothing announced itself within ${after.budgetMs}ms and the game is no longer running, so nothing is going to: editor_output has what it printed on the way down`,
     heldAt: null
   };
 }
@@ -38230,7 +38393,8 @@ class GodotServer {
               ...whichGame(args),
               root: readNonEmptyString(args, "nodePath") ?? "/root",
               depth: readPositiveNumber(args, "depth") ?? 3,
-              include_properties: readBoolean(args, "includeProperties") ?? false
+              include_properties: readBoolean(args, "includeProperties") ?? false,
+              properties: readArray(args, "properties") ?? []
             });
           case "find":
             return await this.handleFindRuntimeNodes(args);
@@ -38632,11 +38796,11 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname11(output.absolutePath);
+    const folder = dirname12(output.absolutePath);
     try {
       mkdirSync10(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname11(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname12(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
     const exportLogs = mkdtempSync3(join19(tmpdir5(), "gdharness-export-"));
@@ -39090,11 +39254,14 @@ class GodotServer {
       return null;
     }
     try {
-      const answer = await Promise.race([
-        this.godotBridge.invokeTool("playing_status", {}),
-        delay3(PLAYING_STATUS_MS).then(() => null)
-      ]);
+      const askedAt = Date.now();
+      const asked = this.godotBridge.invokeTool("playing_status", {});
+      const answer = await Promise.race([asked, delay3(PLAYING_STATUS_MS).then(() => null)]);
       if (answer === null) {
+        this.logDebug(`playing_status did not answer within ${PLAYING_STATUS_MS}ms`);
+        asked.then(() => {
+          this.logDebug(`playing_status answered after ${Date.now() - askedAt}ms`);
+        }).catch(() => {});
         return null;
       }
       return {
@@ -39414,6 +39581,9 @@ class GodotServer {
     let asking = null;
     let editorAskedAt = 0;
     let editorSaysGoing = true;
+    let editorAsks = 0;
+    const waitBegan = Date.now();
+    const lastSaid = () => editorSaysGoing ? "playing" : "not playing";
     const endpoint = await announcedSince(projectPath, before, {
       budgetMs,
       accept: (one) => this.isTheGameOf(this.currentRun(), one, projectPath),
@@ -39427,6 +39597,7 @@ class GodotServer {
         }
         if (asking === null && Date.now() - editorAskedAt >= RUN_POLL_MS) {
           editorAskedAt = Date.now();
+          editorAsks += 1;
           asking = this.runStillGoing(run).then((going) => {
             editorSaysGoing = going;
           }).finally(() => {
@@ -39436,6 +39607,7 @@ class GodotServer {
         return !editorSaysGoing;
       }
     });
+    this.logDebug(`announce wait ended after ${Date.now() - waitBegan}ms: ${endpoint === null ? "nothing announced" : `pid ${endpoint.pid} announced`}, editor asked ${editorAsks} times, last said ${lastSaid()}`);
     const going = this.currentRun();
     if (endpoint !== null && going !== null && going.announcedPid === undefined) {
       going.announcedPid = endpoint.pid;
@@ -39445,7 +39617,8 @@ class GodotServer {
       budgetMs,
       heldAt: this.dapClient?.whereItStopped() ?? null,
       running: endpoint !== null || going !== null && await this.runStillGoing(going),
-      withArgs
+      withArgs,
+      ...going?.throughEditor === true ? { playingSeen: going.seenPlaying === true } : {}
     });
   }
   async playThroughEditor(scene, refreshedClasses, projectPath, alreadyPlaying, runtimeWaitMs, ended) {
@@ -39475,6 +39648,7 @@ class GodotServer {
     const startedAt = Date.now();
     const transcript = openTranscript(startedAt);
     closeSync(transcript.fd);
+    const playAnswer = asParams(JSON.parse(answer.content[0]?.text ?? "{}"));
     const played = {
       process: null,
       pid: null,
@@ -39486,7 +39660,8 @@ class GodotServer {
       exitCode: null,
       throughEditor: true,
       brokeOn: null,
-      announcedBefore: alreadyPlaying
+      announcedBefore: alreadyPlaying,
+      seenPlaying: readBoolean(playAnswer, "playing") === true
     };
     this.activeProcess = played;
     writeEditorRunNote({ projectPath, transcript: transcript.path, startedAt });
@@ -39496,7 +39671,7 @@ class GodotServer {
       through: "editor",
       scene: scene === null ? "the main scene" : `res://${scene}`,
       refreshedClasses,
-      debugPort: readNumber(asParams(JSON.parse(answer.content[0]?.text ?? "{}")), "debugPort"),
+      debugPort: readNumber(playAnswer, "debugPort"),
       endedPreviousRun: endedPreviousRun(ended),
       breakpoints: breakpoints.applied.length === 0 ? undefined : this.breakpointsAsProjectSpells(projectPath, breakpoints.applied),
       breakpointsRefused: breakpoints.refused.length === 0 ? undefined : breakpoints.refused.map((one) => ({
@@ -40022,7 +40197,11 @@ class GodotServer {
     if (announced !== undefined && editorSays === undefined) {
       return stillRunning(run);
     }
-    return runIsUp(run, editorSays === undefined ? (await this.editorPlayingState())?.playing ?? null : editorSays);
+    const said = editorSays === undefined ? (await this.editorPlayingState())?.playing ?? null : editorSays;
+    if (said === true) {
+      run.seenPlaying = true;
+    }
+    return runIsUp(run, said);
   }
   async handleGetDebugOutput(args, waitedMs) {
     await this.pickUpWhatTheEditorIsPlaying();
@@ -40105,11 +40284,19 @@ class GodotServer {
     this.drainEditorOutput(stopped);
     this.drainTranscript(stopped);
     const wasRunning = await this.runStillGoing(stopped);
-    const endedPid = stopped.pid ?? this.announcedPidOf(stopped) ?? null;
+    const announcedPid = this.announcedPidOf(stopped) ?? null;
+    const endedPid = stopped.pid ?? announcedPid;
     const children = readBoolean(args, "andChildren") === true && wasRunning ? await this.whatTheRunStarted(stopped) : null;
     this.logDebug("Stopping the running game");
     await this.endActiveGame("editor_run stop");
     const ended = children === null ? null : endChildrenAmong(children);
+    if (wasRunning) {
+      for (const pid of new Set([endedPid, announcedPid])) {
+        if (pid !== null) {
+          await announcementEnded(pid);
+        }
+      }
+    }
     return this.jsonTextResponse({
       stopped: true,
       through: stopped.throughEditor ? "editor" : "gdharness",
@@ -40205,6 +40392,7 @@ class GodotServer {
     const writtenBefore = projectPath === "" ? null : cacheWrittenAt(projectPath);
     const blind = await this.classesTheEditorCannotSee(args);
     const atRisk = before === null ? [] : blind.unseen.filter((one) => before.has(one.className));
+    const ghosts = blind.stillHeld ?? [];
     const first = await this.handleViaBridge("rescan_filesystem", args);
     if (first.isError) {
       return first;
@@ -40216,7 +40404,7 @@ class GodotServer {
       const pending = Boolean(status["pending"]) && Date.now() - started < SCAN_START_MS;
       busy = Boolean(status["scanning"]) || Boolean(status["importing"]) || pending;
     }
-    if (!busy && projectPath !== "" && (atRisk.length > 0 || blind.unchecked !== undefined)) {
+    if (!busy && projectPath !== "" && (atRisk.length > 0 || ghosts.length > 0 || blind.unchecked !== undefined)) {
       const until = Date.now() + CACHE_WRITE_MS;
       while (Date.now() < until && cacheWrittenAt(projectPath) === writtenBefore) {
         await new Promise((settle) => setTimeout(settle, 100));
@@ -40224,7 +40412,11 @@ class GodotServer {
     }
     const after = projectPath === "" || busy ? null : cachedClasses(projectPath);
     const lost = before === null || after === null ? [] : [...before.keys()].filter((name) => !after.has(name));
-    const restored = lost.length > 0 ? await this.rebuildCacheAfterLoss(projectPath, lost) : [];
+    const atMissingPaths = after === null ? [] : cachedAtMissingPaths(after, projectPath);
+    const restored = lost.length > 0 || atMissingPaths.length > 0 ? await this.rebuildCacheAfterLoss(projectPath, lost) : [];
+    const rebuilt = atMissingPaths.length > 0 ? cachedClasses(projectPath) : null;
+    const dropped = rebuilt === null ? [] : atMissingPaths.filter((name) => !cachedAtMissingPaths(rebuilt, projectPath).includes(name));
+    const stillAtMissingPaths = atMissingPaths.filter((name) => !dropped.includes(name));
     const reloading = readNonEmptyString(args, "reloadScript");
     let reloaded = {};
     if (reloading !== undefined) {
@@ -40240,8 +40432,23 @@ class GodotServer {
     const checked = busy ? { unseen: [] } : await this.classesTheEditorCannotSee(args);
     const unseen = checked.unseen;
     const stillGone = lost.filter((name) => !restored.includes(name));
+    const notes = [];
+    if (busy) {
+      notes.push("The editor was still scanning or importing when the wait ran out, so new files may not be visible yet.");
+    } else if (stillGone.length > 0) {
+      notes.push("The scan wrote the class cache from the list this editor is holding, that list is shorter than the file was, and rebuilding the cache from the files did not bring these back. Every engine that reads the cache next, including a test run, will report them as unknown identifiers. Restart the editor with editor_launch restart before scanning again.");
+    } else if (lost.length > 0) {
+      notes.push("The scan wrote the class cache from the list this editor is holding, which is shorter than the file was, so the cache was rebuilt from the files and these classes are back in it. Nothing was lost, but this editor is still holding the short list: do not rescan again until it has been restarted with editor_launch restart, because it will write the same list over the file each time.");
+    } else if (unseen.length > 0) {
+      notes.push("The scan finished and these classes are still not in the list the editor resolves against, so every use of them reads as an unknown identifier. Its walk skips a file another engine has already imported. Rescan again on its own, which is the measured cure and needs no change to the declaring script, or restart the editor with editor_launch restart.");
+    }
+    if (stillAtMissingPaths.length > 0) {
+      notes.push(`The scan wrote the class cache with ${stillAtMissingPaths.join(", ")} at a path that is not on disk, and rebuilding the cache from the files did not take it out. The next engine to read the cache fails on "Could not parse global class" in whichever correct script shares the bare name. Restart the editor with editor_launch restart, then run project_import refresh_classes.`);
+    } else if (dropped.length > 0) {
+      notes.push(`The scan wrote the class cache from the list this editor is holding, and that list still has ${dropped.join(", ")} for a script that is gone, so the cache was rebuilt from the files without it. The editor goes on holding it and writes it back on every scan until it is restarted with editor_launch restart; until then a scan is followed by this same rebuild.`);
+    }
     return this.jsonTextResponse({
-      ok: !busy && unseen.length === 0 && stillGone.length === 0 && checked.unchecked === undefined,
+      ok: !busy && unseen.length === 0 && stillGone.length === 0 && stillAtMissingPaths.length === 0 && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
       heldBeforeReload: reloaded.heldBefore,
@@ -40250,8 +40457,10 @@ class GodotServer {
       unseenByEditor: unseen.length > 0 ? unseen : undefined,
       cacheLost: lost.length > 0 ? lost : undefined,
       cacheRestored: restored.length > 0 ? restored : undefined,
+      cacheDropped: dropped.length > 0 ? dropped : undefined,
+      cacheAtMissingPaths: stillAtMissingPaths.length > 0 ? stillAtMissingPaths : undefined,
       classesUnchecked: checked.unchecked,
-      note: busy ? "The editor was still scanning or importing when the wait ran out, so new files may not be visible yet." : stillGone.length > 0 ? "The scan wrote the class cache from the list this editor is holding, that list is shorter than the file was, and rebuilding the cache from the files did not bring these back. Every engine that reads the cache next, including a test run, will report them as unknown identifiers. Restart the editor with editor_launch restart before scanning again." : lost.length > 0 ? "The scan wrote the class cache from the list this editor is holding, which is shorter than the file was, so the cache was rebuilt from the files and these classes are back in it. Nothing was lost, but this editor is still holding the short list: do not rescan again until it has been restarted with editor_launch restart, because it will write the same list over the file each time." : unseen.length > 0 ? "The scan finished and these classes are still not in the list the editor resolves against, so every use of them reads as an unknown identifier. Its walk skips a file another engine has already imported. Rescan again on its own, which is the measured cure and needs no change to the declaring script, or restart the editor with editor_launch restart." : undefined
+      note: notes.length > 0 ? notes.join(" ") : undefined
     });
   }
   async rebuildCacheAfterLoss(projectPath, lost) {
@@ -40492,6 +40701,7 @@ class GodotServer {
       property: readString(args, "property") ?? "",
       value: args["value"],
       ...readNonEmptyString(args, "says") === undefined ? {} : { says: readNonEmptyString(args, "says") },
+      ...readBoolean(args, "includeHidden") === undefined ? {} : { include_hidden: readBoolean(args, "includeHidden") },
       timeout_ms: timeoutMs
     }, patience);
   }
@@ -40500,7 +40710,7 @@ async function runGodotServer() {
   const server = new GodotServer;
   await server.run();
 }
-var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run7, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, CONSOLE_WRAPPER, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CACHE_WRITE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
+var UPDATE_NOTICE_EVERY = 500, FEEDBACK_NOTICE_EVERY = 250, run7, __dirname2, EDITOR_RESTART_TIMEOUT_MS = 90000, HOLD_PING_MS = 2000, SLOWEST_FRAME_RATE = 20, PLAY_STARTS_WITHIN_MS = 30000, CONSOLE_WRAPPER, VALUE_NAMES, BRIDGE_RETRY_MS = 2000, SUCCESSOR_CHECK_MS = 1e4, CACHE_WRITE_MS = 2000, PLAYING_STATUS_MS = 1000, SCAN_START_MS = 2000, WAIT_FOR_RUN_MS = 600000, RUN_POLL_MS = 250, PATH_SOLUTIONS, PROJECT_FILE_ARGUMENTS, DEBUG_STATE_CALLS, PROJECT_INFO_SECTIONS2, RUNNER_DIRECTORY = "addons/gdUnit4/";
 var init_server3 = __esm(() => {
   init_mcp();
   init_stdio2();
@@ -40534,7 +40744,7 @@ var init_server3 = __esm(() => {
   init_tool_definitions();
   init_update_check();
   run7 = promisify7(execFile7);
-  __dirname2 = dirname11(fileURLToPath4(import.meta.url));
+  __dirname2 = dirname12(fileURLToPath4(import.meta.url));
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
   VALUE_NAMES = {
     string: "a string",
@@ -42085,6 +42295,7 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | Where a control is, and whether it is visible | \`runtime_inspect\` \`find\`, \`rect\` |
 | What a property reads right now, on a node whose path you already hold | \`runtime_inspect\` \`property\`, \`runtime_invoke\` |
 | What a property on an object a node holds reads | the same two, with colons: \`_game:clock:speed\` |
+| Which control holds the focus, or anything only a method answers | the same path with a step written as a call, \`get_viewport():gui_get_focus_owner\`, which calls a method taking no arguments and walks into what it returned |
 | Press a button | \`runtime_input click\`, which says what was under the pointer |
 | Press the next thing after a click that changed screen | \`runtime_wait until\` with \`says\` and a word the new screen shows, then the click. A click sent straight after a screen change lands on a control the new screen is about to free, answers \`landed: true\`, and does nothing; a frame count is a number nobody can pick correctly across a cold start and a warm one, and waiting for the words answered in about 130ms where twenty frames had not been enough |
 | Fill in a field | \`runtime_input click\` on it, then \`runtime_input text\` with \`replace\`; a submitted field has to be clicked again |
@@ -42093,7 +42304,9 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 | Answer a dialog | \`runtime_input click\` on its button, or \`key\` Escape to dismiss it: an [AcceptDialog] reads that key itself and never asks the InputMap, so \`ui_cancel\` leaves it standing |
 | Press a bound key | \`runtime_input action\` or \`key\`, a whole press unless you hold it |
 | Where a 3D node is on screen | \`runtime_inspect\` \`rect\`, rather than unprojecting by hand |
-| Wait for something in a running game | \`runtime_wait\`, never a sleep; \`until\` with \`says\` for a panel that rebuilds its own labels |
+| Wait for something in a running game | \`runtime_wait\`, never a sleep; \`until\` with \`says\` for a panel that rebuilds its own labels. The words have to be shown: a button that exists hidden through an animation does not satisfy it until it appears, unless \`includeHidden\` says otherwise |
+| What every label on a screen says | \`runtime_inspect tree\` with \`properties\` naming \`text\`, which reads it off every node that has one; \`includeProperties\` is every stored property of every node and ran to seventy-six thousand characters for one row |
+| Whether this engine has a method or property, and what it takes | \`editor_classes info\` with \`member\`, which answers that one member and which class declares it rather than the whole class |
 | Wait for a run to finish | \`editor_run wait\`, never a sleep or a shell loop on the pid: it answers as \`editor_output\` does, once the run is over |
 | End a bench and the workers it opened | \`editor_run stop\` with \`andChildren\`, never a process listing by scene name: it ends every process under the run's, to any depth, that is a game of the project, announced as one or the project's engine run with \`--path\` on it, names them under \`endedChildren\` with what identified each, and leaves and names any other |
 | A picture, for a person who asked to see one | \`runtime_capture\` |