gdharness 1.0.3 → 1.0.5

package/build/cli.js

@@ -16015,7 +16015,7 @@ var init_tool_definitions = __esm(() => {
         runtimeWaitMs: {
           type: "number",
           ops: ["start"],
-          description: "start: how long to wait for the game to announce its runtime before answering. Default 5000. What it waits for is the first frame, so everything the game does before drawing one is inside it, including work the args just asked for: a flag that simulates six years of game time before anything is drawn makes the announcement that late, on a project that announces promptly without it. Raise it for such a run rather than reading runtime listening false as a fault. 0 does not wait at all, which is the one to pass for a scene that announces nothing by construction, such as a bench that prints and quits."
+          description: "start: how long to wait for the game to announce its runtime before answering. Default 5000, or half as long again as the last boot of this project took when that is more, up to 60000: the server notes how long each game took to announce, so a project that boots slowly is waited for from its second start on without being asked to. What it waits for is the first frame, so everything the game does before drawing one is inside it, including work the args just asked for: a flag that simulates six years of game time before anything is drawn makes the announcement that late, on a project that announces promptly without it. Raise it for such a run rather than reading runtime listening false as a fault. 0 does not wait at all, which is the one to pass for a scene that announces nothing by construction, such as a bench that prints and quits."
         },
         frames: {
           type: "number",
@@ -16040,7 +16040,7 @@ var init_tool_definitions = __esm(() => {
           requires: ["projectPath"]
         },
         stop: {
-          summary: "end the run and answer with what it printed last, naming the process ended under endedPid: a game that started processes of its own keeps them unless andChildren says to end those too",
+          summary: "end the run and answer with what it printed last, naming the process ended under endedPid: for a run the editor plays, the number its game announced under, read at the stop rather than remembered, and the operating system hands a freed number to the next process, so it can equal the game before it. A game that started processes of its own keeps them unless andChildren says to end those too",
           requires: []
         },
         check: {
@@ -31240,11 +31240,638 @@ var init_stdio2 = __esm(() => {
   init_stdio();
 });
 
+// src/process-children.ts
+import { execFile as execFile4, execFileSync, spawnSync as spawnSync2 } from "node:child_process";
+import { basename as basename2 } from "node:path";
+import { promisify as promisify4 } 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 {
+    if (process.platform === "win32") {
+      return parseProcessTable(await askWindows(), true);
+    }
+    return parseProcessTable(await askPosix());
+  } catch {
+    return;
+  }
+}
+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);
+    if (fields === null) {
+      continue;
+    }
+    const pid = Number(fields[1]);
+    const parent = Number(fields[2]);
+    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 of tree.keys()) {
+    if (linked(tree, child, pid)) {
+      children.push(child);
+    }
+  }
+  return children;
+}
+function descendantsIn(tree, pid) {
+  const found = [];
+  const queue = [pid];
+  const seen = new Set([pid]);
+  while (queue.length > 0) {
+    const next = queue.shift();
+    if (next === undefined) {
+      break;
+    }
+    for (const child of childrenIn(tree, next)) {
+      if (!seen.has(child)) {
+        seen.add(child);
+        found.push(child);
+        queue.push(child);
+      }
+    }
+  }
+  return found;
+}
+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) && linked(tree, child, parent)) {
+    chain.push(parent);
+    if (parent === root) {
+      break;
+    }
+    seen.add(parent);
+    child = parent;
+    parent = tree.get(parent)?.parent;
+  }
+  return chain;
+}
+function readCommandLine(command) {
+  const words = commandWords(command);
+  const executable = words[0] === undefined ? "" : basename2(words[0].replaceAll("\\", "/"));
+  const at = words.indexOf("--path");
+  let projectPath = null;
+  if (at !== -1 && at + 1 < words.length) {
+    const taken = [];
+    for (const word of words.slice(at + 1)) {
+      if (taken.length > 0 && (word.startsWith("-") || /^[a-z]+:\/\//.test(word))) {
+        break;
+      }
+      taken.push(word);
+    }
+    projectPath = taken.join(" ");
+  }
+  return {
+    executable,
+    projectPath,
+    editor: words.some((word) => word === "-e" || word === "--editor")
+  };
+}
+function commandWords(command) {
+  const words = [];
+  let word = "";
+  let quoted = false;
+  let started = false;
+  for (const char of command) {
+    if (char === '"') {
+      quoted = !quoted;
+      started = true;
+    } else if (!quoted && /\s/.test(char)) {
+      if (started) {
+        words.push(word);
+        word = "";
+        started = false;
+      }
+    } else {
+      word += char;
+      started = true;
+    }
+  }
+  if (started) {
+    words.push(word);
+  }
+  return words;
+}
+async function askWindows() {
+  const { stdout } = await run4("powershell.exe", [
+    "-NoProfile",
+    "-NonInteractive",
+    "-Command",
+    '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;
+}
+async function askPosix() {
+  const { stdout } = await run4("ps", ["-e", "-o", "pid=,ppid=,args="], {
+    timeout: ASK_TIMEOUT_MS,
+    maxBuffer: 16 * 1024 * 1024
+  });
+  return stdout;
+}
+var run4, ASK_TIMEOUT_MS = 15000;
+var init_process_children = __esm(() => {
+  run4 = promisify4(execFile4);
+});
+
+// src/runtime-client.ts
+import { existsSync as existsSync10, readdirSync as readdirSync4, readFileSync as readFileSync10, statSync as statSync3, unlinkSync } from "node:fs";
+import { createConnection } from "node:net";
+import { tmpdir as tmpdir4 } from "node:os";
+import { dirname as dirname7, join as join12, resolve as resolve3 } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+function runtimeDirectory(variables = process.env) {
+  const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
+  if (explicit) {
+    return explicit;
+  }
+  const perUser = envValue("XDG_RUNTIME_DIR", variables);
+  return join12(perUser ?? tmpdir4(), "gdharness");
+}
+function runtimeDirectories(variables = process.env) {
+  const candidates = [runtimeDirectory(variables)];
+  const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
+  for (const base of fallbacks) {
+    candidates.push(join12(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+  }
+  return [...new Set(candidates.map((path) => resolve3(path)))];
+}
+function errorReportOf(pid, directories = runtimeDirectories()) {
+  for (const directory of directories) {
+    const path = join12(directory, `runtime-${pid}.log`);
+    if (existsSync10(path)) {
+      return path;
+    }
+  }
+  return null;
+}
+function processAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function parseAnnouncement(file, pid) {
+  let fields;
+  try {
+    fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
+  } catch {
+    return { kind: "rubbish" };
+  }
+  const project = readParams(fields, "project");
+  const port = readNumber(fields, "port");
+  const address = readString(fields, "address");
+  const protocol = readNumber(fields, "protocol");
+  if (readNumber(fields, "pid") !== pid || port === undefined || !Number.isInteger(port) || port < 1 || port > 65535 || address === undefined || project === undefined) {
+    return { kind: "rubbish" };
+  }
+  const named = {
+    name: readString(project, "name") ?? "",
+    path: readString(project, "path") ?? ""
+  };
+  if (protocol !== RUNTIME_PROTOCOL) {
+    return { kind: "unspoken", unspoken: { pid, protocol: protocol ?? 0, project: named } };
+  }
+  const editorPid = readNumber(fields, "editor_pid");
+  return {
+    kind: "runtime",
+    endpoint: {
+      pid,
+      port,
+      address,
+      project: named,
+      file,
+      ...editorPid !== undefined && Number.isInteger(editorPid) && editorPid > 0 ? { editorPid } : {}
+    }
+  };
+}
+function runtimesAnnounced(directories = runtimeDirectories()) {
+  const running = new Map;
+  const unspoken = new Map;
+  for (const directory of directories) {
+    for (const found of announcedIn(directory)) {
+      if (found.kind === "runtime" && !running.has(found.endpoint.pid)) {
+        running.set(found.endpoint.pid, found.endpoint);
+      } else if (found.kind === "unspoken" && !unspoken.has(found.unspoken.pid)) {
+        unspoken.set(found.unspoken.pid, found.unspoken);
+      }
+    }
+  }
+  const newest = (a, b) => b.pid - a.pid;
+  return { running: [...running.values()].sort(newest), unspoken: [...unspoken.values()].sort(newest) };
+}
+function discoverRuntimes(directories = runtimeDirectories()) {
+  return runtimesAnnounced(directories).running;
+}
+function wentAway(file, pid) {
+  let project = "";
+  try {
+    const fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
+    project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
+  } catch {
+    return;
+  }
+  if (project === "") {
+    return;
+  }
+  gone.unshift({ pid, project, noticedAt: Date.now() });
+  gone.length = Math.min(gone.length, GONE_KEPT);
+}
+function announcedAndGone(projectPath) {
+  if (projectPath === undefined) {
+    return [];
+  }
+  const since = Date.now() - GONE_WINDOW_MS;
+  const wanted = resolve3(projectPath);
+  return gone.filter((one) => one.noticedAt >= since && resolve3(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 (!existsSync10(directory)) {
+    return [];
+  }
+  const found = [];
+  const candidates = [];
+  const entries = [];
+  for (const entry of readdirSync4(directory)) {
+    const report = ERROR_REPORT_PATTERN.exec(entry);
+    if (report) {
+      sweepErrorReport(join12(directory, entry), Number.parseInt(report[1] ?? "", 10));
+      continue;
+    }
+    const match = ANNOUNCEMENT_PATTERN.exec(entry);
+    if (!match) {
+      continue;
+    }
+    const file = join12(directory, entry);
+    const pid = Number.parseInt(match[1] ?? "", 10);
+    const alive = processAlive(pid);
+    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 || 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 = join12(directory, ".");
+  for (const file of verdicts.keys()) {
+    if (dirname7(file) === here && !held.has(file)) {
+      verdicts.delete(file);
+    }
+  }
+  return found;
+}
+async function announcementEnded(pid, directories = runtimeDirectories()) {
+  const files = directories.map((directory) => join12(directory, `runtime-${pid}.json`)).filter((file) => existsSync10(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 delay(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;
+  }
+  try {
+    if (now - statSync3(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
+      unlinkSync(path);
+    }
+  } catch {}
+}
+async function announcedSince(projectPath, before, waiting = {}) {
+  const wanted = resolve3(projectPath);
+  const directories = waiting.directories ?? runtimeDirectories();
+  const until = Date.now() + Math.max(waiting.budgetMs ?? ANNOUNCE_BUDGET_MS, 0);
+  for (;; ) {
+    const fresh = discoverRuntimes(directories).find((endpoint) => !before.has(endpoint.pid) && resolve3(endpoint.project.path) === wanted && (waiting.accept?.(endpoint) ?? true));
+    if (fresh !== undefined) {
+      return fresh;
+    }
+    const left = until - Date.now();
+    if (left <= 0 || waiting.giveUp?.() === true) {
+      return null;
+    }
+    await delay(Math.min(LOOK_EVERY_MS, left));
+  }
+}
+function describe2(endpoint) {
+  return `pid ${endpoint.pid} on ${endpoint.address}:${endpoint.port} (${endpoint.project.name || "unnamed"} at ${endpoint.project.path})`;
+}
+function tooNew(unspoken) {
+  const named = unspoken.map((game) => `pid ${game.pid} speaks ${game.protocol} (${game.project.name || "unnamed"} at ${game.project.path})`).join("; ");
+  const half = unspoken.some((game) => game.protocol > RUNTIME_PROTOCOL) ? "this server is the older half: reconnect it so it spawns the installed version" : "the addon is the older half: reinstall it and restart the game";
+  return `A game is running, in a protocol this server does not speak ${named}. This server speaks ${RUNTIME_PROTOCOL}, so ${half}.`;
+}
+function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
+  if (pid !== undefined) {
+    const named = endpoints.find((endpoint) => endpoint.pid === pid);
+    if (named !== undefined) {
+      if (projectPath !== undefined && resolve3(named.project.path) !== resolve3(projectPath)) {
+        return {
+          problem: `The game with pid ${pid} is running ${named.project.path}, not ${resolve3(projectPath)}. Running: ${endpoints.map(describe2).join("; ")}.`
+        };
+      }
+      return { endpoint: named };
+    }
+    const tooNewToo = unspoken.find((game) => game.pid === pid);
+    if (tooNewToo !== undefined) {
+      return { problem: tooNew([tooNewToo]) };
+    }
+    return {
+      problem: endpoints.length === 0 ? `No game with the runtime addon is running, so there is none with pid ${pid}. Start one with editor_run, or play the project from the editor with the addon enabled.` : `No running game has pid ${pid}. Running: ${endpoints.map(describe2).join("; ")}. editor_status lists them under runtimes as they come and go.`
+    };
+  }
+  if (endpoints.length === 0) {
+    if (unspoken.length > 0) {
+      return { problem: tooNew(unspoken) };
+    }
+    const went = announcedAndGone(projectPath);
+    const first = went[0];
+    if (first !== undefined) {
+      const ago = Math.max(1, Math.round((Date.now() - first.noticedAt) / 1000));
+      const others = went.length - 1;
+      const earlier = others === 0 ? "" : ` ${others} earlier ${others === 1 ? "one" : "ones"} went the same way.`;
+      return {
+        problem: `A game with the runtime addon announced itself and its process is gone: pid ${first.pid}` + `${first.project === "" ? "" : ` for ${first.project}`}, noticed ${ago}s ago.${earlier}` + " It quit or was ended rather than never starting, so editor_output has what it printed" + " on the way, including whatever it broke on. Start another with editor_run once you have read it."
+      };
+    }
+    return {
+      problem: "No game with the runtime addon is running. Start one with editor_run, or play the project from the editor with the addon enabled."
+    };
+  }
+  if (projectPath !== undefined) {
+    const wanted = resolve3(projectPath);
+    const matching = endpoints.filter((endpoint) => resolve3(endpoint.project.path) === wanted);
+    if (matching.length === 0) {
+      return {
+        problem: `No running game is from ${wanted}. Running: ${endpoints.map(describe2).join("; ")}.`
+      };
+    }
+    if (matching.length === 1 && matching[0]) {
+      return { endpoint: matching[0] };
+    }
+    return {
+      problem: `Several games are running from ${wanted}: ${matching.map(describe2).join("; ")}. Pass pid to choose one.`
+    };
+  }
+  if (endpoints.length === 1 && endpoints[0]) {
+    return { endpoint: endpoints[0] };
+  }
+  return {
+    problem: `Several games are running: ${endpoints.map(describe2).join("; ")}. Pass projectPath to choose one, or pid when they are from one project.`
+  };
+}
+function runtimeRequest(endpoint, command, params, timeoutMs) {
+  const id = nextRequestId++;
+  return new Promise((settle) => {
+    let done = false;
+    let buffered = "";
+    let welcomed = false;
+    const socket = createConnection({ port: endpoint.port, host: endpoint.address });
+    const finish = (reply) => {
+      if (done) {
+        return;
+      }
+      done = true;
+      clearTimeout(timer);
+      socket.destroy();
+      settle(reply);
+    };
+    const timer = setTimeout(() => {
+      finish({
+        ok: false,
+        reason: "busy",
+        message: `The game (${describe2(endpoint)}) accepted the connection but did not answer '${command}' within ${timeoutMs}ms. It may be paused at a breakpoint or stuck in a long frame.`
+      });
+    }, timeoutMs);
+    socket.setEncoding("utf8");
+    socket.on("connect", () => {
+      socket.write(`${JSON.stringify({ id, command, params })}
+`);
+    });
+    socket.on("data", (chunk) => {
+      buffered += chunk;
+      let newline = buffered.indexOf(`
+`);
+      while (newline !== -1 && !done) {
+        const line = buffered.slice(0, newline).trim();
+        buffered = buffered.slice(newline + 1);
+        newline = buffered.indexOf(`
+`);
+        if (line === "") {
+          continue;
+        }
+        let message;
+        try {
+          message = asParams(JSON.parse(line));
+        } catch {
+          continue;
+        }
+        if (!welcomed) {
+          welcomed = true;
+          if (readString(message, "type") === "welcome") {
+            const spoken = readNumber(message, "protocol");
+            if (spoken !== RUNTIME_PROTOCOL) {
+              finish({
+                ok: false,
+                reason: "protocol",
+                message: `The game (${describe2(endpoint)}) speaks runtime protocol ${spoken ?? "unknown"} and this server speaks ${RUNTIME_PROTOCOL}. Reinstall the runtime addon into the project.`
+              });
+              return;
+            }
+            continue;
+          }
+        }
+        if (message["id"] !== id) {
+          continue;
+        }
+        if (readString(message, "type") === "error") {
+          finish({ ok: false, reason: "error", message: readString(message, "message") ?? "unknown error" });
+          return;
+        }
+        finish({ ok: true, payload: message, endpoint });
+      }
+    });
+    socket.on("error", (error) => {
+      finish({
+        ok: false,
+        reason: "refused",
+        message: `The game (${describe2(endpoint)}) is running but nothing answered on its port: ${error.code ?? error.message}. It may still be starting, or be shutting down.`
+      });
+    });
+    socket.on("close", () => {
+      finish({
+        ok: false,
+        reason: "refused",
+        message: `The game (${describe2(endpoint)}) closed the connection before answering '${command}'.`
+      });
+    });
+  });
+}
+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/boot-note.ts
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
+import { dirname as dirname8, join as join13 } from "node:path";
+function bootNotePath(projectPath) {
+  return join13(projectPath, ".godot", "gdharness-boot.json");
+}
+function readBootNote(projectPath) {
+  try {
+    const noted = readNumber(asParams(JSON.parse(readFileSync11(bootNotePath(projectPath), "utf8"))), "announcedAfterMs");
+    return noted !== undefined && Number.isFinite(noted) && noted > 0 ? noted : null;
+  } catch {
+    return null;
+  }
+}
+function writeBootNote(projectPath, announcedAfterMs) {
+  try {
+    const path = bootNotePath(projectPath);
+    mkdirSync6(dirname8(path), { recursive: true });
+    writeFileSync8(path, JSON.stringify({ announcedAfterMs: Math.round(announcedAfterMs), at: new Date().toISOString() }, null, 2), "utf8");
+  } catch {}
+}
+function waitSizedTo(lastBootMs, usual = ANNOUNCE_BUDGET_MS) {
+  if (lastBootMs === null) {
+    return usual;
+  }
+  return Math.min(LONGEST_SIZED_WAIT_MS, Math.max(usual, Math.round(lastBootMs * 1.5)));
+}
+var LONGEST_SIZED_WAIT_MS = 60000;
+var init_boot_note = __esm(() => {
+  init_runtime_client();
+});
+
 // src/breakpoint-note.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync10, rmSync as rmSync6, writeFileSync as writeFileSync8 } from "node:fs";
-import { dirname as dirname7, isAbsolute as isAbsolute2, join as join12, relative as relative2 } from "node:path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync12, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "node:fs";
+import { dirname as dirname9, isAbsolute as isAbsolute2, join as join14, relative as relative2 } from "node:path";
 function breakpointNotePath(projectPath) {
-  return join12(projectPath, ".godot", "gdharness-breakpoints.json");
+  return join14(projectPath, ".godot", "gdharness-breakpoints.json");
 }
 function writeBreakpointNote(projectPath, held) {
   const path = breakpointNotePath(projectPath);
@@ -31261,8 +31888,8 @@ function writeBreakpointNote(projectPath, held) {
         lines: [...one.lines]
       }))
     };
-    mkdirSync6(dirname7(path), { recursive: true });
-    writeFileSync8(path, `${JSON.stringify(note, null, 2)}
+    mkdirSync7(dirname9(path), { recursive: true });
+    writeFileSync9(path, `${JSON.stringify(note, null, 2)}
 `, "utf8");
   } catch (error) {
     console.error(`[SERVER] Could not record the breakpoints at ${path}: ${errorMessage(error)}`);
@@ -31270,7 +31897,7 @@ function writeBreakpointNote(projectPath, held) {
 }
 function readBreakpointNote(projectPath) {
   try {
-    const parsed = JSON.parse(readFileSync10(breakpointNotePath(projectPath), "utf8"));
+    const parsed = JSON.parse(readFileSync12(breakpointNotePath(projectPath), "utf8"));
     if (typeof parsed !== "object" || parsed === null || !Array.isArray(parsed.breakpoints)) {
       return [];
     }
@@ -31285,7 +31912,7 @@ function readBreakpointNote(projectPath) {
       }
       const lines = Array.isArray(listed) ? listed.filter((line) => Number.isInteger(line) && line > 0) : [];
       if (lines.length > 0) {
-        held.push({ scriptPath: realPathOr(join12(projectPath, script)), lines });
+        held.push({ scriptPath: realPathOr(join14(projectPath, script)), lines });
       }
     }
     return held;
@@ -31303,14 +31930,14 @@ var init_breakpoint_note = __esm(() => {
 });
 
 // src/bridge-announce.ts
-import { mkdirSync as mkdirSync7, readFileSync as readFileSync11, rmSync as rmSync7, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname8, join as join13 } from "node:path";
+import { mkdirSync as mkdirSync8, readFileSync as readFileSync13, rmSync as rmSync7, writeFileSync as writeFileSync10 } from "node:fs";
+import { dirname as dirname10, join as join15 } from "node:path";
 function announcementPath(projectPath) {
-  return join13(projectPath, ".godot", "gdharness-bridge.json");
+  return join15(projectPath, ".godot", "gdharness-bridge.json");
 }
 function readAnnouncement(path) {
   try {
-    const parsed = JSON.parse(readFileSync11(path, "utf8"));
+    const parsed = JSON.parse(readFileSync13(path, "utf8"));
     if (typeof parsed !== "object" || parsed === null) {
       return null;
     }
@@ -31329,7 +31956,7 @@ function announcementIsOurs(path) {
 function announceBridge(projectPath, bridge) {
   const path = announcementPath(projectPath);
   try {
-    mkdirSync7(dirname8(path), { recursive: true });
+    mkdirSync8(dirname10(path), { recursive: true });
     const announcement = {
       protocol: BRIDGE_ANNOUNCE_PROTOCOL,
       host: bridge.host,
@@ -31338,7 +31965,7 @@ function announceBridge(projectPath, bridge) {
       version: bridge.version,
       startedAt: new Date().toISOString()
     };
-    writeFileSync9(path, `${JSON.stringify(announcement, null, 2)}
+    writeFileSync10(path, `${JSON.stringify(announcement, null, 2)}
 `, "utf8");
     return path;
   } catch (error) {
@@ -31362,16 +31989,16 @@ var init_bridge_announce = __esm(() => {
 });
 
 // src/config-pin.ts
-import { existsSync as existsSync10, readFileSync as readFileSync12 } from "node:fs";
-import { join as join14 } from "node:path";
+import { existsSync as existsSync11, readFileSync as readFileSync14 } from "node:fs";
+import { join as join16 } from "node:path";
 function versionsNamedInConfig(projectPath) {
-  const config = join14(projectPath, ".mcp.json");
-  if (!existsSync10(config)) {
+  const config = join16(projectPath, ".mcp.json");
+  if (!existsSync11(config)) {
     return [];
   }
   let text;
   try {
-    text = readFileSync12(config, "utf8");
+    text = readFileSync14(config, "utf8");
     JSON.parse(text);
   } catch {
     return [];
@@ -31518,8 +32145,8 @@ var init_ports = __esm(() => {
 });
 
 // src/dap_client.ts
-import { createConnection } from "node:net";
-import { setTimeout as delay } from "node:timers/promises";
+import { createConnection as createConnection2 } from "node:net";
+import { setTimeout as delay2 } from "node:timers/promises";
 function said(body, field) {
   const value = body?.[field];
   return typeof value === "string" ? value : "";
@@ -31554,7 +32181,7 @@ class GodotDAPClient {
       return;
     }
     await new Promise((resolve, reject) => {
-      const socket = createConnection({ host: this.host, port: this.port });
+      const socket = createConnection2({ host: this.host, port: this.port });
       this.socket = socket;
       const connectTimeout = setTimeout(() => {
         socket.destroy();
@@ -31963,7 +32590,7 @@ class GodotDAPClient {
           return answered;
         }
       } catch {}
-      await delay(200);
+      await delay2(200);
     }
     return [];
   }
@@ -31984,7 +32611,7 @@ class GodotDAPClient {
           break;
         }
       } catch {}
-      await delay(200);
+      await delay2(200);
     }
     const named = [];
     for (const scope of scopes) {
@@ -35500,10 +36127,10 @@ var init_godot_bridge = __esm(() => {
 });
 
 // src/godot-path.ts
-import { execFile as execFile4 } from "node:child_process";
-import { existsSync as existsSync11 } from "node:fs";
+import { execFile as execFile5 } from "node:child_process";
+import { existsSync as existsSync12 } from "node:fs";
 import { normalize as normalize2 } from "node:path";
-import { promisify as promisify4 } from "node:util";
+import { promisify as promisify5 } from "node:util";
 
 class GodotLocator2 {
   answered = new Map;
@@ -35556,11 +36183,11 @@ class GodotLocator2 {
       return known;
     }
     let reason;
-    if (path !== "godot" && !existsSync11(path)) {
+    if (path !== "godot" && !existsSync12(path)) {
       reason = "does not exist";
     } else {
       try {
-        await run4(path, ["--version"]);
+        await run5(path, ["--version"]);
         reason = null;
       } catch (error) {
         reason = `does not answer --version: ${errorMessage(error)}`;
@@ -35570,11 +36197,11 @@ class GodotLocator2 {
     return reason;
   }
 }
-var run4;
+var run5;
 var init_godot_path = __esm(() => {
   init_detection();
   init_errors();
-  run4 = promisify4(execFile4);
+  run5 = promisify5(execFile5);
 });
 
 // src/issues.ts
@@ -35931,8 +36558,8 @@ var init_junit = __esm(() => {
 // src/lsp_client.ts
 import { realpathSync as realpathSync2 } from "node:fs";
 import { readFile, realpath } from "node:fs/promises";
-import { createConnection as createConnection2 } from "node:net";
-import { dirname as dirname9, resolve as resolve3 } from "node:path";
+import { createConnection as createConnection3 } from "node:net";
+import { dirname as dirname11, resolve as resolve4 } from "node:path";
 import { fileURLToPath as fileURLToPath3, pathToFileURL } from "node:url";
 function diagnosticsKey(uri) {
   let decoded;
@@ -35978,7 +36605,7 @@ class GodotLSPClient {
     }
     this.connectPromise = new Promise((resolveConnect, rejectConnect) => {
       let settled = false;
-      const socket = createConnection2({ port: this.port, host: this.host }, () => {
+      const socket = createConnection3({ port: this.port, host: this.host }, () => {
         this.socket = socket;
         this.connected = true;
         this.reader = new FrameReader;
@@ -36060,7 +36687,7 @@ class GodotLSPClient {
     if (this.initialized) {
       return;
     }
-    const rootPath = this.rootPath ?? dirname9(resolve3(filePath));
+    const rootPath = this.rootPath ?? dirname11(resolve4(filePath));
     await this.initialize(rootPath);
   }
   async sendRequest(method, params) {
@@ -36198,7 +36825,7 @@ class GodotLSPClient {
     });
   }
   toFileUri(filePath) {
-    return pathToFileURL(resolve3(filePath)).href;
+    return pathToFileURL(resolve4(filePath)).href;
   }
   syncDocument(filePath, content) {
     const uri = this.toFileUri(filePath);
@@ -36239,7 +36866,7 @@ class GodotLSPClient {
   }
   async initialize(rootPath) {
     await this.ensureConnected();
-    const resolvedRootPath = resolve3(rootPath);
+    const resolvedRootPath = resolve4(rootPath);
     const rootUri = pathToFileURL(resolvedRootPath).href;
     const result = await this.sendRequest("initialize", {
       processId: process.pid,
@@ -36382,7 +37009,7 @@ function normalizeLSPError(error, port) {
   return String(error);
 }
 async function resolveLSPPaths(projectPathValue, scriptPathValue) {
-  const requestedProjectPath = resolve3(projectPathValue);
+  const requestedProjectPath = resolve4(projectPathValue);
   let projectPath;
   try {
     projectPath = await realpath(requestedProjectPath);
@@ -36432,238 +37059,37 @@ async function handleLSPTool(client, toolName, args) {
         if (!Number.isFinite(line) || !Number.isFinite(character)) {
           throw new Refusal2("Arguments line and character must be numbers.");
         }
-        const completions = await client.getCompletions(scriptPath, content, line, character);
-        return asToolResponse({ completions });
-      }
-      case "lsp_get_hover": {
-        const line = Number(parsedArgs["line"]);
-        const character = Number(parsedArgs["character"]);
-        if (!Number.isFinite(line) || !Number.isFinite(character)) {
-          throw new Refusal2("Arguments line and character must be numbers.");
-        }
-        const hover = await client.getHover(scriptPath, content, line, character);
-        return asToolResponse({ hover });
-      }
-      case "lsp_get_symbols": {
-        const symbols = await client.getDocumentSymbols(scriptPath, content);
-        return asToolResponse({ symbols });
-      }
-      default:
-        return asToolResponse({ error: `Unknown LSP tool: ${toolName}` });
-    }
-  } catch (error) {
-    return asToolResponse({
-      error: normalizeLSPError(error, client.port)
-    });
-  }
-}
-var DEFAULT_LSP_PORT = 6005, DIAGNOSTICS_TIMEOUT_MS = 5000;
-var init_lsp_client = __esm(() => {
-  init_errors();
-  init_framing();
-  init_paths();
-  init_ports();
-});
-
-// src/process-children.ts
-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 {
-    if (process.platform === "win32") {
-      return parseProcessTable(await askWindows(), true);
-    }
-    return parseProcessTable(await askPosix());
-  } catch {
-    return;
-  }
-}
-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);
-    if (fields === null) {
-      continue;
-    }
-    const pid = Number(fields[1]);
-    const parent = Number(fields[2]);
-    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 of tree.keys()) {
-    if (linked(tree, child, pid)) {
-      children.push(child);
-    }
-  }
-  return children;
-}
-function descendantsIn(tree, pid) {
-  const found = [];
-  const queue = [pid];
-  const seen = new Set([pid]);
-  while (queue.length > 0) {
-    const next = queue.shift();
-    if (next === undefined) {
-      break;
-    }
-    for (const child of childrenIn(tree, next)) {
-      if (!seen.has(child)) {
-        seen.add(child);
-        found.push(child);
-        queue.push(child);
-      }
-    }
-  }
-  return found;
-}
-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) && linked(tree, child, parent)) {
-    chain.push(parent);
-    if (parent === root) {
-      break;
-    }
-    seen.add(parent);
-    child = parent;
-    parent = tree.get(parent)?.parent;
-  }
-  return chain;
-}
-function readCommandLine(command) {
-  const words = commandWords(command);
-  const executable = words[0] === undefined ? "" : basename2(words[0].replaceAll("\\", "/"));
-  const at = words.indexOf("--path");
-  let projectPath = null;
-  if (at !== -1 && at + 1 < words.length) {
-    const taken = [];
-    for (const word of words.slice(at + 1)) {
-      if (taken.length > 0 && (word.startsWith("-") || /^[a-z]+:\/\//.test(word))) {
-        break;
-      }
-      taken.push(word);
-    }
-    projectPath = taken.join(" ");
-  }
-  return {
-    executable,
-    projectPath,
-    editor: words.some((word) => word === "-e" || word === "--editor")
-  };
-}
-function commandWords(command) {
-  const words = [];
-  let word = "";
-  let quoted = false;
-  let started = false;
-  for (const char of command) {
-    if (char === '"') {
-      quoted = !quoted;
-      started = true;
-    } else if (!quoted && /\s/.test(char)) {
-      if (started) {
-        words.push(word);
-        word = "";
-        started = false;
+        const completions = await client.getCompletions(scriptPath, content, line, character);
+        return asToolResponse({ completions });
       }
-    } else {
-      word += char;
-      started = true;
+      case "lsp_get_hover": {
+        const line = Number(parsedArgs["line"]);
+        const character = Number(parsedArgs["character"]);
+        if (!Number.isFinite(line) || !Number.isFinite(character)) {
+          throw new Refusal2("Arguments line and character must be numbers.");
+        }
+        const hover = await client.getHover(scriptPath, content, line, character);
+        return asToolResponse({ hover });
+      }
+      case "lsp_get_symbols": {
+        const symbols = await client.getDocumentSymbols(scriptPath, content);
+        return asToolResponse({ symbols });
+      }
+      default:
+        return asToolResponse({ error: `Unknown LSP tool: ${toolName}` });
     }
+  } catch (error) {
+    return asToolResponse({
+      error: normalizeLSPError(error, client.port)
+    });
   }
-  if (started) {
-    words.push(word);
-  }
-  return words;
-}
-async function askWindows() {
-  const { stdout } = await run5("powershell.exe", [
-    "-NoProfile",
-    "-NonInteractive",
-    "-Command",
-    '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;
-}
-async function askPosix() {
-  const { stdout } = await run5("ps", ["-e", "-o", "pid=,ppid=,args="], {
-    timeout: ASK_TIMEOUT_MS,
-    maxBuffer: 16 * 1024 * 1024
-  });
-  return stdout;
 }
-var run5, ASK_TIMEOUT_MS = 15000;
-var init_process_children = __esm(() => {
-  run5 = promisify5(execFile5);
+var DEFAULT_LSP_PORT = 6005, DIAGNOSTICS_TIMEOUT_MS = 5000;
+var init_lsp_client = __esm(() => {
+  init_errors();
+  init_framing();
+  init_paths();
+  init_ports();
 });
 
 // src/process-time.ts
@@ -36706,13 +37132,13 @@ var init_process_time = __esm(() => {
 });
 
 // src/project-scan.ts
-import { existsSync as existsSync12, readdirSync as readdirSync4, readFileSync as readFileSync13 } from "node:fs";
-import { join as join15 } from "node:path";
+import { existsSync as existsSync13, readdirSync as readdirSync5, readFileSync as readFileSync15 } from "node:fs";
+import { join as join17 } from "node:path";
 function skipped(name) {
   return name.startsWith(".") || SKIPPED.has(name);
 }
 function steppedOver(directory) {
-  return existsSync12(join15(directory, ".gdignore"));
+  return existsSync13(join17(directory, ".gdignore"));
 }
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
@@ -36720,12 +37146,12 @@ function projectStructure(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join15(directory, entry.name));
+        visit(join17(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -36749,20 +37175,20 @@ function scriptsWithoutUid(projectPath) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
       if (skipped(entry.name)) {
         continue;
       }
       const spelled = prefix === "" ? entry.name : `${prefix}/${entry.name}`;
       if (entry.isDirectory()) {
-        visit(join15(directory, entry.name), spelled);
+        visit(join17(directory, entry.name), spelled);
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
       const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
-      if (CARRIES_A_UID.has(extension) && !existsSync12(join15(directory, `${entry.name}.uid`))) {
+      if (CARRIES_A_UID.has(extension) && !existsSync13(join17(directory, `${entry.name}.uid`))) {
         found.push(spelled);
       }
     }
@@ -36790,14 +37216,14 @@ function searchProject(projectPath, options) {
     if (steppedOver(directory)) {
       return;
     }
-    for (const entry of readdirSync4(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync5(directory, { withFileTypes: true })) {
       if (full()) {
         return;
       }
       if (skipped(entry.name)) {
         continue;
       }
-      const entryPath = join15(directory, entry.name);
+      const entryPath = join17(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -36808,7 +37234,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync13(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync15(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -36816,494 +37242,100 @@ function searchProject(projectPath, options) {
         const match = regex ? regex.exec(line)?.[0] : (options.caseSensitive ? line : line.toLowerCase()).includes(needle) ? options.query : "";
         if (match) {
           matches.push({ line: index + 1, content: line.trim(), match });
-          result.summary.total_matches += 1;
-        }
-      }
-      if (matches.length > 0) {
-        const relativePath = entryPath.slice(projectPath.length + 1).replace(/\\/g, "/");
-        result.results.push({ file: `res://${relativePath}`, matches });
-        result.summary.files_with_matches += 1;
-      }
-    }
-  };
-  visit(projectPath);
-  return result;
-}
-var SKIPPED, ASSET_EXTENSIONS, CARRIES_A_UID;
-var init_project_scan = __esm(() => {
-  SKIPPED = new Set(["node_modules"]);
-  ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
-  CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
-});
-
-// src/restart-note.ts
-import { mkdirSync as mkdirSync8, readFileSync as readFileSync14, rmSync as rmSync8, writeFileSync as writeFileSync10 } from "node:fs";
-import { dirname as dirname10, join as join16 } from "node:path";
-function restartNotePath(projectPath) {
-  return join16(projectPath, ".godot", "gdharness-restart.json");
-}
-function noteRestartBegun(note) {
-  const path = restartNotePath(note.projectPath);
-  try {
-    mkdirSync8(dirname10(path), { recursive: true });
-    writeFileSync10(path, `${JSON.stringify(note, null, 2)}
-`, "utf8");
-  } catch (error) {
-    console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
-  }
-}
-function restartOwed(projectPath) {
-  try {
-    const parsed = JSON.parse(readFileSync14(restartNotePath(projectPath), "utf8"));
-    if (typeof parsed !== "object" || parsed === null) {
-      return null;
-    }
-    const said = parsed;
-    if (typeof said.quitAt !== "string" || typeof said.byPid !== "number" || typeof said.ports !== "object") {
-      return null;
-    }
-    return said;
-  } catch {
-    return null;
-  }
-}
-function restartSettled(projectPath) {
-  try {
-    rmSync8(restartNotePath(projectPath), { force: true });
-  } catch (error) {
-    console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
-  }
-}
-var init_restart_note = __esm(() => {
-  init_errors();
-});
-
-// src/runtime-client.ts
-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 { 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);
-  if (explicit) {
-    return explicit;
-  }
-  const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join17(perUser ?? tmpdir4(), "gdharness");
-}
-function runtimeDirectories(variables = process.env) {
-  const candidates = [runtimeDirectory(variables)];
-  const fallbacks = process.platform === "win32" ? [envValue("SystemRoot", variables) ?? envValue("windir", variables) ?? "C:\\Windows"] : ["/tmp", "/var/tmp"];
-  for (const base of fallbacks) {
-    candidates.push(join17(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
-  }
-  return [...new Set(candidates.map((path) => resolve4(path)))];
-}
-function errorReportOf(pid, directories = runtimeDirectories()) {
-  for (const directory of directories) {
-    const path = join17(directory, `runtime-${pid}.log`);
-    if (existsSync13(path)) {
-      return path;
-    }
-  }
-  return null;
-}
-function processAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return error.code === "EPERM";
-  }
-}
-function parseAnnouncement(file, pid) {
-  let fields;
-  try {
-    fields = asParams(JSON.parse(readFileSync15(file, "utf8")));
-  } catch {
-    return { kind: "rubbish" };
-  }
-  const project = readParams(fields, "project");
-  const port = readNumber(fields, "port");
-  const address = readString(fields, "address");
-  const protocol = readNumber(fields, "protocol");
-  if (readNumber(fields, "pid") !== pid || port === undefined || !Number.isInteger(port) || port < 1 || port > 65535 || address === undefined || project === undefined) {
-    return { kind: "rubbish" };
-  }
-  const named = {
-    name: readString(project, "name") ?? "",
-    path: readString(project, "path") ?? ""
-  };
-  if (protocol !== RUNTIME_PROTOCOL) {
-    return { kind: "unspoken", unspoken: { pid, protocol: protocol ?? 0, project: named } };
-  }
-  const editorPid = readNumber(fields, "editor_pid");
-  return {
-    kind: "runtime",
-    endpoint: {
-      pid,
-      port,
-      address,
-      project: named,
-      file,
-      ...editorPid !== undefined && Number.isInteger(editorPid) && editorPid > 0 ? { editorPid } : {}
-    }
-  };
-}
-function runtimesAnnounced(directories = runtimeDirectories()) {
-  const running = new Map;
-  const unspoken = new Map;
-  for (const directory of directories) {
-    for (const found of announcedIn(directory)) {
-      if (found.kind === "runtime" && !running.has(found.endpoint.pid)) {
-        running.set(found.endpoint.pid, found.endpoint);
-      } else if (found.kind === "unspoken" && !unspoken.has(found.unspoken.pid)) {
-        unspoken.set(found.unspoken.pid, found.unspoken);
-      }
-    }
-  }
-  const newest = (a, b) => b.pid - a.pid;
-  return { running: [...running.values()].sort(newest), unspoken: [...unspoken.values()].sort(newest) };
-}
-function discoverRuntimes(directories = runtimeDirectories()) {
-  return runtimesAnnounced(directories).running;
-}
-function wentAway(file, pid) {
-  let project = "";
-  try {
-    const fields = asParams(JSON.parse(readFileSync15(file, "utf8")));
-    project = readString(readParams(fields, "project") ?? {}, "path") ?? "";
-  } catch {
-    return;
-  }
-  if (project === "") {
-    return;
-  }
-  gone.unshift({ pid, project, noticedAt: Date.now() });
-  gone.length = Math.min(gone.length, GONE_KEPT);
-}
-function announcedAndGone(projectPath) {
-  if (projectPath === undefined) {
-    return [];
-  }
-  const since = Date.now() - GONE_WINDOW_MS;
-  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) {
-      sweepErrorReport(join17(directory, entry), Number.parseInt(report[1] ?? "", 10));
-      continue;
-    }
-    const match = ANNOUNCEMENT_PATTERN.exec(entry);
-    if (!match) {
-      continue;
-    }
-    const file = join17(directory, entry);
-    const pid = Number.parseInt(match[1] ?? "", 10);
-    const alive = processAlive(pid);
-    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 || strangers.has(file)) {
-        wentAway(file, pid);
+          result.summary.total_matches += 1;
+        }
+      }
+      if (matches.length > 0) {
+        const relativePath = entryPath.slice(projectPath.length + 1).replace(/\\/g, "/");
+        result.results.push({ file: `res://${relativePath}`, matches });
+        result.summary.files_with_matches += 1;
       }
-      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;
+  };
+  visit(projectPath);
+  return result;
 }
-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);
-  }
+var SKIPPED, ASSET_EXTENSIONS, CARRIES_A_UID;
+var init_project_scan = __esm(() => {
+  SKIPPED = new Set(["node_modules"]);
+  ASSET_EXTENSIONS = new Set(["png", "jpg", "jpeg", "webp", "svg", "ttf", "otf", "wav", "mp3", "ogg"]);
+  CARRIES_A_UID = new Set(["gd", "shader", "gdshader"]);
+});
+
+// src/restart-note.ts
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync16, rmSync as rmSync8, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname12, join as join18 } from "node:path";
+function restartNotePath(projectPath) {
+  return join18(projectPath, ".godot", "gdharness-restart.json");
 }
-function sweepErrorReport(path, pid, now = Date.now()) {
-  if (processAlive(pid)) {
-    return;
-  }
+function noteRestartBegun(note) {
+  const path = restartNotePath(note.projectPath);
   try {
-    if (now - statSync3(path).mtimeMs >= ERROR_REPORT_KEEP_MS) {
-      unlinkSync(path);
-    }
-  } catch {}
+    mkdirSync9(dirname12(path), { recursive: true });
+    writeFileSync11(path, `${JSON.stringify(note, null, 2)}
+`, "utf8");
+  } catch (error) {
+    console.error(`[SERVER] Could not record the restart at ${path}: ${errorMessage(error)}`);
+  }
 }
-async function announcedSince(projectPath, before, waiting = {}) {
-  const wanted = resolve4(projectPath);
-  const directories = waiting.directories ?? runtimeDirectories();
-  const until = Date.now() + Math.max(waiting.budgetMs ?? ANNOUNCE_BUDGET_MS, 0);
-  for (;; ) {
-    const fresh = discoverRuntimes(directories).find((endpoint) => !before.has(endpoint.pid) && resolve4(endpoint.project.path) === wanted && (waiting.accept?.(endpoint) ?? true));
-    if (fresh !== undefined) {
-      return fresh;
+function restartOwed(projectPath) {
+  try {
+    const parsed = JSON.parse(readFileSync16(restartNotePath(projectPath), "utf8"));
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
     }
-    const left = until - Date.now();
-    if (left <= 0 || waiting.giveUp?.() === true) {
+    const said = parsed;
+    if (typeof said.quitAt !== "string" || typeof said.byPid !== "number" || typeof said.ports !== "object") {
       return null;
     }
-    await delay2(Math.min(LOOK_EVERY_MS, left));
+    return said;
+  } catch {
+    return null;
   }
 }
-function describe2(endpoint) {
-  return `pid ${endpoint.pid} on ${endpoint.address}:${endpoint.port} (${endpoint.project.name || "unnamed"} at ${endpoint.project.path})`;
-}
-function tooNew(unspoken) {
-  const named = unspoken.map((game) => `pid ${game.pid} speaks ${game.protocol} (${game.project.name || "unnamed"} at ${game.project.path})`).join("; ");
-  const half = unspoken.some((game) => game.protocol > RUNTIME_PROTOCOL) ? "this server is the older half: reconnect it so it spawns the installed version" : "the addon is the older half: reinstall it and restart the game";
-  return `A game is running, in a protocol this server does not speak ${named}. This server speaks ${RUNTIME_PROTOCOL}, so ${half}.`;
-}
-function chooseRuntime(endpoints, projectPath, unspoken = [], pid) {
-  if (pid !== undefined) {
-    const named = endpoints.find((endpoint) => endpoint.pid === pid);
-    if (named !== undefined) {
-      if (projectPath !== undefined && resolve4(named.project.path) !== resolve4(projectPath)) {
-        return {
-          problem: `The game with pid ${pid} is running ${named.project.path}, not ${resolve4(projectPath)}. Running: ${endpoints.map(describe2).join("; ")}.`
-        };
-      }
-      return { endpoint: named };
-    }
-    const tooNewToo = unspoken.find((game) => game.pid === pid);
-    if (tooNewToo !== undefined) {
-      return { problem: tooNew([tooNewToo]) };
-    }
-    return {
-      problem: endpoints.length === 0 ? `No game with the runtime addon is running, so there is none with pid ${pid}. Start one with editor_run, or play the project from the editor with the addon enabled.` : `No running game has pid ${pid}. Running: ${endpoints.map(describe2).join("; ")}. editor_status lists them under runtimes as they come and go.`
-    };
-  }
-  if (endpoints.length === 0) {
-    if (unspoken.length > 0) {
-      return { problem: tooNew(unspoken) };
-    }
-    const went = announcedAndGone(projectPath);
-    const first = went[0];
-    if (first !== undefined) {
-      const ago = Math.max(1, Math.round((Date.now() - first.noticedAt) / 1000));
-      const others = went.length - 1;
-      const earlier = others === 0 ? "" : ` ${others} earlier ${others === 1 ? "one" : "ones"} went the same way.`;
-      return {
-        problem: `A game with the runtime addon announced itself and its process is gone: pid ${first.pid}` + `${first.project === "" ? "" : ` for ${first.project}`}, noticed ${ago}s ago.${earlier}` + " It quit or was ended rather than never starting, so editor_output has what it printed" + " on the way, including whatever it broke on. Start another with editor_run once you have read it."
-      };
-    }
-    return {
-      problem: "No game with the runtime addon is running. Start one with editor_run, or play the project from the editor with the addon enabled."
-    };
-  }
-  if (projectPath !== undefined) {
-    const wanted = resolve4(projectPath);
-    const matching = endpoints.filter((endpoint) => resolve4(endpoint.project.path) === wanted);
-    if (matching.length === 0) {
-      return {
-        problem: `No running game is from ${wanted}. Running: ${endpoints.map(describe2).join("; ")}.`
-      };
-    }
-    if (matching.length === 1 && matching[0]) {
-      return { endpoint: matching[0] };
-    }
-    return {
-      problem: `Several games are running from ${wanted}: ${matching.map(describe2).join("; ")}. Pass pid to choose one.`
-    };
-  }
-  if (endpoints.length === 1 && endpoints[0]) {
-    return { endpoint: endpoints[0] };
+function restartSettled(projectPath) {
+  try {
+    rmSync8(restartNotePath(projectPath), { force: true });
+  } catch (error) {
+    console.error(`[SERVER] Could not clear the restart note: ${errorMessage(error)}`);
   }
-  return {
-    problem: `Several games are running: ${endpoints.map(describe2).join("; ")}. Pass projectPath to choose one, or pid when they are from one project.`
-  };
-}
-function runtimeRequest(endpoint, command, params, timeoutMs) {
-  const id = nextRequestId++;
-  return new Promise((settle) => {
-    let done = false;
-    let buffered = "";
-    let welcomed = false;
-    const socket = createConnection3({ port: endpoint.port, host: endpoint.address });
-    const finish = (reply) => {
-      if (done) {
-        return;
-      }
-      done = true;
-      clearTimeout(timer);
-      socket.destroy();
-      settle(reply);
-    };
-    const timer = setTimeout(() => {
-      finish({
-        ok: false,
-        reason: "busy",
-        message: `The game (${describe2(endpoint)}) accepted the connection but did not answer '${command}' within ${timeoutMs}ms. It may be paused at a breakpoint or stuck in a long frame.`
-      });
-    }, timeoutMs);
-    socket.setEncoding("utf8");
-    socket.on("connect", () => {
-      socket.write(`${JSON.stringify({ id, command, params })}
-`);
-    });
-    socket.on("data", (chunk) => {
-      buffered += chunk;
-      let newline = buffered.indexOf(`
-`);
-      while (newline !== -1 && !done) {
-        const line = buffered.slice(0, newline).trim();
-        buffered = buffered.slice(newline + 1);
-        newline = buffered.indexOf(`
-`);
-        if (line === "") {
-          continue;
-        }
-        let message;
-        try {
-          message = asParams(JSON.parse(line));
-        } catch {
-          continue;
-        }
-        if (!welcomed) {
-          welcomed = true;
-          if (readString(message, "type") === "welcome") {
-            const spoken = readNumber(message, "protocol");
-            if (spoken !== RUNTIME_PROTOCOL) {
-              finish({
-                ok: false,
-                reason: "protocol",
-                message: `The game (${describe2(endpoint)}) speaks runtime protocol ${spoken ?? "unknown"} and this server speaks ${RUNTIME_PROTOCOL}. Reinstall the runtime addon into the project.`
-              });
-              return;
-            }
-            continue;
-          }
-        }
-        if (message["id"] !== id) {
-          continue;
-        }
-        if (readString(message, "type") === "error") {
-          finish({ ok: false, reason: "error", message: readString(message, "message") ?? "unknown error" });
-          return;
-        }
-        finish({ ok: true, payload: message, endpoint });
-      }
-    });
-    socket.on("error", (error) => {
-      finish({
-        ok: false,
-        reason: "refused",
-        message: `The game (${describe2(endpoint)}) is running but nothing answered on its port: ${error.code ?? error.message}. It may still be starting, or be shutting down.`
-      });
-    });
-    socket.on("close", () => {
-      finish({
-        ok: false,
-        reason: "refused",
-        message: `The game (${describe2(endpoint)}) closed the connection before answering '${command}'.`
-      });
-    });
-  });
 }
-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;
+var init_restart_note = __esm(() => {
+  init_errors();
 });
 
 // src/run-record.ts
 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";
+import { mkdirSync as mkdirSync10, openSync, readdirSync as readdirSync6, readFileSync as readFileSync17, rmSync as rmSync9, statSync as statSync4, writeFileSync as writeFileSync12 } from "node:fs";
+import { basename as basename3, join as join19 } from "node:path";
 function runsDirectory() {
-  return join18(runtimeDirectory(), "runs");
+  return join19(runtimeDirectory(), "runs");
 }
 function recordPath() {
-  return join18(runsDirectory(), "run.json");
+  return join19(runsDirectory(), "run.json");
 }
 function recordPaths() {
-  return runtimeDirectories().map((directory) => join18(directory, "runs", "run.json"));
+  return runtimeDirectories().map((directory) => join19(directory, "runs", "run.json"));
 }
 function openTranscript(startedAt) {
-  mkdirSync9(runsDirectory(), { recursive: true });
-  const path = join18(runsDirectory(), `run-${startedAt}.log`);
+  mkdirSync10(runsDirectory(), { recursive: true });
+  const path = join19(runsDirectory(), `run-${startedAt}.log`);
   return { path, fd: openSync(path, "a") };
 }
 function writeRunRecord(record) {
-  mkdirSync9(runsDirectory(), { recursive: true });
-  writeFileSync11(recordPath(), JSON.stringify(record, null, 2), "utf8");
+  mkdirSync10(runsDirectory(), { recursive: true });
+  writeFileSync12(recordPath(), JSON.stringify(record, null, 2), "utf8");
 }
 function editorNotePath() {
-  return join18(runsDirectory(), "editor-run.json");
+  return join19(runsDirectory(), "editor-run.json");
 }
 function writeEditorRunNote(note) {
-  mkdirSync9(runsDirectory(), { recursive: true });
-  writeFileSync11(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
+  mkdirSync10(runsDirectory(), { recursive: true });
+  writeFileSync12(editorNotePath(), JSON.stringify(note, null, 2), "utf8");
 }
 function readEditorRunNote() {
   for (const directory of runtimeDirectories()) {
-    const note = editorNoteAt(join18(directory, "runs", "editor-run.json"));
+    const note = editorNoteAt(join19(directory, "runs", "editor-run.json"));
     if (note !== null) {
       return note;
     }
@@ -37313,7 +37345,7 @@ function readEditorRunNote() {
 function editorNoteAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync16(path, "utf8"));
+    parsed = JSON.parse(readFileSync17(path, "utf8"));
   } catch {
     return null;
   }
@@ -37336,7 +37368,7 @@ function recordRunEnded(pid, exitCode) {
     return;
   }
   try {
-    writeFileSync11(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
+    writeFileSync12(path, JSON.stringify({ ...record, exitCode }, null, 2), "utf8");
   } catch {}
 }
 function readRunRecord() {
@@ -37351,7 +37383,7 @@ function readRunRecord() {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync16(path, "utf8"));
+    parsed = JSON.parse(readFileSync17(path, "utf8"));
   } catch {
     return null;
   }
@@ -37396,7 +37428,7 @@ function runningAs(pid) {
     const began = startedAt(pid, null);
     const when = began === null ? {} : { startedAt: began };
     if (process.platform === "linux") {
-      const raw = readFileSync16(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
+      const raw = readFileSync17(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ").trim();
       return raw === "" ? null : { kind: "commandLine", text: raw, ...when };
     }
     const args = execFileSync2("ps", ["-p", String(pid), "-o", "args="], {
@@ -37547,7 +37579,7 @@ function sweepTranscripts(keepMs = 24 * 60 * 60 * 1000, now = Date.now()) {
     if (!entry.startsWith("run-") || !entry.endsWith(".log")) {
       continue;
     }
-    const path = join18(directory, entry);
+    const path = join19(directory, entry);
     if (path === keep || ageMs(path, now) < keepMs) {
       continue;
     }
@@ -37570,15 +37602,16 @@ import {
   closeSync,
   existsSync as existsSync14,
   fstatSync,
-  mkdirSync as mkdirSync10,
+  mkdirSync as mkdirSync11,
   mkdtempSync as mkdtempSync3,
   openSync as openSync2,
   readdirSync as readdirSync7,
-  readFileSync as readFileSync17,
-  readSync
+  readFileSync as readFileSync18,
+  readSync,
+  statSync as statSync5
 } from "node:fs";
 import { tmpdir as tmpdir5 } from "node:os";
-import { basename as basename4, dirname as dirname12, join as join19, normalize as normalize3, relative as relative3 } from "node:path";
+import { basename as basename4, dirname as dirname13, join as join20, 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";
@@ -37701,10 +37734,11 @@ function runtimeVerdict(endpoint, after) {
     };
   }
   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";
+  const sized = after.sizedToMs === undefined ? "" : `, half as long again as the ${after.sizedToMs}ms its last game took,`;
   return {
     listening: false,
     mayYetAnnounce: after.running,
-    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`,
+    note: after.running ? `nothing announced itself within ${after.budgetMs}ms${sized} 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${sized} and the game is no longer running, so nothing is going to: editor_output has what it printed on the way down`,
     heldAt: null
   };
 }
@@ -37809,7 +37843,7 @@ function aboveTheRunner(entry) {
 }
 function elsewhereIn(projectPath, asked) {
   const wanted = asked.replace(/^res:\/\//, "").replace(/\/+$/, "");
-  if (wanted === "" || existsSync14(join19(projectPath, wanted))) {
+  if (wanted === "" || existsSync14(join20(projectPath, wanted))) {
     return "";
   }
   const root = (wanted.split("/")[0] ?? "").toLowerCase();
@@ -37823,7 +37857,7 @@ function elsewhereIn(projectPath, asked) {
   return near.length === 0 ? "" : ` The project does have ${there}.`;
 }
 function hasMainScene(projectFile) {
-  const scene = parseProjectGodot(readFileSync17(projectFile, "utf8"))["application"]?.["run/main_scene"];
+  const scene = parseProjectGodot(readFileSync18(projectFile, "utf8"))["application"]?.["run/main_scene"];
   return typeof scene === "string" && scene !== "";
 }
 function runtimeAddonAnnouncesEditors(projectPath) {
@@ -37831,13 +37865,13 @@ function runtimeAddonAnnouncesEditors(projectPath) {
     return false;
   }
   try {
-    return readFileSync17(join19(projectPath, RUNTIME_AUTOLOAD2.path), "utf8").includes('"editor_pid"');
+    return readFileSync18(join20(projectPath, RUNTIME_AUTOLOAD2.path), "utf8").includes('"editor_pid"');
   } catch {
     return false;
   }
 }
 function editorPlaysHeadless(projectFile) {
-  const runArgs = parseProjectGodot(readFileSync17(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
+  const runArgs = parseProjectGodot(readFileSync18(projectFile, "utf8"))["editor"]?.["run/main_run_args"];
   return typeof runArgs === "string" && /(?:^|\s)--headless(?:\s|$)/.test(runArgs);
 }
 function camelCased(params) {
@@ -37853,7 +37887,7 @@ function camelCased(params) {
 class GodotServer {
   mcp;
   locator = new GodotLocator2;
-  operationsScript = join19(__dirname2, "godot", "operations", "godot_operations.gd");
+  operationsScript = join20(__dirname2, "godot", "operations", "godot_operations.gd");
   godotBridge;
   tools = buildToolDefinitions();
   activeProcess = null;
@@ -38511,7 +38545,7 @@ class GodotServer {
     if (path === undefined) {
       return { ok: false, response: this.createErrorResponse("projectPath is required.") };
     }
-    const file = join19(path, "project.godot");
+    const file = join20(path, "project.godot");
     if (!existsSync14(file)) {
       return {
         ok: false,
@@ -38735,7 +38769,7 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const application = parseProjectGodot(readFileSync17(project.value.file, "utf8"))["application"] ?? {};
+    const application = parseProjectGodot(readFileSync18(project.value.file, "utf8"))["application"] ?? {};
     const name = application["config/name"];
     const mainScene = application["run/main_scene"];
     const info = {
@@ -38796,18 +38830,18 @@ class GodotServer {
     if (!engine.ok) {
       return engine.response;
     }
-    const folder = dirname12(output.absolutePath);
+    const folder = dirname13(output.absolutePath);
     try {
-      mkdirSync10(folder, { recursive: true });
+      mkdirSync11(folder, { recursive: true });
     } catch (error) {
-      return this.createErrorResponse(`Cannot create ${dirname12(output.relativePath)} to export into: ${errorMessage(error)}`);
+      return this.createErrorResponse(`Cannot create ${dirname13(output.relativePath)} to export into: ${errorMessage(error)}`);
     }
     const debug = readBoolean(args, "debug") ?? false;
-    const exportLogs = mkdtempSync3(join19(tmpdir5(), "gdharness-export-"));
+    const exportLogs = mkdtempSync3(join20(tmpdir5(), "gdharness-export-"));
     const exportArgs = [
       "--headless",
       "--log-file",
-      join19(exportLogs, "engine.log"),
+      join20(exportLogs, "engine.log"),
       "--path",
       project.value.path,
       debug ? "--export-debug" : "--export-release",
@@ -38865,7 +38899,7 @@ class GodotServer {
       return contained.response;
     }
     const runner = "addons/gdUnit4/bin/GdUnitCmdTool.gd";
-    if (!existsSync14(join19(project.value.path, runner))) {
+    if (!existsSync14(join20(project.value.path, runner))) {
       return this.createErrorResponse(`gdUnit4 is not installed in this project: no ${runner}.`, [
         "Install gdUnit4 under addons/gdUnit4, from https://github.com/godot-gdunit-labs/gdUnit4"
       ]);
@@ -38900,7 +38934,7 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const userData = mkdtempSync3(join19(tmpdir5(), "gdharness-tests-"));
+    const userData = mkdtempSync3(join20(tmpdir5(), "gdharness-tests-"));
     const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
@@ -38916,14 +38950,14 @@ class GodotServer {
         resolve(false);
       });
     });
-    const reportsDir = join19(project.value.path, ".godot", ...ours.split("/"));
+    const reportsDir = join20(project.value.path, ".godot", ...ours.split("/"));
     let report = null;
     let reportProblem = null;
     try {
       const written = existsSync14(reportsDir) ? readdirSync7(reportsDir).filter((name) => name.startsWith("report_")).sort((a, b) => Number(a.slice("report_".length)) - Number(b.slice("report_".length))) : [];
       const newest = written.at(-1);
       if (newest !== undefined) {
-        report = parseJUnit(readFileSync17(join19(reportsDir, newest, "results.xml"), "utf8"));
+        report = parseJUnit(readFileSync18(join20(reportsDir, newest, "results.xml"), "utf8"));
       }
     } catch (error) {
       reportProblem = errorMessage(error);
@@ -39063,7 +39097,7 @@ class GodotServer {
         return null;
       }
       try {
-        return readFileSync17(contained.absolutePath, "utf8");
+        return readFileSync18(contained.absolutePath, "utf8");
       } catch {
         return null;
       }
@@ -39105,7 +39139,7 @@ class GodotServer {
       return null;
     }
     try {
-      return readFileSync17(contained.absolutePath, "utf8");
+      return readFileSync18(contained.absolutePath, "utf8");
     } catch {
       return null;
     }
@@ -39334,7 +39368,7 @@ class GodotServer {
       return null;
     }
     try {
-      return settingKeys(readFileSync17(join19(projectPath, "project.godot"), "utf8"));
+      return settingKeys(readFileSync18(join20(projectPath, "project.godot"), "utf8"));
     } catch {
       return null;
     }
@@ -39541,7 +39575,7 @@ class GodotServer {
       platform: process.platform,
       variables: process.env
     });
-    const runtimeWaitMs = readNonNegativeNumber(args, "runtimeWaitMs") ?? ANNOUNCE_BUDGET_MS;
+    const runtimeWaitMs = this.announceBudget(args, project.value.path);
     const editorWouldPlay = !headless || editorPlaysHeadless(project.value.file);
     if (this.godotBridge.isConnected() && editorWouldPlay && given.value.length === 0) {
       return await this.playThroughEditor(sceneArgument, refreshed.value, project.value.path, alreadyPlaying, runtimeWaitMs, ended);
@@ -39574,8 +39608,9 @@ class GodotServer {
       message: `Use editor_output for what it prints and editor_run stop to end it.${spawnedInstead}${endedForThis}${alsoRunning}`
     });
   }
-  async runtimeUp(projectPath, before, budgetMs, withArgs) {
-    if (!existsSync14(join19(projectPath, RUNTIME_AUTOLOAD2.path))) {
+  async runtimeUp(projectPath, before, budget, withArgs) {
+    const budgetMs = budget.ms;
+    if (!existsSync14(join20(projectPath, RUNTIME_AUTOLOAD2.path))) {
       return runtimeVerdict(null, { addon: false, budgetMs, heldAt: null, running: false, withArgs });
     }
     let asking = null;
@@ -39610,17 +39645,43 @@ class GodotServer {
     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;
+      this.tie(going, endpoint);
     }
     return runtimeVerdict(endpoint, {
       addon: true,
       budgetMs,
+      ...budget.sizedToMs === undefined ? {} : { sizedToMs: budget.sizedToMs },
       heldAt: this.dapClient?.whereItStopped() ?? null,
       running: endpoint !== null || going !== null && await this.runStillGoing(going),
       withArgs,
       ...going?.throughEditor === true ? { playingSeen: going.seenPlaying === true } : {}
     });
   }
+  announceBudget(args, projectPath) {
+    const asked = readNonNegativeNumber(args, "runtimeWaitMs");
+    if (asked !== undefined) {
+      return { ms: asked };
+    }
+    const lastBoot = readBootNote(projectPath);
+    const ms = waitSizedTo(lastBoot);
+    return lastBoot !== null && ms > ANNOUNCE_BUDGET_MS ? { ms, sizedToMs: lastBoot } : { ms };
+  }
+  noteBootOf(run, endpoint) {
+    if (run.projectPath === null) {
+      return;
+    }
+    let announcedAt;
+    try {
+      announcedAt = statSync5(endpoint.file).mtimeMs;
+    } catch {
+      return;
+    }
+    const took = announcedAt - run.startedAt;
+    this.logDebug(`boot of pid ${endpoint.pid} announced ${Math.round(took)}ms after the start of ${run.projectPath}`);
+    if (took > 0 && took <= LONGEST_BOOT_NOTED_MS) {
+      writeBootNote(run.projectPath, took);
+    }
+  }
   async playThroughEditor(scene, refreshedClasses, projectPath, alreadyPlaying, runtimeWaitMs, ended) {
     const log = new GameLog;
     try {
@@ -39941,15 +40002,16 @@ class GodotServer {
       return run.announcedPid;
     }
     const ours = this.announcedOfTheRunsProject(run, announced ?? runtimesAnnounced().running);
-    if (run.pid !== null && ours.some((one) => one.pid === run.pid)) {
-      run.announcedPid = run.pid;
+    const own = ours.find((one) => one.pid === run.pid);
+    if (own !== undefined) {
+      this.tie(run, own);
       return run.announcedPid;
     }
     const before = run.announcedBefore ?? new Set;
     const candidates = ours.filter((one) => !before.has(one.pid) && this.isTheGameOf(run, one, run.projectPath));
     const theOne = candidates.length === 1 ? candidates[0] : undefined;
     if (theOne !== undefined) {
-      run.announcedPid = theOne.pid;
+      this.tie(run, theOne);
     }
     return run.announcedPid;
   }
@@ -39987,7 +40049,7 @@ class GodotServer {
     if (tree === undefined) {
       return;
     }
-    return this.tieThroughTheTree(run, tree, new Set(ours.map((one) => one.pid)));
+    return this.tieThroughTheTree(run, tree, ours);
   }
   async gameProcessOf(run) {
     if (run.gamePid !== undefined) {
@@ -40008,21 +40070,28 @@ class GodotServer {
     }
     return found;
   }
-  tieThroughTheTree(run, tree, games) {
+  tieThroughTheTree(run, tree, announced) {
     const root = run.pid ?? (run.throughEditor ? this.godotBridge.getStatus().editorPid : undefined);
     if (root === undefined) {
       return;
     }
-    if (games.has(root)) {
-      run.announcedPid = root;
-      return root;
+    const games = new Set(announced.map((one) => one.pid));
+    const own = announced.find((one) => one.pid === root);
+    if (own !== undefined) {
+      this.tie(run, own);
+      return own.pid;
     }
-    const nearest = descendantsIn(tree, root).filter((one) => games.has(one) && !gameBetween(tree, one, root, games));
+    const under = new Set(descendantsIn(tree, root));
+    const nearest = announced.filter((one) => under.has(one.pid) && !gameBetween(tree, one.pid, root, games));
     const theOne = nearest.length === 1 ? nearest[0] : undefined;
     if (theOne !== undefined) {
-      run.announcedPid = theOne;
+      this.tie(run, theOne);
     }
-    return theOne;
+    return theOne?.pid;
+  }
+  tie(run, endpoint) {
+    run.announcedPid = endpoint.pid;
+    this.noteBootOf(run, endpoint);
   }
   playedByOurEditor(endpoint, projectPath) {
     const editor = this.godotBridge.getStatus().editorPid;
@@ -40323,7 +40392,7 @@ class GodotServer {
     }
     const announced = this.announcedOfTheRunsProject(run, runtimesAnnounced().running);
     const games = new Set(announced.map((one) => one.pid));
-    const own = this.announcedPidOf(run, announced) ?? this.tieThroughTheTree(run, tree, games) ?? run.gamePid ?? this.gameByCommandLineIn(run, tree);
+    const own = this.announcedPidOf(run, announced) ?? this.tieThroughTheTree(run, tree, announced) ?? run.gamePid ?? this.gameByCommandLineIn(run, tree);
     if (own !== undefined && run.announcedPid === undefined) {
       run.gamePid = own;
     }
@@ -40618,8 +40687,8 @@ class GodotServer {
       ]);
     }
     const expectsScreenshot = command === "capture_screenshot" || command === "capture_viewport";
-    const screenshotDir = expectsScreenshot ? mkdtempSync3(join19(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
-    const screenshotPath = screenshotDir ? join19(screenshotDir, "capture.png") : null;
+    const screenshotDir = expectsScreenshot ? mkdtempSync3(join20(tmpdir5(), "gdharness-runtime-screenshot-")) : null;
+    const screenshotPath = screenshotDir ? join20(screenshotDir, "capture.png") : null;
     try {
       const reply = await runtimeRequest(choice.endpoint, command, screenshotPath ? { ...params, output_path: screenshotPath } : params, timeoutMs);
       if (!reply.ok) {
@@ -40643,7 +40712,7 @@ class GodotServer {
             type: "text",
             text: `Screenshot captured: ${dimensions}${chosenAmongSeveral ? ` from pid ${own}, the game this server holds` : ""}`
           },
-          { type: "image", data: readFileSync17(screenshotPath).toString("base64"), mimeType: "image/png" }
+          { type: "image", data: readFileSync18(screenshotPath).toString("base64"), mimeType: "image/png" }
         ]
       };
     } finally {
@@ -40710,11 +40779,12 @@ 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, 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 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, LONGEST_BOOT_NOTED_MS, 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();
   init_types();
+  init_boot_note();
   init_breakpoint_note();
   init_bridge_announce();
   init_class_cache();
@@ -40744,8 +40814,9 @@ var init_server3 = __esm(() => {
   init_tool_definitions();
   init_update_check();
   run7 = promisify7(execFile7);
-  __dirname2 = dirname12(fileURLToPath4(import.meta.url));
+  __dirname2 = dirname13(fileURLToPath4(import.meta.url));
   CONSOLE_WRAPPER = /_console(\.exe)?$/i;
+  LONGEST_BOOT_NOTED_MS = 5 * 60000;
   VALUE_NAMES = {
     string: "a string",
     number: "a number",
@@ -40784,7 +40855,7 @@ var init_server3 = __esm(() => {
 
 // src/cli.ts
 import { existsSync as existsSync15 } from "fs";
-import { join as join20, resolve as resolve5 } from "path";
+import { join as join21, resolve as resolve5 } from "path";
 
 // src/errors.ts
 class Refusal extends Error {
@@ -42489,7 +42560,7 @@ class UsageError extends Refusal {
 function projectArgument(at) {
   const named = args.slice(at).find((value) => !value.startsWith("--"));
   const projectPath = resolve5(named ?? ".");
-  if (!existsSync15(join20(projectPath, "project.godot"))) {
+  if (!existsSync15(join21(projectPath, "project.godot"))) {
     throw new UsageError(`Not a Godot project: ${projectPath} holds no project.godot.`);
   }
   return projectPath;
@@ -42528,7 +42599,7 @@ async function registerRuntime(godot, projectPath) {
     return;
   }
   console.log(`${RUNTIME_AUTOLOAD.name} autoload left at ${named}, which this project registers itself`);
-  if (!existsSync15(join20(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
+  if (!existsSync15(join21(projectPath, (named ?? "").replace(/^res:\/\//, "")))) {
     console.log(`  that file is not in this project, so it boots with a missing script: restore it, or point the entry at res://${RUNTIME_AUTOLOAD.path}`);
   }
 }