gdharness 1.0.1 → 1.0.3

package/build/index.js

@@ -10183,7 +10183,7 @@ import {
   readSync
 } from "node:fs";
 import { tmpdir as tmpdir4 } from "node:os";
-import { basename as basename3, dirname as dirname6, join as join13, normalize as normalize2, relative as relative3 } from "node:path";
+import { basename as basename3, dirname as dirname7, join as join13, normalize as normalize2, relative as relative3 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { promisify as promisify5 } from "node:util";
@@ -25052,6 +25052,9 @@ function cacheWrittenAt(projectPath) {
     return null;
   }
 }
+function cachedAtMissingPaths(cached, projectPath) {
+  return [...cached].filter(([, path]) => path.startsWith("res://") && !existsSync2(join4(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);
 }
@@ -27710,20 +27713,61 @@ async function handleLSPTool(client, toolName, args) {
 }
 
 // src/process-children.ts
-import { execFile as execFile3 } from "node:child_process";
+import { execFile as execFile3, execFileSync, spawnSync } from "node:child_process";
 import { basename } from "node:path";
 import { promisify as promisify3 } from "node:util";
 var run3 = promisify3(execFile3);
+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 = spawnSync("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;
+}
 var ASK_TIMEOUT_MS = 15000;
 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);
@@ -27732,16 +27776,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);
     }
   }
@@ -27769,13 +27835,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;
@@ -27831,7 +27899,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;
 }
@@ -28289,7 +28357,7 @@ function restartSettled(projectPath) {
 }
 
 // src/run-record.ts
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 import { mkdirSync as mkdirSync5, openSync, readdirSync as readdirSync5, readFileSync as readFileSync11, rmSync as rmSync5, statSync as statSync4, writeFileSync as writeFileSync6 } from "node:fs";
 import { basename as basename2, join as join11 } from "node:path";
 
@@ -28297,7 +28365,7 @@ import { basename as basename2, join as join11 } from "node:path";
 import { existsSync as existsSync7, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync3, unlinkSync } from "node:fs";
 import { createConnection as createConnection3 } from "node:net";
 import { tmpdir as tmpdir3 } from "node:os";
-import { join as join10, resolve as resolve4 } from "node:path";
+import { dirname as dirname5, join as join10, resolve as resolve4 } from "node:path";
 import { setTimeout as delay2 } from "node:timers/promises";
 
 // src/tool-args.ts
@@ -28471,11 +28539,35 @@ function announcedAndGone(projectPath) {
   const wanted = resolve4(projectPath);
   return gone.filter((one) => one.noticedAt >= since && resolve4(one.project) === wanted);
 }
+var STARTED_AFTER_ANNOUNCING_MS = 2000;
+var CONFIRMED_FOR_MS = 60000;
+var JUDGED_AFTER_MS = 60000;
+var verdicts = new Map;
+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 (!existsSync7(directory)) {
     return [];
   }
   const found = [];
+  const candidates = [];
+  const entries = [];
   for (const entry of readdirSync4(directory)) {
     const report = ERROR_REPORT_PATTERN.exec(entry);
     if (report) {
@@ -28489,20 +28581,60 @@ function announcedIn(directory) {
     const file = join10(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 = join10(directory, ".");
+  for (const file of verdicts.keys()) {
+    if (dirname5(file) === here && !held.has(file)) {
+      verdicts.delete(file);
+    }
+  }
   return found;
 }
+var ENDED_WITHIN_MS = 3000;
+async function announcementEnded(pid, directories = runtimeDirectories()) {
+  const files = directories.map((directory) => join10(directory, `runtime-${pid}.json`)).filter((file) => existsSync7(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;
@@ -28811,7 +28943,7 @@ function runningAs(pid) {
       const raw = readFileSync11(`/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();
@@ -28823,20 +28955,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]);
@@ -28848,9 +28974,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",
@@ -28868,7 +29007,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();
@@ -28880,7 +29019,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
@@ -28966,7 +29105,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
 
 // src/setup.ts
 import { cpSync, existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync12, rmSync as rmSync6, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname5, join as join12 } from "node:path";
+import { dirname as dirname6, join as join12 } from "node:path";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
 var RUNTIME_AUTOLOAD = {
   name: "GdharnessRuntime",
@@ -29687,7 +29826,7 @@ var TOOL_SPECS = [
   },
   {
     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." },
@@ -29723,12 +29862,20 @@ var TOOL_SPECS = [
       },
       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"
@@ -29747,13 +29894,19 @@ var TOOL_SPECS = [
       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",
@@ -29822,7 +29975,7 @@ var TOOL_SPECS = [
       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"],
@@ -29832,7 +29985,7 @@ var TOOL_SPECS = [
       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",
@@ -29892,7 +30045,7 @@ var TOOL_SPECS = [
       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: {
@@ -29942,7 +30095,7 @@ var TOOL_SPECS = [
       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",
@@ -29962,7 +30115,7 @@ var TOOL_SPECS = [
       },
       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: {
@@ -29970,11 +30123,11 @@ var TOOL_SPECS = [
         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"]
       }
     }
@@ -29992,12 +30145,21 @@ var TOOL_SPECS = [
       },
       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",
@@ -30112,7 +30274,7 @@ function buildToolDefinitions() {
 var UPDATE_NOTICE_EVERY = 500;
 var FEEDBACK_NOTICE_EVERY = 250;
 var run5 = promisify5(execFile5);
-var __dirname2 = dirname6(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname7(fileURLToPath2(import.meta.url));
 var EDITOR_RESTART_TIMEOUT_MS = 90000;
 var HOLD_PING_MS = 2000;
 var SLOWEST_FRAME_RATE = 20;
@@ -30151,13 +30313,17 @@ function stillRunning(run) {
   }
   return true;
 }
-function runIsUp(run, editorSays) {
+var PLAY_STARTS_WITHIN_MS = 30000;
+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) {
@@ -30232,10 +30398,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
   };
 }
@@ -30966,7 +31133,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);
@@ -31368,11 +31536,11 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname6(output.absolutePath);
+    const folder = dirname7(output.absolutePath);
     try {
       mkdirSync7(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname6(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname7(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
     const exportLogs = mkdtempSync2(join13(tmpdir4(), "gdharness-export-"));
@@ -31826,11 +31994,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 {
@@ -32150,6 +32321,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),
@@ -32163,6 +32337,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(() => {
@@ -32172,6 +32347,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;
@@ -32181,7 +32357,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) {
@@ -32211,6 +32388,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,
@@ -32222,7 +32400,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 });
@@ -32232,7 +32411,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) => ({
@@ -32758,7 +32937,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();
@@ -32841,11 +33024,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",
@@ -32941,6 +33132,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;
@@ -32952,7 +33144,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));
@@ -32960,7 +33152,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) {
@@ -32976,8 +33172,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,
@@ -32986,8 +33197,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) {
@@ -33228,6 +33441,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);
   }