gdharness 1.2.26 → 1.2.27

package/build/keeper.js

@@ -226,745 +226,1244 @@ function throughHelper(how, command, args, files) {
   };
 }
 
-// src/keeper-channel.ts
-import { randomUUID } from "node:crypto";
-import { mkdtempSync, rmSync } from "node:fs";
-import { connect, createServer } from "node:net";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import process2 from "node:process";
-function endedOrWhyNot(end) {
-  try {
-    return end();
-  } catch (error) {
-    return `could not end it: ${error instanceof Error ? error.message : String(error)}`.replaceAll(`
-`, " ");
+// src/game-debugger.ts
+import { createServer } from "node:net";
+
+// 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;
   }
-}
-async function listenForAStop(end) {
-  let directory = null;
-  try {
-    directory = process2.platform === "win32" ? null : mkdtempSync(join(tmpdir(), "gdharness-keeper-"));
-    const address = directory === null ? `\\\\.\\pipe\\gdharness-keeper-${randomUUID()}` : join(directory, "keeper.sock");
-    const server = createServer((socket) => {
-      socket.setEncoding("utf8");
-      socket.on("error", () => {});
-      let asked = "";
-      socket.on("data", (chunk) => {
-        asked += chunk;
-        if (asked.includes(`
-`)) {
-          socket.end(asked.startsWith(`stop
-`) ? `${endedOrWhyNot(end)}
-` : `unknown
-`);
-        }
-      });
-    });
-    await listening(server, address);
-    const made = directory;
-    return {
-      address,
-      close: () => {
-        server.close();
-        if (made !== null) {
-          rmSync(made, { recursive: true, force: true });
-        }
-      }
-    };
-  } catch {
-    if (directory !== null) {
-      rmSync(directory, { recursive: true, force: true });
-    }
-    return null;
+  get remaining() {
+    return this.view.byteLength - this.offset;
   }
-}
-function listening(server, address) {
-  return new Promise((resolve, reject) => {
-    server.once("error", reject);
-    server.listen(address, () => {
-      server.off("error", reject);
-      resolve();
-    });
-  });
-}
-
-// src/outside.ts
-import { fileURLToPath } from "node:url";
-function withChanges(base, changes) {
-  const env = { ...base };
-  for (const [name, value] of Object.entries(changes)) {
-    if (value === null) {
-      delete env[name];
-    } else {
-      env[name] = value;
+  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 env;
-}
-function sendSpec(child, spec) {
-  child.stdin?.end(JSON.stringify(spec), "utf8");
-}
-async function receivedSpec() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
+  u32() {
+    this.need(4);
+    const value = this.view.getUint32(this.offset, true);
+    this.offset += 4;
+    return value;
   }
-  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
-}
-var KEEPER_SCRIPT = fileURLToPath(new URL("./keeper.js", import.meta.url));
-function readLaunched(printed) {
-  const line = printed.split(`
-`).find((one) => one.trim() !== "")?.trim() ?? "";
-  const pid = /^pid (\d+)$/.exec(line);
-  if (pid?.[1] !== undefined) {
-    return { pid: Number(pid[1]) };
+  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;
   }
-  return { error: line.replace(/^error /, "") || "the launcher said nothing" };
-}
-
-// src/run-record.ts
-import { execFile as execFile2 } from "node:child_process";
-import { createHash as createHash2 } from "node:crypto";
-import { mkdirSync, openSync, readdirSync, readFileSync, realpathSync, rmSync as rmSync3, statSync } from "node:fs";
-import { basename, dirname as dirname2, join as join3, resolve as resolve2 } from "node:path";
-import { promisify as promisify2 } from "node:util";
-
-// src/process-children.ts
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-
-// 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/process-children.ts
-var run = promisify(execFile);
-
-// src/runtime-client.ts
-import { tmpdir as tmpdir2 } from "node:os";
-import { dirname, join as join2, resolve } from "node:path";
-
-// src/launch.ts
-function envValue(name, variables = process.env) {
-  const value = variables[name];
-  return value === undefined || value === "" ? undefined : value;
 }
-var ENGINE_FLAGS = Object.freeze({
-  "--verbose": "none",
-  "--quiet": "none",
-  "--debug-collisions": "none",
-  "--debug-paths": "none",
-  "--debug-navigation": "none",
-  "--debug-avoidance": "none",
-  "--debug-stringnames": "none",
-  "--debug-canvas-item-redraw": "none",
-  "--debug-mute-audio": "none",
-  "--print-fps": "none",
-  "--gpu-profile": "none",
-  "--gpu-validation": "none",
-  "--gpu-abort": "none",
-  "--disable-vsync": "none",
-  "--frame-delay": "number",
-  "--time-scale": "number",
-  "--fixed-fps": "number",
-  "--max-fps": "number",
-  "--resolution": "size",
-  "--write-movie": "file",
-  "--rendering-driver": "driver",
-  "--rendering-method": "method",
-  "--accessibility": "accessibility"
-});
-var SET_BY_ARGUMENT = Object.freeze({
-  "--headless": "headless",
-  "--audio-driver": "silent",
-  "--quit-after": "frames, on editor_run check"
-});
-
-// src/runtime-client.ts
-function runtimeDirectory(variables = process.env) {
-  const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
-  if (explicit) {
-    return explicit;
+var MAX_DEPTH = 1024;
+function containerType(reader, kind) {
+  if (kind === 1) {
+    reader.u32();
+  } else if (kind === 2 || kind === 3) {
+    reader.string();
   }
-  const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join2(perUser ?? tmpdir2(), "gdharness");
 }
-var ERROR_REPORT_KEEP_MS = 60 * 60 * 1000;
-var verdicts = new Map;
-var LATE_ANSWER_MS = 30 * 60000;
-var lateAnswers = new Map;
-
-// src/whole-file.ts
-import { renameSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
-var HELD_FILE_MS = 1000;
-var HELD_FILE_RETRY_MS = 10;
-var HELD_BY_A_READER = new Set(["EPERM", "EACCES", "EBUSY"]);
-function writeWhole(path, text) {
-  const partial = `${path}.${process.pid}.partial`;
-  try {
-    writeFileSync2(partial, text, "utf8");
-  } catch {
-    return false;
+function decodeValue(reader, depth) {
+  if (depth > MAX_DEPTH) {
+    throw new RangeError("a value nests deeper than the engine allows");
   }
-  const until = Date.now() + HELD_FILE_MS;
-  for (;; ) {
-    try {
-      renameSync(partial, path);
-      return true;
-    } catch (error) {
-      const code = error.code ?? "";
-      if (!HELD_BY_A_READER.has(code) || Date.now() >= until) {
-        try {
-          rmSync2(partial, { force: true });
-        } catch {}
-        return false;
+  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");
       }
-      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, HELD_FILE_RETRY_MS);
+      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()) };
     }
-  }
-}
-
-// src/run-record.ts
-var execFileAsync = promisify2(execFile2);
-function runsDirectory() {
-  return join3(runtimeDirectory(), "runs");
-}
-function realAsFarAsItExists(path) {
-  const missing = [];
-  let at = path;
-  for (;; ) {
-    try {
-      return join3(realpathSync.native(at), ...missing);
-    } catch {
-      const parent = dirname2(at);
-      if (parent === at) {
-        return path;
+    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");
       }
-      missing.unshift(basename(at));
-      at = parent;
+      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`);
   }
 }
-function projectKey(projectPath) {
-  const real = realAsFarAsItExists(resolve2(projectPath)).replace(/[\\/]+$/, "");
-  const folded = process.platform === "win32" || process.platform === "darwin" ? real.toLowerCase() : real;
-  return createHash2("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
+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 runRecordPath(projectPath, directory = runtimeDirectory()) {
-  return join3(directory, "runs", `note-${projectKey(projectPath)}.json`);
+function pushU32(out, value) {
+  out.push(value & 255, value >>> 8 & 255, value >>> 16 & 255, value >>> 24 & 255);
 }
-function writeRunRecord(record) {
-  mkdirSync(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}`);
+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));
+    }
+  } 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);
+    }
   }
 }
