gdharness 1.3.50 → 1.3.53

package/build/keeper.js

@@ -6946,8 +6946,8 @@ var require_public_api = __commonJS(function(exports) {
 });
 
 // src/keeper.ts
-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 { closeSync as closeSync3, existsSync as existsSync4, mkdtempSync as mkdtempSync4, openSync as openSync4, readFileSync as readFileSync9, rmSync as rmSync7, writeFileSync as writeFileSync4 } from "node:fs";
+import { tmpdir as tmpdir8 } from "node:os";
 import { join as join10 } from "node:path";
 import { setTimeout as delay3 } from "node:timers/promises";
 
@@ -6976,6 +6976,10 @@ function alive(pid) {
 }
 
 // src/desktop.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+
+// src/compiled-helper.ts
 import { createHash } from "node:crypto";
 import {
   closeSync,
@@ -7018,6 +7022,109 @@ function runHidden(command, args, options = {}) {
   });
 }
 
+// src/compiled-helper.ts
+var HELPER_COMPILE_MS = 180000;
+
+class CompiledHelper {
+  named;
+  file;
+  source;
+  digest;
+  constructor(named, file, source) {
+    this.named = named;
+    this.file = file;
+    this.source = source;
+    this.digest = createHash("sha256").update(source).digest("hex").slice(0, 16);
+  }
+  assembly(directory = tmpdir()) {
+    return join(directory, `${this.file}-${this.digest}.dll`);
+  }
+  async ensure(directory = tmpdir(), budgetMs = HELPER_COMPILE_MS, wait = true) {
+    const assembly = this.assembly(directory);
+    const lock = `${assembly}.compiling`;
+    const until = Date.now() + budgetMs;
+    while (Date.now() < until) {
+      if (existsSync(assembly)) {
+        return null;
+      }
+      let mine = false;
+      try {
+        const held = openSync(lock, "wx");
+        writeSync(held, String(process.pid));
+        closeSync(held);
+        mine = true;
+      } catch {}
+      if (mine) {
+        try {
+          return await this.compile(directory, assembly, until - Date.now());
+        } finally {
+          rmSync(lock, { force: true });
+        }
+      }
+      try {
+        const holder = Number(readFileSync(lock, "utf8").trim());
+        const old = Date.now() - statSync(lock).mtimeMs > budgetMs;
+        if (old || Number.isInteger(holder) && holder > 0 && !alive(holder)) {
+          rmSync(lock, { force: true });
+          continue;
+        }
+      } catch {}
+      if (!wait) {
+        return null;
+      }
+      await delay(200);
+    }
+    return `the ${this.named} was not compiled within ${String(budgetMs)} ms`;
+  }
+  async compile(directory, assembly, budgetMs) {
+    const scratch = mkdtempSync(join(directory, `${this.file}-source-`));
+    const source = join(scratch, "helper.cs");
+    writeFileSync(source, this.source, "utf8");
+    const literal = (path) => `'${path.replaceAll("'", "''")}'`;
+    const script = [
+      "$ErrorActionPreference = 'Stop'",
+      "try {",
+      `  $partial = ${literal(assembly)} + '.' + $PID`,
+      `  Add-Type -TypeDefinition ([IO.File]::ReadAllText(${literal(source)}, [Text.Encoding]::UTF8)) -OutputAssembly $partial`,
+      `  Move-Item -LiteralPath $partial -Destination ${literal(assembly)}`,
+      "} catch {",
+      "  [Console]::Error.WriteLine($_.Exception.Message)",
+      "  exit 1",
+      "}"
+    ].join(`
+`);
+    try {
+      return await new Promise((resolve) => {
+        const compiler = spawnHidden("powershell.exe", [
+          "-NoProfile",
+          "-NonInteractive",
+          "-ExecutionPolicy",
+          "Bypass",
+          "-EncodedCommand",
+          Buffer.from(script, "utf16le").toString("base64")
+        ], { stdio: ["ignore", "ignore", "pipe"] });
+        let complained = "";
+        compiler.stderr.on("data", (chunk) => {
+          complained += chunk.toString();
+        });
+        const timer = setTimeout(() => {
+          compiler.kill();
+        }, budgetMs);
+        compiler.once("error", (error) => {
+          clearTimeout(timer);
+          resolve(`Windows PowerShell did not start: ${error.message}`);
+        });
+        compiler.once("close", (code) => {
+          clearTimeout(timer);
+          resolve(existsSync(assembly) ? null : `Windows PowerShell could not compile the ${this.named}${code === null ? " in time" : ""}: ${complained.trim() || `exit code ${String(code)}`}`);
+        });
+      });
+    } finally {
+      rmSync(scratch, { recursive: true, force: true });
+    }
+  }
+}
+
 // src/desktop.ts
 var DESKTOP_VARIABLE = "GDHARNESS_DESKTOP";
 var SOURCE = `using System;
@@ -7244,94 +7351,12 @@ public static class GdharnessDesktop {
   }
 }
 `;
