gdharness 1.3.46 → 1.3.48

package/build/keeper.js

@@ -6946,8 +6946,8 @@ var require_public_api = __commonJS(function(exports) {
 });
 
 // src/keeper.ts
-import { closeSync as closeSync2, existsSync as existsSync3, mkdtempSync as mkdtempSync4, openSync as openSync3, readFileSync as readFileSync7, rmSync as rmSync6, writeFileSync as writeFileSync3 } from "node:fs";
-import { tmpdir as tmpdir5 } from "node:os";
+import { closeSync as closeSync3, existsSync as existsSync3, mkdtempSync as mkdtempSync4, openSync as openSync4, readFileSync as readFileSync8, rmSync as rmSync7, writeFileSync as writeFileSync3 } from "node:fs";
+import { tmpdir as tmpdir6 } from "node:os";
 import { join as join10 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 
@@ -7407,344 +7407,541 @@ function throughHelper(how, command, args, files, assembly = helperAssembly()) {
   };
 }
 
-// src/error-mode.ts
-import process3 from "node:process";
-var NO_FAULT_ERROR_BOX = 2;
-var cleared = process3.platform !== "win32";
-async function letWindowsReportCrashes() {
-  if (cleared || !("bun" in process3.versions)) {
-    return;
-  }
-  try {
-    const { dlopen, FFIType } = await import("bun:ffi");
-    const kernel32 = dlopen("kernel32.dll", {
-      GetErrorMode: { args: [], returns: FFIType.u32 },
-      SetErrorMode: { args: [FFIType.u32], returns: FFIType.u32 }
-    });
-    try {
-      const mode = kernel32.symbols.GetErrorMode();
-      kernel32.symbols.SetErrorMode(mode & ~NO_FAULT_ERROR_BOX);
-      cleared = true;
-    } finally {
-      kernel32.close();
-    }
-  } catch {}
-}
-function crashesReported() {
-  return cleared;
-}
+// src/engine-slots.ts
+import {
+  closeSync as closeSync2,
+  mkdirSync,
+  openSync as openSync2,
+  readFileSync as readFileSync4,
+  rmSync as rmSync3,
+  statSync as statSync3,
+  watch,
+  writeSync as writeSync2
+} from "node:fs";
+import process4 from "node:process";
 
-// src/game-debugger.ts
-import { readFileSync as readFileSync5 } from "node:fs";
-import { createServer } from "node:net";
-import { join as join6 } from "node:path";
+// src/call-signal.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var current = new AsyncLocalStorage;
 
-// src/godot-variant.ts
-var NIL = 0;
-var BOOL = 1;
-var INT = 2;
-var FLOAT = 3;
-var STRING = 4;
-var ARRAY = 28;
-var FLAG_64 = 1 << 16;
-var MATH = {
-  5: { name: "Vector2", count: 2 },
-  6: { name: "Vector2i", count: 2, ints: true },
-  7: { name: "Rect2", count: 4 },
-  8: { name: "Rect2i", count: 4, ints: true },
-  9: { name: "Vector3", count: 3 },
-  10: { name: "Vector3i", count: 3, ints: true },
-  11: { name: "Transform2D", count: 6 },
-  12: { name: "Vector4", count: 4 },
-  13: { name: "Vector4i", count: 4, ints: true },
-  14: { name: "Plane", count: 4 },
-  15: { name: "Quaternion", count: 4 },
-  16: { name: "AABB", count: 6 },
-  17: { name: "Basis", count: 9 },
-  18: { name: "Transform3D", count: 12 },
-  19: { name: "Projection", count: 16 }
-};
-var PACKED_VECTORS = { 35: 2, 36: 3, 38: 4 };
+// src/harnesses.ts
+import { basename as basename2, dirname as dirname2, isAbsolute as isAbsolute2, join as join3, relative as relative2, resolve as resolve2 } from "node:path";
 