-function recordRunEnded(projectPath, pid, ending) {
-  const path = runRecordPath(projectPath);
-  const record = recordAt(path);
-  if (record === null || record.pid !== pid) {
-    return;
+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;
+      }
+      out.push(readMessage(joined.subarray(at + 4, at + 4 + length)));
+      at += 4 + length;
+    }
+    this.pending = joined.slice(at);
+    return out;
   }
-  const written = {
-    ...record,
-    ...ending.exitCode === null ? {} : { exitCode: ending.exitCode },
-    ...ending.exitSignal === null ? {} : { exitSignal: ending.exitSignal },
-    endedAt: Date.now()
-  };
-  writeWhole(path, JSON.stringify(written, null, 2));
 }
-function recordAt(path) {
-  let parsed;
+function readMessage(body) {
+  let value;
   try {
-    parsed = JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return null;
+    value = decodeVariant(body);
+  } catch (error) {
+    return { unreadable: error instanceof Error ? error.message : String(error) };
   }
-  if (!parsed || typeof parsed !== "object") {
-    return null;
+  if (!Array.isArray(value) || value.length !== 3) {
+    return { unreadable: "a message that is not [message, thread, data]" };
   }
-  const fields = parsed;
-  const pid = fields["pid"];
-  const transcript = fields["transcript"];
-  const startedAt = fields["startedAt"];
-  if (typeof pid !== "number" || typeof transcript !== "string" || typeof startedAt !== "number") {
-    return null;
+  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" };
   }
-  const args = fields["arguments"];
-  return {
-    pid,
-    transcript,
-    startedAt,
-    ...typeof fields["startedBy"] === "number" ? { startedBy: fields["startedBy"] } : {},
-    projectPath: typeof fields["projectPath"] === "string" ? fields["projectPath"] : "",
-    ...typeof fields["servedBy"] === "string" && fields["servedBy"] !== "" ? { servedBy: fields["servedBy"] } : {},
-    ...typeof fields["keeper"] === "string" && fields["keeper"] !== "" ? { keeper: fields["keeper"] } : {},
-    ...typeof fields["profile"] === "string" && fields["profile"] !== "" ? { profile: fields["profile"] } : {},
-    arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : [],
-    ...typeof fields["command"] === "string" ? { command: fields["command"] } : {},
-    ...typeof fields["exitCode"] === "number" ? { exitCode: fields["exitCode"] } : {},
-    ...typeof fields["exitSignal"] === "string" ? { exitSignal: fields["exitSignal"] } : {},
-    ...typeof fields["endedAt"] === "number" ? { endedAt: fields["endedAt"] } : {}
-  };
+  return { message, thread, data };
 }
 
-// src/scratch.ts
-import { existsSync, mkdtempSync as mkdtempSync2, readdirSync as readdirSync2, rmSync as rmSync4 } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
-import { join as join4 } from "node:path";
-import process3 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(tmpdir3(), `gdharness-${kind}-${process3.pid}-`));
+// src/game-debugger.ts
+var PAUSE_MS = 30000;
+var STEP_MS = 1e4;
+var READ_MS = 5000;
+var REPLIES = new Set([
+  "debug_enter",
+  "debug_exit",
+  "stack_dump",
+  "stack_frame_vars",
+  "stack_frame_var"
+]);
+var INBOX_KEPT = 1e4;
+var OUTPUT_KEPT = 1000;
+var TYPE_NAMES = [
+  "Nil",
+  "bool",
+  "int",
+  "float",
+  "String",
+  "Vector2",
+  "Vector2i",
+  "Rect2",
+  "Rect2i",
+  "Vector3",
+  "Vector3i",
+  "Transform2D",
+  "Vector4",
+  "Vector4i",
+  "Plane",
+  "Quaternion",
+  "AABB",
+  "Basis",
+  "Transform3D",
+  "Projection",
+  "Color",
+  "StringName",
+  "NodePath",
+  "RID",
+  "Object",
+  "Callable",
+  "Signal",
+  "Dictionary",
+  "Array",
+  "PackedByteArray",
+  "PackedInt32Array",
+  "PackedInt64Array",
+  "PackedFloat32Array",
+  "PackedFloat64Array",
+  "PackedStringArray",
+  "PackedVector2Array",
+  "PackedVector3Array",
+  "PackedColorArray",
+  "PackedVector4Array"
+];
+var SCOPES = ["Locals", "Members", "Globals"];
+var ELEMENTS_SHOWN = 20;
+function isList(value) {
+  return Array.isArray(value);
 }
-function discardWith(remove, paths) {
-  const left = [];
-  for (const path of paths) {
-    if (!path) {
-      continue;
-    }
-    try {
-      remove(path);
-    } catch (error) {
-      left.push({ path, reason: error instanceof Error ? error.message : String(error) });
-    }
+function shownValue(value, typeHint = "") {
+  if (value === null) {
+    return "null";
   }
-  return left;
-}
-function discard(...paths) {
-  const left = discardWith(remove, paths);
-  for (const { path } of left) {
-    tryAgain(path, 0);
+  if (typeof value === "string") {
+    return value;
   }
-  return left;
-}
-function remove(path) {
-  rmSync4(path, SWEPT);
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (isList(value)) {
+    const shown = value.slice(0, ELEMENTS_SHOWN).map((each) => shownValue(each));
+    const more = value.length - shown.length;
+    return `[${shown.join(", ")}${more > 0 ? `, and ${more} more` : ""}]`;
+  }
+  if (value.kind === "dictionary" && "entries" in value) {
+    const shown = value.entries.slice(0, ELEMENTS_SHOWN).map(([key, each]) => `${shownValue(key)}: ${shownValue(each)}`);
+    const more = value.entries.length - shown.length;
+    return `{${shown.join(", ")}${more > 0 ? `, and ${more} more` : ""}}`;
+  }
+  if (!("values" in value)) {
+    return value.kind;
+  }
+  if (value.kind === "Object") {
+    return `<${typeHint === "" ? "Object" : typeHint}#${String(value.values[0])}>`;
+  }
+  return `${value.kind}(${value.values.join(", ")})`;
 }
-function tryAgain(path, attempt) {
-  if (attempt === 0) {
-    if (waiting.has(path)) {
-      return;
+function framesOf(data) {
+  const frames = [];
+  for (let at = 1;at + 2 < data.length; at += 3) {
+    const [script, line, name] = [data[at], data[at + 1], data[at + 2]];
+    if (typeof script !== "string" || typeof line !== "number" || typeof name !== "string") {
+      break;
     }
-    waiting.add(path);
-    atExit.delete(path);
-    lastTryOnExit();
+    frames.push({ id: frames.length, name, line, script });
   }
-  const after = AGAIN_AFTER_MS[attempt];
-  if (after === undefined || !existsSync(path)) {
-    waiting.delete(path);
-    if (after === undefined) {
-      atExit.add(path);
-    }
-    return;
+  return frames;
+}
+
+class GameDebugger {
+  connection = null;
+  held = null;
+  ended = false;
+  waiters = [];
+  inbox = [];
+  onClosed = [];
+  output = [];
+  outputDropped = 0;
+  queue = Promise.resolve();
+  server;
+  port;
+  breakpoints;
+  observers;
+  constructor(server, port, breakpoints, observers) {
+    this.server = server;
+    this.port = port;
+    this.breakpoints = breakpoints;
+    this.observers = observers;
   }
-  setTimeout(() => {
-    try {
-      remove(path);
-      waiting.delete(path);
-    } catch {
-      tryAgain(path, attempt + 1);
+  static async open(breakpoints, observers = []) {
+    const server = createServer();
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(0, "127.0.0.1", () => {
+        resolve();
+      });
+    });
+    const address = server.address();
+    if (address === null || typeof address === "string") {
+      server.close();
+      throw new Error("the debugger has no port");
     }
-  }, after).unref();
-}
-var lastTryWatched = false;
-function lastTryOnExit() {
-  if (lastTryWatched) {
-    return;
+    const peer = new GameDebugger(server, address.port, breakpoints, observers);
+    server.on("connection", (socket) => {
+      peer.accept(socket);
+    });
+    return peer;
   }
-  lastTryWatched = true;
-  process3.once("exit", () => {
-    for (const path of [...waiting, ...atExit]) {
-      try {
-        remove(path);
-      } catch {}
+  get engineArguments() {
+    const listed = this.breakpoints.map((one) => one.replaceAll(" ", "%20")).join(",");
+    return [
+      "--remote-debug",
+      `tcp://127.0.0.1:${this.port}`,
+      "--ignore-error-breaks",
+      ...listed === "" ? [] : ["--breakpoints", listed]
+    ];
+  }
+  accept(socket) {
+    if (this.connection !== null) {
+      socket.destroy();
+      return;
     }
-  });
-}
-
-// src/script-profile.ts
-import { createServer as createServer2 } from "node:net";
-
-// 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}_]*";
-var ANNOTATIONS = "(?:@[\\p{L}_][\\p{L}\\p{N}_]*(?:\\([^)]*\\))?\\s+)*";
-var DECLARATION_LINE = new RegExp(`^(${ANNOTATIONS})(static\\s+)?(func|var|const|signal|enum|class)\\s+(${NAME})`, "u");
-var CLASS_NAME_LINE = new RegExp(`^${ANNOTATIONS}class_name\\s+(${NAME})`, "u");
-var EXTENDS_LINE = new RegExp(`^${ANNOTATIONS}(?:class_name\\s+${NAME}\\s+)?extends\\s`, "u");
-var FUNC_LINE = new RegExp(`^[ \\t]*${ANNOTATIONS}(?:static\\s+)?func\\s+(${NAME})\\s*\\(`, "u");
-var LAMBDA_HEADER = new RegExp(`(?<![\\p{L}\\p{N}_])func(?:\\s+${NAME})?\\s*\\(`, "u");
-var DOTTED = `${NAME}(?:\\.${NAME})*`;
-var MEMBER_KINDS = new Set(["var", "const", "signal", "enum", "enumValue"]);
-var KEYWORDS = new Set([
-  "and",
-  "as",
-  "assert",
-  "await",
-  "break",
-  "breakpoint",
-  "class",
-  "class_name",
-  "const",
-  "continue",
-  "elif",
-  "else",
-  "enum",
-  "extends",
-  "false",
-  "for",
-  "func",
-  "if",
-  "in",
-  "is",
-  "match",
-  "namespace",
-  "not",
-  "null",
-  "or",
-  "pass",
-  "preload",
-  "return",
-  "self",
-  "signal",
-  "static",
-  "super",
-  "trait",
-  "true",
-  "var",
-  "void",
-  "when",
-  "while",
-  "yield",
-  "INF",
-  "NAN",
-  "PI",
-  "TAU"
-]);
-
-// 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;
+    this.connection = socket;
+    this.server.close();
+    const send = (message, data) => {
+      this.send(message, data);
+    };
+    for (const observer of this.observers) {
+      observer.connected(send);
+    }
+    const stream = new DebuggerStream;
+    socket.on("data", (chunk) => {
+      let messages;
+      try {
+        messages = stream.push(chunk);
+      } catch {
+        socket.destroy();
+        return;
+      }
+      for (const received of messages) {
+        if ("message" in received) {
+          this.take(received);
+          for (const observer of this.observers) {
+            observer.message(received, send);
+          }
+        }
+      }
+    });
+    socket.on("error", () => {
+      return;
+    });
+    socket.on("close", () => {
+      this.ended = true;
+      this.held = null;
+      for (const waiter of this.waiters.splice(0)) {
+        waiter.resolve(null);
+      }
+      for (const done of this.onClosed.splice(0)) {
+        done();
+      }
+    });
   }
-  get remaining() {
-    return this.view.byteLength - this.offset;
+  drained(ms) {
+    if (this.connection === null || this.ended) {
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      const timer = setTimeout(resolve, ms);
+      this.onClosed.push(() => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
   }
-  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)`);
+  take(received) {
+    if (received.message === "debug_enter") {
+      const [canContinue, reason, hasStack] = received.data;
+      this.held = {
+        thread: received.thread,
+        canContinue: canContinue === true,
+        reason: typeof reason === "string" ? reason : "",
+        hasStack: hasStack === true
+      };
+    } else if (received.message === "debug_exit" && this.held?.thread === received.thread) {
+      this.held = null;
+    } else if (received.message === "output") {
+      const [strings] = received.data;
+      if (Array.isArray(strings)) {
+        for (const each of strings) {
+          if (typeof each === "string") {
+            this.output.push(...each.split(`
+`));
+          }
+        }
+        const over = this.output.length - OUTPUT_KEPT;
+        if (over > 0) {
+          this.output.splice(0, over);
+          this.outputDropped += over;
+        }
+      }
+    }
+    const at = this.waiters.findIndex((waiter) => waiter.wanted(received));
+    if (at !== -1) {
+      this.waiters.splice(at, 1)[0]?.resolve(received);
+    } else if (REPLIES.has(received.message)) {
+      this.inbox.push(received);
+      if (this.inbox.length > INBOX_KEPT) {
+        this.inbox.shift();
+      }
     }
   }
-  u32() {
-    this.need(4);
-    const value = this.view.getUint32(this.offset, true);
-    this.offset += 4;
-    return value;
+  forget(message) {
+    for (let at = this.inbox.length - 1;at >= 0; at -= 1) {
+      const kept = this.inbox[at];
+      if (kept !== undefined && "message" in kept && kept.message === message) {
+        this.inbox.splice(at, 1);
+      }
+    }
   }
-  i32() {
-    this.need(4);
-    const value = this.view.getInt32(this.offset, true);
-    this.offset += 4;
-    return value;
+  send(message, data, thread = MAIN_THREAD) {
+    this.connection?.write(framedCommand(message, data, thread));
   }
-  i64() {
-    this.need(8);
-    const value = Number(this.view.getBigInt64(this.offset, true));
-    this.offset += 8;
-    return value;
+  next(wanted, ms) {
+    const kept = this.inbox.findIndex(wanted);
+    if (kept !== -1) {
+      return Promise.resolve(this.inbox.splice(kept, 1)[0] ?? null);
+    }
+    if (this.ended) {
+      return Promise.resolve(null);
+    }
+    return new Promise((resolve) => {
+      const waiter = {
+        wanted,
+        resolve: (received) => {
+          clearTimeout(timer);
+          resolve(received);
+        }
+      };
+      const timer = setTimeout(() => {
+        const at = this.waiters.indexOf(waiter);
+        if (at !== -1) {
+          this.waiters.splice(at, 1);
+        }
+        resolve(null);
+      }, ms);
+      this.waiters.push(waiter);
+    });
   }
-  u64() {
-    this.need(8);
-    const value = Number(this.view.getBigUint64(this.offset, true));
-    this.offset += 8;
-    return value;
+  static named(message) {
+    return (received) => ("message" in received) && received.message === message;
   }
-  f32() {
-    this.need(4);
-    const value = this.view.getFloat32(this.offset, true);
-    this.offset += 4;
-    return value;
+  ask(request) {
+    const answered = this.queue.then(() => this.answer(request));
+    this.queue = answered.catch(() => {
+      return;
+    });
+    return answered;
+  }
+  async answer(request) {
+    if (request.op === "output") {
+      return {
+        output: [...this.output],
+        ...this.outputDropped > 0 ? { notShown: this.outputDropped } : {}
+      };
+    }
+    if (request.op === "state") {
+      return { connected: this.connection !== null && !this.ended, held: this.heldState() };
+    }
+    if (this.connection === null) {
+      return {
+        refused: "The game never connected to its debugger: it dials once as it starts, and a game that has not got that far, or that was started without a debugger, has none."
+      };
+    }
+    if (this.ended) {
+      return { refused: "The game has closed its debugger connection, which it does as it exits." };
+    }
+    switch (request.op) {
+      case "breakpoint":
+        this.send("breakpoint", [request.script, request.line, request.set], this.held?.thread ?? MAIN_THREAD);
+        return { sent: true };
+      case "pause":
+        return await this.pause();
+      case "resume":
+        return await this.resume(request.how);
+      case "stack": {
+        const frames = await this.stack();
+        if (frames === null) {
+          return this.notHeld();
+        }
+        return {
+          held: this.heldState(),
+          stack: frames,
+          ...frames.length === 0 ? {
+            note: "The game is held between frames, where no script runs, so there is no stack: debug_control step_over takes it to the next line of script it runs."
+          } : {}
+        };
+      }
+      case "variables":
+        return await this.variables(request.frame);
+      default:
+        return { refused: `Nothing here answers ${JSON.stringify(request)}.` };
+    }
   }
-  f64() {
-    this.need(8);
-    const value = this.view.getFloat64(this.offset, true);
-    this.offset += 8;
-    return value;
+  heldState() {
+    if (this.held === null) {
+      return null;
+    }
+    return {
+      thread: this.held.thread,
+      ...this.held.reason === "" ? {} : { reason: this.held.reason },
+      ...this.held.canContinue ? {} : { canContinue: false }
+    };
   }
-  real(wide) {
-    return wide ? this.f64() : this.f32();
+  notHeld() {
+    return {
+      refused: "The game is running, not held, so it has no stack to read: debug_control pause stops it where it is, and a breakpoint stops it on its line."
+    };
   }
-  bytes(count) {
-    this.need(count);
-    const out = new Uint8Array(this.view.buffer, this.view.byteOffset + this.offset, count);
-    this.offset += count;
-    return out;
+  async stack() {
+    const held = this.held;
+    if (held === null) {
+      return null;
+    }
+    this.forget("stack_dump");
+    this.send("get_stack_dump", [], held.thread);
+    const dumped = await this.next(GameDebugger.named("stack_dump"), READ_MS);
+    return dumped !== null && "data" in dumped ? framesOf(dumped.data) : null;
+  }
+  async pause() {
+    if (this.held === null) {
+      this.forget("debug_enter");
+      this.send("break", []);
+      const entered = await this.next(GameDebugger.named("debug_enter"), PAUSE_MS);
+      if (entered === null) {
+        return {
+          paused: false,
+          note: `The game has been asked to stop and had not within ${PAUSE_MS / 1000}s. It takes the request between frames, and in a script every 2048 lines it runs, so its main thread is in a loop that sleeps between few lines, or inside one long engine call or a native extension's own loop. The request stays with the game, which stops when it next reaches that point; debug_state stack reads where once it has.`
+        };
+      }
+    }
+    const held = this.held;
+    if (held === null) {
+      return { refused: "The game stopped and was let go again before its stack could be read." };
+    }
+    if (!held.hasStack) {
+      this.forget("debug_enter");
+      this.send("next", [], held.thread);
+      const again = await this.next(GameDebugger.named("debug_enter"), STEP_MS);
+      if (again === null) {
+        return {
+          paused: false,
+          note: `The game stopped between frames, where no script runs, so it was let go to stop at the next line of script it runs, and none ran within ${STEP_MS / 1000}s. It stops there when one does; debug_state stack reads it then.`
+        };
+      }
+    }
+    this.stoppedBy("Paused");
+    const frames = await this.stack();
+    return { paused: true, held: this.heldState(), stack: frames ?? [] };
   }
-  string() {
-    const length = this.u32();
-    const text = new TextDecoder().decode(this.bytes(length));
-    this.bytes((4 - length % 4) % 4);
-    return text;
+  stoppedBy(cause) {
+    if (this.held !== null) {
+      this.held = { ...this.held, reason: cause };
+    }
+  }
+  async resume(how) {
+    const held = this.held;
+    if (held === null) {
+      return {
+        refused: "The game is running, not held, so there is nothing to continue or step from: debug_control pause stops it, and a breakpoint stops it on its line."
+      };
+    }
+    if (how === "continue") {
+      this.forget("debug_exit");
+      const exited = this.next((received) => ("message" in received) && received.message === "debug_exit" && received.thread === held.thread, READ_MS);
+      this.send("continue", [], held.thread);
+      return await exited === null ? { refused: `The game did not say it had gone on within ${READ_MS / 1000}s.` } : { continued: true };
+    }
+    this.forget("debug_enter");
+    this.send(how, [], held.thread);
+    const entered = await this.next(GameDebugger.named("debug_enter"), STEP_MS);
+    if (entered === null) {
+      return {
+        stepped: true,
+        heldAgain: false,
+        note: `The game had not stopped again ${STEP_MS / 1000}s after the step: the step is still running, as one out of a function that never returns does, or it went on without reaching another line. debug_state stack answers once it stops, and debug_control pause stops it wherever it is.`
+      };
+    }
+    this.stoppedBy("Stepped");
+    return { stepped: true, heldAgain: true, held: this.heldState(), stack: await this.stack() ?? [] };
+  }
+  async variables(frame) {
+    const held = this.held;
+    if (held === null) {
+      return this.notHeld();
+    }
+    const frames = await this.stack();
+    if (frames === null) {
+      return { refused: `The game did not send its stack within ${READ_MS / 1000}s.` };
+    }
+    if (frames.find((each) => each.id === frame) === undefined) {
+      return {
+        refused: frames.length === 0 ? "The game is held where no script runs, so it has no frames: debug_control step_over takes it to the next line of script." : `The stack has no frame ${frame}; its frames are ${frames.map((each) => each.id).join(", ")}.`
+      };
+    }
+    this.forget("stack_frame_vars");
+    this.forget("stack_frame_var");
+    this.send("get_stack_frame_vars", [frame], held.thread);
+    const counted = await this.next(GameDebugger.named("stack_frame_vars"), READ_MS);
+    const count = counted !== null && "data" in counted ? counted.data[0] : undefined;
+    if (typeof count !== "number") {
+      return { refused: `The game did not send the frame's values within ${READ_MS / 1000}s.` };
+    }
+    const scopes = SCOPES.map((name) => ({
+      name,
+      variables: []
+    }));
+    for (let index = 0;index < count; index += 1) {
+      const one = await this.next(GameDebugger.named("stack_frame_var"), READ_MS);
+      if (one === null || !("data" in one)) {
+        return {
+          scopes,
+          valuesMissing: count - index,
+          note: `${count - index} of the frame's ${count} values did not arrive within ${READ_MS / 1000}s, so the scopes are not whole. Ask again.`
+        };
+      }
+      const [name, scope, type, value, hint] = one.data;
+      const into = scopes[typeof scope === "number" ? scope : 0];
+      into?.variables.push({
+        name: typeof name === "string" ? name : shownValue(name ?? null),
+        value: shownValue(value ?? null, typeof hint === "string" ? hint : ""),
+        type: typeof hint === "string" && hint !== "" ? hint : typeof type === "number" ? TYPE_NAMES[type] ?? String(type) : "Variant"
+      });
+    }
+    return { held: this.heldState(), frame, scopes };
+  }
+  close() {
+    this.connection?.destroy();
+    this.server.close();
+  }
+}
+
+// src/keeper-channel.ts
+import { randomUUID } from "node:crypto";
+import { mkdtempSync, rmSync } from "node:fs";
+import { connect, createServer as createServer2 } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import process2 from "node:process";
+var DEBUG_PREFIX = "debug ";
+function endedOrWhyNot(end) {
+  try {
+    return end();
+  } catch (error) {
+    return `could not end it: ${error instanceof Error ? error.message : String(error)}`.replaceAll(`
+`, " ");
+  }
+}
+async function debuggedOrWhyNot(debug, asked) {
+  if (debug === null) {
+    return JSON.stringify({ refused: "This run has no debugger." });
+  }
+  try {
+    return JSON.stringify(await debug(JSON.parse(asked)));
+  } catch (error) {
+    return JSON.stringify({ refused: `The debugger could not answer: ${errorText(error)}` });
+  }
+}
+function errorText(error) {
+  return (error instanceof Error ? error.message : String(error)).replaceAll(`
+`, " ");
+}
+async function listenForTheServer(end, debug) {
+  let directory = null;
+  try {
+    directory = process2.platform === "win32" ? null : mkdtempSync(join(tmpdir(), "gdharness-keeper-"));
+    const address = directory === null ? `\\\\.\\pipe\\gdharness-keeper-${randomUUID()}` : join(directory, "keeper.sock");
+    const server = createServer2((socket) => {
+      socket.setEncoding("utf8");
+      socket.on("error", () => {});
+      let asked = "";
+      let answering = false;
+      socket.on("data", (chunk) => {
+        asked += chunk;
+        const line = asked.split(`
+`)[0] ?? "";
+        if (answering || !asked.includes(`
+`)) {
+          return;
+        }
+        answering = true;
+        if (line === "stop") {
+          socket.end(`${endedOrWhyNot(end)}
+`);
+        } else if (line.startsWith(DEBUG_PREFIX)) {
+          debuggedOrWhyNot(debug, line.slice(DEBUG_PREFIX.length)).then((answer) => {
+            socket.end(`${answer}
+`);
+          });
+        } else {
+          socket.end(`unknown
+`);
+        }
+      });
+    });
+    await listening(server, address);
+    const made = directory;
+    return {
+      address,
+      close: () => {
+        server.close();
+        if (made !== null) {
+          rmSync(made, { recursive: true, force: true });
+        }
+      }
+    };
+  } catch {
+    if (directory !== null) {
+      rmSync(directory, { recursive: true, force: true });
+    }
+    return null;
+  }
+}
+function listening(server, address) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(address, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+}
+
+// src/outside.ts
+import { fileURLToPath } from "node:url";
+function withChanges(base, changes) {
+  const env = { ...base };
+  for (const [name, value] of Object.entries(changes)) {
+    if (value === null) {
+      delete env[name];
+    } else {
+      env[name] = value;
+    }
+  }
+  return env;
+}
+function sendSpec(child, spec) {
+  child.stdin?.end(JSON.stringify(spec), "utf8");
+}
+async function receivedSpec() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+var KEEPER_SCRIPT = fileURLToPath(new URL("./keeper.js", import.meta.url));
+function readLaunched(printed) {
+  const line = printed.split(`
+`).find((one) => one.trim() !== "")?.trim() ?? "";
+  const pid = /^pid (\d+)$/.exec(line);
+  if (pid?.[1] !== undefined) {
+    return { pid: Number(pid[1]) };
   }
+  return { error: line.replace(/^error /, "") || "the launcher said nothing" };
+}
+
+// src/run-record.ts
+import { execFile as execFile2 } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { mkdirSync, openSync, readdirSync, readFileSync, realpathSync, rmSync as rmSync3, statSync } from "node:fs";
+import { basename, dirname as dirname2, join as join3, resolve as resolve2 } from "node:path";
+import { promisify as promisify2 } from "node:util";
+
+// src/process-children.ts
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+// 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/process-children.ts
+var run = promisify(execFile);
+
+// src/runtime-client.ts
+import { tmpdir as tmpdir2 } from "node:os";
+import { dirname, join as join2, resolve } from "node:path";
+
+// src/launch.ts
+function envValue(name, variables = process.env) {
+  const value = variables[name];
+  return value === undefined || value === "" ? undefined : value;
 }
-var MAX_DEPTH = 1024;
-function containerType(reader, kind) {
-  if (kind === 1) {
-    reader.u32();
-  } else if (kind === 2 || kind === 3) {
-    reader.string();
+var ENGINE_FLAGS = Object.freeze({
+  "--verbose": "none",
+  "--quiet": "none",
+  "--debug-collisions": "none",
+  "--debug-paths": "none",
+  "--debug-navigation": "none",
+  "--debug-avoidance": "none",
+  "--debug-stringnames": "none",
+  "--debug-canvas-item-redraw": "none",
+  "--debug-mute-audio": "none",
+  "--print-fps": "none",
+  "--gpu-profile": "none",
+  "--gpu-validation": "none",
+  "--gpu-abort": "none",
+  "--disable-vsync": "none",
+  "--frame-delay": "number",
+  "--time-scale": "number",
+  "--fixed-fps": "number",
+  "--max-fps": "number",
+  "--resolution": "size",
+  "--write-movie": "file",
+  "--rendering-driver": "driver",
+  "--rendering-method": "method",
+  "--accessibility": "accessibility"
+});
+var SET_BY_ARGUMENT = Object.freeze({
+  "--headless": "headless",
+  "--audio-driver": "silent",
+  "--quit-after": "frames, on editor_run check"
+});
+
+// src/runtime-client.ts
+function runtimeDirectory(variables = process.env) {
+  const explicit = envValue("GDHARNESS_RUNTIME_DIR", variables);
+  if (explicit) {
+    return explicit;
   }
+  const perUser = envValue("XDG_RUNTIME_DIR", variables);
+  return join2(perUser ?? tmpdir2(), "gdharness");
 }
-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))
-    }));
+var ERROR_REPORT_KEEP_MS = 60 * 60 * 1000;
+var verdicts = new Map;
+var LATE_ANSWER_MS = 30 * 60000;
+var lateAnswers = new Map;
+
+// src/whole-file.ts
+import { renameSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+var HELD_FILE_MS = 1000;
+var HELD_FILE_RETRY_MS = 10;
+var HELD_BY_A_READER = new Set(["EPERM", "EACCES", "EBUSY"]);
+function writeWhole(path, text) {
+  const partial = `${path}.${process.pid}.partial`;
+  try {
+    writeFileSync2(partial, text, "utf8");
+  } catch {
+    return false;
   }
-  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;
+  const until = Date.now() + HELD_FILE_MS;
+  for (;; ) {
+    try {
+      renameSync(partial, path);
+      return true;
+    } catch (error) {
+      const code = error.code ?? "";
+      if (!HELD_BY_A_READER.has(code) || Date.now() >= until) {
+        try {
+          rmSync2(partial, { force: true });
+        } catch {}
+        return false;
       }
-      return { kind: "NodePath", values: Array.from({ length: names + subnames }, () => reader.string()) };
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, HELD_FILE_RETRY_MS);
     }
-    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)]);
+  }
+}
+
+// src/run-record.ts
+var execFileAsync = promisify2(execFile2);
+function runsDirectory() {
+  return join3(runtimeDirectory(), "runs");
+}
+function realAsFarAsItExists(path) {
+  const missing = [];
+  let at = path;
+  for (;; ) {
+    try {
+      return join3(realpathSync.native(at), ...missing);
+    } catch {
+      const parent = dirname2(at);
+      if (parent === at) {
+        return path;
       }
-      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;
+      missing.unshift(basename(at));
+      at = parent;
     }
-    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`);
+function projectKey(projectPath) {
+  const real = realAsFarAsItExists(resolve2(projectPath)).replace(/[\\/]+$/, "");
+  const folded = process.platform === "win32" || process.platform === "darwin" ? real.toLowerCase() : real;
+  return createHash2("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
+}
+function runRecordPath(projectPath, directory = runtimeDirectory()) {
+  return join3(directory, "runs", `note-${projectKey(projectPath)}.json`);
+}
+function writeRunRecord(record) {
+  mkdirSync(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}`);
   }
-  return value;
 }