-var DIGEST = createHash("sha256").update(SOURCE).digest("hex").slice(0, 16);
-var HELPER_COMPILE_MS = 180000;
-function helperAssembly(directory = tmpdir()) {
-  return join(directory, `gdharness-desktop-${DIGEST}.dll`);
+var HELPER = new CompiledHelper("desktop helper", "gdharness-desktop", SOURCE);
+function helperAssembly(directory = tmpdir2()) {
+  return HELPER.assembly(directory);
 }
-async function ensureHelperCompiled(directory = tmpdir(), budgetMs = HELPER_COMPILE_MS, wait = true) {
-  const assembly = helperAssembly(directory);
-  const lock = `${assembly}.compiling`;
-  const until = Date.now() + budgetMs;
-  while (Date.now() < until) {
-    if (existsSync(assembly)) {
-      return null;
-    }
-    let mine = false;
-    try {
-      const held = openSync(lock, "wx");
-      writeSync(held, String(process.pid));
-      closeSync(held);
-      mine = true;
-    } catch {}
-    if (mine) {
-      try {
-        return await compileHelper(directory, assembly, until - Date.now());
-      } finally {
-        rmSync(lock, { force: true });
-      }
-    }
-    try {
-      const holder = Number(readFileSync(lock, "utf8").trim());
-      const old = Date.now() - statSync(lock).mtimeMs > budgetMs;
-      if (old || Number.isInteger(holder) && holder > 0 && !alive(holder)) {
-        rmSync(lock, { force: true });
-        continue;
-      }
-    } catch {}
-    if (!wait) {
-      return null;
-    }
-    await delay(200);
-  }
-  return `the desktop helper was not compiled within ${String(budgetMs)} ms`;
-}
-async function compileHelper(directory, assembly, budgetMs) {
-  const scratch = mkdtempSync(join(directory, "gdharness-desktop-source-"));
-  const source = join(scratch, "helper.cs");
-  writeFileSync(source, SOURCE, "utf8");
-  const literal = (path) => `'${path.replaceAll("'", "''")}'`;
-  const script = [
-    "$ErrorActionPreference = 'Stop'",
-    "try {",
-    `  $partial = ${literal(assembly)} + '.' + $PID`,
-    `  Add-Type -TypeDefinition ([IO.File]::ReadAllText(${literal(source)}, [Text.Encoding]::UTF8)) -OutputAssembly $partial`,
-    `  Move-Item -LiteralPath $partial -Destination ${literal(assembly)}`,
-    "} catch {",
-    "  [Console]::Error.WriteLine($_.Exception.Message)",
-    "  exit 1",
-    "}"
-  ].join(`
-`);
-  try {
-    return await new Promise((resolve) => {
-      const compiler = spawnHidden("powershell.exe", [
-        "-NoProfile",
-        "-NonInteractive",
-        "-ExecutionPolicy",
-        "Bypass",
-        "-EncodedCommand",
-        Buffer.from(script, "utf16le").toString("base64")
-      ], { stdio: ["ignore", "ignore", "pipe"] });
-      let complained = "";
-      compiler.stderr.on("data", (chunk) => {
-        complained += chunk.toString();
-      });
-      const timer = setTimeout(() => {
-        compiler.kill();
-      }, budgetMs);
-      compiler.once("error", (error) => {
-        clearTimeout(timer);
-        resolve(`Windows PowerShell did not start: ${error.message}`);
-      });
-      compiler.once("close", (code) => {
-        clearTimeout(timer);
-        resolve(existsSync(assembly) ? null : `Windows PowerShell could not compile it${code === null ? " in time" : ""}: ${complained.trim() || `exit code ${String(code)}`}`);
-      });
-    });
-  } finally {
-    rmSync(scratch, { recursive: true, force: true });
-  }
+function ensureHelperCompiled(directory = tmpdir2(), budgetMs = HELPER_COMPILE_MS, wait = true) {
+  return HELPER.ensure(directory, budgetMs, wait);
 }
 function quoted(argument) {
   if (argument !== "" && !/[\s"]/.test(argument)) {
@@ -7354,7 +7379,7 @@ function windowsCommandLine(command, args) {
 }
 function helperFailure(file) {
   try {
-    const said = readFileSync(file, "utf8").trim();
+    const said = readFileSync2(file, "utf8").trim();
     return said === "" ? null : said;
   } catch {
     return null;
@@ -7363,7 +7388,7 @@ function helperFailure(file) {
 function helperStep(stepFile) {
   let step = null;
   try {
-    step = readFileSync(stepFile, "utf8").trim();
+    step = readFileSync2(stepFile, "utf8").trim();
   } catch {}
   return step === null || step === "" ? "Windows PowerShell had not begun running the helper" : `the helper was ${step}`;
 }
@@ -7378,7 +7403,7 @@ function throughHelper(how, command, args, files, assembly = helperAssembly()) {
     files.step,
     how.affinity === undefined ? "" : how.affinity.toString()
   ];
-  writeFileSync(files.spec, fields.map((field) => Buffer.from(field, "utf8").toString("base64")).join(`
+  writeFileSync2(files.spec, fields.map((field) => Buffer.from(field, "utf8").toString("base64")).join(`
 `), "utf8");
   const literal = (path) => `'${path.replaceAll("'", "''")}'`;
   const script = [
@@ -7410,10 +7435,11 @@ function throughHelper(how, command, args, files, assembly = helperAssembly()) {
 // src/engine-slots.ts
 import {
   closeSync as closeSync2,
+  existsSync as existsSync2,
   mkdirSync,
   openSync as openSync2,
   readdirSync,
-  readFileSync as readFileSync4,
+  readFileSync as readFileSync5,
   rmSync as rmSync3,
   statSync as statSync3,
   watch,
@@ -7943,6 +7969,506 @@ function entryFor(shape, launch, held) {
   };
 }
 
+// src/log-read.ts
+var LOG_LIMIT_BYTES = 128 * 1024 * 1024;
+
+// src/process-table.ts
+import { tmpdir as tmpdir4 } from "node:os";
+
+// src/windows-ask.ts
+import { tmpdir as tmpdir3 } 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: tmpdir3() });
+  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/process-table.ts
+var SOURCE2 = String.raw`
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public static class GdhProcessTable
+{
+    [DllImport("ntdll.dll")]
+    private static extern int NtQuerySystemInformation(int infoClass, IntPtr info, int length, out int needed);
+
+    [DllImport("ntdll.dll")]
+    private static extern int NtQueryInformationProcess(IntPtr process, int infoClass, IntPtr info, int length, out int needed);
+
+    [DllImport("kernel32.dll")]
+    private static extern IntPtr OpenProcess(int access, bool inherit, int pid);
+
+    [DllImport("kernel32.dll")]
+    private static extern bool CloseHandle(IntPtr handle);
+
+    [DllImport("kernel32.dll")]
+    private static extern bool GetProcessTimes(IntPtr process, out long created, out long exited, out long kernel, out long user);
+
+    [DllImport("kernel32.dll")]
+    private static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
+
+    [DllImport("kernel32.dll")]
+    private static extern bool GetExitCodeProcess(IntPtr process, out int code);
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct MemoryStatus
+    {
+        public uint Length;
+        public uint MemoryLoad;
+        public ulong TotalPhys;
+        public ulong AvailPhys;
+        public ulong TotalPageFile;
+        public ulong AvailPageFile;
+        public ulong TotalVirtual;
+        public ulong AvailVirtual;
+        public ulong AvailExtendedVirtual;
+    }
+
+    [DllImport("kernel32.dll")]
+    private static extern bool GlobalMemoryStatusEx(ref MemoryStatus status);
+
+    private const int SystemProcessInformation = 5;
+    private const int ProcessCommandLineInformation = 60;
+    private const int QueryLimitedInformation = 0x1000;
+    private const int Synchronize = 0x100000;
+    private const int InfoLengthMismatch = unchecked((int)0xC0000004);
+    private const int BufferTooSmall = unchecked((int)0xC0000023);
+    private const int BufferOverflow = unchecked((int)0x80000005);
+    private const long UnixEpoch = 116444736000000000L;
+
+    private struct Entry
+    {
+        public int Pid;
+        public int Parent;
+        public long Created;
+        public long Processor;
+    }
+
+    private static readonly Dictionary<int, IntPtr> held = new Dictionary<int, IntPtr>();
+
+    // The offsets of SYSTEM_PROCESS_INFORMATION's fields, which move with the pointer size after
+    // ImageName, a UNICODE_STRING.
+    private static List<Entry> Snapshot()
+    {
+        int pidAt = IntPtr.Size == 8 ? 80 : 68;
+        int parentAt = IntPtr.Size == 8 ? 88 : 72;
+        int length = 1 << 20;
+        while (true)
+        {
+            IntPtr buffer = Marshal.AllocHGlobal(length);
+            try
+            {
+                int needed;
+                int status = NtQuerySystemInformation(SystemProcessInformation, buffer, length, out needed);
+                if (status == InfoLengthMismatch)
+                {
+                    // Room for the processes started between this call and the next.
+                    length = Math.Max(length * 2, needed + (1 << 16));
+                    continue;
+                }
+                if (status != 0)
+                {
+                    throw new InvalidOperationException("NtQuerySystemInformation answered 0x" + status.ToString("X8", CultureInfo.InvariantCulture));
+                }
+                List<Entry> entries = new List<Entry>();
+                long offset = 0;
+                while (true)
+                {
+                    IntPtr at = new IntPtr(buffer.ToInt64() + offset);
+                    Entry entry = new Entry();
+                    entry.Created = Marshal.ReadInt64(at, 32);
+                    entry.Processor = Marshal.ReadInt64(at, 40) + Marshal.ReadInt64(at, 48);
+                    entry.Pid = (int)Marshal.ReadIntPtr(at, pidAt).ToInt64();
+                    entry.Parent = (int)Marshal.ReadIntPtr(at, parentAt).ToInt64();
+                    entries.Add(entry);
+                    int next = Marshal.ReadInt32(at, 0);
+                    if (next == 0)
+                    {
+                        return entries;
+                    }
+                    offset += next;
+                }
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(buffer);
+            }
+        }
+    }
+
+    // Zero for the few processes the kernel does not date, the idle process and System among them.
+    private static string Milliseconds(long created)
+    {
+        long milliseconds = created > UnixEpoch ? (created - UnixEpoch) / 10000 : 0;
+        return milliseconds.ToString(CultureInfo.InvariantCulture);
+    }
+
+    private static string Number(int value)
+    {
+        return value.ToString(CultureInfo.InvariantCulture);
+    }
+
+    // The handle is to the listed process only if it started when the listing says, since a number
+    // can be handed on between the listing and the open.
+    private static IntPtr Open(Entry entry, int access)
+    {
+        IntPtr handle = OpenProcess(access, false, entry.Pid);
+        if (handle == IntPtr.Zero)
+        {
+            return handle;
+        }
+        long created;
+        long exited;
+        long kernel;
+        long user;
+        if (!GetProcessTimes(handle, out created, out exited, out kernel, out user) || created != entry.Created)
+        {
+            CloseHandle(handle);
+            return IntPtr.Zero;
+        }
+        return handle;
+    }
+
+    // Empty where the process will not be opened, which for another user's process is the usual
+    // answer. On one line, so that a line break in it cannot pass for a process; a few system
+    // processes carry a NUL in theirs.
+    private static string CommandLineOf(IntPtr process)
+    {
+        int length = 4096;
+        for (int tries = 0; tries < 4; tries++)
+        {
+            IntPtr buffer = Marshal.AllocHGlobal(length);
+            try
+            {
+                int needed;
+                int status = NtQueryInformationProcess(process, ProcessCommandLineInformation, buffer, length, out needed);
+                if (status == InfoLengthMismatch || status == BufferTooSmall || status == BufferOverflow)
+                {
+                    length = Math.Max(needed, length * 2);
+                    continue;
+                }
+                if (status != 0)
+                {
+                    return "";
+                }
+                int bytes = Marshal.ReadInt16(buffer, 0) & 0xFFFF;
+                IntPtr text = Marshal.ReadIntPtr(buffer, IntPtr.Size);
+                if (bytes == 0 || text == IntPtr.Zero)
+                {
+                    return "";
+                }
+                return Marshal.PtrToStringUni(text, bytes / 2).Replace('\r', ' ').Replace('\n', ' ').Replace('\0', ' ');
+            }
+            finally
+            {
+                Marshal.FreeHGlobal(buffer);
+            }
+        }
+        return "";
+    }
+
+    private static string CommandLineOf(Entry entry)
+    {
+        IntPtr handle = Open(entry, QueryLimitedInformation);
+        if (handle == IntPtr.Zero)
+        {
+            return "";
+        }
+        try
+        {
+            return CommandLineOf(handle);
+        }
+        finally
+        {
+            CloseHandle(handle);
+        }
+    }
+
+    private static HashSet<int> Pids(string listed)
+    {
+        HashSet<int> pids = new HashSet<int>();
+        foreach (string one in listed.Split(','))
+        {
+            int pid;
+            if (int.TryParse(one.Trim(), NumberStyles.Integer, CultureInfo.InvariantCulture, out pid))
+            {
+                pids.Add(pid);
+            }
+        }
+        return pids;
+    }
+
+    /// <summary>Every process as "pid parent started command", one a line.</summary>
+    public static string Table()
+    {
+        StringBuilder said = new StringBuilder();
+        foreach (Entry entry in Snapshot())
+        {
+            if (entry.Pid <= 0)
+            {
+                continue;
+            }
+            said.Append(Number(entry.Pid)).Append(' ').Append(Number(entry.Parent)).Append(' ')
+                .Append(Milliseconds(entry.Created)).Append(' ').Append(CommandLineOf(entry)).Append('\n');
+        }
+        return said.ToString();
+    }
+
+    /// <summary>"pid started" for each of the comma-separated pids the kernel dates.</summary>
+    public static string Starts(string pids)
+    {
+        HashSet<int> wanted = Pids(pids);
+        StringBuilder said = new StringBuilder();
+        foreach (Entry entry in Snapshot())
+        {
+            if (wanted.Contains(entry.Pid) && entry.Created > UnixEpoch)
+            {
+                said.Append(Number(entry.Pid)).Append(' ').Append(Milliseconds(entry.Created)).Append('\n');
+            }
+        }
+        return said.ToString();
+    }
+
+    /// <summary>When the pid started and, on the next line, its command line; empty when it is not running.</summary>
+    public static string One(int pid)
+    {
+        foreach (Entry entry in Snapshot())
+        {
+            if (entry.Pid == pid)
+            {
+                return Milliseconds(entry.Created) + "\n" + CommandLineOf(entry);
+            }
+        }
+        return "";
+    }
+
+    /// <summary>The processor seconds the pid has used; empty when it is not running.</summary>
+    public static string ProcessorSeconds(int pid)
+    {
+        foreach (Entry entry in Snapshot())
+        {
+            if (entry.Pid == pid)
+            {
+                return (entry.Processor / 1e7).ToString("R", CultureInfo.InvariantCulture);
+            }
+        }
+        return "";
+    }
+
+    /// <summary>How many more bytes Windows will commit.</summary>
+    public static string CommitLeft()
+    {
+        MemoryStatus status = new MemoryStatus();
+        status.Length = (uint)Marshal.SizeOf(typeof(MemoryStatus));
+        if (!GlobalMemoryStatusEx(ref status))
+        {
+            throw new InvalidOperationException("GlobalMemoryStatusEx failed with " + Number(Marshal.GetLastWin32Error()));
+        }
+        return status.AvailPageFile.ToString(CultureInfo.InvariantCulture);
+    }
+
+    /// <summary>
+    /// "pid started command" for each dated child of the pid, holding a handle to each: Windows tells
+    /// a process's exit code only to whoever holds a handle to it, and the handle keeps its number
+    /// from going to anything else.
+    /// </summary>
+    public static string HoldChildren(int parent)
+    {
+        StringBuilder said = new StringBuilder();
+        foreach (Entry entry in Snapshot())
+        {
+            if (entry.Parent != parent || entry.Pid <= 0 || entry.Created <= UnixEpoch || held.ContainsKey(entry.Pid))
+            {
+                continue;
+            }
+            IntPtr handle = Open(entry, QueryLimitedInformation | Synchronize);
+            if (handle == IntPtr.Zero)
+            {
+                continue;
+            }
+            held[entry.Pid] = handle;
+            said.Append(Number(entry.Pid)).Append(' ').Append(Milliseconds(entry.Created)).Append(' ')
+                .Append(CommandLineOf(handle)).Append('\n');
+        }
+        return said.ToString();
+    }
+
+    /// <summary>"exit code" once a child held by HoldChildren has ended; empty for one not held.</summary>
+    public static string WaitFor(int pid)
+    {
+        IntPtr handle;
+        if (!held.TryGetValue(pid, out handle))
+        {
+            return "";
+        }
+        WaitForSingleObject(handle, 0xFFFFFFFF);
+        int code;
+        return GetExitCodeProcess(handle, out code) ? "exit " + Number(code) : "";
+    }
+}
+`;
+var TABLE = new CompiledHelper("process table", "gdharness-processes", SOURCE2);
+
+class ProcessTableUnbuilt extends Error {
+}
+function ensureProcessTable(directory = tmpdir4(), wait = true) {
+  return TABLE.ensure(directory, HELPER_COMPILE_MS, wait);
+}
+async function loadingTheTable() {
+  const failed = await ensureProcessTable();
+  if (failed !== null) {
+    throw new ProcessTableUnbuilt(failed);
+  }
+  return `$null = [Reflection.Assembly]::LoadFrom('${TABLE.assembly().replaceAll("'", "''")}')`;
+}
+async function askProcessTable(call, withinMs) {
+  return askWindows(`${await loadingTheTable()}; [GdhProcessTable]::${call}`, withinMs);
+}
+
 // 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}_]*";
@@ -8001,7 +8527,7 @@ var KEYWORDS = new Set([
 ]);
 
 // src/whole-file.ts
-import { readFileSync as readFileSync2, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { readFileSync as readFileSync3, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "node:fs";
 var HELD_FILE_MS = 1000;
 var HELD_FILE_RETRY_MS = 10;
 var HELD_BY_A_READER = new Set(["EPERM", "EACCES", "EBUSY"]);
@@ -8009,7 +8535,7 @@ function readWhole(path) {
   const until = Date.now() + HELD_FILE_MS;
   for (;; ) {
     try {
-      return readFileSync2(path, "utf8");
+      return readFileSync3(path, "utf8");
     } catch (error) {
       const code = error.code ?? "";
       if (code === "ENOENT") {
@@ -8025,7 +8551,7 @@ function readWhole(path) {
 function writeWhole(path, text) {
   const partial = `${path}.${process.pid}.partial`;
   try {
-    writeFileSync2(partial, text, "utf8");
+    writeFileSync3(partial, text, "utf8");
   } catch {
     return false;
   }
@@ -8109,161 +8635,14 @@ var QUEUE_OVERFLOW_FRAMES = new Map([
   ["ed1daf0bf001b61586d9930840f2f1394092c079", ["main+3e1082a", "main+3e0f4aa"]]
 ]);
 
-// 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;
+var SCAN_BYTES = 1024 * 1024;
 
 // src/process-children.ts
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 import { basename as basename3 } from "node:path";
 async function startTimesOf(pids) {
   const began = new Map;
@@ -8272,8 +8651,7 @@ async function startTimesOf(pids) {
   }
   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);
+      const said = await askProcessTable(`Starts('${pids.join(",")}')`, ASK_TIMEOUT_MS);
       for (const line of said.split(`
 `)) {
         const found = /^\s*(\d+)\s+(\d+)\s*$/.exec(line);
@@ -8306,7 +8684,7 @@ async function linuxStartTimes(pids) {
   const hertz = await ticksPerSecond();
   let booted;
   try {
-    booted = Number(/^btime\s+(\d+)$/m.exec(readFileSync3("/proc/stat", "utf8"))?.[1] ?? Number.NaN) * 1000;
+    booted = Number(/^btime\s+(\d+)$/m.exec(readFileSync4("/proc/stat", "utf8"))?.[1] ?? Number.NaN) * 1000;
   } catch {
     return began;
   }
@@ -8316,7 +8694,7 @@ async function linuxStartTimes(pids) {
   for (const pid of pids) {
     let stat;
     try {
-      stat = readFileSync3(`/proc/${String(pid)}/stat`, "utf8");
+      stat = readFileSync4(`/proc/${String(pid)}/stat`, "utf8");
     } catch {
       continue;
     }
@@ -8453,7 +8831,7 @@ function handSlot(lock, from, to) {
 }
 function giveBackSlot(lock, pid) {
   try {
-    if (holderOf(readFileSync4(lock, "utf8"))?.pid === pid) {
+    if (holderOf(readFileSync5(lock, "utf8"))?.pid === pid) {
       removeWhole(lock);
     }
   } catch {}
@@ -8487,7 +8865,7 @@ function crashesReported() {
 }
 
 // src/game-debugger.ts
-import { readFileSync as readFileSync6 } from "node:fs";
+import { readFileSync as readFileSync7 } from "node:fs";
 import { createServer } from "node:net";
 import { join as join6 } from "node:path";
 
@@ -8909,8 +9287,8 @@ var IMPORTABLE = new Set(IMPORTABLE_EXTENSIONS);
 var hashes = new Map;
 
 // src/scratch.ts
-import { existsSync as existsSync2, mkdtempSync as mkdtempSync2, readdirSync as readdirSync2, rmSync as rmSync4 } from "node:fs";
-import { tmpdir as tmpdir3 } from "node:os";
+import { existsSync as existsSync3, mkdtempSync as mkdtempSync2, readdirSync as readdirSync2, rmSync as rmSync4 } from "node:fs";
+import { tmpdir as tmpdir5 } from "node:os";
 import { join as join4 } from "node:path";
 import process6 from "node:process";
 var SWEPT = { recursive: true, force: true };
@@ -8918,7 +9296,7 @@ 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}-${process6.pid}-`));
+  return mkdtempSync2(join4(tmpdir5(), `gdharness-${kind}-${process6.pid}-`));
 }
 function discardWith(remove, paths) {
   const left = [];
@@ -8954,7 +9332,7 @@ function tryAgain(path, attempt) {
     lastTryOnExit();
   }
   const after = AGAIN_AFTER_MS[attempt];
-  if (after === undefined || !existsSync2(path)) {
+  if (after === undefined || !existsSync3(path)) {
     waiting.delete(path);
     if (after === undefined) {
       atExit.add(path);
@@ -9103,7 +9481,7 @@ function parseIniLikeValue(value) {
 }
 
 // src/server-version.ts
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync6 } from "node:fs";
 
 // src/update-check.ts
 var CACHE_MS = 10 * 60 * 1000;
@@ -9114,7 +9492,7 @@ var MAX_RETRY_MS = 60 * 60 * 1000;
 var DEBUG_MODE = process.env["GDHARNESS_DEBUG"] === "1";
 var SERVER_VERSION = (() => {
   try {
-    const pkg = JSON.parse(readFileSync5(new URL("../package.json", import.meta.url), "utf8"));
+    const pkg = JSON.parse(readFileSync6(new URL("../package.json", import.meta.url), "utf8"));
     return typeof pkg.version === "string" ? pkg.version : "0.0.0";
   } catch {
     return "0.0.0";
@@ -9140,7 +9518,7 @@ var RUNTIME_AUTOLOAD2 = `${RUNTIME_ADDON}runtime_autoload.gd`;
 var frameEnd = null;
 function frameEndLine() {
   if (frameEnd === null) {
-    const lines = readFileSync6(join6(shippedAddonsDirectory(), "gdharness_runtime", "runtime_autoload.gd"), "utf8").split(`
+    const lines = readFileSync7(join6(shippedAddonsDirectory(), "gdharness_runtime", "runtime_autoload.gd"), "utf8").split(`
 `);
     const declared = lines.findIndex((line) => line.startsWith("func _notification("));
     if (declared === -1) {
@@ -9794,7 +10172,7 @@ class GameDebugger {
 import { randomUUID } from "node:crypto";
 import { mkdtempSync as mkdtempSync3, rmSync as rmSync5 } from "node:fs";
 import { connect, createServer as createServer2 } from "node:net";
-import { tmpdir as tmpdir4 } from "node:os";
+import { tmpdir as tmpdir6 } from "node:os";
 import { join as join7 } from "node:path";
 import process7 from "node:process";
 var DEBUG_PREFIX = "debug ";
@@ -9823,7 +10201,7 @@ function errorText(error) {
 async function listenForTheServer(end, debug) {
   let directory = null;
   try {
-    directory = process7.platform === "win32" ? null : mkdtempSync3(join7(tmpdir4(), "gdharness-keeper-"));
+    directory = process7.platform === "win32" ? null : mkdtempSync3(join7(tmpdir6(), "gdharness-keeper-"));
     const address = directory === null ? `\\\\.\\pipe\\gdharness-keeper-${randomUUID()}` : join7(directory, "keeper.sock");
     const server = createServer2((socket) => {
       socket.setEncoding("utf8");
@@ -9917,11 +10295,11 @@ function readLaunched(printed) {
 
 // src/run-record.ts
 import { createHash as createHash2 } from "node:crypto";
-import { mkdirSync as mkdirSync2, openSync as openSync3, readdirSync as readdirSync3, readFileSync as readFileSync7, rmSync as rmSync6, statSync as statSync4 } from "node:fs";
+import { mkdirSync as mkdirSync2, openSync as openSync3, readdirSync as readdirSync3, readFileSync as readFileSync8, 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 tmpdir5 } from "node:os";
+import { tmpdir as tmpdir7 } from "node:os";
 import { dirname as dirname4, join as join8, resolve as resolve3 } from "node:path";
 
 // src/launch.ts
@@ -9967,7 +10345,7 @@ function runtimeDirectory(variables = process.env) {
     return explicit;
   }
   const perUser = envValue("XDG_RUNTIME_DIR", variables);
-  return join8(perUser ?? tmpdir5(), "gdharness");
+  return join8(perUser ?? tmpdir7(), "gdharness");
 }
 var ERROR_REPORT_KEEP_MS = 60 * 60 * 1000;
 var verdicts = new Map;
@@ -10013,7 +10391,7 @@ function recordRunEnded(projectPath, pid, ending) {
 function recordAt(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync7(path, "utf8"));
+    parsed = JSON.parse(readFileSync8(path, "utf8"));
   } catch {
     return null;
   }
@@ -10258,21 +10636,19 @@ async function followSuccessor(exitedPid, engine, notBefore, exitedAt, transcrip
   return transcript === undefined ? null : await followOnPosix(exitedPid, engine, notBefore, exitedAt, transcript);
 }
 async function followOnWindows(exitedPid, engine, notBefore, exitedAt) {
+  let loading;
+  try {
+    loading = await loadingTheTable();
+  } catch {
+    return null;
+  }
   const script = [
     "[Console]::OutputEncoding = [Text.Encoding]::UTF8",
-    "$held = @{}",
-    `foreach ($c in @(Get-CimInstance Win32_Process -Filter "ParentProcessId=${exitedPid}" -Property ProcessId,CreationDate,CommandLine)) {`,
-    "  if (-not $c.CreationDate) { continue }",
-    "  $began = ([DateTimeOffset]$c.CreationDate).ToUnixTimeMilliseconds()",
-    "  $p = Get-Process -Id $c.ProcessId -ErrorAction SilentlyContinue",
-    "  if ($null -eq $p -or [Math]::Abs(([DateTimeOffset]$p.StartTime).ToUnixTimeMilliseconds() - $began) -gt 1000) { continue }",
-    "  $null = $p.Handle",
-    "  $held[[int]$c.ProcessId] = $p",
-    '  "$($c.ProcessId) $began $($c.CommandLine)"',
-    "}",
+    loading,
+    `[Console]::Out.Write([GdhProcessTable]::HoldChildren(${exitedPid}))`,
     "'listed'",
     "$chosen = [Console]::In.ReadLine()",
-    "if ($chosen -and $held.ContainsKey([int]$chosen)) { $p = $held[[int]$chosen]; $p.WaitForExit(); 'exit ' + $p.ExitCode }"
+    "if ($chosen) { [GdhProcessTable]::WaitFor([int]$chosen) }"
   ].join(`
 `);
   const holder = spawnHidden("powershell.exe", [
@@ -10452,7 +10828,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", tmpdir6());
+    const started = await startDirectly({ ...spec, command: wrapper.command, args: wrapper.args, envChanges }, output, true, false, "ignore", tmpdir8());
     if ("error" in started) {
       return started;
     }
@@ -10461,7 +10837,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(readFileSync8(pidFile, "utf8").trim()) : Number.NaN;
+      const pid = existsSync4(pidFile) ? Number(readFileSync9(pidFile, "utf8").trim()) : Number.NaN;
       if (Number.isInteger(pid) && pid > 0) {
         return { child: started.child, pid };
       }
@@ -10492,7 +10868,7 @@ function profiledBy(path, projectPath) {
   };
   let projectGodot = null;
   try {
-    projectGodot = readFileSync8(join10(projectPath, "project.godot"), "utf8");
+    projectGodot = readFileSync9(join10(projectPath, "project.godot"), "utf8");
   } catch {}
   const observer = new ProfileObserver((totals) => {
     const first = latest === null;
@@ -10593,11 +10969,11 @@ 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(tmpdir6(), "gdharness-exit-"));
+  const exitNotes = run === undefined ? null : mkdtempSync4(join10(tmpdir8(), "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" : openSync4(run.transcript, "a");
-  const own = run !== undefined && throughTheHelper(spec) ? mkdtempSync4(join10(tmpdir6(), "gdharness-stop-")) : null;
+  const own = run !== undefined && throughTheHelper(spec) ? mkdtempSync4(join10(tmpdir8(), "gdharness-stop-")) : null;
   const stopFile = own === null ? "" : join10(own, "stop");
   let started;
   const keeperStarted = run?.slot === undefined ? undefined : ownStart();
@@ -10635,7 +11011,7 @@ async function keep() {
   let listening = null;
   let end = () => {
     if (stopFile !== "") {
-      writeFileSync3(stopFile, "");
+      writeFileSync4(stopFile, "");
       return "signalled";
     }
     return child.kill() ? "signalled" : "gone";
@@ -10743,7 +11119,7 @@ function restartSaid(notes, pid) {
     return null;
   }
   try {
-    const said = JSON.parse(readFileSync8(join10(notes, `exit-${String(pid)}.json`), "utf8"));
+    const said = JSON.parse(readFileSync9(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;