-class Reader {
-  offset = 0;
-  view;
-  constructor(view) {
-    this.view = view;
-  }
-  get remaining() {
-    return this.view.byteLength - this.offset;
-  }
-  need(bytes) {
-    if (bytes < 0 || bytes > this.remaining) {
-      throw new RangeError(`a value runs past the end of its message (${bytes} bytes wanted, ${this.remaining} left)`);
+// node_modules/yaml/dist/index.js
+var composer = require_composer();
+var Document = require_Document();
+var Schema = require_Schema();
+var errors = require_errors();
+var Alias = require_Alias();
+var identity = require_identity();
+var Pair = require_Pair();
+var Scalar = require_Scalar();
+var YAMLMap = require_YAMLMap();
+var YAMLSeq = require_YAMLSeq();
+var cst = require_cst();
+var lexer = require_lexer();
+var lineCounter = require_line_counter();
+var parser = require_parser();
+var publicApi = require_public_api();
+var visit = require_visit();
+var $Composer = composer.Composer;
+var $Document = Document.Document;
+var $Schema = Schema.Schema;
+var $YAMLError = errors.YAMLError;
+var $YAMLParseError = errors.YAMLParseError;
+var $YAMLWarning = errors.YAMLWarning;
+var $Alias = Alias.Alias;
+var $isAlias = identity.isAlias;
+var $isCollection = identity.isCollection;
+var $isDocument = identity.isDocument;
+var $isMap = identity.isMap;
+var $isNode = identity.isNode;
+var $isPair = identity.isPair;
+var $isScalar = identity.isScalar;
+var $isSeq = identity.isSeq;
+var $Pair = Pair.Pair;
+var $Scalar = Scalar.Scalar;
+var $YAMLMap = YAMLMap.YAMLMap;
+var $YAMLSeq = YAMLSeq.YAMLSeq;
+var $Lexer = lexer.Lexer;
+var $LineCounter = lineCounter.LineCounter;
+var $Parser = parser.Parser;
+var $parse = publicApi.parse;
+var $parseAllDocuments = publicApi.parseAllDocuments;
+var $parseDocument = publicApi.parseDocument;
+var $stringify = publicApi.stringify;
+var $visit = visit.visit;
+var $visitAsync = visit.visitAsync;
+
+// src/paths.ts
+import { realpathSync, statSync as statSync2 } from "node:fs";
+import { basename, dirname, isAbsolute, join as join2, relative, resolve, sep } from "node:path";
+function realAsFarAsItExists(path) {
+  const missing = [];
+  let at = path;
+  for (;; ) {
+    try {
+      return join2(realpathSync.native(at), ...missing);
+    } catch {
+      const parent = dirname(at);
+      if (parent === at) {
+        return path;
+      }
+      missing.unshift(basename(at));
+      at = parent;
     }
   }
-  u32() {
-    this.need(4);
-    const value = this.view.getUint32(this.offset, true);
-    this.offset += 4;
-    return value;
-  }
-  i32() {
-    this.need(4);
-    const value = this.view.getInt32(this.offset, true);
-    this.offset += 4;
-    return value;
-  }
-  i64() {
-    this.need(8);
-    const value = Number(this.view.getBigInt64(this.offset, true));
-    this.offset += 8;
-    return value;
-  }
-  u64() {
-    this.need(8);
-    const value = Number(this.view.getBigUint64(this.offset, true));
-    this.offset += 8;
-    return value;
-  }
-  f32() {
-    this.need(4);
-    const value = this.view.getFloat32(this.offset, true);
-    this.offset += 4;
-    return value;
-  }
-  f64() {
-    this.need(8);
-    const value = this.view.getFloat64(this.offset, true);
-    this.offset += 8;
-    return value;
-  }
-  real(wide) {
-    return wide ? this.f64() : this.f32();
-  }
-  bytes(count) {
-    this.need(count);
-    const out = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, count);
-    this.offset += count;
-    return out;
-  }
-  string() {
-    const length = this.u32();
-    const text = new TextDecoder().decode(this.bytes(length));
-    this.bytes((4 - length % 4) % 4);
-    return text;
-  }
 }
-var MAX_DEPTH = 1024;
-function containerType(reader, kind) {
-  if (kind === 1) {
-    reader.u32();
-  } else if (kind === 2 || kind === 3) {
-    reader.string();
-  }
+
+// src/harnesses.ts
+var SERVER_KEY = "gdharness";
+function tomlArray(values) {
+  return `[${values.map((value) => `"${value}"`).join(", ")}]`;
 }
-function decodeValue(reader, depth) {
-  if (depth > MAX_DEPTH) {
-    throw new RangeError("a value nests deeper than the engine allows");
-  }
-  const header = reader.u32();
-  const type = header & 255;
-  const wide = (header & FLAG_64) !== 0;
-  const math = MATH[type];
-  if (math !== undefined) {
-    return {
-      kind: math.name,
-      values: Array.from({ length: math.count }, () => math.ints === true ? reader.i32() : reader.real(wide))
-    };
-  }
-  const vectorWidth = PACKED_VECTORS[type];
-  if (vectorWidth !== undefined) {
-    const count = reader.u32();
-    return Array.from({ length: count }, () => ({
-      kind: "Vector",
-      values: Array.from({ length: vectorWidth }, () => reader.real(wide))
-    }));
-  }
-  switch (type) {
-    case NIL:
-      return null;
-    case BOOL:
-      return reader.u32() !== 0;
-    case INT:
-      return wide ? reader.i64() : reader.i32();
-    case FLOAT:
-      return wide ? reader.f64() : reader.f32();
-    case STRING:
-    case 21:
-      return reader.string();
-    case 20:
-      return { kind: "Color", values: [reader.f32(), reader.f32(), reader.f32(), reader.f32()] };
-    case 22: {
-      const first = reader.u32();
-      if ((first & 2147483648) === 0) {
-        throw new RangeError("a node path in the format before 3.0");
-      }
-      const names = first & 2147483647;
-      let subnames = reader.u32();
-      const flags = reader.u32();
-      if ((flags & 2) !== 0) {
-        subnames += 1;
-      }
-      return { kind: "NodePath", values: Array.from({ length: names + subnames }, () => reader.string()) };
-    }
-    case 23:
-      return { kind: "RID", values: [reader.u64()] };
-    case 24:
-      if ((header & FLAG_64) === 0) {
-        throw new RangeError("a full object, which this reader does not take");
-      }
-      return { kind: "Object", values: [reader.u64()] };
-    case 25:
-      return { kind: "Callable", values: [] };
-    case 26:
-      return { kind: "Signal", values: [reader.string(), reader.u64()] };
-    case 27: {
-      containerType(reader, header >> 16 & 3);
-      containerType(reader, header >> 18 & 3);
-      const count = reader.u32() & 2147483647;
-      const entries = [];
-      for (let index = 0;index < count; index += 1) {
-        const key = decodeValue(reader, depth + 1);
-        entries.push([key, decodeValue(reader, depth + 1)]);
-      }
-      return { kind: "dictionary", entries };
+function tomlEnv(launch) {
+  const pairs = Object.entries(launch.env).map(([name, value]) => `${name} = "${value}"`);
+  return `env = { ${pairs.join(", ")} }`;
+}
+function jsonSnippet(launch, container, shape) {
+  return JSON.stringify({ [container]: { [SERVER_KEY]: entryFor(shape, launch) } }, null, 2);
+}
+var HARNESSES = [
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    scope: "project",
+    file: ".mcp.json",
+    container: "mcpServers",
+    shape: "plain",
+    home: ".claude",
+    marker: ".claude",
+    skills: { dir: join3(".claude", "skills"), shared: false }
+  },
+  {
+    id: "copilot-cli",
+    name: "Copilot CLI",
+    scope: "project",
+    file: ".mcp.json",
+    container: "mcpServers",
+    shape: "plain",
+    home: ".copilot",
+    skills: { dir: join3(".github", "skills"), shared: true },
+    manual: "Trust the folder when Copilot CLI first asks, or it reads no config here."
+  },
+  {
+    id: "qoder",
+    name: "Qoder",
+    scope: "project",
+    file: ".mcp.json",
+    container: "mcpServers",
+    shape: "plain",
+    home: ".qoder",
+    marker: ".qoder"
+  },
+  {
+    id: "command-code",
+    name: "Command Code",
+    scope: "project",
+    file: ".mcp.json",
+    container: "mcpServers",
+    shape: "plain",
+    home: ".commandcode"
+  },
+  {
+    id: "cursor",
+    name: "Cursor",
+    scope: "project",
+    file: join3(".cursor", "mcp.json"),
+    container: "mcpServers",
+    shape: "plain",
+    home: ".cursor",
+    skills: { dir: join3(".cursor", "skills"), shared: true },
+    manual: "Cursor asks before each tool call by default, and the server can be toggled off."
+  },
+  {
+    id: "vscode",
+    name: "VS Code",
+    scope: "project",
+    file: join3(".vscode", "mcp.json"),
+    container: "servers",
+    shape: "typed",
+    home: ".vscode",
+    skills: { dir: join3(".github", "skills"), shared: true },
+    manual: "VS Code asks you to trust a server the first time it starts one."
+  },
+  {
+    id: "opencode",
+    name: "opencode",
+    scope: "project",
+    file: "opencode.json",
+    container: "mcp",
+    shape: "opencode",
+    home: join3(".config", "opencode"),
+    marker: ".opencode",
+    skills: { dir: join3(".opencode", "skills"), shared: true }
+  },
+  {
+    id: "junie",
+    name: "Junie",
+    scope: "project",
+    file: join3(".junie", "mcp", "mcp.json"),
+    container: "mcpServers",
+    shape: "plain",
+    home: ".junie",
+    skills: { dir: join3(".junie", "skills"), shared: true }
+  },
+  {
+    id: "kiro",
+    name: "Kiro",
+    scope: "project",
+    file: join3(".kiro", "settings", "mcp.json"),
+    container: "mcpServers",
+    shape: "plain",
+    home: ".kiro",
+    skills: { dir: join3(".kiro", "skills"), shared: false }
+  },
+  {
+    id: "gemini",
+    name: "Gemini CLI",
+    scope: "project",
+    file: join3(".gemini", "settings.json"),
+    container: "mcpServers",
+    shape: "plain",
+    home: ".gemini",
+    skills: { dir: join3(".gemini", "skills"), shared: true }
+  },
+  {
+    id: "roo",
+    name: "Roo Code",
+    scope: "project",
+    file: join3(".roo", "mcp.json"),
+    container: "mcpServers",
+    shape: "plain"
+  },
+  {
+    id: "kilo",
+    name: "Kilo Code",
+    scope: "project",
+    file: join3(".kilocode", "mcp.json"),
+    container: "mcpServers",
+    shape: "plain"
+  },
+  {
+    id: "amazon-q",
+    name: "Amazon Q Developer CLI",
+    scope: "project",
+    file: join3(".amazonq", "mcp.json"),
+    container: "mcpServers",
+    shape: "plain",
+    home: join3(".aws", "amazonq")
+  },
+  {
+    id: "zed",
+    name: "Zed",
+    scope: "project",
+    file: join3(".zed", "settings.json"),
+    container: "context_servers",
+    shape: "plain"
+  },
+  {
+    id: "amp",
+    name: "Amp",
+    scope: "project",
+    file: join3(".amp", "settings.json"),
+    container: "amp.mcpServers",
+    shape: "plain",
+    home: join3(".config", "amp")
+  },
+  {
+    id: "warp",
+    name: "Warp",
+    scope: "project",
+    file: join3(".warp", ".mcp.json"),
+    container: "mcpServers",
+    shape: "plain",
+    home: ".warp",
+    manual: "Warp starts a project server only once you toggle it on, on its MCP servers page."
+  },
+  {
+    id: "trae",
+    name: "Trae",
+    scope: "project",
+    file: join3(".trae", "mcp.json"),
+    container: "mcpServers",
+    shape: "plain",
+    home: ".trae"
+  },
+  {
+    id: "factory",
+    name: "Factory Droid",
+    scope: "project",
+    file: join3(".factory", "mcp.json"),
+    container: "mcpServers",
+    shape: "typed",
+    home: ".factory"
+  },
+  {
+    id: "tabnine",
+    name: "Tabnine",
+    scope: "project",
+    file: join3(".tabnine", "mcp_servers.json"),
+    container: "mcpServers",
+    shape: "plain",
+    home: ".tabnine"
+  },
+  {
+    id: "firebender",
+    name: "Firebender",
+    scope: "project",
+    file: "firebender.json",
+    container: "mcpServers",
+    shape: "plain"
+  },
+  {
+    id: "pi",
+    name: "pi",
+    scope: "project",
+    file: join3(".pi", "mcp.json"),
+    container: "mcpServers",
+    shape: "plain",
+    home: ".pi"
+  },
+  {
+    id: "mistral-vibe",
+    name: "Mistral Vibe",
+    scope: "project",
+    file: join3(".vibe", "config.toml"),
+    container: "mcp_servers",
+    shape: "plain",
+    toml: {
+      header: "[[mcp_servers]]",
+      identity: `name = "${SERVER_KEY}"`,
+      block: (launch) => [
+        "[[mcp_servers]]",
+        `name = "${SERVER_KEY}"`,
+        'transport = "stdio"',
+        `command = "${launch.command}"`,
+        `args = ${tomlArray(launch.args)}`,
+        tomlEnv(launch)
+      ].join(`
+`)
     }
-    case ARRAY: {
-      containerType(reader, header >> 16 & 3);
-      const count = reader.u32() & 2147483647;
-      return Array.from({ length: count }, () => decodeValue(reader, depth + 1));
+  },
+  {
+    id: "vtcode",
+    name: "VT Code",
+    scope: "project",
+    file: "vtcode.toml",
+    container: "mcp.providers",
+    shape: "plain",
+    marker: ".vtcode",
+    toml: {
+      header: "[[mcp.providers]]",
+      identity: `name = "${SERVER_KEY}"`,
+      enable: { header: "[mcp]", line: "enabled = true" },
+      block: (launch) => [
+        "[[mcp.providers]]",
+        `name = "${SERVER_KEY}"`,
+        "enabled = true",
+        `command = "${launch.command}"`,
+        `args = ${tomlArray(launch.args)}`,
+        tomlEnv(launch)
+      ].join(`
+`)
     }
-    case 29: {
-      const count = reader.u32();
-      const bytes = [...reader.bytes(count)];
-      reader.bytes((4 - count % 4) % 4);
-      return bytes;
+  },
+  {
+    id: "fast-agent",
+    name: "fast-agent",
+    scope: "project",
+    file: "fastagent.config.yaml",
+    container: "mcp",
+    shape: "plain",
+    yaml: {
+      path: ["mcp", "servers", SERVER_KEY],
+      entry: (launch) => ({ command: launch.command, args: [...launch.args], env: { ...launch.env } })
+    }
+  },
+  {
+    id: "codex",
+    name: "Codex CLI",
+    scope: "home",
+    file: join3(".codex", "config.toml"),
+    container: "mcp_servers",
+    shape: "plain",
+    manual: "Codex reads its config at startup, so restart it.",
+    toml: {
+      header: `[mcp_servers.${SERVER_KEY}]`,
+      block: (launch) => [
+        `[mcp_servers.${SERVER_KEY}]`,
+        `command = "${launch.command}"`,
+        `args = ${tomlArray(launch.args)}`,
+        tomlEnv(launch)
+      ].join(`
+`)
+    }
+  },
+  {
+    id: "cline",
+    name: "Cline",
+    scope: "home",
+    file: join3(".cline", "data", "settings", "cline_mcp_settings.json"),
+    container: "mcpServers",
+    shape: "plain",
+    marker: ".cline",
+    skills: { dir: join3(".cline", "skills"), shared: false }
+  },
+  {
+    id: "goose",
+    name: "Goose",
+    scope: "home",
+    file: {
+      win32: { appData: join3("Block", "goose", "config", "config.yaml") },
+      darwin: join3(".config", "goose", "config.yaml"),
+      linux: join3(".config", "goose", "config.yaml")
+    },
+    container: "extensions",
+    shape: "plain",
+    yaml: {
+      path: ["extensions", SERVER_KEY],
+      entry: (launch) => ({
+        name: SERVER_KEY,
+        type: "stdio",
+        enabled: true,
+        cmd: launch.command,
+        args: [...launch.args],
+        envs: { ...launch.env },
+        timeout: 300
+      })
     }
-    case 30:
-      return Array.from({ length: reader.u32() }, () => reader.i32());
-    case 31:
-      return Array.from({ length: reader.u32() }, () => reader.i64());
-    case 32:
-      return Array.from({ length: reader.u32() }, () => reader.f32());
-    case 33:
-      return Array.from({ length: reader.u32() }, () => reader.f64());
-    case 34:
-      return Array.from({ length: reader.u32() }, () => reader.string().replace(/\0$/, ""));
-    case 37:
-      return Array.from({ length: reader.u32() }, () => ({
-        kind: "Color",
-        values: [reader.f32(), reader.f32(), reader.f32(), reader.f32()]
-      }));
-    default:
-      throw new RangeError(`a value of type ${type}, which Godot 4.7 does not have`);
-  }
-}
-function decodeVariant(bytes) {
-  const reader = new Reader(new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength));
-  const value = decodeValue(reader, 0);
-  if (reader.remaining !== 0) {
-    throw new RangeError(`${reader.remaining} bytes left over after the value`);
-  }
-  return value;
-}
-function pushU32(out, value) {
-  out.push(value & 255, value >>> 8 & 255, value >>> 16 & 255, value >>> 24 & 255);
-}
-function encodeInto(out, value) {
-  if (value === null) {
-    pushU32(out, NIL);
-  } else if (typeof value === "boolean") {
-    pushU32(out, BOOL);
-    pushU32(out, value ? 1 : 0);
-  } else if (typeof value === "number") {
-    const view = new DataView(new ArrayBuffer(8));
-    if (Number.isInteger(value) && value >= -2147483648 && value <= 2147483647) {
-      pushU32(out, INT);
-      view.setInt32(0, value, true);
-      out.push(...new Uint8Array(view.buffer, 0, 4));
-    } else if (Number.isInteger(value)) {
-      pushU32(out, INT | FLAG_64);
-      view.setBigInt64(0, BigInt(value), true);
-      out.push(...new Uint8Array(view.buffer));
-    } else {
-      pushU32(out, FLOAT | FLAG_64);
-      view.setFloat64(0, value, true);
-      out.push(...new Uint8Array(view.buffer));
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    scope: "home",
+    file: join3(".codeium", "windsurf", "mcp_config.json"),
+    container: "mcpServers",
+    shape: "plain",
+    skills: { dir: join3(".windsurf", "skills"), shared: true }
+  },
+  {
+    id: "hermes",
+    name: "Hermes",
+    scope: "home",
+    file: join3(".hermes", "config.yaml"),
+    container: "mcp_servers",
+    shape: "plain",
+    skills: { dir: join3(".hermes", "skills"), shared: true },
+    yaml: {
+      path: ["mcp_servers", SERVER_KEY],
+      entry: (launch) => ({
+        command: launch.command,
+        args: [...launch.args],
+        env: { ...launch.env },
+        enabled: true
+      })
     }
-  } else if (typeof value === "string") {
-    const bytes = new TextEncoder().encode(value);
-    pushU32(out, STRING);
-    pushU32(out, bytes.length);
-    out.push(...bytes, ...Array.from({ length: (4 - bytes.length % 4) % 4 }, () => 0));
-  } else {
-    pushU32(out, ARRAY);
-    pushU32(out, value.length);
-    for (const element of value) {
-      encodeInto(out, element);
+  },
+  {
+    id: "openclaw",
+    name: "OpenClaw",
+    scope: "home",
+    file: join3(".openclaw", "openclaw.json"),
+    container: "mcpServers",
+    shape: "plain"
+  },
+  {
+    id: "claude-desktop",
+    name: "Claude Desktop",
+    scope: "home",
+    file: {
+      win32: { appData: join3("Claude", "claude_desktop_config.json") },
+      darwin: join3("Library", "Application Support", "Claude", "claude_desktop_config.json"),
+      linux: join3(".config", "Claude", "claude_desktop_config.json")
+    },
+    container: "mcpServers",
+    shape: "plain"
+  },
+  {
+    id: "zeroclaw",
+    name: "ZeroClaw",
+    scope: "home",
+    file: join3(".zeroclaw", "config.toml"),
+    container: "mcp.servers",
+    shape: "plain",
+    toml: {
+      header: "[[mcp.servers]]",
+      identity: `name = "${SERVER_KEY}"`,
+      enable: { header: "[mcp]", line: "enabled = true" },
+      block: (launch) => [
+        "[[mcp.servers]]",
+        `name = "${SERVER_KEY}"`,
+        `command = "${launch.command}"`,
+        `args = ${tomlArray(launch.args)}`,
+        tomlEnv(launch)
+      ].join(`
+`)
     }
+  },
+  {
+    id: "deepcode",
+    name: "Deep Code",
+    scope: "home",
+    file: join3(".deepcode", "settings.json"),
+    container: "mcpServers",
+    shape: "plain"
+  },
+  {
+    id: "nanobot",
+    name: "nanobot",
+    scope: "home",
+    file: join3(".nanobot", "config.json"),
+    container: "mcpServers",
+    shape: "plain",
+    snippet: (launch) => jsonSnippet(launch, "mcpServers", "plain")
+  },
+  {
+    id: "autohand",
+    name: "Autohand",
+    scope: "home",
+    file: join3(".autohand", "config.json"),
+    container: "mcpServers",
+    shape: "plain",
+    snippet: (launch) => jsonSnippet(launch, "mcpServers", "plain")
   }
-}
-function encodeVariant(value) {
-  const out = [];
-  encodeInto(out, value);
-  return Uint8Array.from(out);
-}
-var MAIN_THREAD = 1;
-function framedCommand(message, data, thread = MAIN_THREAD) {
-  const body = encodeVariant([message, thread, data]);
-  const framed = new Uint8Array(body.length + 4);
-  new DataView(framed.buffer).setUint32(0, body.length, true);
-  framed.set(body, 4);
-  return framed;
-}
-var MOST_MESSAGE_BYTES = (8 << 20) + 4;
-
-class DebuggerStream {
-  pending = new Uint8Array(0);
-  push(chunk) {
-    const joined = new Uint8Array(this.pending.length + chunk.length);
-    joined.set(this.pending, 0);
-    joined.set(chunk, this.pending.length);
-    const out = [];
-    let at = 0;
-    while (joined.length - at >= 4) {
-      const length = new DataView(joined.buffer, joined.byteOffset + at, 4).getUint32(0, true);
-      if (length > MOST_MESSAGE_BYTES) {
-        throw new RangeError(`a message of ${length} bytes, more than the engine sends`);
-      }
-      if (joined.length - at - 4 < length) {
-        break;
+];
+var OURS = ["GODOT_PATH", "GDHARNESS_PROJECT"];
+function environmentFor(launch, held) {
+  const kept = {};
+  if (typeof held === "object" && held !== null && !Array.isArray(held)) {
+    for (const [name, value] of Object.entries(held)) {
+      if (typeof value === "string" && !OURS.includes(name)) {
+        kept[name] = value;
       }
-      out.push(readMessage(joined.subarray(at + 4, at + 4 + length)));
-      at += 4 + length;
     }
-    this.pending = joined.slice(at);
-    return out;
   }
+  return { ...kept, ...launch.env };
 }
-function readMessage(body) {
-  let value;
-  try {
-    value = decodeVariant(body);
-  } catch (error) {
-    return { unreadable: error instanceof Error ? error.message : String(error) };
-  }
-  if (!Array.isArray(value) || value.length !== 3) {
-    return { unreadable: "a message that is not [message, thread, data]" };
-  }
-  const [message, thread, data] = value;
-  if (typeof message !== "string" || typeof thread !== "number" || !Array.isArray(data)) {
-    return { unreadable: "a message whose name, thread or data is the wrong type" };
+function entryFor(shape, launch, held) {
+  const before = typeof held === "object" && held !== null && !Array.isArray(held) ? { ...held } : {};
+  if (shape === "opencode") {
+    return {
+      ...before,
+      type: "local",
+      command: [launch.command, ...launch.args],
+      environment: environmentFor(launch, before["environment"]),
+      enabled: true
+    };
   }
-  return { message, thread, data };
+  return {
+    ...before,
+    ...shape === "typed" ? { type: "stdio" } : {},
+    command: launch.command,
+    args: [...launch.args],
+    env: environmentFor(launch, before["env"])
+  };
 }
 
-// src/setup.ts
-import { dirname as dirname3, join as join5 } from "node:path";
-import { fileURLToPath } from "node:url";
-
 // src/gdscript-source.ts
 var DECLARING = new Set(["var", "const", "func", "signal", "enum", "class", "for", "class_name"]);
 var NAME = "[\\p{L}_][\\p{L}\\p{N}_]*";
@@ -7807,6 +8004,23 @@ import { readFileSync as readFileSync2, renameSync, rmSync as rmSync2, writeFile
 var HELD_FILE_MS = 1000;
 var HELD_FILE_RETRY_MS = 10;
 var HELD_BY_A_READER = new Set(["EPERM", "EACCES", "EBUSY"]);
+function readWhole(path) {
+  const until = Date.now() + HELD_FILE_MS;
+  for (;; ) {
+    try {
+      return readFileSync2(path, "utf8");
+    } catch (error) {
+      const code = error.code ?? "";
+      if (code === "ENOENT") {
+        return null;
+      }
+      if (!HELD_BY_A_READER.has(code) || Date.now() >= until) {
+        throw error;
+      }
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, HELD_FILE_RETRY_MS);
+    }
+  }
+}
 function writeWhole(path, text) {
   const partial = `${path}.${process.pid}.partial`;
   try {
@@ -7831,719 +8045,757 @@ function writeWhole(path, text) {
     }
   }
 }
-
-// src/dictionary.ts
-function emptyRecord() {
-  return Object.create(null);
+function removeWhole(path) {
+  const until = Date.now() + HELD_FILE_MS;
+  for (;; ) {
+    try {
+      rmSync2(path, { force: true });
+      return true;
+    } catch (error) {
+      const code = error.code ?? "";
+      if (!HELD_BY_A_READER.has(code) || Date.now() >= until) {
+        return false;
+      }
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, HELD_FILE_RETRY_MS);
+    }
+  }
 }
 
-// src/call-signal.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var current = new AsyncLocalStorage;
+// src/engine-leaks.ts
+var REFCOUNTED_HELD = "A RefCounted alive at exit is held by a cycle of references (two holding each other, or one " + "holding a lambda that captures it) or by an Object never freed, rather than by a node left out " + "of the tree; a WeakRef on one side of the cycle, or clearing the reference once done, frees it.";
+var WALK_STOPPED_SENTENCE = "The engine's shutdown stopped part way through its scripts (godot#117991, fixed in 4.8 by " + "godot#120976), so it reported as leaked at exit what it never got to free, and the report is the " + "engine's rather than the run's. gdharness holds every script loaded from a file past that walk, " + "which keeps it whole, so this one stopped on a script it could not hold, such as one made in code. " + "A leak of the run's own is not told apart in such a run.";
+var NAME2 = "[\\p{L}_][\\p{L}\\p{N}_]*";
+var EXPORTED = new RegExp(`@export(?!_(?:group|subgroup|category)\\b)\\w*(?:\\([^)]*\\))?\\s+(?:@${NAME2}(?:\\([^)]*\\))?\\s+)*` + `(?:static\\s+)?var\\s+(${NAME2})\\s*:\\s*(?:Array|Dictionary)\\s*\\[([^\\]]*)\\]`, "gu");
 
-// src/harnesses.ts
-import { basename as basename2, dirname as dirname2, isAbsolute as isAbsolute2, join as join3, relative as relative2, resolve as resolve2 } from "node:path";
+// src/junit.ts
+var ESCAPE = String.fromCharCode(27);
+var LOCATION = `'[^'\\n]*' in \\S+:\\d+`;
+var IGNORING_CASE = " \\(ignoring case\\)";
+var PRINTED_ACTUAL = new RegExp(` but was\\n '((?:(?!\\tat ${LOCATION})[\\s\\S])*?)'((?:${ESCAPE}\\[[0-9;]*m)*)(${IGNORING_CASE})?((?:${ESCAPE}\\[[0-9;]*m)*)\\tat (${LOCATION})`, "g");
+var QUOTED_EQUALITY = new RegExp(`^Expecting(?: error message)?:\\n '([\\s\\S]*)'\\n but was\\n '([\\s\\S]*)'(?:${IGNORING_CASE})?\\n\\tat `);
+var COLOUR = new RegExp(`${ESCAPE}\\[([0-9;]*)m`, "g");
+var HOOKS_LEFT = new Map([
+  ["before", "before()"],
+  ["after", "after()"],
+  ["before or after", "before() or after()"]
+]);
 
-// node_modules/yaml/dist/index.js
-var composer = require_composer();
-var Document = require_Document();
-var Schema = require_Schema();
-var errors = require_errors();
-var Alias = require_Alias();
-var identity = require_identity();
-var Pair = require_Pair();
-var Scalar = require_Scalar();
-var YAMLMap = require_YAMLMap();
-var YAMLSeq = require_YAMLSeq();
-var cst = require_cst();
-var lexer = require_lexer();
-var lineCounter = require_line_counter();
-var parser = require_parser();
-var publicApi = require_public_api();
-var visit = require_visit();
-var $Composer = composer.Composer;
-var $Document = Document.Document;
-var $Schema = Schema.Schema;
-var $YAMLError = errors.YAMLError;
-var $YAMLParseError = errors.YAMLParseError;
-var $YAMLWarning = errors.YAMLWarning;
-var $Alias = Alias.Alias;
-var $isAlias = identity.isAlias;
-var $isCollection = identity.isCollection;
-var $isDocument = identity.isDocument;
-var $isMap = identity.isMap;
-var $isNode = identity.isNode;
-var $isPair = identity.isPair;
-var $isScalar = identity.isScalar;
-var $isSeq = identity.isSeq;
-var $Pair = Pair.Pair;
-var $Scalar = Scalar.Scalar;
-var $YAMLMap = YAMLMap.YAMLMap;
-var $YAMLSeq = YAMLSeq.YAMLSeq;
-var $Lexer = lexer.Lexer;
-var $LineCounter = lineCounter.LineCounter;
-var $Parser = parser.Parser;
-var $parse = publicApi.parse;
-var $parseAllDocuments = publicApi.parseAllDocuments;
-var $parseDocument = publicApi.parseDocument;
-var $stringify = publicApi.stringify;
-var $visit = visit.visit;
-var $visitAsync = visit.visitAsync;
+// src/suite-judge.ts
+var TIME = String.raw`(?:\d+h )?(?:\d+min )?(?:\d+s )?\d+ms`;
+var CASE_LINE = new RegExp(String.raw`^\s*(res://.+?\.gd) > (.+?) (STARTED|PASSED|FAILED|FLAKY|SKIPPED|WARNING)(?: \((?:retry \d+|\d+ retries)\))?(?: (${TIME}))?\s*$`);
+var STATISTICS = new RegExp(String.raw`^Statistics:.*\|\s*([A-Z]+)(?:\s+\(.*?\))?\s+(${TIME})\s*$`);
+var WINDOWS_EXITS = new Map([
+  [3221225477, "STATUS_ACCESS_VIOLATION"],
+  [3221225495, "STATUS_NO_MEMORY"],
+  [3221225773, "STATUS_COMMITMENT_LIMIT"],
+  [3221225794, "STATUS_DLL_INIT_FAILED"],
+  [3221226505, "STATUS_STACK_BUFFER_OVERRUN"],
+  [3228369022, "a module that could not be found (VcppException)"],
+  [3228369023, "a procedure that could not be found (VcppException)"]
+]);
+var MEMORY_EXITS = new Set([3221225495, 3221225773]);
+var GDUNIT_FAILED = 100;
+var GDUNIT_ORPHANS = 101;
+var GDUNIT_EXITS = new Map([
+  [GDUNIT_FAILED, "gdUnit4's code for a case that failed or errored"],
+  [GDUNIT_ORPHANS, "gdUnit4's code for orphan nodes left behind"],
+  [103, "gdUnit4's code for a suite that cannot run headless"],
+  [104, "gdUnit4's code for a Godot version it does not support"],
+  [105, "gdUnit4's code for scripts that did not compile"]
+]);
+var GODOT_EXITS = new Set([1, 255]);
 
-// src/paths.ts
-import { realpathSync, statSync as statSync2 } from "node:fs";
-import { basename, dirname, isAbsolute, join as join2, relative, resolve, sep } from "node:path";
-function realAsFarAsItExists(path) {
-  const missing = [];
-  let at = path;
-  for (;; ) {
+// src/windows-ask.ts
+import { tmpdir as tmpdir2 } from "node:os";
+import process3 from "node:process";
+var SCRIPT = [
+  "[Console]::OutputEncoding = [Text.Encoding]::UTF8",
+  "$in = [Console]::In",
+  "while ($null -ne ($line = $in.ReadLine())) {",
+  '  $parts = $line.Split(" ", 2)',
+  "  try {",
+  "    $asked = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($parts[1]))",
+  "    $said = (& ([ScriptBlock]::Create($asked)) | Out-String -Width 1000000)",
+  '    $tag = "OK"',
+  "  } catch {",
+  "    $said = $_.Exception.Message",
+  '    $tag = "ERR"',
+  "  }",
+  '  [Console]::Out.Write($parts[0] + " " + $tag + " " + [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($said)) + "`n")',
+  "  [Console]::Out.Flush()",
+  "}"
+].join(`
+`);
+
+class WindowsAskFailure extends Error {
+  constructor(how) {
+    super(`PowerShell ${how}`);
+  }
+}
+var helper = null;
+var buffered = "";
+var next = 1;
+var out = null;
+var queued = [];
+var held = false;
+function holding(child, wanted) {
+  if (held === wanted) {
+    return;
+  }
+  held = wanted;
+  const stdout = child.stdout;
+  if (wanted) {
+    stdout.ref?.();
+  } else {
+    stdout.unref?.();
+  }
+}
+function running() {
+  if (helper?.exitCode === null && helper.signalCode === null) {
+    return helper;
+  }
+  const child = spawnHidden("powershell.exe", [
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-EncodedCommand",
+    Buffer.from(SCRIPT, "utf16le").toString("base64")
+  ], { cwd: tmpdir2() });
+  buffered = "";
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    buffered += chunk;
+    for (let end = buffered.indexOf(`
+`);end !== -1; end = buffered.indexOf(`
+`)) {
+      answered(buffered.slice(0, end).trim());
+      buffered = buffered.slice(end + 1);
+    }
+  });
+  child.stderr.resume();
+  child.stdin.on("error", () => {});
+  const gone = () => {
+    if (helper !== child) {
+      return;
+    }
+    helper = null;
+    if (out !== null) {
+      clearTimeout(out.timer);
+      out.question.reject(new WindowsAskFailure("exited before it answered"));
+      out = null;
+    }
+    sendNext();
+  };
+  child.once("exit", gone);
+  child.once("error", gone);
+  child.unref();
+  child.stdin.unref?.();
+  child.stderr.unref?.();
+  held = true;
+  holding(child, false);
+  helper = child;
+  return child;
+}
+function answered(line) {
+  const [id, tag, body] = line.split(" ");
+  if (out === null || out.id !== Number(id)) {
+    return;
+  }
+  const { question, timer } = out;
+  clearTimeout(timer);
+  out = null;
+  const said = Buffer.from(body ?? "", "base64").toString("utf8");
+  if (tag === "OK") {
+    question.resolve(said);
+  } else {
+    question.reject(new WindowsAskFailure(`refused the question: ${said.trim() || "no reason given"}`));
+  }
+  sendNext();
+}
+function sendNext() {
+  const question = queued.shift();
+  if (question === undefined) {
+    if (helper !== null) {
+      holding(helper, false);
+    }
+    return;
+  }
+  const child = running();
+  holding(child, true);
+  const id = next;
+  next += 1;
+  const timer = setTimeout(() => {
+    if (out?.id !== id) {
+      return;
+    }
+    out = null;
+    question.reject(new WindowsAskFailure(`did not answer within ${question.withinMs}ms`));
+    if (helper === child) {
+      helper = null;
+    }
+    child.kill();
+    sendNext();
+  }, question.withinMs);
+  out = { id, question, timer };
+  child.stdin.write(`${id} ${Buffer.from(question.script, "utf8").toString("base64")}
+`);
+}
+function askWindows(script, withinMs) {
+  if (process3.platform !== "win32") {
+    return Promise.reject(new WindowsAskFailure("is asked only on Windows"));
+  }
+  return new Promise((resolve, reject) => {
+    queued.push({ script, withinMs, resolve, reject });
+    if (out === null) {
+      sendNext();
+    }
+  });
+}
+
+// src/engine-launch.ts
+var CONTROL_SEQUENCE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;?]*[A-Za-z]`, "g");
+var MEMORY_KEPT = 4 * 1024 ** 3;
+var MEMORY_PER_ENGINE = 1.5 * 1024 ** 3;
+
+// src/process-children.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { basename as basename3 } from "node:path";
+async 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 = await askWindows(`Get-CimInstance Win32_Process -Filter "${filter}" | ForEach-Object { "$($_.ProcessId) $(([DateTimeOffset]$_.CreationDate).ToUnixTimeMilliseconds())" }`, ASK_TIMEOUT_MS);
+      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;
+    }
+    if (process.platform === "linux") {
+      return await linuxStartTimes(pids);
+    }
+    const said = await printedBy("ps", ["-p", pids.join(","), "-o", "pid=,lstart="], {
+      ...process.env,
+      LC_ALL: "C"
+    });
+    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 linuxStartTimes(pids) {
+  const began = new Map;
+  const hertz = await ticksPerSecond();
+  let booted;
+  try {
+    booted = Number(/^btime\s+(\d+)$/m.exec(readFileSync3("/proc/stat", "utf8"))?.[1] ?? Number.NaN) * 1000;
+  } catch {
+    return began;
+  }
+  if (hertz === null || Number.isNaN(booted)) {
+    return began;
+  }
+  for (const pid of pids) {
+    let stat;
     try {
-      return join2(realpathSync.native(at), ...missing);
+      stat = readFileSync3(`/proc/${String(pid)}/stat`, "utf8");
     } catch {
-      const parent = dirname(at);
-      if (parent === at) {
-        return path;
-      }
-      missing.unshift(basename(at));
-      at = parent;
+      continue;
+    }
+    const ticks = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19]);
+    if (Number.isInteger(ticks) && ticks >= 0) {
+      began.set(pid, booted + Math.round(ticks * 1000 / hertz));
     }
   }
+  return began;
 }
-
-// src/harnesses.ts
-var SERVER_KEY = "gdharness";
-function tomlArray(values) {
-  return `[${values.map((value) => `"${value}"`).join(", ")}]`;
+async function linuxStartEarliest() {
+  return 1000 + Math.ceil(1000 / (await ticksPerSecond() ?? 100));
 }
-function tomlEnv(launch) {
-  const pairs = Object.entries(launch.env).map(([name, value]) => `${name} = "${value}"`);
-  return `env = { ${pairs.join(", ")} }`;
+var ticksAnswered;
+async function ticksPerSecond() {
+  if (ticksAnswered !== undefined) {
+    return ticksAnswered;
+  }
+  try {
+    const hertz = Number((await runHidden("getconf", ["CLK_TCK"], { timeout: ASK_TIMEOUT_MS })).stdout.trim());
+    if (Number.isInteger(hertz) && hertz > 0) {
+      ticksAnswered = hertz;
+      return hertz;
+    }
+  } catch {}
+  return null;
 }
-function jsonSnippet(launch, container, shape) {
-  return JSON.stringify({ [container]: { [SERVER_KEY]: entryFor(shape, launch) } }, null, 2);
+function printedBy(command, args, env) {
+  return runHidden(command, args, { timeout: ASK_TIMEOUT_MS, env }).then(({ stdout }) => stdout, (error) => {
+    const printed = error.stdout;
+    return typeof printed === "string" ? printed : "";
+  });
 }
-var HARNESSES = [
-  {
-    id: "claude-code",
-    name: "Claude Code",
-    scope: "project",
-    file: ".mcp.json",
-    container: "mcpServers",
-    shape: "plain",
-    home: ".claude",
-    marker: ".claude",
-    skills: { dir: join3(".claude", "skills"), shared: false }
-  },
-  {
-    id: "copilot-cli",
-    name: "Copilot CLI",
-    scope: "project",
-    file: ".mcp.json",
-    container: "mcpServers",
-    shape: "plain",
-    home: ".copilot",
-    skills: { dir: join3(".github", "skills"), shared: true },
-    manual: "Trust the folder when Copilot CLI first asks, or it reads no config here."
-  },
-  {
-    id: "qoder",
-    name: "Qoder",
-    scope: "project",
-    file: ".mcp.json",
-    container: "mcpServers",
-    shape: "plain",
-    home: ".qoder",
-    marker: ".qoder"
-  },
-  {
-    id: "command-code",
-    name: "Command Code",
-    scope: "project",
-    file: ".mcp.json",
-    container: "mcpServers",
-    shape: "plain",
-    home: ".commandcode"
-  },
-  {
-    id: "cursor",
-    name: "Cursor",
-    scope: "project",
-    file: join3(".cursor", "mcp.json"),
-    container: "mcpServers",
-    shape: "plain",
-    home: ".cursor",
-    skills: { dir: join3(".cursor", "skills"), shared: true },
-    manual: "Cursor asks before each tool call by default, and the server can be toggled off."
-  },
-  {
-    id: "vscode",
-    name: "VS Code",
-    scope: "project",
-    file: join3(".vscode", "mcp.json"),
-    container: "servers",
-    shape: "typed",
-    home: ".vscode",
-    skills: { dir: join3(".github", "skills"), shared: true },
-    manual: "VS Code asks you to trust a server the first time it starts one."
-  },
-  {
-    id: "opencode",
-    name: "opencode",
-    scope: "project",
-    file: "opencode.json",
-    container: "mcp",
-    shape: "opencode",
-    home: join3(".config", "opencode"),
-    marker: ".opencode",
-    skills: { dir: join3(".opencode", "skills"), shared: true }
-  },
-  {
-    id: "junie",
-    name: "Junie",
-    scope: "project",
-    file: join3(".junie", "mcp", "mcp.json"),
-    container: "mcpServers",
-    shape: "plain",
-    home: ".junie",
-    skills: { dir: join3(".junie", "skills"), shared: true }
-  },
-  {
-    id: "kiro",
-    name: "Kiro",
-    scope: "project",
-    file: join3(".kiro", "settings", "mcp.json"),
-    container: "mcpServers",
-    shape: "plain",
-    home: ".kiro",
-    skills: { dir: join3(".kiro", "skills"), shared: false }
-  },
-  {
-    id: "gemini",
-    name: "Gemini CLI",
-    scope: "project",
-    file: join3(".gemini", "settings.json"),
-    container: "mcpServers",
-    shape: "plain",
-    home: ".gemini",
-    skills: { dir: join3(".gemini", "skills"), shared: true }
-  },
-  {
-    id: "roo",
-    name: "Roo Code",
-    scope: "project",
-    file: join3(".roo", "mcp.json"),
-    container: "mcpServers",
-    shape: "plain"
-  },
-  {
-    id: "kilo",
-    name: "Kilo Code",
-    scope: "project",
-    file: join3(".kilocode", "mcp.json"),
-    container: "mcpServers",
-    shape: "plain"
-  },
-  {
-    id: "amazon-q",
-    name: "Amazon Q Developer CLI",
-    scope: "project",
-    file: join3(".amazonq", "mcp.json"),
-    container: "mcpServers",
-    shape: "plain",
-    home: join3(".aws", "amazonq")
-  },
-  {
-    id: "zed",
-    name: "Zed",
-    scope: "project",
-    file: join3(".zed", "settings.json"),
-    container: "context_servers",
-    shape: "plain"
-  },
-  {
-    id: "amp",
-    name: "Amp",
-    scope: "project",
-    file: join3(".amp", "settings.json"),
-    container: "amp.mcpServers",
-    shape: "plain",
-    home: join3(".config", "amp")
-  },
-  {
-    id: "warp",
-    name: "Warp",
-    scope: "project",
-    file: join3(".warp", ".mcp.json"),
-    container: "mcpServers",
-    shape: "plain",
-    home: ".warp",
-    manual: "Warp starts a project server only once you toggle it on, on its MCP servers page."
-  },
-  {
-    id: "trae",
-    name: "Trae",
-    scope: "project",
-    file: join3(".trae", "mcp.json"),
-    container: "mcpServers",
-    shape: "plain",
-    home: ".trae"
-  },
-  {
-    id: "factory",
-    name: "Factory Droid",
-    scope: "project",
-    file: join3(".factory", "mcp.json"),
-    container: "mcpServers",
-    shape: "typed",
-    home: ".factory"
-  },
-  {
-    id: "tabnine",
-    name: "Tabnine",
-    scope: "project",
-    file: join3(".tabnine", "mcp_servers.json"),
-    container: "mcpServers",
-    shape: "plain",
-    home: ".tabnine"
-  },
-  {
-    id: "firebender",
-    name: "Firebender",
-    scope: "project",
-    file: "firebender.json",
-    container: "mcpServers",
-    shape: "plain"
-  },
-  {
-    id: "pi",
-    name: "pi",
-    scope: "project",
-    file: join3(".pi", "mcp.json"),
-    container: "mcpServers",
-    shape: "plain",
-    home: ".pi"
-  },
-  {
-    id: "mistral-vibe",
-    name: "Mistral Vibe",
-    scope: "project",
-    file: join3(".vibe", "config.toml"),
-    container: "mcp_servers",
-    shape: "plain",
-    toml: {
-      header: "[[mcp_servers]]",
-      identity: `name = "${SERVER_KEY}"`,
-      block: (launch) => [
-        "[[mcp_servers]]",
-        `name = "${SERVER_KEY}"`,
-        'transport = "stdio"',
-        `command = "${launch.command}"`,
-        `args = ${tomlArray(launch.args)}`,
-        tomlEnv(launch)
-      ].join(`
-`)
-    }
-  },
-  {
-    id: "vtcode",
-    name: "VT Code",
-    scope: "project",
-    file: "vtcode.toml",
-    container: "mcp.providers",
-    shape: "plain",
-    marker: ".vtcode",
-    toml: {
-      header: "[[mcp.providers]]",
-      identity: `name = "${SERVER_KEY}"`,
-      enable: { header: "[mcp]", line: "enabled = true" },
-      block: (launch) => [
-        "[[mcp.providers]]",
-        `name = "${SERVER_KEY}"`,
-        "enabled = true",
-        `command = "${launch.command}"`,
-        `args = ${tomlArray(launch.args)}`,
-        tomlEnv(launch)
-      ].join(`
-`)
+var ASK_TIMEOUT_MS = 15000;
+var ONE_SHOT_OPTIONS = [
+  "--import",
+  "--quit",
+  "--quit-after",
+  "--export-release",
+  "--export-debug",
+  "--export-pack",
+  "--export-patch",
+  "--doctool",
+  "--gdscript-docs",
+  "--script",
+  "-s",
+  "--check-only",
+  "--build-solutions",
+  "--dump-gdextension-interface",
+  "--dump-extension-api",
+  "--dump-extension-api-with-docs",
+  "--validate-extension-api",
+  "--convert-3to4",
+  "--validate-conversion-3to4"
+];
+function readCommandLine(command) {
+  const all = commandWords(command);
+  const separator = all.findIndex((word) => word === "--" || word === "++");
+  const words = separator === -1 ? all : all.slice(0, separator);
+  const executable = words[0] === undefined ? "" : basename3(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);
     }
-  },
-  {
-    id: "fast-agent",
-    name: "fast-agent",
-    scope: "project",
-    file: "fastagent.config.yaml",
-    container: "mcp",
-    shape: "plain",
-    yaml: {
-      path: ["mcp", "servers", SERVER_KEY],
-      entry: (launch) => ({ command: launch.command, args: [...launch.args], env: { ...launch.env } })
+    projectPath = taken.join(" ").replaceAll("%20", " ");
+  }
+  return {
+    executable,
+    projectPath,
+    editor: words.some((word) => word === "-e" || word === "--editor"),
+    oneShot: words.find((word) => ONE_SHOT_OPTIONS.includes(word)) ?? null
+  };
+}
+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;
     }
-  },
-  {
-    id: "codex",
-    name: "Codex CLI",
-    scope: "home",
-    file: join3(".codex", "config.toml"),
-    container: "mcp_servers",
-    shape: "plain",
-    manual: "Codex reads its config at startup, so restart it.",
-    toml: {
-      header: `[mcp_servers.${SERVER_KEY}]`,
-      block: (launch) => [
-        `[mcp_servers.${SERVER_KEY}]`,
-        `command = "${launch.command}"`,
-        `args = ${tomlArray(launch.args)}`,
-        tomlEnv(launch)
-      ].join(`
-`)
+  }
+  if (started) {
+    words.push(word);
+  }
+  return words;
+}
+
+// src/engine-slots.ts
+function holderOf(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null) {
+      return null;
     }
-  },
-  {
-    id: "cline",
-    name: "Cline",
-    scope: "home",
-    file: join3(".cline", "data", "settings", "cline_mcp_settings.json"),
-    container: "mcpServers",
-    shape: "plain",
-    marker: ".cline",
-    skills: { dir: join3(".cline", "skills"), shared: false }
-  },
-  {
-    id: "goose",
-    name: "Goose",
-    scope: "home",
-    file: {
-      win32: { appData: join3("Block", "goose", "config", "config.yaml") },
-      darwin: join3(".config", "goose", "config.yaml"),
-      linux: join3(".config", "goose", "config.yaml")
-    },
-    container: "extensions",
-    shape: "plain",
-    yaml: {
-      path: ["extensions", SERVER_KEY],
-      entry: (launch) => ({
-        name: SERVER_KEY,
-        type: "stdio",
-        enabled: true,
-        cmd: launch.command,
-        args: [...launch.args],
-        envs: { ...launch.env },
-        timeout: 300
-      })
+    const { pid, started, by } = parsed;
+    if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0 || typeof started !== "number") {
+      return null;
     }
-  },
-  {
-    id: "windsurf",
-    name: "Windsurf",
-    scope: "home",
-    file: join3(".codeium", "windsurf", "mcp_config.json"),
-    container: "mcpServers",
-    shape: "plain",
-    skills: { dir: join3(".windsurf", "skills"), shared: true }
-  },
-  {
-    id: "hermes",
-    name: "Hermes",
-    scope: "home",
-    file: join3(".hermes", "config.yaml"),
-    container: "mcp_servers",
-    shape: "plain",
-    skills: { dir: join3(".hermes", "skills"), shared: true },
-    yaml: {
-      path: ["mcp_servers", SERVER_KEY],
-      entry: (launch) => ({
-        command: launch.command,
-        args: [...launch.args],
-        env: { ...launch.env },
-        enabled: true
-      })
+    return typeof by === "string" && by !== "" ? { pid, started, by } : { pid, started };
+  } catch {
+    return null;
+  }
+}
+async function ownStart() {
+  const said = (await startTimesOf([process4.pid])).get(process4.pid);
+  return said ?? Math.round(Date.now() - process4.uptime() * 1000);
+}
+function handSlot(lock, from, to) {
+  let content;
+  try {
+    content = readWhole(lock);
+  } catch {
+    return false;
+  }
+  return content !== null && holderOf(content)?.pid === from && writeWhole(lock, JSON.stringify(to));
+}
+function giveBackSlot(lock, pid) {
+  try {
+    if (holderOf(readFileSync4(lock, "utf8"))?.pid === pid) {
+      removeWhole(lock);
     }
-  },
-  {
-    id: "openclaw",
-    name: "OpenClaw",
-    scope: "home",
-    file: join3(".openclaw", "openclaw.json"),
-    container: "mcpServers",
-    shape: "plain"
-  },
-  {
-    id: "claude-desktop",
-    name: "Claude Desktop",
-    scope: "home",
-    file: {
-      win32: { appData: join3("Claude", "claude_desktop_config.json") },
-      darwin: join3("Library", "Application Support", "Claude", "claude_desktop_config.json"),
-      linux: join3(".config", "Claude", "claude_desktop_config.json")
-    },
-    container: "mcpServers",
-    shape: "plain"
-  },
-  {
-    id: "zeroclaw",
-    name: "ZeroClaw",
-    scope: "home",
-    file: join3(".zeroclaw", "config.toml"),
-    container: "mcp.servers",
-    shape: "plain",
-    toml: {
-      header: "[[mcp.servers]]",
-      identity: `name = "${SERVER_KEY}"`,
-      enable: { header: "[mcp]", line: "enabled = true" },
-      block: (launch) => [
-        "[[mcp.servers]]",
-        `name = "${SERVER_KEY}"`,
-        `command = "${launch.command}"`,
-        `args = ${tomlArray(launch.args)}`,
-        tomlEnv(launch)
-      ].join(`
-`)
+  } catch {}
+}
+
+// src/error-mode.ts
+import process5 from "node:process";
+var NO_FAULT_ERROR_BOX = 2;
+var cleared = process5.platform !== "win32";
+async function letWindowsReportCrashes() {
+  if (cleared || !("bun" in process5.versions)) {
+    return;
+  }
+  try {
+    const { dlopen, FFIType } = await import("bun:ffi");
+    const kernel32 = dlopen("kernel32.dll", {
+      GetErrorMode: { args: [], returns: FFIType.u32 },
+      SetErrorMode: { args: [FFIType.u32], returns: FFIType.u32 }
+    });
+    try {
+      const mode = kernel32.symbols.GetErrorMode();
+      kernel32.symbols.SetErrorMode(mode & ~NO_FAULT_ERROR_BOX);
+      cleared = true;
+    } finally {
+      kernel32.close();
     }
-  },
-  {
-    id: "deepcode",
-    name: "Deep Code",
-    scope: "home",
-    file: join3(".deepcode", "settings.json"),
-    container: "mcpServers",
-    shape: "plain"
-  },
-  {
-    id: "nanobot",
-    name: "nanobot",
-    scope: "home",
-    file: join3(".nanobot", "config.json"),
-    container: "mcpServers",
-    shape: "plain",
-    snippet: (launch) => jsonSnippet(launch, "mcpServers", "plain")
-  },
-  {
-    id: "autohand",
-    name: "Autohand",
-    scope: "home",
-    file: join3(".autohand", "config.json"),
-    container: "mcpServers",
-    shape: "plain",
-    snippet: (launch) => jsonSnippet(launch, "mcpServers", "plain")
+  } catch {}
+}
+function crashesReported() {
+  return cleared;
+}
+
+// src/game-debugger.ts
+import { readFileSync as readFileSync6 } from "node:fs";
+import { createServer } from "node:net";
+import { join as join6 } from "node:path";
+
+// src/godot-variant.ts
+var NIL = 0;
+var BOOL = 1;
+var INT = 2;
+var FLOAT = 3;
+var STRING = 4;
+var ARRAY = 28;
+var FLAG_64 = 1 << 16;
+var MATH = {
+  5: { name: "Vector2", count: 2 },
+  6: { name: "Vector2i", count: 2, ints: true },
+  7: { name: "Rect2", count: 4 },
+  8: { name: "Rect2i", count: 4, ints: true },
+  9: { name: "Vector3", count: 3 },
+  10: { name: "Vector3i", count: 3, ints: true },
+  11: { name: "Transform2D", count: 6 },
+  12: { name: "Vector4", count: 4 },
+  13: { name: "Vector4i", count: 4, ints: true },
+  14: { name: "Plane", count: 4 },
+  15: { name: "Quaternion", count: 4 },
+  16: { name: "AABB", count: 6 },
+  17: { name: "Basis", count: 9 },
+  18: { name: "Transform3D", count: 12 },
+  19: { name: "Projection", count: 16 }
+};
+var PACKED_VECTORS = { 35: 2, 36: 3, 38: 4 };
+
+class Reader {
+  offset = 0;
+  view;
+  constructor(view) {
+    this.view = view;
   }
-];
-var OURS = ["GODOT_PATH", "GDHARNESS_PROJECT"];
-function environmentFor(launch, held) {
-  const kept = {};
-  if (typeof held === "object" && held !== null && !Array.isArray(held)) {
-    for (const [name, value] of Object.entries(held)) {
-      if (typeof value === "string" && !OURS.includes(name)) {
-        kept[name] = value;
-      }
+  get remaining() {
+    return this.view.byteLength - this.offset;
+  }
+  need(bytes) {
+    if (bytes < 0 || bytes > this.remaining) {
+      throw new RangeError(`a value runs past the end of its message (${bytes} bytes wanted, ${this.remaining} left)`);
     }
   }
-  return { ...kept, ...launch.env };
+  u32() {
+    this.need(4);
+    const value = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  i32() {
+    this.need(4);
+    const value = this.view.getInt32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  i64() {
+    this.need(8);
+    const value = Number(this.view.getBigInt64(this.offset, true));
+    this.offset += 8;
+    return value;
+  }
+  u64() {
+    this.need(8);
+    const value = Number(this.view.getBigUint64(this.offset, true));
+    this.offset += 8;
+    return value;
+  }
+  f32() {
+    this.need(4);
+    const value = this.view.getFloat32(this.offset, true);
+    this.offset += 4;
+    return value;
+  }
+  f64() {
+    this.need(8);
+    const value = this.view.getFloat64(this.offset, true);
+    this.offset += 8;
+    return value;
+  }
+  real(wide) {
+    return wide ? this.f64() : this.f32();
+  }
+  bytes(count) {
+    this.need(count);
+    const out = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, count);
+    this.offset += count;
+    return out;
+  }
+  string() {
+    const length = this.u32();
+    const text = new TextDecoder().decode(this.bytes(length));
+    this.bytes((4 - length % 4) % 4);
+    return text;
+  }
 }
-function entryFor(shape, launch, held) {
-  const before = typeof held === "object" && held !== null && !Array.isArray(held) ? { ...held } : {};
-  if (shape === "opencode") {
+var MAX_DEPTH = 1024;
+function containerType(reader, kind) {
+  if (kind === 1) {
+    reader.u32();
+  } else if (kind === 2 || kind === 3) {
+    reader.string();
+  }
+}
+function decodeValue(reader, depth) {
+  if (depth > MAX_DEPTH) {
+    throw new RangeError("a value nests deeper than the engine allows");
+  }
+  const header = reader.u32();
+  const type = header & 255;
+  const wide = (header & FLAG_64) !== 0;
+  const math = MATH[type];
+  if (math !== undefined) {
     return {
-      ...before,
-      type: "local",
-      command: [launch.command, ...launch.args],
-      environment: environmentFor(launch, before["environment"]),
-      enabled: true
+      kind: math.name,
+      values: Array.from({ length: math.count }, () => math.ints === true ? reader.i32() : reader.real(wide))
     };
   }
-  return {
-    ...before,
-    ...shape === "typed" ? { type: "stdio" } : {},
-    command: launch.command,
-    args: [...launch.args],
-    env: environmentFor(launch, before["env"])
-  };
-}
-
-// src/engine-leaks.ts
-var REFCOUNTED_HELD = "A RefCounted alive at exit is held by a cycle of references (two holding each other, or one " + "holding a lambda that captures it) or by an Object never freed, rather than by a node left out " + "of the tree; a WeakRef on one side of the cycle, or clearing the reference once done, frees it.";
-var WALK_STOPPED_SENTENCE = "The engine's shutdown stopped part way through its scripts (godot#117991, fixed in 4.8 by " + "godot#120976), so it reported as leaked at exit what it never got to free, and the report is the " + "engine's rather than the run's. gdharness holds every script loaded from a file past that walk, " + "which keeps it whole, so this one stopped on a script it could not hold, such as one made in code. " + "A leak of the run's own is not told apart in such a run.";
-var NAME2 = "[\\p{L}_][\\p{L}\\p{N}_]*";
-var EXPORTED = new RegExp(`@export(?!_(?:group|subgroup|category)\\b)\\w*(?:\\([^)]*\\))?\\s+(?:@${NAME2}(?:\\([^)]*\\))?\\s+)*` + `(?:static\\s+)?var\\s+(${NAME2})\\s*:\\s*(?:Array|Dictionary)\\s*\\[([^\\]]*)\\]`, "gu");
-
-// src/junit.ts
-var ESCAPE = String.fromCharCode(27);
-var LOCATION = `'[^'\\n]*' in \\S+:\\d+`;
-var IGNORING_CASE = " \\(ignoring case\\)";
-var PRINTED_ACTUAL = new RegExp(` but was\\n '((?:(?!\\tat ${LOCATION})[\\s\\S])*?)'((?:${ESCAPE}\\[[0-9;]*m)*)(${IGNORING_CASE})?((?:${ESCAPE}\\[[0-9;]*m)*)\\tat (${LOCATION})`, "g");
-var QUOTED_EQUALITY = new RegExp(`^Expecting(?: error message)?:\\n '([\\s\\S]*)'\\n but was\\n '([\\s\\S]*)'(?:${IGNORING_CASE})?\\n\\tat `);
-var COLOUR = new RegExp(`${ESCAPE}\\[([0-9;]*)m`, "g");
-var HOOKS_LEFT = new Map([
-  ["before", "before()"],
-  ["after", "after()"],
-  ["before or after", "before() or after()"]
-]);
-
-// src/suite-judge.ts
-var TIME = String.raw`(?:\d+h )?(?:\d+min )?(?:\d+s )?\d+ms`;
-var CASE_LINE = new RegExp(String.raw`^\s*(res://.+?\.gd) > (.+?) (STARTED|PASSED|FAILED|FLAKY|SKIPPED|WARNING)(?: \((?:retry \d+|\d+ retries)\))?(?: (${TIME}))?\s*$`);
-var STATISTICS = new RegExp(String.raw`^Statistics:.*\|\s*([A-Z]+)(?:\s+\(.*?\))?\s+(${TIME})\s*$`);
-var WINDOWS_EXITS = new Map([
-  [3221225477, "STATUS_ACCESS_VIOLATION"],
-  [3221225495, "STATUS_NO_MEMORY"],
-  [3221225773, "STATUS_COMMITMENT_LIMIT"],
-  [3221225794, "STATUS_DLL_INIT_FAILED"],
-  [3221226505, "STATUS_STACK_BUFFER_OVERRUN"],
-  [3228369022, "a module that could not be found (VcppException)"],
-  [3228369023, "a procedure that could not be found (VcppException)"]
-]);
-var MEMORY_EXITS = new Set([3221225495, 3221225773]);
-var GDUNIT_FAILED = 100;
-var GDUNIT_ORPHANS = 101;
-var GDUNIT_EXITS = new Map([
-  [GDUNIT_FAILED, "gdUnit4's code for a case that failed or errored"],
-  [GDUNIT_ORPHANS, "gdUnit4's code for orphan nodes left behind"],
-  [103, "gdUnit4's code for a suite that cannot run headless"],
-  [104, "gdUnit4's code for a Godot version it does not support"],
-  [105, "gdUnit4's code for scripts that did not compile"]
-]);
-var GODOT_EXITS = new Set([1, 255]);
-
-// src/windows-ask.ts
-var SCRIPT = [
-  "[Console]::OutputEncoding = [Text.Encoding]::UTF8",
-  "$in = [Console]::In",
-  "while ($null -ne ($line = $in.ReadLine())) {",
-  '  $parts = $line.Split(" ", 2)',
-  "  try {",
-  "    $asked = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($parts[1]))",
-  "    $said = (& ([ScriptBlock]::Create($asked)) | Out-String -Width 1000000)",
-  '    $tag = "OK"',
-  "  } catch {",
-  "    $said = $_.Exception.Message",
-  '    $tag = "ERR"',
-  "  }",
-  '  [Console]::Out.Write($parts[0] + " " + $tag + " " + [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($said)) + "`n")',
-  "  [Console]::Out.Flush()",
-  "}"
-].join(`
-`);
-
-// src/engine-launch.ts
-var CONTROL_SEQUENCE = new RegExp(`${String.fromCharCode(27)}\\[[0-9;?]*[A-Za-z]`, "g");
-var MEMORY_KEPT = 4 * 1024 ** 3;
-var MEMORY_PER_ENGINE = 1.5 * 1024 ** 3;
-
-// src/process-children.ts
-import { readFileSync as readFileSync3 } from "node:fs";
-import { basename as basename3 } from "node:path";
-async function linuxStartTimes(pids) {
-  const began = new Map;
-  const hertz = await ticksPerSecond();
-  let booted;
-  try {
-    booted = Number(/^btime\s+(\d+)$/m.exec(readFileSync3("/proc/stat", "utf8"))?.[1] ?? Number.NaN) * 1000;
-  } catch {
-    return began;
+  const vectorWidth = PACKED_VECTORS[type];
+  if (vectorWidth !== undefined) {
+    const count = reader.u32();
+    return Array.from({ length: count }, () => ({
+      kind: "Vector",
+      values: Array.from({ length: vectorWidth }, () => reader.real(wide))
+    }));
+  }
+  switch (type) {
+    case NIL:
+      return null;
+    case BOOL:
+      return reader.u32() !== 0;
+    case INT:
+      return wide ? reader.i64() : reader.i32();
+    case FLOAT:
+      return wide ? reader.f64() : reader.f32();
+    case STRING:
+    case 21:
+      return reader.string();
+    case 20:
+      return { kind: "Color", values: [reader.f32(), reader.f32(), reader.f32(), reader.f32()] };
+    case 22: {
+      const first = reader.u32();
+      if ((first & 2147483648) === 0) {
+        throw new RangeError("a node path in the format before 3.0");
+      }
+      const names = first & 2147483647;
+      let subnames = reader.u32();
+      const flags = reader.u32();
+      if ((flags & 2) !== 0) {
+        subnames += 1;
+      }
+      return { kind: "NodePath", values: Array.from({ length: names + subnames }, () => reader.string()) };
+    }
+    case 23:
+      return { kind: "RID", values: [reader.u64()] };
+    case 24:
+      if ((header & FLAG_64) === 0) {
+        throw new RangeError("a full object, which this reader does not take");
+      }
+      return { kind: "Object", values: [reader.u64()] };
+    case 25:
+      return { kind: "Callable", values: [] };
+    case 26:
+      return { kind: "Signal", values: [reader.string(), reader.u64()] };
+    case 27: {
+      containerType(reader, header >> 16 & 3);
+      containerType(reader, header >> 18 & 3);
+      const count = reader.u32() & 2147483647;
+      const entries = [];
+      for (let index = 0;index < count; index += 1) {
+        const key = decodeValue(reader, depth + 1);
+        entries.push([key, decodeValue(reader, depth + 1)]);
+      }
+      return { kind: "dictionary", entries };
+    }
+    case ARRAY: {
+      containerType(reader, header >> 16 & 3);
+      const count = reader.u32() & 2147483647;
+      return Array.from({ length: count }, () => decodeValue(reader, depth + 1));
+    }
+    case 29: {
+      const count = reader.u32();
+      const bytes = [...reader.bytes(count)];
+      reader.bytes((4 - count % 4) % 4);
+      return bytes;
+    }
+    case 30:
+      return Array.from({ length: reader.u32() }, () => reader.i32());
+    case 31:
+      return Array.from({ length: reader.u32() }, () => reader.i64());
+    case 32:
+      return Array.from({ length: reader.u32() }, () => reader.f32());
+    case 33:
+      return Array.from({ length: reader.u32() }, () => reader.f64());
+    case 34:
+      return Array.from({ length: reader.u32() }, () => reader.string().replace(/\0$/, ""));
+    case 37:
+      return Array.from({ length: reader.u32() }, () => ({
+        kind: "Color",
+        values: [reader.f32(), reader.f32(), reader.f32(), reader.f32()]
+      }));
+    default:
+      throw new RangeError(`a value of type ${type}, which Godot 4.7 does not have`);
   }
-  if (hertz === null || Number.isNaN(booted)) {
-    return began;
+}
+function decodeVariant(bytes) {
+  const reader = new Reader(new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+  const value = decodeValue(reader, 0);
+  if (reader.remaining !== 0) {
+    throw new RangeError(`${reader.remaining} bytes left over after the value`);
   }
-  for (const pid of pids) {
-    let stat;
-    try {
-      stat = readFileSync3(`/proc/${String(pid)}/stat`, "utf8");
-    } catch {
-      continue;
+  return value;
+}
+function pushU32(out, value) {
+  out.push(value & 255, value >>> 8 & 255, value >>> 16 & 255, value >>> 24 & 255);
+}
+function encodeInto(out, value) {
+  if (value === null) {
+    pushU32(out, NIL);
+  } else if (typeof value === "boolean") {
+    pushU32(out, BOOL);
+    pushU32(out, value ? 1 : 0);
+  } else if (typeof value === "number") {
+    const view = new DataView(new ArrayBuffer(8));
+    if (Number.isInteger(value) && value >= -2147483648 && value <= 2147483647) {
+      pushU32(out, INT);
+      view.setInt32(0, value, true);
+      out.push(...new Uint8Array(view.buffer, 0, 4));
+    } else if (Number.isInteger(value)) {
+      pushU32(out, INT | FLAG_64);
+      view.setBigInt64(0, BigInt(value), true);
+      out.push(...new Uint8Array(view.buffer));
+    } else {
+      pushU32(out, FLOAT | FLAG_64);
+      view.setFloat64(0, value, true);
+      out.push(...new Uint8Array(view.buffer));
     }
-    const ticks = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19]);
-    if (Number.isInteger(ticks) && ticks >= 0) {
-      began.set(pid, booted + Math.round(ticks * 1000 / hertz));
+  } else if (typeof value === "string") {
+    const bytes = new TextEncoder().encode(value);
+    pushU32(out, STRING);
+    pushU32(out, bytes.length);
+    out.push(...bytes, ...Array.from({ length: (4 - bytes.length % 4) % 4 }, () => 0));
+  } else {
+    pushU32(out, ARRAY);
+    pushU32(out, value.length);
+    for (const element of value) {
+      encodeInto(out, element);
     }
   }
-  return began;
 }
-async function linuxStartEarliest() {
-  return 1000 + Math.ceil(1000 / (await ticksPerSecond() ?? 100));
+function encodeVariant(value) {
+  const out = [];
+  encodeInto(out, value);
+  return Uint8Array.from(out);
 }
-var ticksAnswered;
-async function ticksPerSecond() {
-  if (ticksAnswered !== undefined) {
-    return ticksAnswered;
-  }
-  try {
-    const hertz = Number((await runHidden("getconf", ["CLK_TCK"], { timeout: ASK_TIMEOUT_MS })).stdout.trim());
-    if (Number.isInteger(hertz) && hertz > 0) {
-      ticksAnswered = hertz;
-      return hertz;
-    }
-  } catch {}
-  return null;
+var MAIN_THREAD = 1;
+function framedCommand(message, data, thread = MAIN_THREAD) {
+  const body = encodeVariant([message, thread, data]);
+  const framed = new Uint8Array(body.length + 4);
+  new DataView(framed.buffer).setUint32(0, body.length, true);
+  framed.set(body, 4);
+  return framed;
 }
-var ASK_TIMEOUT_MS = 15000;
-var ONE_SHOT_OPTIONS = [
-  "--import",
-  "--quit",
-  "--quit-after",
-  "--export-release",
-  "--export-debug",
-  "--export-pack",
-  "--export-patch",
-  "--doctool",
-  "--gdscript-docs",
-  "--script",
-  "-s",
-  "--check-only",
-  "--build-solutions",
-  "--dump-gdextension-interface",
-  "--dump-extension-api",
-  "--dump-extension-api-with-docs",
-  "--validate-extension-api",
-  "--convert-3to4",
-  "--validate-conversion-3to4"
-];
-function readCommandLine(command) {
-  const all = commandWords(command);
-  const separator = all.findIndex((word) => word === "--" || word === "++");
-  const words = separator === -1 ? all : all.slice(0, separator);
-  const executable = words[0] === undefined ? "" : basename3(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))) {
+var MOST_MESSAGE_BYTES = (8 << 20) + 4;
+
+class DebuggerStream {
+  pending = new Uint8Array(0);
+  push(chunk) {
+    const joined = new Uint8Array(this.pending.length + chunk.length);
+    joined.set(this.pending, 0);
+    joined.set(chunk, this.pending.length);
+    const out = [];
+    let at = 0;
+    while (joined.length - at >= 4) {
+      const length = new DataView(joined.buffer, joined.byteOffset + at, 4).getUint32(0, true);
+      if (length > MOST_MESSAGE_BYTES) {
+        throw new RangeError(`a message of ${length} bytes, more than the engine sends`);
+      }
+      if (joined.length - at - 4 < length) {
         break;
       }
-      taken.push(word);
+      out.push(readMessage(joined.subarray(at + 4, at + 4 + length)));
+      at += 4 + length;
     }
-    projectPath = taken.join(" ").replaceAll("%20", " ");
+    this.pending = joined.slice(at);
+    return out;
   }
-  return {
-    executable,
-    projectPath,
-    editor: words.some((word) => word === "-e" || word === "--editor"),
-    oneShot: words.find((word) => ONE_SHOT_OPTIONS.includes(word)) ?? null
-  };
 }
-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;
-    }
+function readMessage(body) {
+  let value;
+  try {
+    value = decodeVariant(body);
+  } catch (error) {
+    return { unreadable: error instanceof Error ? error.message : String(error) };
   }
-  if (started) {
-    words.push(word);
+  if (!Array.isArray(value) || value.length !== 3) {
+    return { unreadable: "a message that is not [message, thread, data]" };
   }
-  return words;
+  const [message, thread, data] = value;
+  if (typeof message !== "string" || typeof thread !== "number" || !Array.isArray(data)) {
+    return { unreadable: "a message whose name, thread or data is the wrong type" };
+  }
+  return { message, thread, data };
+}
+
+// src/setup.ts
+import { dirname as dirname3, join as join5 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/dictionary.ts
+function emptyRecord() {
+  return Object.create(null);
 }
 
 // src/game-log.ts
@@ -8653,16 +8905,16 @@ var IMPORTABLE = new Set(IMPORTABLE_EXTENSIONS);
 var hashes = new Map;
 
 // src/scratch.ts
-import { existsSync as existsSync2, mkdtempSync as mkdtempSync2, readdirSync, rmSync as rmSync3 } from "node:fs";
-import { tmpdir as tmpdir2 } from "node:os";
+import { existsSync as existsSync2, mkdtempSync as mkdtempSync2, readdirSync, rmSync as rmSync4 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
 import { join as join4 } from "node:path";
-import process4 from "node:process";
+import process6 from "node:process";
 var SWEPT = { recursive: true, force: true };
 var AGAIN_AFTER_MS = [250, 500, 1000, 2000, 4000, 8000, 16000];
 var waiting = new Set;
 var atExit = new Set;
 function scratchDirectory(kind) {
-  return mkdtempSync2(join4(tmpdir2(), `gdharness-${kind}-${process4.pid}-`));
+  return mkdtempSync2(join4(tmpdir3(), `gdharness-${kind}-${process6.pid}-`));
 }
 function discardWith(remove, paths) {
   const left = [];
@@ -8686,7 +8938,7 @@ function discard(...paths) {
   return left;
 }
 function remove(path) {
-  rmSync3(path, SWEPT);
+  rmSync4(path, SWEPT);
 }
 function tryAgain(path, attempt) {
   if (attempt === 0) {
@@ -8720,7 +8972,7 @@ function lastTryOnExit() {
     return;
   }
   lastTryWatched = true;
-  process4.once("exit", () => {
+  process6.once("exit", () => {
     for (const path of [...waiting, ...atExit]) {
       try {
         remove(path);
@@ -8847,7 +9099,7 @@ function parseIniLikeValue(value) {
 }
 
 // src/server-version.ts
-import { readFileSync as readFileSync4 } from "node:fs";
+import { readFileSync as readFileSync5 } from "node:fs";
 
 // src/update-check.ts
 var CACHE_MS = 10 * 60 * 1000;
@@ -8858,7 +9110,7 @@ var MAX_RETRY_MS = 60 * 60 * 1000;
 var DEBUG_MODE = process.env["GDHARNESS_DEBUG"] === "1";
 var SERVER_VERSION = (() => {
   try {
-    const pkg = JSON.parse(readFileSync4(new URL("../package.json", import.meta.url), "utf8"));
+    const pkg = JSON.parse(readFileSync5(new URL("../package.json", import.meta.url), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {
     return "0.0.0";
@@ -8884,7 +9136,7 @@ var RUNTIME_AUTOLOAD2 = `${RUNTIME_ADDON}runtime_autoload.gd`;
 var frameEnd = null;
 function frameEndLine() {
   if (frameEnd === null) {
-    const lines = readFileSync5(join6(shippedAddonsDirectory(), "gdharness_runtime", "runtime_autoload.gd"), "utf8").split(`
+    const lines = readFileSync6(join6(shippedAddonsDirectory(), "gdharness_runtime", "runtime_autoload.gd"), "utf8").split(`
 `);
     const declared = lines.findIndex((line) => line.startsWith("func _notification("));
     if (declared === -1) {
@@ -9008,6 +9260,7 @@ class GameDebugger {
   onClosed = [];
   output = [];
   outputDropped = 0;
+  expressionErrors = [];
   queue = Promise.resolve();
   server;
   port;
@@ -9132,6 +9385,14 @@ class GameDebugger {
           this.outputDropped += over;
         }
       }
+    } else if (received.message === "error") {
+      const [, , , , file, , , error, described] = received.data;
+      if (file === "core/math/expression.cpp" && this.expressionErrors.length < 10) {
+        const why = typeof described === "string" && described !== "" ? described : error;
+        if (typeof why === "string") {
+          this.expressionErrors.push(why);
+        }
+      }
     }
     const at = this.waiters.findIndex((waiter) => waiter.wanted(received));
     if (at !== -1) {
@@ -9478,6 +9739,7 @@ class GameDebugger {
       };
     }
     this.forget("evaluation_return");
+    this.expressionErrors.length = 0;
     this.send("evaluate", [expression, frame], held.thread);
     const answered = await this.next(GameDebugger.named("evaluation_return"), EVALUATE_MS);
     if (answered === null || !("data" in answered)) {
@@ -9486,16 +9748,24 @@ class GameDebugger {
       };
     }
     const [, , type, value, hint] = answered.data;
-    return {
+    const answer = {
       held: this.heldState(),
       frame,
       expression,
       value: shownValue(value ?? null, typeof hint === "string" ? hint : ""),
-      type: typeNamed(type, hint),
-      ...value === null || value === undefined ? {
-        note: "null is also what an expression comes to when it does not parse or fails as it runs. The game prints why as an error, which editor_output reads, since its debugger hands errors over apart from the console debug_state output keeps."
-      } : {}
+      type: typeNamed(type, hint)
     };
+    if (value !== null && value !== undefined) {
+      return answer;
+    }
+    if (!await this.taken()) {
+      return {
+        ...answer,
+        note: "null is also what an expression comes to when it does not parse or fails as it runs, and the game did not answer the question asked after it to say whether this one failed. editor_output has any error it printed."
+      };
+    }
+    const why = this.expressionErrors.join(" ");
+    return why === "" ? answer : { ...answer, failed: why };
   }
   async taken() {
     this.forget("scene:inspect_object");
@@ -9518,11 +9788,11 @@ class GameDebugger {
 
 // src/keeper-channel.ts
 import { randomUUID } from "node:crypto";
-import { mkdtempSync as mkdtempSync3, rmSync as rmSync4 } from "node:fs";
+import { mkdtempSync as mkdtempSync3, rmSync as rmSync5 } from "node:fs";
 import { connect, createServer as createServer2 } from "node:net";
-import { tmpdir as tmpdir3 } from "node:os";
+import { tmpdir as tmpdir4 } from "node:os";
 import { join as join7 } from "node:path";
-import process5 from "node:process";
+import process7 from "node:process";
 var DEBUG_PREFIX = "debug ";
 function endedOrWhyNot(end) {
   try {
@@ -9549,7 +9819,7 @@ function errorText(error) {
 async function listenForTheServer(end, debug) {
   let directory = null;
   try {
-    directory = process5.platform === "win32" ? null : mkdtempSync3(join7(tmpdir3(), "gdharness-keeper-"));
+    directory = process7.platform === "win32" ? null : mkdtempSync3(join7(tmpdir4(), "gdharness-keeper-"));
     const address = directory === null ? `\\\\.\\pipe\\gdharness-keeper-${randomUUID()}` : join7(directory, "keeper.sock");
     const server = createServer2((socket) => {
       socket.setEncoding("utf8");
@@ -9586,13 +9856,13 @@ async function listenForTheServer(end, debug) {
       close: () => {
         server.close();
         if (made !== null) {
-          rmSync4(made, { recursive: true, force: true });
+          rmSync5(made, { recursive: true, force: true });
         }
       }
     };
   } catch {
     if (directory !== null) {
-      rmSync4(directory, { recursive: true, force: true });
+      rmSync5(directory, { recursive: true, force: true });
     }
     return null;
   }
@@ -9643,11 +9913,11 @@ function readLaunched(printed) {
 
 // src/run-record.ts
 import { createHash as createHash2 } from "node:crypto";
-import { mkdirSync, openSync as openSync2, readdirSync as readdirSync2, readFileSync as readFileSync6, rmSync as rmSync5, statSync as statSync3 } from "node:fs";
+import { mkdirSync as mkdirSync2, openSync as openSync3, readdirSync as readdirSync2, readFileSync as readFileSync7, rmSync as rmSync6, statSync as statSync4 } from "node:fs";
 import { basename as basename4, join as join9, resolve as resolve4 } from "node:path";
 
 // src/runtime-client.ts
-import { tmpdir as tmpdir4 } from "node:os";
+import { tmpdir as tmpdir5 } from "node:os";
 import { dirname as dirname4, join as join8, resolve as resolve3 } from "node:path";
 
 // src/launch.ts
@@ -9693,7 +9963,7 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join8(perUser ?? tmpdir4(), "gdharness");
+  return join8(perUser ?? tmpdir5(), "gdharness");
 }
 var ERROR_REPORT_KEEP_MS = 60 * 60 * 1000;
 var verdicts = new Map;
@@ -9714,7 +9984,7 @@ function runRecordPath(projectPath, directory = runtimeDirectory()) {
   return join9(directory, "runs", `note-${projectKey(projectPath)}.json`);
 }
 function writeRunRecord(record) {
-  mkdirSync(runsDirectory(), { recursive: true });
+  mkdirSync2(runsDirectory(), { recursive: true });
   const path = runRecordPath(record.projectPath);
   if (!writeWhole(path, JSON.stringify(record, null, 2))) {
     throw new Error(`the run note could not be written at ${path}`);
@@ -9739,7 +10009,7 @@ function recordRunEnded(projectPath, pid, ending) {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync6(path, "utf8"));
+    parsed = JSON.parse(readFileSync7(path, "utf8"));
   } catch {
     return null;
   }
@@ -10178,7 +10448,7 @@ async function startThroughHelper(spec, output, stopFile) {
       step: stepFile
     });
     const envChanges = spec.desktop === undefined ? spec.envChanges : { ...spec.envChanges, [DESKTOP_VARIABLE]: spec.desktop };
-    const started = await startDirectly({ ...spec, command: wrapper.command, args: wrapper.args, envChanges }, output, true, false, "ignore", tmpdir5());
+    const started = await startDirectly({ ...spec, command: wrapper.command, args: wrapper.args, envChanges }, output, true, false, "ignore", tmpdir6());
     if ("error" in started) {
       return started;
     }
@@ -10187,7 +10457,7 @@ async function startThroughHelper(spec, output, stopFile) {
       exited.now = true;
     });
     for (let waited = 0;waited < DESKTOP_START_MS; waited += 50) {
-      const pid = existsSync3(pidFile) ? Number(readFileSync7(pidFile, "utf8").trim()) : Number.NaN;
+      const pid = existsSync3(pidFile) ? Number(readFileSync8(pidFile, "utf8").trim()) : Number.NaN;
       if (Number.isInteger(pid) && pid > 0) {
         return { child: started.child, pid };
       }
@@ -10218,7 +10488,7 @@ function profiledBy(path, projectPath) {
   };
   let projectGodot = null;
   try {
-    projectGodot = readFileSync7(join10(projectPath, "project.godot"), "utf8");
+    projectGodot = readFileSync8(join10(projectPath, "project.godot"), "utf8");
   } catch {}
   const observer = new ProfileObserver((totals) => {
     const first = latest === null;
@@ -10319,19 +10589,20 @@ async function keep() {
   }
   const profiled = run?.profile === undefined ? null : profiledBy(run.profile, run.projectPath);
   const debuggerPeer = run === undefined || run.debugged === false ? null : await GameDebugger.open(run.breakpoints ?? [], profiled === null ? [] : [profiled.observer]);
-  const exitNotes = run === undefined ? null : mkdtempSync4(join10(tmpdir5(), "gdharness-exit-"));
+  const exitNotes = run === undefined ? null : mkdtempSync4(join10(tmpdir6(), "gdharness-exit-"));
   const noted = exitNotes === null ? spec : { ...spec, envChanges: { ...spec.envChanges, [EXIT_NOTES_VARIABLE]: exitNotes } };
   const toStart = debuggerPeer === null ? noted : { ...noted, args: withEngineArguments(noted.args, debuggerPeer.engineArguments) };
-  const transcript = run === undefined ? "ignore" : openSync3(run.transcript, "a");
-  const own = run !== undefined && throughTheHelper(spec) ? mkdtempSync4(join10(tmpdir5(), "gdharness-stop-")) : null;
+  const transcript = run === undefined ? "ignore" : openSync4(run.transcript, "a");
+  const own = run !== undefined && throughTheHelper(spec) ? mkdtempSync4(join10(tmpdir6(), "gdharness-stop-")) : null;
   const stopFile = own === null ? "" : join10(own, "stop");
   let started;
+  const keeperStarted = run?.slot === undefined ? undefined : ownStart();
   const spawnedAt = Date.now();
   try {
     started = await startDetached(toStart, transcript, run === undefined, stopFile);
   } finally {
     if (transcript !== "ignore") {
-      closeSync2(transcript);
+      closeSync3(transcript);
     }
   }
   if ("error" in started) {
@@ -10382,6 +10653,14 @@ async function keep() {
     process.stdout.end(`pid ${pid}
 `, resolve);
   });
+  const slot = run?.slot;
+  if (slot !== undefined && keeperStarted !== undefined) {
+    handSlot(slot.lock, slot.from, {
+      pid: process.pid,
+      started: await keeperStarted,
+      by: `${slot.by}, through the keeper process that runs it`
+    });
+  }
   let { code, signal } = await exited;
   let exitedAt = Date.now();
   let note = record === null ? null : listening === null ? record : { ...record, keeper: listening.address };
@@ -10442,11 +10721,14 @@ async function keep() {
       notTold
     });
   }
+  if (slot !== undefined) {
+    giveBackSlot(slot.lock, process.pid);
+  }
   debuggerPeer?.close();
   listening?.close();
   for (const made of [own, exitNotes]) {
     if (made !== null) {
-      rmSync6(made, { recursive: true, force: true });
+      rmSync7(made, { recursive: true, force: true });
     }
   }
   process.exit(0);
@@ -10457,7 +10739,7 @@ function restartSaid(notes, pid) {
     return null;
   }
   try {
-    const said = JSON.parse(readFileSync7(join10(notes, `exit-${String(pid)}.json`), "utf8"));
+    const said = JSON.parse(readFileSync8(join10(notes, `exit-${String(pid)}.json`), "utf8"));
     return typeof said === "object" && said !== null && "restart" in said && typeof said.restart === "boolean" ? said.restart : null;
   } catch {
     return null;