-function pushU32(out, value) {
-  out.push(value & 255, value >>> 8 & 255, value >>> 16 & 255, value >>> 24 & 255);
+function recordRunEnded(projectPath, pid, ending) {
+  const path = runRecordPath(projectPath);
+  const record = recordAt(path);
+  if (record === null || record.pid !== pid) {
+    return;
+  }
+  const written = {
+    ...record,
+    ...ending.exitCode === null ? {} : { exitCode: ending.exitCode },
+    ...ending.exitSignal === null ? {} : { exitSignal: ending.exitSignal },
+    endedAt: Date.now()
+  };
+  writeWhole(path, JSON.stringify(written, null, 2));
+}
+function recordAt(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") {
+    return null;
+  }
+  const fields = parsed;
+  const pid = fields["pid"];
+  const transcript = fields["transcript"];
+  const startedAt = fields["startedAt"];
+  if (typeof pid !== "number" || typeof transcript !== "string" || typeof startedAt !== "number") {
+    return null;
+  }
+  const args = fields["arguments"];
+  return {
+    pid,
+    transcript,
+    startedAt,
+    ...typeof fields["startedBy"] === "number" ? { startedBy: fields["startedBy"] } : {},
+    projectPath: typeof fields["projectPath"] === "string" ? fields["projectPath"] : "",
+    ...typeof fields["servedBy"] === "string" && fields["servedBy"] !== "" ? { servedBy: fields["servedBy"] } : {},
+    ...typeof fields["keeper"] === "string" && fields["keeper"] !== "" ? { keeper: fields["keeper"] } : {},
+    ...typeof fields["profile"] === "string" && fields["profile"] !== "" ? { profile: fields["profile"] } : {},
+    arguments: Array.isArray(args) ? args.filter((value) => typeof value === "string") : [],
+    ...typeof fields["command"] === "string" ? { command: fields["command"] } : {},
+    ...typeof fields["exitCode"] === "number" ? { exitCode: fields["exitCode"] } : {},
+    ...typeof fields["exitSignal"] === "string" ? { exitSignal: fields["exitSignal"] } : {},
+    ...typeof fields["endedAt"] === "number" ? { endedAt: fields["endedAt"] } : {}
+  };
+}
+
+// src/scratch.ts
+import { existsSync, mkdtempSync as mkdtempSync2, readdirSync as readdirSync2, rmSync as rmSync4 } from "node:fs";
+import { tmpdir as tmpdir3 } from "node:os";
+import { join as join4 } from "node:path";
+import process3 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(tmpdir3(), `gdharness-${kind}-${process3.pid}-`));
 }
