gdharness 0.5.0 → 0.5.2

package/build/cli.js

@@ -160,6 +160,19 @@ function runArguments(options) {
 function editorArguments(projectPath) {
   return ["-e", "--path", projectPath];
 }
+function userDataIn(home, variables = process.env) {
+  const moved = ["APPDATA", "XDG_DATA_HOME"];
+  const carried = {};
+  for (const [name, value] of Object.entries(variables)) {
+    if (!moved.some((named) => named.toLowerCase() === name.toLowerCase())) {
+      carried[name] = value;
+    }
+  }
+  for (const named of moved) {
+    carried[named] = home;
+  }
+  return carried;
+}
 
 // node_modules/yaml/dist/nodes/identity.js
 var require_identity = __commonJS(function(exports) {
@@ -7228,15 +7241,196 @@ var init_game_log = __esm(() => {
   COLOUR_CODE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g");
 });
 
+// src/update-check.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { homedir as homedir3, tmpdir as tmpdir2 } from "node:os";
+import { join as join4 } from "node:path";
+function cacheDirectory(environment) {
+  const set = (name) => {
+    const value = environment[name];
+    return value !== undefined && value !== "" ? value : null;
+  };
+  const home = set("HOME") ?? homedir3();
+  if (process.platform === "win32") {
+    return join4(set("LOCALAPPDATA") ?? home, "gdharness");
+  }
+  if (process.platform === "darwin") {
+    return join4(home, "Library", "Caches", "gdharness");
+  }
+  return join4(set("XDG_CACHE_HOME") ?? join4(home, ".cache"), "gdharness");
+}
+function cacheFile(environment = process.env) {
+  try {
+    const directory = cacheDirectory(environment);
+    mkdirSync2(directory, { recursive: true, mode: 448 });
+    return join4(directory, "update-check.json");
+  } catch {
+    return join4(tmpdir2(), "gdharness-update-check.json");
+  }
+}
+function readCache(path) {
+  try {
+    if (!existsSync4(path)) {
+      return null;
+    }
+    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
+    }
+    const record = parsed;
+    const checkedAt = record["checkedAt"];
+    const latest = record["latest"];
+    if (typeof checkedAt !== "number" || typeof latest !== "string" || !VERSION.test(latest)) {
+      return null;
+    }
+    return { checkedAt, latest };
+  } catch {
+    return null;
+  }
+}
+function writeCache(path, entry) {
+  try {
+    writeFileSync3(path, JSON.stringify(entry), { encoding: "utf8", mode: 384 });
+  } catch {}
+}
+function parts(version) {
+  const withoutBuild = version.split("+")[0] ?? version;
+  const dash = withoutBuild.indexOf("-");
+  const numeric = dash === -1 ? withoutBuild : withoutBuild.slice(0, dash);
+  return {
+    numbers: numeric.split(".").map((piece) => Number.parseInt(piece, 10) || 0),
+    prerelease: dash !== -1
+  };
+}
+function isNewer(candidate, current) {
+  const left = parts(candidate);
+  const right = parts(current);
+  for (let index = 0;index < 3; index += 1) {
+    const a = left.numbers[index] ?? 0;
+    const b = right.numbers[index] ?? 0;
+    if (a !== b) {
+      return a > b;
+    }
+  }
+  return !left.prerelease && right.prerelease;
+}
+async function fetchLatest() {
+  const response = await fetch(REGISTRY, {
+    headers: { accept: "application/vnd.npm.install-v1+json, application/json" },
+    redirect: "error",
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+  });
+  if (!response.ok || response.body === null) {
+    return null;
+  }
+  const declared = Number.parseInt(response.headers.get("content-length") ?? "", 10);
+  if (Number.isFinite(declared) && declared > MAX_BODY_BYTES) {
+    return null;
+  }
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of response.body) {
+    size += chunk.byteLength;
+    if (size > MAX_BODY_BYTES) {
+      return null;
+    }
+    chunks.push(chunk);
+  }
+  const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  if (typeof parsed !== "object" || parsed === null) {
+    return null;
+  }
+  const version = parsed["version"];
+  return typeof version === "string" && VERSION.test(version) ? version : null;
+}
+
+class UpdateCheck {
+  latest = null;
+  checking = false;
+  checkedAt = 0;
+  retryAt = 0;
+  backoffMs = FIRST_RETRY_MS;
+  enabled;
+  current;
+  cachePath;
+  constructor(current, environment = process.env) {
+    this.current = current;
+    this.enabled = (environment["GDHARNESS_NO_UPDATE_CHECK"] ?? "") === "";
+    this.cachePath = cacheFile(environment);
+    const cached = this.enabled ? readCache(this.cachePath) : null;
+    if (cached !== null) {
+      this.latest = cached.latest;
+      this.checkedAt = cached.checkedAt;
+    }
+  }
+  refresh(now = Date.now()) {
+    if (!this.enabled || this.checking || now < this.retryAt || now - this.checkedAt < CACHE_MS) {
+      return;
+    }
+    this.checking = true;
+    fetchLatest().then((version) => {
+      if (version === null) {
+        this.scheduleRetry(now);
+        return;
+      }
+      this.latest = version;
+      this.checkedAt = Date.now();
+      this.backoffMs = FIRST_RETRY_MS;
+      this.retryAt = 0;
+      writeCache(this.cachePath, { checkedAt: this.checkedAt, latest: version });
+    }).catch(() => {
+      this.scheduleRetry(now);
+    }).finally(() => {
+      this.checking = false;
+    });
+  }
+  scheduleRetry(now) {
+    this.retryAt = now + this.backoffMs;
+    this.backoffMs = Math.min(this.backoffMs * 2, MAX_RETRY_MS);
+  }
+  notice() {
+    const latest = this.latest;
+    if (!this.enabled || latest === null || !isNewer(latest, this.current)) {
+      return null;
+    }
+    return {
+      current: this.current,
+      latest,
+      releaseNotes: `${RELEASES}/v${latest}`,
+      upgrade: runLine(currentRunner(), latest, "upgrade")
+    };
+  }
+}
+var REGISTRY = "https://registry.npmjs.org/gdharness/latest", RELEASES = "https://github.com/Aureliolo/gdharness/releases/tag", CACHE_MS, REQUEST_TIMEOUT_MS = 1e4, MAX_BODY_BYTES, FIRST_RETRY_MS = 30000, MAX_RETRY_MS, VERSION;
+var init_update_check = __esm(() => {
+  CACHE_MS = 4 * 60 * 60 * 1000;
+  MAX_BODY_BYTES = 1 << 20;
+  MAX_RETRY_MS = 60 * 60 * 1000;
+  VERSION = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+});
+
 // src/server-version.ts
-import { readFileSync as readFileSync2 } from "node:fs";
-var DEBUG_MODE, GODOT_DEBUG_MODE_DEFAULT, SERVER_VERSION;
+import { readFileSync as readFileSync3 } from "node:fs";
+function addonMismatch(addonVersion, serverVersion) {
+  if (addonVersion === serverVersion) {
+    return;
+  }
+  const reported = addonVersion ?? "";
+  const editor = reported === "" ? UNVERSIONED : reported;
+  const both = `The editor is running the ${editor} addon while this server ships ${serverVersion}.`;
+  if (reported !== "" && isNewer(reported, serverVersion)) {
+    return `${both} This server is the older half: reconnect it in your harness so it spawns ${reported}.`;
+  }
+  return `${both} Restart it with editor_launch restart to pick the new one up.`;
+}
+var DEBUG_MODE, GODOT_DEBUG_MODE_DEFAULT, SERVER_VERSION, UNVERSIONED = "addon from before versions were reported";
 var init_server_version = __esm(() => {
+  init_update_check();
   DEBUG_MODE = process.env["DEBUG"] === "true";
   GODOT_DEBUG_MODE_DEFAULT = process.env["GODOT_DEBUG"] === "true" || DEBUG_MODE;
   SERVER_VERSION = (() => {
     try {
-      const pkg = JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf8"));
+      const pkg = JSON.parse(readFileSync3(new URL("../package.json", import.meta.url), "utf8"));
       return typeof pkg.version === "string" ? pkg.version : "0.0.0";
     } catch {
       return "0.0.0";
@@ -7245,8 +7439,8 @@ var init_server_version = __esm(() => {
 });
 
 // src/class-cache.ts
-import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "node:fs";
+import { join as join5 } from "node:path";
 function declaredClasses(projectPath) {
   const declared = new Map;
   const visit = (directory, prefix) => {
@@ -7254,11 +7448,11 @@ function declaredClasses(projectPath) {
       if (entry.name.startsWith(".")) {
         continue;
       }
-      const path = join4(directory, entry.name);
+      const path = join5(directory, entry.name);
       if (entry.isDirectory()) {
         visit(path, `${prefix}${entry.name}/`);
       } else if (entry.isFile() && entry.name.endsWith(".gd")) {
-        const found = /^class_name\s+([A-Za-z_][A-Za-z0-9_]*)/m.exec(readFileSync4(path, "utf8"));
+        const found = /^class_name\s+([A-Za-z_][A-Za-z0-9_]*)/m.exec(readFileSync5(path, "utf8"));
         if (found?.[1]) {
           declared.set(found[1], `res://${prefix}${entry.name}`);
         }
@@ -7269,12 +7463,12 @@ function declaredClasses(projectPath) {
   return declared;
 }
 function cachedClasses(projectPath) {
-  const cache = join4(projectPath, ".godot", "global_script_class_cache.cfg");
-  if (!existsSync4(cache)) {
+  const cache = join5(projectPath, ".godot", "global_script_class_cache.cfg");
+  if (!existsSync5(cache)) {
     return null;
   }
   const listed = new Map;
-  const text = readFileSync4(cache, "utf8");
+  const text = readFileSync5(cache, "utf8");
   for (const entry of text.matchAll(/"class":\s*&"([^"]+)"[\s\S]*?"path":\s*"([^"]+)"/g)) {
     listed.set(entry[1] ?? "", entry[2] ?? "");
   }
@@ -7291,9 +7485,9 @@ var init_class_cache = () => {};
 
 // src/headless.ts
 import { execFile as execFile3 } from "node:child_process";
-import { mkdtempSync as mkdtempSync2, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { mkdtempSync as mkdtempSync2, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join6 } from "node:path";
 import { promisify as promisify3 } from "node:util";
 function snakeCased2(params) {
   const result = emptyRecord();
@@ -7333,9 +7527,9 @@ function reason2(stdout, stderr) {
   return stdout.trim().split(/\r?\n/).at(-1) ?? "no output at all";
 }
 async function runOperation2(engine, operation, params, projectPath) {
-  const paramsDir = mkdtempSync2(join5(tmpdir2(), "gdharness-params-"));
-  const paramsFile = join5(paramsDir, `${operation}.json`);
-  writeFileSync3(paramsFile, JSON.stringify(snakeCased2(params)), "utf8");
+  const paramsDir = mkdtempSync2(join6(tmpdir3(), "gdharness-params-"));
+  const paramsFile = join6(paramsDir, `${operation}.json`);
+  writeFileSync4(paramsFile, JSON.stringify(snakeCased2(params)), "utf8");
   const args = [
     "--headless",
     "--path",
@@ -14537,7 +14731,7 @@ var init_paths = __esm(() => {
 });
 
 // src/resources.ts
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync6 } from "node:fs";
 import { extname, resolve as resolve2 } from "node:path";
 function ensureProjectPath(getProjectPath) {
   const projectPath = getProjectPath();
@@ -14679,7 +14873,7 @@ function readResourceText(uri, getProjectPath) {
   const parsedUri = parseGodotUri(uri);
   if (parsedUri.kind === "project-info") {
     const projectFilePath = resolveProjectFile(projectPath, "project.godot");
-    const rawProject = readFileSync5(projectFilePath, "utf-8");
+    const rawProject = readFileSync6(projectFilePath, "utf-8");
     const parsedProject = parseProjectGodot(rawProject);
     return {
       mimeType: "application/json",
@@ -14688,7 +14882,7 @@ function readResourceText(uri, getProjectPath) {
   }
   const filePath = resolveProjectFile(projectPath, parsedUri.resourcePath);
   ensureAllowedExtension(parsedUri.kind, filePath);
-  const text = readFileSync5(filePath, "utf-8");
+  const text = readFileSync6(filePath, "utf-8");
   return {
     mimeType: parsedUri.kind === "script" ? "text/x-gdscript" : "text/plain",
     text
@@ -15157,7 +15351,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "project_test",
-      description: "Runs the project's gdUnit4 tests headless and answers with every case: which failed, where, and what the assertion said. The class list is rebuilt first, so a suite written a moment ago is found. Needs gdUnit4 under addons/gdUnit4.",
+      description: "Runs the project's gdUnit4 tests headless and answers with every case: which failed, where, and what the assertion said. The class list is rebuilt first, so a suite written a moment ago is found. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. Needs gdUnit4 under addons/gdUnit4.",
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
@@ -34297,7 +34491,7 @@ var init_godot_bridge = __esm(() => {
 
 // src/godot-path.ts
 import { execFile as execFile4 } from "node:child_process";
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import { normalize as normalize2 } from "node:path";
 import { promisify as promisify4 } from "node:util";
 var run4, GodotLocator2;
@@ -34339,7 +34533,7 @@ var init_godot_path = __esm(() => {
         return known;
       }
       let ok = false;
-      if (path === "godot" || existsSync7(path)) {
+      if (path === "godot" || existsSync8(path)) {
         try {
           await run4(path, ["--version"]);
           ok = true;
@@ -35142,8 +35336,8 @@ var init_lsp_client = __esm(() => {
 });
 
 // src/project-scan.ts
-import { readdirSync as readdirSync4, readFileSync as readFileSync8 } from "node:fs";
-import { join as join9 } from "node:path";
+import { readdirSync as readdirSync4, readFileSync as readFileSync9 } from "node:fs";
+import { join as join10 } from "node:path";
 function projectStructure(projectPath) {
   const structure = { scenes: 0, scripts: 0, assets: 0, other: 0 };
   const visit = (directory) => {
@@ -35152,7 +35346,7 @@ function projectStructure(projectPath) {
         continue;
       }
       if (entry.isDirectory()) {
-        visit(join9(directory, entry.name));
+        visit(join10(directory, entry.name));
       } else if (entry.isFile()) {
         const extension = entry.name.split(".").pop()?.toLowerCase() ?? "";
         if (extension === "tscn") {
@@ -35194,7 +35388,7 @@ function searchProject(projectPath, options) {
       if (SKIPPED.has(entry.name)) {
         continue;
       }
-      const entryPath = join9(directory, entry.name);
+      const entryPath = join10(directory, entry.name);
       if (entry.isDirectory()) {
         visit(entryPath);
         continue;
@@ -35205,7 +35399,7 @@ function searchProject(projectPath, options) {
       }
       result.summary.files_searched += 1;
       const matches = [];
-      for (const [index, line] of readFileSync8(entryPath, "utf8").split(`
+      for (const [index, line] of readFileSync9(entryPath, "utf8").split(`
 `).entries()) {
         if (full()) {
           break;
@@ -35233,17 +35427,25 @@ var init_project_scan = __esm(() => {
 });
 
 // src/runtime-client.ts
-import { existsSync as existsSync8, readdirSync as readdirSync5, readFileSync as readFileSync9, unlinkSync } from "node:fs";
+import { existsSync as existsSync9, readdirSync as readdirSync5, readFileSync as readFileSync10, 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 { tmpdir as tmpdir4 } from "node:os";
+import { join as join11, resolve as resolve4 } from "node:path";
 function runtimeDirectory(variables = process.env) {
   const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
   if (explicit) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join10(perUser ?? tmpdir3(), "gdharness");
+  return join11(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(join11(base, process.platform === "win32" ? "Temp" : "", "gdharness"));
+  }
+  return [...new Set(candidates.map((path) => resolve4(path)))];
 }
 function processAlive(pid) {
   try {
@@ -35256,7 +35458,7 @@ function processAlive(pid) {
 function parseAnnouncement(file, pid) {
   let fields;
   try {
-    fields = asParams(JSON.parse(readFileSync9(file, "utf8")));
+    fields = asParams(JSON.parse(readFileSync10(file, "utf8")));
   } catch {
     return null;
   }
@@ -35274,8 +35476,19 @@ function parseAnnouncement(file, pid) {
     file
   };
 }
-function discoverRuntimes(directory = runtimeDirectory()) {
-  if (!existsSync8(directory)) {
+function discoverRuntimes(directories = runtimeDirectories()) {
+  const found = new Map;
+  for (const directory of directories) {
+    for (const endpoint of announcedIn(directory)) {
+      if (!found.has(endpoint.pid)) {
+        found.set(endpoint.pid, endpoint);
+      }
+    }
+  }
+  return [...found.values()].sort((a, b) => b.pid - a.pid);
+}
+function announcedIn(directory) {
+  if (!existsSync9(directory)) {
     return [];
   }
   const found = [];
@@ -35284,7 +35497,7 @@ function discoverRuntimes(directory = runtimeDirectory()) {
     if (!match) {
       continue;
     }
-    const file = join10(directory, entry);
+    const file = join11(directory, entry);
     const pid = Number.parseInt(match[1] ?? "", 10);
     const endpoint = processAlive(pid) ? parseAnnouncement(file, pid) : null;
     if (endpoint) {
@@ -35295,7 +35508,7 @@ function discoverRuntimes(directory = runtimeDirectory()) {
       } catch {}
     }
   }
-  return found.sort((a, b) => b.pid - a.pid);
+  return found;
 }
 function describe2(endpoint) {
   return `pid ${endpoint.pid} on ${endpoint.address}:${endpoint.port} (${endpoint.project.name || "unnamed"} at ${endpoint.project.path})`;
@@ -35420,174 +35633,6 @@ var init_runtime_client = __esm(() => {
   ANNOUNCEMENT_PATTERN = /^runtime-(\d+)\.json$/;
 });
 
-// src/update-check.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "node:fs";
-import { homedir as homedir3, tmpdir as tmpdir4 } from "node:os";
-import { join as join11 } from "node:path";
-function cacheDirectory(environment) {
-  const set = (name) => {
-    const value = environment[name];
-    return value !== undefined && value !== "" ? value : null;
-  };
-  const home = set("HOME") ?? homedir3();
-  if (process.platform === "win32") {
-    return join11(set("LOCALAPPDATA") ?? home, "gdharness");
-  }
-  if (process.platform === "darwin") {
-    return join11(home, "Library", "Caches", "gdharness");
-  }
-  return join11(set("XDG_CACHE_HOME") ?? join11(home, ".cache"), "gdharness");
-}
-function cacheFile(environment = process.env) {
-  try {
-    const directory = cacheDirectory(environment);
-    mkdirSync4(directory, { recursive: true, mode: 448 });
-    return join11(directory, "update-check.json");
-  } catch {
-    return join11(tmpdir4(), "gdharness-update-check.json");
-  }
-}
-function readCache(path) {
-  try {
-    if (!existsSync9(path)) {
-      return null;
-    }
-    const parsed = JSON.parse(readFileSync10(path, "utf8"));
-    if (typeof parsed !== "object" || parsed === null) {
-      return null;
-    }
-    const record = parsed;
-    const checkedAt = record["checkedAt"];
-    const latest = record["latest"];
-    if (typeof checkedAt !== "number" || typeof latest !== "string" || !VERSION.test(latest)) {
-      return null;
-    }
-    return { checkedAt, latest };
-  } catch {
-    return null;
-  }
-}
-function writeCache(path, entry) {
-  try {
-    writeFileSync6(path, JSON.stringify(entry), { encoding: "utf8", mode: 384 });
-  } catch {}
-}
-function parts(version) {
-  const withoutBuild = version.split("+")[0] ?? version;
-  const dash = withoutBuild.indexOf("-");
-  const numeric = dash === -1 ? withoutBuild : withoutBuild.slice(0, dash);
-  return {
-    numbers: numeric.split(".").map((piece) => Number.parseInt(piece, 10) || 0),
-    prerelease: dash !== -1
-  };
-}
-function isNewer(candidate, current) {
-  const left = parts(candidate);
-  const right = parts(current);
-  for (let index = 0;index < 3; index += 1) {
-    const a = left.numbers[index] ?? 0;
-    const b = right.numbers[index] ?? 0;
-    if (a !== b) {
-      return a > b;
-    }
-  }
-  return !left.prerelease && right.prerelease;
-}
-async function fetchLatest() {
-  const response = await fetch(REGISTRY, {
-    headers: { accept: "application/vnd.npm.install-v1+json, application/json" },
-    redirect: "error",
-    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
-  });
-  if (!response.ok || response.body === null) {
-    return null;
-  }
-  const declared = Number.parseInt(response.headers.get("content-length") ?? "", 10);
-  if (Number.isFinite(declared) && declared > MAX_BODY_BYTES) {
-    return null;
-  }
-  const chunks = [];
-  let size = 0;
-  for await (const chunk of response.body) {
-    size += chunk.byteLength;
-    if (size > MAX_BODY_BYTES) {
-      return null;
-    }
-    chunks.push(chunk);
-  }
-  const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-  if (typeof parsed !== "object" || parsed === null) {
-    return null;
-  }
-  const version = parsed["version"];
-  return typeof version === "string" && VERSION.test(version) ? version : null;
-}
-
-class UpdateCheck {
-  latest = null;
-  checking = false;
-  checkedAt = 0;
-  retryAt = 0;
-  backoffMs = FIRST_RETRY_MS;
-  enabled;
-  current;
-  cachePath;
-  constructor(current, environment = process.env) {
-    this.current = current;
-    this.enabled = (environment["GDHARNESS_NO_UPDATE_CHECK"] ?? "") === "";
-    this.cachePath = cacheFile(environment);
-    const cached = this.enabled ? readCache(this.cachePath) : null;
-    if (cached !== null) {
-      this.latest = cached.latest;
-      this.checkedAt = cached.checkedAt;
-    }
-  }
-  refresh(now = Date.now()) {
-    if (!this.enabled || this.checking || now < this.retryAt || now - this.checkedAt < CACHE_MS) {
-      return;
-    }
-    this.checking = true;
-    fetchLatest().then((version) => {
-      if (version === null) {
-        this.scheduleRetry(now);
-        return;
-      }
-      this.latest = version;
-      this.checkedAt = Date.now();
-      this.backoffMs = FIRST_RETRY_MS;
-      this.retryAt = 0;
-      writeCache(this.cachePath, { checkedAt: this.checkedAt, latest: version });
-    }).catch(() => {
-      this.scheduleRetry(now);
-    }).finally(() => {
-      this.checking = false;
-    });
-  }
-  scheduleRetry(now) {
-    this.retryAt = now + this.backoffMs;
-    this.backoffMs = Math.min(this.backoffMs * 2, MAX_RETRY_MS);
-  }
-  notice() {
-    const latest = this.latest;
-    if (!this.enabled || latest === null || !isNewer(latest, this.current)) {
-      return null;
-    }
-    return {
-      current: this.current,
-      latest,
-      releaseNotes: `${RELEASES}/v${latest}`,
-      upgrade: runLine(currentRunner(), latest, "upgrade")
-    };
-  }
-}
-var REGISTRY = "https://registry.npmjs.org/gdharness/latest", RELEASES = "https://github.com/Aureliolo/gdharness/releases/tag", CACHE_MS, REQUEST_TIMEOUT_MS = 1e4, MAX_BODY_BYTES, FIRST_RETRY_MS = 30000, MAX_RETRY_MS, VERSION;
-var init_update_check = __esm(() => {
-  CACHE_MS = 4 * 60 * 60 * 1000;
-  MAX_BODY_BYTES = 1 << 20;
-  MAX_RETRY_MS = 60 * 60 * 1000;
-  VERSION = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
-});
-
 // src/server.ts
 import { execFile as execFile5, spawn } from "node:child_process";
 import { existsSync as existsSync10, mkdtempSync as mkdtempSync3, readdirSync as readdirSync6, readFileSync as readFileSync11, realpathSync as realpathSync2, rmSync as rmSync6 } from "node:fs";
@@ -36390,7 +36435,8 @@ class GodotServer {
     ];
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 600000;
     this.logDebug(`Running tests: ${engine.value} ${cmdArgs.join(" ")}`);
-    const run = this.spawnGame(engine.value, cmdArgs);
+    const userData = mkdtempSync3(join12(tmpdir5(), "gdharness-tests-"));
+    const run = this.spawnGame(engine.value, cmdArgs, userDataIn(userData));
     const hung = await new Promise((resolve) => {
       const timer = setTimeout(() => {
         run.process.kill();
@@ -36418,6 +36464,7 @@ class GodotServer {
       reportProblem = errorMessage(error);
     } finally {
       rmSync6(reportsDir, { recursive: true, force: true });
+      rmSync6(userData, { recursive: true, force: true });
     }
     const engineEntries = run.log.select({ severity: "warning", sinceLastCall: false, limit: 200 }).entries;
     const verdicts = {
@@ -36528,7 +36575,7 @@ class GodotServer {
       addonIsStale: status.connected ? stale : undefined,
       bridgeAvailable: this.bridgeStartupError === null,
       startupError: this.bridgeStartupError,
-      staleNote: stale ? `The editor is running the ${status.addonVersion === "" ? "addon from before versions were reported" : status.addonVersion} addon while this server ships ${SERVER_VERSION}. Restart it with editor_launch restart to pick the new one up.` : undefined,
+      staleNote: stale ? addonMismatch(status.addonVersion, SERVER_VERSION) : undefined,
       note: isPortConflict ? "Bridge port is already in use. Another gdharness instance may own the editor bridge, so this server cannot report that editor connection." : undefined,
       suggestion: isPortConflict ? "Stop duplicate gdharness/MCP server instances or re-run the command from the same server process that owns the bridge port." : undefined
     };
@@ -36606,6 +36653,7 @@ class GodotServer {
       addonVersion: now.addonVersion,
       serverVersion: SERVER_VERSION,
       addonIsStale: now.addonVersion !== SERVER_VERSION,
+      staleNote: addonMismatch(now.addonVersion, SERVER_VERSION),
       tookMs: Date.now() - began
     });
   }
@@ -36639,7 +36687,8 @@ class GodotServer {
     this.logDebug(`Launching Godot editor for project: ${project.value.path}`);
     const editor = spawn(engine.value, editorArguments(project.value.path), {
       stdio: "ignore",
-      detached: true
+      detached: true,
+      env: { ...process.env, GDHARNESS_RUNTIME_DIR: runtimeDirectory() }
     });
     const started = await new Promise((resolve) => {
       editor.once("spawn", () => {
@@ -36772,8 +36821,8 @@ class GodotServer {
     }
     running.process?.kill();
   }
-  spawnGame(godotPath, cmdArgs) {
-    const child = spawn(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"] });
+  spawnGame(godotPath, cmdArgs, env) {
+    const child = spawn(godotPath, cmdArgs, { stdio: ["ignore", "pipe", "pipe"], ...env ? { env } : {} });
     const log = new GameLog;
     const started = {
       process: child,
@@ -38133,12 +38182,13 @@ class Ask {
 }
 
 // src/server-version.ts
-import { readFileSync as readFileSync3 } from "node:fs";
+init_update_check();
+import { readFileSync as readFileSync4 } from "node:fs";
 var DEBUG_MODE2 = process.env["DEBUG"] === "true";
 var GODOT_DEBUG_MODE_DEFAULT2 = process.env["GODOT_DEBUG"] === "true" || DEBUG_MODE2;
 var SERVER_VERSION2 = (() => {
   try {
-    const pkg = JSON.parse(readFileSync3(new URL("../package.json", import.meta.url), "utf8"));
+    const pkg = JSON.parse(readFileSync4(new URL("../package.json", import.meta.url), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {
     return "0.0.0";
@@ -38150,8 +38200,8 @@ init_class_cache();
 init_headless();
 init_resources();
 init_server_version();
-import { cpSync, existsSync as existsSync5, mkdirSync as mkdirSync2, readFileSync as readFileSync6, rmSync as rmSync4, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname2, join as join6 } from "node:path";
+import { cpSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync7, rmSync as rmSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname2, join as join7 } from "node:path";
 import { fileURLToPath } from "node:url";
 var ADDONS = ["gdharness_editor", "gdharness_runtime", "auto_reload"];
 var EDITOR_PLUGINS = ["gdharness_editor", "auto_reload"];
@@ -38161,24 +38211,24 @@ var RUNTIME_AUTOLOAD = {
 };
 var VERSION_MARKER = ".gdharness-version";
 function shippedAddonsDirectory() {
-  return join6(dirname2(fileURLToPath(import.meta.url)), "godot", "addons");
+  return join7(dirname2(fileURLToPath(import.meta.url)), "godot", "addons");
 }
 function shippedOperationsScript() {
-  return join6(dirname2(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
+  return join7(dirname2(fileURLToPath(import.meta.url)), "godot", "operations", "godot_operations.gd");
 }
 function installAddons(projectPath, from = shippedAddonsDirectory()) {
   const installed = [];
   for (const name of ADDONS) {
-    const source = join6(from, name);
-    if (!existsSync5(join6(source, name === "gdharness_runtime" ? "runtime_autoload.gd" : "plugin.cfg"))) {
+    const source = join7(from, name);
+    if (!existsSync6(join7(source, name === "gdharness_runtime" ? "runtime_autoload.gd" : "plugin.cfg"))) {
       throw new Error(`The package holds no ${name} addon at ${source}.`);
     }
-    const target = join6(projectPath, "addons", name);
-    const replaced = existsSync5(target);
+    const target = join7(projectPath, "addons", name);
+    const replaced = existsSync6(target);
     rmSync4(target, { recursive: true, force: true });
-    mkdirSync2(dirname2(target), { recursive: true });
+    mkdirSync3(dirname2(target), { recursive: true });
     cpSync(source, target, { recursive: true });
-    writeFileSync4(join6(target, VERSION_MARKER), `${SERVER_VERSION}
+    writeFileSync5(join7(target, VERSION_MARKER), `${SERVER_VERSION}
 `);
     installed.push({ name, path: target, replaced });
   }
@@ -38187,8 +38237,8 @@ function installAddons(projectPath, from = shippedAddonsDirectory()) {
 function removeAddons(projectPath) {
   const removed = [];
   for (const name of ADDONS) {
-    const target = join6(projectPath, "addons", name);
-    if (existsSync5(target)) {
+    const target = join7(projectPath, "addons", name);
+    if (existsSync6(target)) {
       rmSync4(target, { recursive: true, force: true });
       removed.push(target);
     }
@@ -38222,10 +38272,10 @@ function enabledPlugins(settings) {
 function inspectProject(projectPath) {
   const problems = [];
   const addons = ADDONS.map((name) => {
-    const directory = join6(projectPath, "addons", name);
-    const marker = join6(directory, VERSION_MARKER);
-    const installed = existsSync5(directory);
-    const version = existsSync5(marker) ? readFileSync6(marker, "utf8").trim() : null;
+    const directory = join7(projectPath, "addons", name);
+    const marker = join7(directory, VERSION_MARKER);
+    const installed = existsSync6(directory);
+    const version = existsSync6(marker) ? readFileSync7(marker, "utf8").trim() : null;
     const current = version === SERVER_VERSION;
     if (!installed) {
       problems.push(`addons/${name} is not installed; run gdharness setup`);
@@ -38234,7 +38284,7 @@ function inspectProject(projectPath) {
     }
     return { name, installed, version, current };
   });
-  const settings = parseProjectGodot(readFileSync6(join6(projectPath, "project.godot"), "utf8"));
+  const settings = parseProjectGodot(readFileSync7(join7(projectPath, "project.godot"), "utf8"));
   const pluginsEnabled = enabledPlugins(settings);
   for (const name of EDITOR_PLUGINS) {
     if (!pluginsEnabled.includes(name)) {
@@ -38263,8 +38313,8 @@ function inspectProject(projectPath) {
 
 // src/skill.ts
 init_tool_definitions();
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readdirSync as readdirSync3, rmSync as rmSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import { basename, dirname as dirname3, join as join7 } from "node:path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readdirSync as readdirSync3, rmSync as rmSync5, writeFileSync as writeFileSync6 } from "node:fs";
+import { basename, dirname as dirname3, join as join8 } from "node:path";
 
 // src/tool-reference.ts
 init_tool_definitions();
@@ -38311,7 +38361,7 @@ function renderToolsMarkdown() {
 
 // src/skill.ts
 var SKILL_NAME = "gdharness";
-var SHARED_SKILLS = join7(".agents", "skills");
+var SHARED_SKILLS = join8(".agents", "skills");
 function skillMarkdown(version) {
   return `---
 name: ${SKILL_NAME}
@@ -38333,7 +38383,8 @@ that is running, and the project on disk. ${TOOL_SPECS.length} tools, named \`do
 - Every call takes \`projectPath\`, except \`runtime_*\` and \`debug_*\`, where it picks between
   running games. There is no ambient project.
 - \`editor_status\` says whether an editor is connected and whether its addon matches the server.
-  \`addonIsStale\` means the editor is serving an older addon and needs restarting.
+  \`addonIsStale\` means they differ, and \`staleNote\` says which half is behind: an editor that
+  needs restarting, or a server that needs reconnecting in your harness.
 - Start the game with \`editor_run start\`, never by spawning an engine. The editor plays it, so
   its debugger holds it, which is what gives the \`debug_*\` tools something to talk to.
 - Read \`editor_output\` after every run. It returns the engine's errors and warnings as entries
@@ -38392,27 +38443,27 @@ whatever the engine said on stderr comes back under \`engine_messages\`.
 function skillFiles(version) {
   return new Map([
     ["SKILL.md", skillMarkdown(version)],
-    [join7("references", "tools.md"), renderToolsMarkdown()]
+    [join8("references", "tools.md"), renderToolsMarkdown()]
   ]);
 }
 function skillDirectories(harnesses, projectPath, exists) {
-  const directories = [join7(projectPath, SHARED_SKILLS, SKILL_NAME)];
+  const directories = [join8(projectPath, SHARED_SKILLS, SKILL_NAME)];
   for (const harness of harnesses) {
     if (harness.skills === undefined) {
       continue;
     }
-    const own = join7(projectPath, harness.skills.dir);
-    if ((!harness.skills.shared || exists(own)) && !directories.includes(join7(own, SKILL_NAME))) {
-      directories.push(join7(own, SKILL_NAME));
+    const own = join8(projectPath, harness.skills.dir);
+    if ((!harness.skills.shared || exists(own)) && !directories.includes(join8(own, SKILL_NAME))) {
+      directories.push(join8(own, SKILL_NAME));
     }
   }
   return directories;
 }
 function everySkillDirectory(projectPath, harnesses) {
-  const directories = new Set([join7(projectPath, SHARED_SKILLS, SKILL_NAME)]);
+  const directories = new Set([join8(projectPath, SHARED_SKILLS, SKILL_NAME)]);
   for (const harness of harnesses) {
     if (harness.skills !== undefined) {
-      directories.add(join7(projectPath, harness.skills.dir, SKILL_NAME));
+      directories.add(join8(projectPath, harness.skills.dir, SKILL_NAME));
     }
   }
   return [...directories];
@@ -38420,7 +38471,7 @@ function everySkillDirectory(projectPath, harnesses) {
 function removeSkill(directories, projectPath) {
   const removed = [];
   for (const directory of directories) {
-    if (existsSync6(directory)) {
+    if (existsSync7(directory)) {
       rmSync5(directory, { recursive: true, force: true });
       pruneEmpty(dirname3(directory), projectPath);
       removed.push(directory);
@@ -38429,7 +38480,7 @@ function removeSkill(directories, projectPath) {
   return removed;
 }
 function pruneEmpty(directory, projectPath) {
-  const shared = join7(projectPath, ".agents");
+  const shared = join8(projectPath, ".agents");
   let path = directory;
   while (path !== projectPath && (basename(path) === "skills" || path === shared)) {
     if (readdirSync3(path).length > 0) {
@@ -38442,30 +38493,30 @@ function pruneEmpty(directory, projectPath) {
 function writeSkill(directories, version) {
   const files = skillFiles(version);
   return directories.map((directory) => {
-    const replaced = existsSync6(directory);
+    const replaced = existsSync7(directory);
     rmSync5(directory, { recursive: true, force: true });
     for (const [name, contents] of files) {
-      const path = join7(directory, name);
-      mkdirSync3(dirname3(path), { recursive: true });
-      writeFileSync5(path, contents, "utf8");
+      const path = join8(directory, name);
+      mkdirSync4(dirname3(path), { recursive: true });
+      writeFileSync6(path, contents, "utf8");
     }
     return { path: directory, replaced };
   });
 }
 
 // src/version.ts
-import { readFileSync as readFileSync7 } from "node:fs";
-import { dirname as dirname4, join as join8 } from "node:path";
+import { readFileSync as readFileSync8 } from "node:fs";
+import { dirname as dirname4, join as join9 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function getLocalVersion() {
   const currentDirectory = dirname4(fileURLToPath2(import.meta.url));
   const packageCandidates = [
-    join8(currentDirectory, "..", "package.json"),
-    join8(currentDirectory, "..", "..", "package.json")
+    join9(currentDirectory, "..", "package.json"),
+    join9(currentDirectory, "..", "..", "package.json")
   ];
   for (const packagePath of packageCandidates) {
     try {
-      const value = JSON.parse(readFileSync7(packagePath, "utf-8"));
+      const value = JSON.parse(readFileSync8(packagePath, "utf-8"));
       if (typeof value === "object" && value !== null && "name" in value && value.name === "gdharness" && "version" in value && typeof value.version === "string") {
         return value.version;
       }