@stringsync/splates 0.0.61 → 1.13.3

package/vendor/core/system/index.js

@@ -0,0 +1,1385 @@
+// system/fs/node-fs.ts
+import { watch } from "node:fs";
+import fs from "node:fs/promises";
+import { join, normalize } from "node:path";
+
+class NodeFs {
+  async exists(path) {
+    return fs.access(normalize(path)).then(() => true, () => false);
+  }
+  async mkdir(path, opts) {
+    await fs.mkdir(normalize(path), {
+      recursive: opts?.recursive ?? true
+    });
+  }
+  read(path) {
+    return fs.readFile(normalize(path), "utf-8");
+  }
+  write(path, data) {
+    return fs.writeFile(normalize(path), data);
+  }
+  append(path, data) {
+    return fs.appendFile(normalize(path), data);
+  }
+  async readBytes(path) {
+    const buffer = await fs.readFile(normalize(path));
+    return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  writeBytes(path, data) {
+    return fs.writeFile(normalize(path), data);
+  }
+  rename(from, to) {
+    return fs.rename(normalize(from), normalize(to));
+  }
+  readdir(path) {
+    return fs.readdir(normalize(path));
+  }
+  chmod(path, mode) {
+    return fs.chmod(normalize(path), mode);
+  }
+  stat(path) {
+    return fs.stat(normalize(path));
+  }
+  rm(path, opts) {
+    return fs.rm(normalize(path), opts);
+  }
+  isSymlink(path) {
+    return fs.lstat(normalize(path)).then((stat) => stat.isSymbolicLink(), () => false);
+  }
+  watch(path, onChange, opts) {
+    const root = normalize(path);
+    const watcher = watch(root, { recursive: opts?.recursive ?? false }, (_event, name) => onChange(name ? join(root, String(name)) : root));
+    watcher.on("error", () => watcher.close());
+    return { dispose: () => watcher.close() };
+  }
+}
+// system/glob/node-glob.ts
+import { matchesGlob } from "node:path";
+
+class NodeGlob {
+  matches(pattern, path) {
+    return matchesGlob(path, pattern);
+  }
+}
+// system/heavy/heavy-jobs.ts
+import { Duration as Duration2, sleep as sleep2 } from "../time/index.js";
+
+// system/lock/file-lock.ts
+import { rmSync as rmSync2 } from "node:fs";
+import { Disposer } from "../disposable/index.js";
+import { ConsoleLogger, color } from "../log/index.js";
+import { Duration, sleep } from "../time/index.js";
+
+// system/ps/node-ps.ts
+import { spawn } from "node:child_process";
+import { readlink } from "node:fs/promises";
+import { hostname } from "node:os";
+import { Readable, Writable } from "node:stream";
+import { disposables } from "../disposable/index.js";
+
+// system/ps/file-process.ts
+import {
+  closeSync,
+  constants as constants2,
+  mkdtempSync,
+  openSync,
+  readSync,
+  rmSync
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join2 } from "node:path";
+
+// system/ps/reap.ts
+import { constants } from "node:os";
+var reap = process.versions.bun && process.platform === "darwin" ? await load() : null;
+var WNOHANG = 1;
+async function load() {
+  const { dlopen, FFIType, ptr } = await import("bun:ffi");
+  const { symbols } = dlopen("libc.dylib", {
+    waitpid: {
+      args: [FFIType.i32, FFIType.ptr, FFIType.i32],
+      returns: FFIType.i32
+    }
+  });
+  const status = new Int32Array(1);
+  return (pid) => symbols.waitpid(pid, ptr(status), WNOHANG) === pid ? status[0] ?? 0 : null;
+}
+function decode(status) {
+  const signal = status & 127;
+  return signal === 0 ? status >> 8 & 255 : 128 + signal;
+}
+async function exitOf(child, kernel) {
+  let timer;
+  const polled = new Promise((resolve) => {
+    timer = setInterval(() => {
+      if (child.exitCode !== null || child.signalCode !== null) {
+        resolve(shellCode(child.exitCode, child.signalCode));
+        return;
+      }
+      const status = kernel.reap(child.pid);
+      if (status !== null) {
+        resolve(decode(status));
+      }
+    }, 250);
+  });
+  try {
+    return await Promise.race([
+      child.exited.then((code) => shellCode(code, child.signalCode)),
+      polled
+    ]);
+  } finally {
+    clearInterval(timer);
+  }
+}
+function shellCode(code, signal) {
+  if (!signal) {
+    return code ?? 0;
+  }
+  const number = typeof signal === "number" ? signal : constants.signals[signal] ?? 0;
+  return 128 + number;
+}
+
+// system/ps/file-process.ts
+var mkfifo = reap === null ? null : await load2();
+async function load2() {
+  const { dlopen, FFIType } = await import("bun:ffi");
+  const { symbols } = dlopen("libc.dylib", {
+    mkfifo: { args: [FFIType.cstring, FFIType.u16], returns: FFIType.i32 }
+  });
+  return (path) => {
+    if (symbols.mkfifo(Buffer.from(`${path}\x00`), 384) !== 0) {
+      throw new Error(`cannot make a FIFO at ${path}`);
+    }
+  };
+}
+var runtime = {
+  spawn: (argv, opts) => Bun.spawn(argv, opts),
+  reap: (pid) => reap?.(pid) ?? null
+};
+function fileStart(argv, opts) {
+  const { stdin = "pipe", runtime: rt = runtime, ...spawnOptions } = opts;
+  opts.signal?.throwIfAborted();
+  const dir = mkdtempSync(join2(tmpdir(), "webappwiz-ps-"));
+  let out;
+  let err;
+  const writers = [];
+  let child;
+  try {
+    out = new FifoOutput(join2(dir, "stdout"));
+    err = new FifoOutput(join2(dir, "stderr"));
+    const stdout = openSync(out.path, constants2.O_WRONLY);
+    writers.push(stdout);
+    const stderr = openSync(err.path, constants2.O_WRONLY);
+    writers.push(stderr);
+    child = rt.spawn(argv, { ...spawnOptions, stdin, stdout, stderr });
+  } catch (error) {
+    out?.[Symbol.dispose]();
+    err?.[Symbol.dispose]();
+    return unstarted(error);
+  } finally {
+    for (const fd of writers) {
+      closeSync(fd);
+    }
+    rmSync(dir, { recursive: true, force: true });
+  }
+  return follow(child, out, err, opts.signal, rt);
+}
+function unstarted(error) {
+  const failed = () => new ReadableStream({ start: (controller) => controller.error(error) });
+  return {
+    pid: null,
+    stdin: new WritableStream,
+    stdout: failed(),
+    stderr: failed(),
+    exited: Promise.reject(error),
+    kill: () => {}
+  };
+}
+function follow(child, out, err, signal, rt) {
+  let gone = false;
+  let readError;
+  let poll;
+  const read = () => {
+    try {
+      const flowing = [out.drain(false), err.drain(false)].includes(true);
+      poll = flowing ? setTimeout(read, 0) : setTimeout(read, 20);
+    } catch (error) {
+      readError = error;
+      child.kill();
+    }
+  };
+  read();
+  const exited = (async () => {
+    try {
+      const code = await exitOf(child, rt);
+      gone = true;
+      clearTimeout(poll);
+      if (readError !== undefined) {
+        throw readError;
+      }
+      out.finish();
+      err.finish();
+      signal?.throwIfAborted();
+      return code;
+    } catch (error) {
+      out.fail(error);
+      err.fail(error);
+      throw error;
+    } finally {
+      gone = true;
+      clearTimeout(poll);
+      child.unref();
+      out[Symbol.dispose]();
+      err[Symbol.dispose]();
+    }
+  })();
+  const input = child.stdin;
+  const stopped = exited.then(() => {
+    return;
+  });
+  const closeInput = async () => {
+    if (typeof input === "object") {
+      try {
+        await Promise.race([input.end(), stopped]);
+      } catch (error) {
+        ignoreClosedInput(error);
+      }
+    }
+  };
+  stopped.catch(() => {});
+  return {
+    pid: child.pid,
+    stdin: new WritableStream({
+      async write(bytes) {
+        if (gone || typeof input !== "object") {
+          return;
+        }
+        try {
+          input.write(bytes);
+          await Promise.race([input.flush(), stopped]);
+        } catch (error) {
+          ignoreClosedInput(error);
+        }
+      },
+      close: closeInput,
+      abort: closeInput
+    }),
+    stdout: out.stream,
+    stderr: err.stream,
+    exited,
+    kill: (signal = "SIGTERM") => {
+      if (!gone && child.exitCode === null && child.signalCode === null) {
+        child.kill(signal);
+      }
+    }
+  };
+}
+async function fileCapture(argv, opts) {
+  const { input, watcher, ...startOptions } = opts;
+  const child = fileStart(argv, {
+    ...startOptions,
+    stdin: input === undefined ? "inherit" : "pipe"
+  });
+  const feed = async () => {
+    if (input !== undefined) {
+      const writer = child.stdin.getWriter();
+      try {
+        await writer.write(new TextEncoder().encode(input));
+        await writer.close();
+      } finally {
+        writer.releaseLock();
+      }
+    }
+  };
+  const [exitCode, stdout, stderr] = await Promise.all([
+    child.exited,
+    text(child.stdout, { watcher, channel: "stdout" }),
+    text(child.stderr, { watcher, channel: "stderr" }),
+    feed()
+  ]);
+  return { exitCode, stdout, stderr };
+}
+async function text(stream, opts) {
+  const decoder = new TextDecoder;
+  let result = "";
+  for await (const bytes of stream) {
+    const chunk = decoder.decode(bytes, { stream: true });
+    result += chunk;
+    opts.watcher?.[opts.channel](chunk);
+  }
+  const tail = decoder.decode();
+  if (tail !== "") {
+    result += tail;
+    opts.watcher?.[opts.channel](tail);
+  }
+  return result;
+}
+function ignoreClosedInput(error) {
+  const code = error.code;
+  if (code !== "EPIPE" && code !== "ERR_STREAM_DESTROYED" && code !== "ERR_STREAM_PREMATURE_CLOSE") {
+    throw error;
+  }
+}
+var LEFT_OVER = 1048576;
+
+class FifoOutput {
+  path;
+  stream;
+  fd;
+  buffer = Buffer.allocUnsafe(65536);
+  controller;
+  closed = false;
+  disposed = false;
+  constructor(path) {
+    this.path = path;
+    if (mkfifo === null) {
+      throw new Error("FIFO-backed processes need Bun on macOS");
+    }
+    mkfifo(path);
+    this.fd = openSync(path, constants2.O_RDONLY | constants2.O_NONBLOCK);
+    this.stream = new ReadableStream({
+      start: (controller) => {
+        this.controller = controller;
+      },
+      cancel: () => {
+        this.closed = true;
+        this[Symbol.dispose]();
+      }
+    });
+  }
+  drain(final) {
+    let read = false;
+    let taken = 0;
+    while (!this.closed && (final ? taken < LEFT_OVER : (this.controller.desiredSize ?? 0) > 0)) {
+      const count = this.next();
+      if (count === null) {
+        break;
+      }
+      if (count === 0) {
+        this.end();
+        this[Symbol.dispose]();
+        break;
+      }
+      read = true;
+      taken += count;
+      this.controller.enqueue(Uint8Array.from(this.buffer.subarray(0, count)));
+    }
+    return read;
+  }
+  finish() {
+    this.drain(true);
+    this.end();
+  }
+  fail(error) {
+    if (!this.closed) {
+      this.closed = true;
+      this.controller.error(error);
+    }
+  }
+  [Symbol.dispose]() {
+    if (!this.disposed) {
+      this.disposed = true;
+      closeSync(this.fd);
+    }
+  }
+  end() {
+    if (!this.closed) {
+      this.closed = true;
+      this.controller.close();
+    }
+  }
+  next() {
+    try {
+      return readSync(this.fd, this.buffer, 0, this.buffer.length, null);
+    } catch (error) {
+      if (error.code === "EAGAIN") {
+        return null;
+      }
+      throw error;
+    }
+  }
+}
+
+// system/ps/listening.ts
+function parseLsof(stdout) {
+  const found = [];
+  let pid = null;
+  for (const line of stdout.split(`
+`)) {
+    if (line.startsWith("p")) {
+      pid = Number(line.slice(1));
+      continue;
+    }
+    if (!line.startsWith("n") || pid === null) {
+      continue;
+    }
+    const address = hostPort(line.slice(1));
+    if (address !== null) {
+      found.push({ pid, ...address });
+    }
+  }
+  return unique(found);
+}
+function parseSs(stdout) {
+  const found = [];
+  for (const line of stdout.split(`
+`)) {
+    const columns = line.trim().split(/\s+/);
+    const address = hostPort(columns[3] ?? "");
+    if (address === null) {
+      continue;
+    }
+    for (const match of line.matchAll(/pid=(\d+)/g)) {
+      found.push({ pid: Number(match[1]), ...address });
+    }
+  }
+  return unique(found);
+}
+function parseLsofCwds(stdout) {
+  const cwds = new Map;
+  let pid = null;
+  for (const line of stdout.split(`
+`)) {
+    if (line.startsWith("p")) {
+      pid = Number(line.slice(1));
+    } else if (line.startsWith("n") && pid !== null) {
+      cwds.set(pid, line.slice(1));
+    }
+  }
+  return cwds;
+}
+function hostPort(text) {
+  const at = text.lastIndexOf(":");
+  const port = Number(text.slice(at + 1));
+  if (at <= 0 || !Number.isInteger(port) || port <= 0) {
+    return null;
+  }
+  const host = text.slice(0, at).replace(/%.*?(\]?)$/, "$1");
+  return { host: ["0.0.0.0", "[::]", "*"].includes(host) ? "*" : host, port };
+}
+function unique(found) {
+  const seen = new Set;
+  return found.filter((each) => {
+    const key = `${each.pid} ${each.host} ${each.port}`;
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+}
+
+// system/ps/node-ps.ts
+class NodePs {
+  platform;
+  pid;
+  hostname = hostname();
+  args;
+  self;
+  proc;
+  constructor(opts = {}) {
+    this.proc = opts.proc ?? process;
+    this.platform = this.proc.platform;
+    this.pid = this.proc.pid;
+    this.args = this.proc.argv.slice(2);
+    this.self = this.proc.argv.slice(0, 2);
+  }
+  alive(pid) {
+    try {
+      this.proc.kill(pid, 0);
+      return true;
+    } catch (e) {
+      return e.code === "EPERM";
+    }
+  }
+  async spawn(argv, opts) {
+    const [cmd, args] = parse(argv);
+    if (reap !== null) {
+      opts?.signal?.throwIfAborted();
+      const child = Bun.spawn(argv, {
+        ...this.options(opts),
+        stdio: ["inherit", "inherit", "inherit"]
+      });
+      try {
+        const code = await exitOf(child, { reap });
+        opts?.signal?.throwIfAborted();
+        return { exitCode: code };
+      } finally {
+        child.unref();
+      }
+    }
+    const child = spawn(cmd, args, {
+      ...this.options(opts),
+      stdio: "inherit"
+    });
+    return { exitCode: await exitCode(child) };
+  }
+  async spawnCapture(argv, opts) {
+    const [cmd, args] = parse(argv);
+    if (reap !== null) {
+      return fileCapture(argv, {
+        ...this.options(opts),
+        input: opts?.stdin,
+        watcher: opts?.watcher
+      });
+    }
+    const child = spawn(cmd, args, {
+      ...this.options(opts),
+      stdio: [opts?.stdin === undefined ? "inherit" : "pipe", "pipe", "pipe"]
+    });
+    child.stdin?.on("error", () => {});
+    child.stdin?.end(opts?.stdin);
+    if (child.stdout === null || child.stderr === null) {
+      throw new Error("spawnCapture lost its output pipes");
+    }
+    let stdout = "";
+    let stderr = "";
+    child.stdout.setEncoding("utf8").on("data", (chunk) => {
+      stdout += chunk;
+      opts?.watcher?.stdout(chunk);
+    });
+    child.stderr.setEncoding("utf8").on("data", (chunk) => {
+      stderr += chunk;
+      opts?.watcher?.stderr(chunk);
+    });
+    return { exitCode: await exitCode(child), stdout, stderr };
+  }
+  start(argv, opts) {
+    const [cmd, args] = parse(argv);
+    if (reap !== null) {
+      return fileStart(argv, this.options(opts));
+    }
+    const child = spawn(cmd, args, {
+      ...this.options(opts),
+      stdio: "pipe"
+    });
+    child.stdin.on("error", () => {});
+    const exited = exitCode(child);
+    return {
+      pid: child.pid ?? null,
+      stdin: forgivingInput(child.stdin),
+      stdout: web(child.stdout),
+      stderr: web(child.stderr),
+      exited,
+      kill: (signal = "SIGTERM") => {
+        if (child.exitCode === null && child.signalCode === null) {
+          child.kill(signal);
+        }
+      }
+    };
+  }
+  startOnTerminal(argv, opts) {
+    parse(argv);
+    if (!process.versions.bun || this.platform === "win32") {
+      throw new Error("startOnTerminal needs Bun on a POSIX system");
+    }
+    let closed = false;
+    let reader;
+    const output = new ReadableStream({
+      start: (controller) => {
+        reader = controller;
+      }
+    });
+    const end = () => {
+      if (!closed) {
+        closed = true;
+        reader?.close();
+      }
+    };
+    const terminal = new Bun.Terminal({
+      cols: opts.cols,
+      rows: opts.rows,
+      data: (_, bytes) => {
+        if (!closed) {
+          reader?.enqueue(bytes.slice());
+        }
+      },
+      exit: end
+    });
+    const { cwd, env, timeout, signal } = this.options(opts);
+    const child = Bun.spawn([process.execPath, "-e", CLAIM, "--", ...argv], {
+      terminal,
+      cwd,
+      env,
+      timeout,
+      signal,
+      detached: true
+    });
+    const running = () => child.exitCode === null && child.signalCode === null;
+    return {
+      pid: child.pid,
+      output,
+      write: (data) => {
+        if (!terminal.closed) {
+          terminal.write(data);
+        }
+      },
+      resize: (cols, rows) => {
+        if (!terminal.closed) {
+          terminal.resize(cols, rows);
+        }
+      },
+      exited: child.exited.then(() => shellCode(child.exitCode, child.signalCode)),
+      kill: (signal = "SIGTERM") => {
+        if (running()) {
+          child.kill(signal);
+        }
+      },
+      close: () => {
+        terminal.close();
+        end();
+      }
+    };
+  }
+  async processes() {
+    if (this.platform === "win32") {
+      return [];
+    }
+    const { stdout } = await this.spawnCapture(["ps", "-A", "-o", "pid=,ppid=,pgid=,tpgid=,command="], { stdin: "" });
+    return stdout.split(`
+`).flatMap((line) => {
+      const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(-?\d+)\s+(.*)$/.exec(line);
+      return match === null ? [] : [
+        {
+          pid: Number(match[1]),
+          ppid: Number(match[2]),
+          pgid: Number(match[3]),
+          tpgid: Number(match[4]),
+          command: match[5] ?? ""
+        }
+      ];
+    });
+  }
+  async listening() {
+    if (this.platform === "win32") {
+      return [];
+    }
+    const lsof = await this.spawnCapture(["lsof", "-nP", "-iTCP", "-sTCP:LISTEN", "-Fpn"], { stdin: "" }).catch(() => null);
+    if (lsof !== null && lsof.exitCode <= 1) {
+      const listeners = parseLsof(lsof.stdout);
+      const pids = [...new Set(listeners.map((each) => each.pid))];
+      const cwds = pids.length === 0 ? new Map : parseLsofCwds((await this.spawnCapture([
+        "lsof",
+        "-nP",
+        "-a",
+        "-d",
+        "cwd",
+        "-p",
+        pids.join(","),
+        "-Fpn"
+      ], { stdin: "" })).stdout);
+      return withCwds(listeners, (pid) => cwds.get(pid) ?? null);
+    }
+    if (this.platform === "linux") {
+      const ss = await this.spawnCapture(["ss", "-Hltnp"], {
+        stdin: ""
+      }).catch(() => null);
+      if (ss?.exitCode === 0) {
+        const listeners = parseSs(ss.stdout);
+        const cwds = new Map;
+        for (const { pid } of listeners) {
+          cwds.set(pid, await readlink(`/proc/${pid}/cwd`).catch(() => null));
+        }
+        return withCwds(listeners, (pid) => cwds.get(pid) ?? null);
+      }
+    }
+    return [];
+  }
+  options(opts) {
+    const env = { ...this.proc.env };
+    for (const name of opts?.unset ?? []) {
+      delete env[name];
+    }
+    return {
+      cwd: opts?.cwd,
+      env: { ...env, ...opts?.env },
+      timeout: opts?.timeoutMs,
+      signal: opts?.signal
+    };
+  }
+  cwd() {
+    return this.proc.cwd();
+  }
+  env(name) {
+    return this.proc.env[name];
+  }
+  columns() {
+    return this.proc.stdout?.columns;
+  }
+  cd(path) {
+    this.proc.chdir(path);
+  }
+  exit(code) {
+    this.proc.exit(code);
+  }
+  on(signal, handler) {
+    this.proc.on(signal, handler);
+    return disposables.callback(() => this.proc.off(signal, handler));
+  }
+  once(event, handler) {
+    this.proc.once(event, handler);
+    return disposables.callback(() => this.proc.off(event, handler));
+  }
+}
+function parse(argv) {
+  const [cmd, ...args] = argv;
+  if (!cmd) {
+    throw new Error("spawn requires a command");
+  }
+  return [cmd, args];
+}
+function web(readable) {
+  return Readable.toWeb(readable);
+}
+function forgivingInput(input) {
+  const writer = Writable.toWeb(input).getWriter();
+  return new WritableStream({
+    write: (bytes) => writer.write(bytes).catch(ignoreClosedInput),
+    close: () => writer.close().catch(ignoreClosedInput),
+    abort: (reason) => writer.abort(reason).catch(ignoreClosedInput)
+  });
+}
+function exitCode(child) {
+  return new Promise((resolve, reject) => {
+    child.on("close", (code, signal) => resolve(shellCode(code, signal)));
+    child.on("error", reject);
+  });
+}
+var CLAIM = `
+import { dlopen, FFIType, ptr } from "bun:ffi";
+const darwin = process.platform === "darwin";
+const libc = dlopen(darwin ? "libc.dylib" : "libc.so.6", {
+	ioctl: { args: [FFIType.i32, FFIType.u64, FFIType.i32], returns: FFIType.i32 },
+	execvp: { args: [FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+});
+const TIOCSCTTY = darwin ? 0x20007461 : 0x540e;
+if (libc.symbols.ioctl(0, TIOCSCTTY, 0) !== 0) {
+	console.error("^C and resizes will not reach programs in this terminal");
+}
+const argv = process.argv.slice(1);
+const strings = argv.map((arg) => Buffer.from(arg + "\\0"));
+const pointers = new BigUint64Array(argv.length + 1);
+strings.forEach((each, i) => { pointers[i] = BigInt(ptr(each)); });
+libc.symbols.execvp(ptr(strings[0]), ptr(pointers));
+console.error("could not run " + argv[0]);
+process.exit(127);
+`;
+function withCwds(listeners, cwd) {
+  return listeners.map((each) => ({ ...each, cwd: cwd(each.pid) }));
+}
+
+// system/lock/file-lock.ts
+class FileLock {
+  path;
+  held = false;
+  listeners = null;
+  stalenessMs;
+  pollMs;
+  pidOnly;
+  fs;
+  ps;
+  log;
+  constructor(path, opts = {}) {
+    this.path = path;
+    this.fs = opts.fs ?? new NodeFs;
+    this.ps = opts.ps ?? new NodePs;
+    this.log = opts.log ?? new ConsoleLogger;
+    this.stalenessMs = opts.stalenessMs ?? 60000;
+    this.pollMs = opts.pollMs ?? 2000;
+    this.pidOnly = opts.pidOnly ?? false;
+  }
+  async acquire() {
+    let unreadableSince = null;
+    let sleepMs = 5;
+    for (let waited = false;; waited = true) {
+      try {
+        await this.fs.mkdir(this.path, { recursive: false });
+      } catch {
+        const holder = await this.holder();
+        if (holder === null) {
+          unreadableSince ??= Date.now();
+          if (Date.now() - unreadableSince > this.stalenessMs) {
+            unreadableSince = null;
+            this.steal("it has no holder metadata");
+            continue;
+          }
+        } else if (this.isStale(holder)) {
+          this.steal(`holder pid ${holder.pid} is gone or stale`);
+          continue;
+        }
+        await sleep(Duration.ms(sleepMs));
+        sleepMs = Math.min(sleepMs * 2, this.pollMs);
+        continue;
+      }
+      if (waited) {
+        this.log.error(`acquired ${this.path} after waiting`);
+      }
+      break;
+    }
+    this.held = true;
+    await this.fs.write(this.holderPath, JSON.stringify({
+      pid: this.ps.pid,
+      hostname: this.ps.hostname,
+      at: new Date().toISOString()
+    }));
+    this.registerCleanup();
+  }
+  async release() {
+    this.listeners?.dispose();
+    this.listeners = null;
+    if (this.held) {
+      this.held = false;
+      await this.fs.rm(this.path, { recursive: true, force: true });
+    }
+  }
+  async releaseIfOurs() {
+    const holder = await this.holder();
+    if (holder?.pid === this.ps.pid && this.sameHost(holder)) {
+      this.held = true;
+      await this.release();
+    }
+  }
+  get holderPath() {
+    return `${this.path}/holder.json`;
+  }
+  async holder() {
+    const raw = await this.fs.read(this.holderPath).catch(() => null);
+    try {
+      return raw === null ? null : JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  isStale(holder) {
+    if (this.sameHost(holder)) {
+      return !this.ps.alive(holder.pid);
+    }
+    return Date.now() - Date.parse(holder.at) > this.stalenessMs;
+  }
+  sameHost(holder) {
+    return this.pidOnly || holder.hostname === this.ps.hostname;
+  }
+  steal(why) {
+    this.log.error(color.yellow(`stealing stale lock ${this.path} (${why})`));
+    rmSync2(this.path, { recursive: true, force: true });
+  }
+  registerCleanup() {
+    if (this.listeners !== null) {
+      return;
+    }
+    const listeners = new Disposer;
+    this.listeners = listeners;
+    const drop = () => {
+      if (this.held) {
+        this.held = false;
+        rmSync2(this.path, { recursive: true, force: true });
+      }
+    };
+    listeners.use(this.ps.once("exit", drop));
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+      listeners.use(this.ps.on(signal, () => {
+        drop();
+        this.ps.exit(130);
+      }));
+    }
+    listeners.use(this.ps.on("uncaughtException", (error) => {
+      drop();
+      this.log.error(error);
+      this.ps.exit(1);
+    }));
+  }
+}
+
+// system/heavy/heavy-jobs.ts
+class HeavyJobs {
+  #path;
+  #opts;
+  #ids = 0;
+  static under(dir, {
+    fs,
+    ps,
+    log,
+    cap,
+    held
+  }) {
+    return new HeavyJobs(`${dir}/heavy.json`, {
+      fs,
+      ps,
+      log,
+      lock: new FileLock(`${dir}/heavy.lock`, { fs, ps, log }),
+      cap,
+      held
+    });
+  }
+  constructor(path, opts) {
+    this.#path = path;
+    this.#opts = opts;
+  }
+  async take({
+    what,
+    task = null
+  }) {
+    const { ps, log, held, now = () => new Date } = this.#opts;
+    if (ps.env(held) !== undefined) {
+      return { env: {}, [Symbol.asyncDispose]: async () => {} };
+    }
+    const entry = {
+      id: `${ps.pid}-${this.#ids++}`,
+      what,
+      task,
+      pid: ps.pid,
+      since: now().toISOString()
+    };
+    let told = false;
+    let wait = Duration2.ms(50);
+    for (;; ) {
+      const holders = await this.#change((file) => {
+        const waiting = file.waiting.some((each) => each.id === entry.id) ? file.waiting : [...file.waiting, entry];
+        const ahead = waiting.findIndex((each) => each.id === entry.id);
+        if (file.running.length + ahead < this.#opts.cap) {
+          return {
+            file: {
+              running: [
+                ...file.running,
+                { ...entry, since: now().toISOString() }
+              ],
+              waiting: waiting.filter((each) => each.id !== entry.id)
+            },
+            holders: null
+          };
+        }
+        return { file: { ...file, waiting }, holders: file.running };
+      });
+      if (holders === null) {
+        break;
+      }
+      if (!told) {
+        told = true;
+        log.info([
+          `waiting for ${this.#opts.cap === 1 ? "the heavy-job slot" : `one of ${this.#opts.cap} heavy-job slots`} for ${what}, held by:`,
+          ...holders.map((each) => `  ${describe(each)}`)
+        ].join(`
+`));
+      }
+      await sleep2(wait);
+      wait = Duration2.ms(Math.min(wait.ms * 2, POLL.ms));
+    }
+    if (told) {
+      log.info(`took a heavy-job slot for ${what}`);
+    }
+    return {
+      env: { [held]: entry.id },
+      [Symbol.asyncDispose]: () => this.#give(entry.id)
+    };
+  }
+  async read() {
+    const file = this.#living(await this.#read());
+    return { cap: this.#opts.cap, ...file };
+  }
+  async#give(id) {
+    await this.#change((file) => ({
+      file: {
+        running: file.running.filter((each) => each.id !== id),
+        waiting: file.waiting.filter((each) => each.id !== id)
+      },
+      holders: null
+    }));
+  }
+  async#change(change) {
+    const { fs, lock } = this.#opts;
+    await fs.mkdir(this.#path.slice(0, this.#path.lastIndexOf("/")));
+    await lock.acquire();
+    try {
+      const { file, holders } = change(this.#living(await this.#read()));
+      await fs.write(this.#path, JSON.stringify(file));
+      return holders;
+    } finally {
+      await lock.release();
+    }
+  }
+  #living(file) {
+    const alive = (each) => this.#opts.ps.alive(each.pid);
+    return {
+      running: file.running.filter(alive),
+      waiting: file.waiting.filter(alive)
+    };
+  }
+  async#read() {
+    const raw = await this.#opts.fs.read(this.#path).catch(() => null);
+    try {
+      return raw === null ? empty() : slotsFile(JSON.parse(raw));
+    } catch {
+      return empty();
+    }
+  }
+}
+var POLL = Duration2.secs(1);
+var empty = () => ({ running: [], waiting: [] });
+function slotsFile(value) {
+  const { running, waiting } = value ?? {};
+  if (!isEntries(running) || !isEntries(waiting)) {
+    throw new Error("not a heavy-job slots file");
+  }
+  return { running, waiting };
+}
+function isEntries(value) {
+  return Array.isArray(value) && value.every(isEntry);
+}
+function isEntry(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const each = value;
+  return typeof each.id === "string" && typeof each.what === "string" && (typeof each.task === "string" || each.task === null) && typeof each.pid === "number" && typeof each.since === "string";
+}
+function describe(job) {
+  return `${job.what}${job.task === null ? "" : ` in ${job.task}`} (pid ${job.pid}, since ${job.since})`;
+}
+// system/host-mapper/file-host-mapper.ts
+import { ConsoleLogger as ConsoleLogger2 } from "../log/index.js";
+var HOSTS_PATH_UNIX = "/etc/hosts";
+var HOSTS_PATH_WINDOWS = "C:\\Windows\\System32\\drivers\\etc\\hosts";
+
+class FileHostMapper {
+  path;
+  fs;
+  ps;
+  log;
+  constructor(path, opts = {}) {
+    this.path = path;
+    this.fs = opts.fs ?? new NodeFs;
+    this.ps = opts.ps ?? new NodePs;
+    this.log = opts.log ?? new ConsoleLogger2;
+  }
+  static default(opts = {}) {
+    const ps = opts.ps ?? new NodePs;
+    switch (ps.platform) {
+      case "darwin":
+      case "linux":
+        return new FileHostMapper(HOSTS_PATH_UNIX, { ...opts, ps });
+      case "win32":
+        return new FileHostMapper(HOSTS_PATH_WINDOWS, { ...opts, ps });
+      default:
+        throw new Error(`Unsupported platform: ${ps.platform}`);
+    }
+  }
+  async map(hostname, ip) {
+    const hosts = await this.fs.read(this.path);
+    const lines = hosts.split(`
+`);
+    const pattern = new RegExp(`^(\\d+\\.\\d+\\.\\d+\\.\\d+)\\s+${hostname}$`);
+    let found = false;
+    let changed = false;
+    const updatedLines = lines.map((line) => {
+      const match = line.match(pattern);
+      if (match) {
+        found = true;
+        if (match[1] !== ip) {
+          changed = true;
+          return `${ip}   ${hostname}`;
+        }
+      }
+      return line;
+    });
+    if (!found) {
+      updatedLines.push(`${ip}   ${hostname}`);
+      changed = true;
+    }
+    if (!changed) {
+      return;
+    }
+    const updatedHosts = updatedLines.join(`
+`);
+    if (this.ps.platform === "win32") {
+      await this.fs.write(this.path, updatedHosts);
+    } else {
+      await this.writeHostFileUnix(updatedHosts);
+    }
+  }
+  async writeHostFileUnix(contents) {
+    const tempFile = `/tmp/hosts-${Date.now()}`;
+    await this.fs.write(tempFile, contents);
+    this.log.info(`requesting sudo to update ${this.path}`);
+    const copyResult = await this.ps.spawn(["sudo", "cp", tempFile, this.path]);
+    if (copyResult.exitCode !== 0) {
+      throw new Error(`failed to update ${this.path}`);
+    }
+    await this.fs.rm(tempFile);
+  }
+}
+// system/host-mapper/noop-host-mapper.ts
+class NoopHostMapper {
+  map() {
+    return Promise.resolve();
+  }
+}
+// system/ip-provider/darwin-ip-provider.ts
+class DarwinIpProvider {
+  ps;
+  constructor(opts = {}) {
+    this.ps = opts.ps ?? new NodePs;
+    if (this.ps.platform !== "darwin") {
+      throw new Error("DarwinIpProvider is only supported on macOS");
+    }
+  }
+  async get() {
+    const result = await this.ps.spawnCapture(["ipconfig", "getifaddr", "en0"]);
+    if (result.exitCode !== 0) {
+      throw new Error("failed to get IP address from en0");
+    }
+    const ip = result.stdout.trim();
+    if (!ip) {
+      throw new Error("no IP address found on en0");
+    }
+    return ip;
+  }
+}
+// system/ip-provider/linux-ip-provider.ts
+class LinuxIpProvider {
+  ps;
+  constructor(opts = {}) {
+    this.ps = opts.ps ?? new NodePs;
+    if (this.ps.platform !== "linux") {
+      throw new Error("LinuxIpProvider is only supported on Linux");
+    }
+  }
+  async get() {
+    const result = await this.ps.spawnCapture(["hostname", "-I"]);
+    if (result.exitCode !== 0) {
+      throw new Error("failed to get IP address");
+    }
+    const ip = result.stdout.trim().split(/\s+/)[0];
+    if (!ip) {
+      throw new Error("no IP address found");
+    }
+    return ip;
+  }
+}
+// system/ip-provider/win32-ip-provider.ts
+class Win32IpProvider {
+  ps;
+  constructor(opts = {}) {
+    this.ps = opts.ps ?? new NodePs;
+    if (this.ps.platform !== "win32") {
+      throw new Error("Win32IpProvider is only supported on Windows");
+    }
+  }
+  async get() {
+    const result = await this.ps.spawnCapture([
+      "powershell",
+      "-Command",
+      "(Get-NetIPAddress -AddressFamily IPv4 | Where-Object { $_.InterfaceAlias -notmatch 'Loopback' -and $_.PrefixOrigin -ne 'WellKnown' } | Select-Object -First 1).IPAddress"
+    ]);
+    if (result.exitCode !== 0) {
+      throw new Error("failed to get IP address");
+    }
+    const ip = result.stdout.trim();
+    if (!ip) {
+      throw new Error("no IP address found");
+    }
+    return ip;
+  }
+}
+
+// system/ip-provider/platform-ip-provider.ts
+class PlatformIpProvider {
+  provider;
+  constructor(opts = {}) {
+    const ps = opts.ps ?? new NodePs;
+    switch (ps.platform) {
+      case "darwin":
+        this.provider = new DarwinIpProvider({ ps });
+        break;
+      case "linux":
+        this.provider = new LinuxIpProvider({ ps });
+        break;
+      case "win32":
+        this.provider = new Win32IpProvider({ ps });
+        break;
+      default:
+        throw new Error(`Unsupported platform: ${ps.platform}`);
+    }
+  }
+  get() {
+    return this.provider.get();
+  }
+}
+// system/ip-provider/sequential-ip-provider.ts
+class SequentialIpProvider {
+  ipProviders;
+  constructor(ipProviders) {
+    this.ipProviders = ipProviders;
+  }
+  async get() {
+    for (const provider of this.ipProviders) {
+      try {
+        const ip = await provider.get();
+        if (ip) {
+          return ip;
+        }
+      } catch {}
+    }
+    return "";
+  }
+}
+// system/ip-provider/static-ip-provider.ts
+class StaticIpProvider {
+  ip;
+  constructor(ip) {
+    this.ip = ip;
+  }
+  static localhost() {
+    return new StaticIpProvider("0.0.0.0");
+  }
+  static empty() {
+    return new StaticIpProvider("");
+  }
+  async get() {
+    return this.ip;
+  }
+}
+// system/lock/memory-lock.ts
+class MemoryLock {
+  tail = Promise.resolve();
+  handOff = null;
+  async acquire() {
+    const { promise, resolve } = Promise.withResolvers();
+    const ahead = this.tail;
+    this.tail = promise;
+    await ahead;
+    this.handOff = resolve;
+  }
+  release() {
+    this.handOff?.();
+    this.handOff = null;
+    return Promise.resolve();
+  }
+  releaseIfOurs() {
+    return this.release();
+  }
+}
+// system/port-provider/open-port-provider.ts
+import { createServer } from "node:net";
+import { assert } from "../assert/index.js";
+var MAX_PORT = 65535;
+
+class OpenPortProvider {
+  from;
+  to;
+  host;
+  constructor({ from, to = from, host }) {
+    assert.integer(from, `port ${from} is not a whole number`);
+    assert.integer(to, `port ${to} is not a whole number`);
+    assert.inRange(from, 0, MAX_PORT, `port ${from} is outside 0 to ${MAX_PORT}`);
+    assert.inRange(to, from, MAX_PORT, `no ports between ${from} and ${to}`);
+    this.from = from;
+    this.to = to;
+    this.host = host;
+  }
+  static span({ from, span, host }) {
+    assert.integer(span, `a span of ${span} is not a whole number`);
+    assert.inRange(span, 1, MAX_PORT + 1, `a span of ${span} covers no ports`);
+    return new OpenPortProvider({
+      from,
+      to: Math.min(from + span - 1, MAX_PORT),
+      host
+    });
+  }
+  static any() {
+    return new OpenPortProvider({ from: 0 });
+  }
+  async get() {
+    for (let port = this.from;port <= this.to; port++) {
+      if (await this.open(port) && (this.host === undefined || await this.open(port, this.host))) {
+        return port;
+      }
+    }
+    throw new Error(`no open port between ${this.from} and ${this.to}`);
+  }
+  open(port, host) {
+    return new Promise((resolve) => {
+      const socket = createServer();
+      socket.once("error", () => resolve(false));
+      socket.listen(port, host, () => socket.close(() => resolve(true)));
+    });
+  }
+}
+// system/undumpable.ts
+var PR_GET_DUMPABLE = 3;
+var PR_SET_DUMPABLE = 4;
+var PT_DENY_ATTACH = 31;
+async function makeUndumpable(opts = {}) {
+  const platform = opts.platform ?? process.platform;
+  if (platform === "linux") {
+    const { dlopen, FFIType } = await import("bun:ffi");
+    const { symbols } = openLibc(dlopen, {
+      prctl: {
+        args: [FFIType.i32, FFIType.u64, FFIType.u64, FFIType.u64, FFIType.u64],
+        returns: FFIType.i32
+      }
+    });
+    if (symbols.prctl(PR_SET_DUMPABLE, 0, 0, 0, 0) !== 0 || symbols.prctl(PR_GET_DUMPABLE, 0, 0, 0, 0) !== 0) {
+      throw new Error("prctl(PR_SET_DUMPABLE, 0) did not take");
+    }
+    return { undumpable: true, how: "prctl(PR_SET_DUMPABLE, 0)" };
+  }
+  if (platform === "darwin") {
+    const { dlopen, FFIType } = await import("bun:ffi");
+    const { symbols } = dlopen("libc.dylib", {
+      ptrace: {
+        args: [FFIType.i32, FFIType.i32, FFIType.ptr, FFIType.i32],
+        returns: FFIType.i32
+      }
+    });
+    if (symbols.ptrace(PT_DENY_ATTACH, 0, null, 0) !== 0) {
+      throw new Error("ptrace(PT_DENY_ATTACH) failed");
+    }
+    return { undumpable: true, how: "ptrace(PT_DENY_ATTACH)" };
+  }
+  return {
+    undumpable: false,
+    why: `${platform} has no call that keeps a user's own processes out of each other's memory`
+  };
+}
+function openLibc(dlopen, symbols) {
+  try {
+    return dlopen("libc.so.6", symbols);
+  } catch {
+    return dlopen("libc.so", symbols);
+  }
+}
+// system/walk.ts
+async function* walk(dir, opts = {}) {
+  const files = opts.fs ?? new NodeFs;
+  for (const entry of await files.readdir(dir)) {
+    if (entry.startsWith(".") || entry === "node_modules") {
+      continue;
+    }
+    const path = `${dir}/${entry}`;
+    if ((await files.stat(path)).isDirectory()) {
+      yield* walk(path, { fs: files });
+    } else {
+      yield path;
+    }
+  }
+}
+export {
+  DarwinIpProvider,
+  FileHostMapper,
+  FileLock,
+  HeavyJobs,
+  LinuxIpProvider,
+  MAX_PORT,
+  MemoryLock,
+  NodeFs,
+  NodeGlob,
+  NodePs,
+  NoopHostMapper,
+  OpenPortProvider,
+  PlatformIpProvider,
+  SequentialIpProvider,
+  StaticIpProvider,
+  Win32IpProvider,
+  makeUndumpable,
+  walk
+};