-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));
+function discardWith(remove, paths) {
+  const left = [];
+  for (const path of paths) {
+    if (!path) {
+      continue;
     }
-  } 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);
+    try {
+      remove(path);
+    } catch (error) {
+      left.push({ path, reason: error instanceof Error ? error.message : String(error) });
     }
   }
+  return left;
 }
-function encodeVariant(value) {
-  const out = [];
-  encodeInto(out, value);
-  return Uint8Array.from(out);
+function discard(...paths) {
+  const left = discardWith(remove, paths);
+  for (const { path } of left) {
+    tryAgain(path, 0);
+  }
+  return left;
 }
-var MAIN_THREAD = 1;
-function framedCommand(message, data) {
-  const body = encodeVariant([message, MAIN_THREAD, data]);
-  const framed = new Uint8Array(body.length + 4);
-  new DataView(framed.buffer).setUint32(0, body.length, true);
-  framed.set(body, 4);
-  return framed;
+function remove(path) {
+  rmSync4(path, SWEPT);
 }
-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;
-      }
-      out.push(readMessage(joined.subarray(at + 4, at + 4 + length)));
-      at += 4 + length;
+function tryAgain(path, attempt) {
+  if (attempt === 0) {
+    if (waiting.has(path)) {
+      return;
     }
-    this.pending = joined.slice(at);
-    return out;
-  }
-}
-function readMessage(body) {
-  let value;
-  try {
-    value = decodeVariant(body);
-  } catch (error) {
-    return { unreadable: error instanceof Error ? error.message : String(error) };
+    waiting.add(path);
+    atExit.delete(path);
+    lastTryOnExit();
   }
-  if (!Array.isArray(value) || value.length !== 3) {
-    return { unreadable: "a message that is not [message, thread, data]" };
+  const after = AGAIN_AFTER_MS[attempt];
+  if (after === undefined || !existsSync(path)) {
+    waiting.delete(path);
+    if (after === undefined) {
+      atExit.add(path);
+    }
+    return;
   }
-  const [message, , data] = value;
-  if (typeof message !== "string" || !Array.isArray(data)) {
-    return { unreadable: "a message whose name or data is the wrong type" };
+  setTimeout(() => {
+    try {
+      remove(path);
+      waiting.delete(path);
+    } catch {
+      tryAgain(path, attempt + 1);
+    }
+  }, after).unref();
+}
+var lastTryWatched = false;
+function lastTryOnExit() {
+  if (lastTryWatched) {
+    return;
   }
-  return { message, data };
+  lastTryWatched = true;
+  process3.once("exit", () => {
+    for (const path of [...waiting, ...atExit]) {
+      try {
+        remove(path);
+      } catch {}
+    }
+  });
 }
 
+// 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}_]*";
+var ANNOTATIONS = "(?:@[\\p{L}_][\\p{L}\\p{N}_]*(?:\\([^)]*\\))?\\s+)*";
+var DECLARATION_LINE = new RegExp(`^(${ANNOTATIONS})(static\\s+)?(func|var|const|signal|enum|class)\\s+(${NAME})`, "u");
+var CLASS_NAME_LINE = new RegExp(`^${ANNOTATIONS}class_name\\s+(${NAME})`, "u");
+var EXTENDS_LINE = new RegExp(`^${ANNOTATIONS}(?:class_name\\s+${NAME}\\s+)?extends\\s`, "u");
+var FUNC_LINE = new RegExp(`^[ \\t]*${ANNOTATIONS}(?:static\\s+)?func\\s+(${NAME})\\s*\\(`, "u");
+var LAMBDA_HEADER = new RegExp(`(?<![\\p{L}\\p{N}_])func(?:\\s+${NAME})?\\s*\\(`, "u");
+var DOTTED = `${NAME}(?:\\.${NAME})*`;
+var MEMBER_KINDS = new Set(["var", "const", "signal", "enum", "enumValue"]);
+var KEYWORDS = new Set([
+  "and",
+  "as",
+  "assert",
+  "await",
+  "break",
+  "breakpoint",
+  "class",
+  "class_name",
+  "const",
+  "continue",
+  "elif",
+  "else",
+  "enum",
+  "extends",
+  "false",
+  "for",
+  "func",
+  "if",
+  "in",
+  "is",
+  "match",
+  "namespace",
+  "not",
+  "null",
+  "or",
+  "pass",
+  "preload",
+  "return",
+  "self",
+  "signal",
+  "static",
+  "super",
+  "trait",
+  "true",
+  "var",
+  "void",
+  "when",
+  "while",
+  "yield",
+  "INF",
+  "NAN",
+  "PI",
+  "TAU"
+]);
+
 // src/answer-json.ts
 var SCALAR = String.raw`(?:-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?|true|false|null)`;
 var SCALAR_ARRAY = new RegExp(String.raw`\[\n\s+(${SCALAR}(?:,\n\s+${SCALAR})*)\n\s*\]`, "g");
@@ -1150,9 +1649,7 @@ function queuedMessagesOf(projectGodot) {
 var PROFILE_SENT = "gdharness:profile_sent";
 var PROFILE_RECEIVED = "gdharness:profile_received";
 var UNNAMED_PREFIX = "#";
-function profilerOn(frameFunctions) {
-  return framedCommand("profiler:servers", [true, [frameFunctions, false]]);
-}
+var PROFILER_SWITCH = "profiler:servers";
 function withEngineArguments(args, extra) {
   const user = args.indexOf("--");
   return user < 0 ? [...args, ...extra] : [...args.slice(0, user), ...extra, ...args.slice(user)];
@@ -1252,88 +1749,36 @@ class ProfileAggregate {
     };
   }
 }
-class ProfileListener {
-  connection = null;
+class ProfileObserver {
   aggregate = null;
-  server;
-  port;
   changed;
   frameFunctions;
-  constructor(server, port, changed, frameFunctions) {
-    this.server = server;
-    this.port = port;
+  constructor(changed, frameFunctions) {
     this.changed = changed;
     this.frameFunctions = frameFunctions;
   }
-  static async open(changed, frameFunctions) {
-    const server = createServer2();
-    await new Promise((resolve, reject) => {
-      server.once("error", reject);
-      server.listen(0, "127.0.0.1", () => {
-        resolve();
-      });
-    });
-    const address = server.address();
-    if (address === null || typeof address === "string") {
-      server.close();
-      throw new Error("the profiler listener has no port");
-    }
-    const listener = new ProfileListener(server, address.port, changed, frameFunctions);
-    server.on("connection", (socket) => {
-      listener.accept(socket);
-    });
-    return listener;
-  }
-  get engineArguments() {
-    return ["--remote-debug", `tcp://127.0.0.1:${this.port}`, "--skip-breakpoints", "--ignore-error-breaks"];
-  }
-  accept(socket) {
-    if (this.connection !== null) {
-      socket.destroy();
-      return;
-    }
-    this.connection = socket;
-    this.server.close();
-    const started = Date.now();
-    const aggregate = new ProfileAggregate(started, this.frameFunctions);
+  connected(send) {
+    const aggregate = new ProfileAggregate(Date.now(), this.frameFunctions);
     this.aggregate = aggregate;
-    const stream = new DebuggerStream;
-    socket.write(profilerOn(this.frameFunctions));
+    send(PROFILER_SWITCH, [true, [this.frameFunctions, false]]);
     this.changed(aggregate.snapshot());
-    socket.on("data", (chunk) => {
-      let messages;
-      try {
-        messages = stream.push(chunk);
-      } catch {
-        socket.destroy();
-        return;
-      }
-      let frames = false;
-      for (const received of messages) {
-        if ("message" in received && received.message === "debug_enter") {
-          socket.write(framedCommand("continue", []));
-        }
-        if ("message" in received && received.message === PROFILE_SENT) {
-          socket.write(framedCommand(PROFILE_RECEIVED, []));
-        }
-        aggregate.take(received, Date.now());
-        frames ||= "message" in received && (received.message === "servers:profile_frame" || received.message === "servers:profile_total");
-      }
-      if (frames) {
-        this.changed(aggregate.snapshot());
-      }
-    });
-    socket.on("error", () => {
+  }
+  message(received, send) {
+    const aggregate = this.aggregate;
+    if (aggregate === null) {
       return;
-    });
+    }
+    if ("message" in received && received.message === PROFILE_SENT) {
+      send(PROFILE_RECEIVED, []);
+    }
+    aggregate.take(received, Date.now());
+    if ("message" in received && (received.message === "servers:profile_frame" || received.message === "servers:profile_total")) {
+      this.changed(aggregate.snapshot());
+    }
   }
   totals() {
     return this.aggregate?.snapshot() ?? null;
   }
-  close() {
-    this.connection?.destroy();
-    this.server.close();
-  }
 }
 
 // src/keeper.ts
@@ -1394,7 +1839,7 @@ async function startThroughHelper(spec, output, stopFile) {
 }
 var PROFILE_WRITE_MS = 500;
 var LAST_WRITE_TRIES = 5;
-async function profiledBy(path, projectPath) {
+function profiledBy(path, projectPath) {
   let latest = null;
   let timer = null;
   const write = () => {
@@ -1407,7 +1852,7 @@ async function profiledBy(path, projectPath) {
   try {
     projectGodot = readFileSync2(join5(projectPath, "project.godot"), "utf8");
   } catch {}
-  const listener = await ProfileListener.open((totals) => {
+  const observer = new ProfileObserver((totals) => {
     const first = latest === null;
     latest = totals;
     if (first) {
@@ -1418,20 +1863,20 @@ async function profiledBy(path, projectPath) {
   }, frameFunctionsFor(queuedMessagesOf(projectGodot)));
   writeProfileFile(path, { connected: false, listeningSince: Date.now() });
   return {
-    listener,
+    observer,
     finish: () => {
       if (timer !== null) {
         clearTimeout(timer);
       }
-      latest = listener.totals() ?? latest;
+      latest = observer.totals() ?? latest;
       let tries = 0;
       while (latest !== null && !writeProfileFile(path, { ...latest, connected: true }) && tries < LAST_WRITE_TRIES) {
         tries += 1;
       }
-      listener.close();
     }
   };
 }
+var DRAIN_MS = 2000;
 var DESKTOP_START_MS = 60000;
 async function startDetached(spec, output, hidden, stopFile = "") {
   return throughTheHelper(spec) ? await startThroughHelper(spec, output, stopFile) : await startDirectly(spec, output, hidden);
@@ -1505,8 +1950,9 @@ async function keep() {
 `);
     process.exit(1);
   }
-  const profiled = run?.profile === undefined ? null : await profiledBy(run.profile, run.projectPath);
-  const toStart = profiled === null ? spec : { ...spec, args: withEngineArguments(spec.args, profiled.listener.engineArguments) };
+  const profiled = run?.profile === undefined ? null : profiledBy(run.profile, run.projectPath);
+  const debuggerPeer = run === undefined ? null : await GameDebugger.open(run.breakpoints ?? [], profiled === null ? [] : [profiled.observer]);
+  const toStart = debuggerPeer === null ? spec : { ...spec, args: withEngineArguments(spec.args, debuggerPeer.engineArguments) };
   const transcript = run === undefined ? "ignore" : openSync2(run.transcript, "a");
   const own = run !== undefined && throughTheHelper(spec) ? mkdtempSync3(join5(tmpdir4(), "gdharness-stop-")) : null;
   const stopFile = own === null ? "" : join5(own, "stop");
@@ -1519,7 +1965,7 @@ async function keep() {
     }
   }
   if ("error" in started) {
-    profiled?.listener.close();
+    debuggerPeer?.close();
     process.stdout.write(`error ${started.error}
 `);
     process.exit(1);
@@ -1541,24 +1987,32 @@ async function keep() {
   }
   let listening = null;
   child.once("exit", (code, signal) => {
-    if (run !== undefined) {
-      recordRunEnded(run.projectPath, pid, { exitCode: code, exitSignal: code === null ? signal : null });
-    }
-    profiled?.finish();
-    listening?.close();
-    if (own !== null) {
-      rmSync5(own, { recursive: true, force: true });
+    const finish = () => {
+      profiled?.finish();
+      if (run !== undefined) {
+        recordRunEnded(run.projectPath, pid, { exitCode: code, exitSignal: code === null ? signal : null });
+      }
+      debuggerPeer?.close();
+      listening?.close();
+      if (own !== null) {
+        rmSync5(own, { recursive: true, force: true });
+      }
+      process.exit(0);
+    };
+    if (debuggerPeer === null) {
+      finish();
+    } else {
+      debuggerPeer.drained(DRAIN_MS).then(finish);
     }
-    process.exit(0);
   });
   if (record !== null) {
-    listening = await listenForAStop(() => {
+    listening = await listenForTheServer(() => {
       if (stopFile !== "") {
         writeFileSync3(stopFile, "");
         return "signalled";
       }
       return child.kill() ? "signalled" : "gone";
-    });
+    }, debuggerPeer === null ? null : (request) => debuggerPeer.ask(request));
     if (listening !== null) {
       writeNoteIfItCan({ ...record, keeper: listening.address });
     }