@frontmcp/utils 1.10.16 → 1.11.0-rc.2

package/browser/naming/naming.mjs

@@ -0,0 +1,68 @@
+// libs/utils/src/naming/naming.ts
+import { trimBoth } from "../regex/index.mjs";
+function splitWords(input) {
+  const parts = [];
+  let buff = "";
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    const isAlphaNum = /[A-Za-z0-9]/.test(ch);
+    if (!isAlphaNum) {
+      if (buff) {
+        parts.push(buff);
+        buff = "";
+      }
+      continue;
+    }
+    if (buff && /[a-z]/.test(buff[buff.length - 1]) && /[A-Z]/.test(ch)) {
+      parts.push(buff);
+      buff = ch;
+    } else {
+      buff += ch;
+    }
+  }
+  if (buff) parts.push(buff);
+  return parts;
+}
+function toCase(words, kind) {
+  const safe = words.filter(Boolean);
+  switch (kind) {
+    case "snake":
+      return safe.map((w) => w.toLowerCase()).join("_");
+    case "kebab":
+      return safe.map((w) => w.toLowerCase()).join("-");
+    case "dot":
+      return safe.map((w) => w.toLowerCase()).join(".");
+    case "camel":
+      if (safe.length === 0) return "";
+      return safe[0].toLowerCase() + safe.slice(1).map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
+  }
+}
+function sepFor(kind) {
+  return kind === "snake" ? "_" : kind === "kebab" ? "-" : kind === "dot" ? "." : "";
+}
+function shortHash(s) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) h = (h << 5) + h + s.charCodeAt(i);
+  return (h >>> 0).toString(16).slice(-6).padStart(6, "0");
+}
+function ensureMaxLen(name, max) {
+  if (name.length <= max) return name;
+  const hash = shortHash(name);
+  const lastSep = Math.max(name.lastIndexOf("_"), name.lastIndexOf("-"), name.lastIndexOf("."), name.lastIndexOf("/"));
+  const tail = lastSep > 0 ? name.slice(lastSep + 1) : name.slice(-Math.max(3, Math.min(16, Math.floor(max / 4))));
+  const budget = Math.max(1, max - (1 + hash.length + 1 + tail.length));
+  const prefix = name.slice(0, budget);
+  return `${prefix}-${hash}-${tail}`.slice(0, max);
+}
+function idFromString(name) {
+  const cleaned = name.replace(/[^A-Za-z0-9_-]+/g, "-");
+  return trimBoth(cleaned, "-").slice(0, 64);
+}
+export {
+  ensureMaxLen,
+  idFromString,
+  sepFor,
+  shortHash,
+  splitWords,
+  toCase
+};

package/browser/net/index.mjs

@@ -0,0 +1,10 @@
+// libs/utils/src/net/index.ts
+import { classifyIpAddress, expandIpv6, extractEmbeddedIpv4, parseIpv4 } from "./ip-address.mjs";
+import { isRedirectResponse } from "./redirect.mjs";
+export {
+  classifyIpAddress,
+  expandIpv6,
+  extractEmbeddedIpv4,
+  isRedirectResponse,
+  parseIpv4
+};

package/browser/net/ip-address.mjs

@@ -0,0 +1,128 @@
+// libs/utils/src/net/ip-address.ts
+var IPV4_OCTET_PATTERN = /^(0|[1-9]\d{0,2})$/;
+var IPV6_GROUP_PATTERN = /^[0-9a-f]{1,4}$/;
+var IPV4_BLOCKS = compileBlocks(
+  [
+    ["0.0.0.0/8", "this-network"],
+    ["10.0.0.0/8", "private"],
+    ["100.64.0.0/10", "carrier-grade-nat"],
+    ["127.0.0.0/8", "loopback"],
+    ["169.254.0.0/16", "link-local"],
+    ["172.16.0.0/12", "private"],
+    ["192.0.0.0/24", "ietf-protocol"],
+    ["192.168.0.0/16", "private"],
+    ["198.18.0.0/15", "benchmarking"],
+    ["224.0.0.0/4", "multicast"],
+    ["255.255.255.255/32", "reserved"],
+    ["240.0.0.0/4", "reserved"]
+  ],
+  parseIpv4
+);
+var IPV6_BLOCKS = compileBlocks(
+  [
+    ["::/128", "unspecified"],
+    ["::1/128", "loopback"],
+    ["fd00:ec2::254/128", "cloud-metadata"],
+    ["fc00::/7", "private"],
+    ["fe80::/10", "link-local"],
+    ["fec0::/10", "site-local"],
+    // RFC 8215 local-use NAT64: where the IPv4 address sits depends on the operator's prefix length.
+    ["64:ff9b:1::/48", "local-use-nat64"],
+    ["ff00::/8", "multicast"]
+  ],
+  expandIpv6
+);
+var IPV4_EMBEDDINGS = compileBlocks(
+  [
+    ["::ffff:0:0/96", 6],
+    ["::ffff:0:0:0/96", 6],
+    ["::/96", 6],
+    ["64:ff9b::/96", 6],
+    ["2002::/16", 1]
+  ],
+  expandIpv6
+);
+function parseIpv4(address) {
+  const parts = address.split(".");
+  if (parts.length !== 4 || !parts.every((part) => IPV4_OCTET_PATTERN.test(part))) return void 0;
+  const octets = parts.map(Number);
+  return octets.every((octet) => octet <= 255) ? octets : void 0;
+}
+function expandIpv6(address) {
+  const zoneIndex = address.indexOf("%");
+  let text = (zoneIndex === -1 ? address : address.slice(0, zoneIndex)).toLowerCase();
+  const lastColonIndex = text.lastIndexOf(":");
+  const trailingSegment = text.slice(lastColonIndex + 1);
+  if (lastColonIndex !== -1 && trailingSegment.includes(".")) {
+    const octets = parseIpv4(trailingSegment);
+    if (!octets) return void 0;
+    const highGroup = (octets[0] << 8 | octets[1]).toString(16);
+    const lowGroup = (octets[2] << 8 | octets[3]).toString(16);
+    text = `${text.slice(0, lastColonIndex + 1)}${highGroup}:${lowGroup}`;
+  }
+  const halves = text.split("::");
+  if (halves.length > 2) return void 0;
+  const head = parseIpv6Groups(halves[0]);
+  if (!head) return void 0;
+  if (halves.length === 1) return head.length === 8 ? head : void 0;
+  const tail = parseIpv6Groups(halves[1]);
+  if (!tail || head.length + tail.length > 7) return void 0;
+  return [...head, ...new Array(8 - head.length - tail.length).fill(0), ...tail];
+}
+function extractEmbeddedIpv4(groups) {
+  const octets = findEmbeddedIpv4Octets(groups);
+  return octets ? octets.join(".") : void 0;
+}
+function classifyIpAddress(address) {
+  const isBracketed = address.startsWith("[") && address.endsWith("]");
+  const octets = isBracketed ? void 0 : parseIpv4(address);
+  if (octets) return classifyIpv4(octets);
+  const groups = expandIpv6(isBracketed ? address.slice(1, -1) : address);
+  if (!groups) return void 0;
+  const block = IPV6_BLOCKS.find((candidate) => matchesBlock(groups, candidate, 16));
+  if (block) return { family: 6, range: block.value, cidr: block.cidr };
+  const embeddedOctets = findEmbeddedIpv4Octets(groups);
+  if (!embeddedOctets) return { family: 6, range: "public" };
+  return { ...classifyIpv4(embeddedOctets), family: 6, embeddedIpv4: embeddedOctets.join(".") };
+}
+function classifyIpv4(octets) {
+  const block = IPV4_BLOCKS.find((candidate) => matchesBlock(octets, candidate, 8));
+  return block ? { family: 4, range: block.value, cidr: block.cidr } : { family: 4, range: "public" };
+}
+function findEmbeddedIpv4Octets(groups) {
+  const embedding = IPV4_EMBEDDINGS.find((block) => matchesBlock(groups, block, 16));
+  if (!embedding) return void 0;
+  const highGroup = groups[embedding.value];
+  const lowGroup = groups[embedding.value + 1];
+  return [highGroup >> 8, highGroup & 255, lowGroup >> 8, lowGroup & 255];
+}
+function parseIpv6Groups(part) {
+  if (part === "") return [];
+  const groups = part.split(":");
+  if (!groups.every((group) => IPV6_GROUP_PATTERN.test(group))) return void 0;
+  return groups.map((group) => parseInt(group, 16));
+}
+function matchesBlock(words, block, bitsPerWord) {
+  let remainingBits = block.prefixLength;
+  for (let index = 0; remainingBits > 0; index++) {
+    const comparedBits = Math.min(bitsPerWord, remainingBits);
+    const ignoredBits = bitsPerWord - comparedBits;
+    if (words[index] >> ignoredBits !== block.network[index] >> ignoredBits) return false;
+    remainingBits -= comparedBits;
+  }
+  return true;
+}
+function compileBlocks(entries, parseNetwork) {
+  return entries.map(([cidr, value]) => {
+    const [networkText, prefixText] = cidr.split("/");
+    const network = parseNetwork(networkText);
+    if (!network) throw new Error(`Invalid network in address block "${cidr}"`);
+    return { cidr, network, prefixLength: Number(prefixText), value };
+  });
+}
+export {
+  classifyIpAddress,
+  expandIpv6,
+  extractEmbeddedIpv4,
+  parseIpv4
+};

package/browser/net/redirect.mjs

@@ -0,0 +1,7 @@
+// libs/utils/src/net/redirect.ts
+function isRedirectResponse(response) {
+  return response.type === "opaqueredirect" || response.status >= 300 && response.status < 400;
+}
+export {
+  isRedirectResponse
+};

package/browser/path/browser-path.mjs

@@ -0,0 +1,47 @@
+// libs/utils/src/path/browser-path.ts
+function notAvailable(name) {
+  throw new Error(`path.${name}() is not available in browser environments`);
+}
+function resolve(..._segments) {
+  return notAvailable("resolve");
+}
+function join(..._segments) {
+  return notAvailable("join");
+}
+function basename(p, ext) {
+  const trimmed = p.replace(/[/\\]+$/, "");
+  const lastSep = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\"));
+  let base = lastSep >= 0 ? trimmed.slice(lastSep + 1) : trimmed;
+  if (ext && base.endsWith(ext)) {
+    base = base.slice(0, -ext.length);
+  }
+  return base;
+}
+function dirname(_p) {
+  return notAvailable("dirname");
+}
+function extname(p) {
+  const base = basename(p);
+  const dotIndex = base.lastIndexOf(".");
+  return dotIndex > 0 ? base.slice(dotIndex) : "";
+}
+function isAbsolute(p) {
+  if (!p) return false;
+  if (p.startsWith("/") || p.startsWith("\\")) return true;
+  if (/^[A-Za-z]:[\\/]/.test(p)) return true;
+  return false;
+}
+function pathToFileURL(_p) {
+  return notAvailable("pathToFileURL");
+}
+var sep = "/";
+export {
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  join,
+  pathToFileURL,
+  resolve,
+  sep
+};

package/browser/path/index.mjs

@@ -0,0 +1,24 @@
+// libs/utils/src/path/index.ts
+import { trimSlashes, joinPath } from "./path.mjs";
+import {
+  resolve,
+  join,
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  pathToFileURL,
+  sep
+} from "./browser-path.mjs";
+export {
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  joinPath,
+  join as pathJoin,
+  resolve as pathResolve,
+  pathToFileURL,
+  sep,
+  trimSlashes
+};

package/browser/path/path.mjs

@@ -0,0 +1,13 @@
+// libs/utils/src/path/path.ts
+import { trimBoth } from "../regex/index.mjs";
+function trimSlashes(s) {
+  return trimBoth(s ?? "", "/");
+}
+function joinPath(...parts) {
+  const cleaned = parts.map((p) => trimSlashes(p)).filter(Boolean);
+  return cleaned.length ? `/${cleaned.join("/")}` : "";
+}
+export {
+  joinPath,
+  trimSlashes
+};

package/browser/process/child-process.mjs

@@ -0,0 +1,23 @@
+var __frontmcpModule = typeof process !== "undefined" && typeof process.getBuiltinModule === "function" ? process.getBuiltinModule("module") : undefined;
+const require = __frontmcpModule ? __frontmcpModule.createRequire(import.meta.url || 'file:///') : undefined;
+// __frontmcpCreateRequire
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// libs/utils/src/process/child-process.ts
+import { assertNode } from "../crypto/runtime.mjs";
+var childProcess = null;
+function getChildProcess() {
+  if (!childProcess) {
+    assertNode("Process operations");
+    childProcess = __require("child_process");
+  }
+  return childProcess;
+}
+export {
+  getChildProcess
+};

package/browser/process/index.mjs

@@ -0,0 +1,15 @@
+// libs/utils/src/process/index.ts
+import { processTreeSpawnOptions, signalProcessTree, isProcessTreeAlive, stopProcessTree } from "./process-tree.mjs";
+import { spawnOwned, reapOrphans, OwnedProcessError } from "./owned-process.mjs";
+import { watchParent, watchPath } from "./process-watch.mjs";
+export {
+  OwnedProcessError,
+  isProcessTreeAlive,
+  processTreeSpawnOptions,
+  reapOrphans,
+  signalProcessTree,
+  spawnOwned,
+  stopProcessTree,
+  watchParent,
+  watchPath
+};

package/browser/process/owned-process.mjs

@@ -0,0 +1,175 @@
+// libs/utils/src/process/owned-process.ts
+import { getChildProcess } from "./child-process.mjs";
+import { isPidRunning, sleep, stopProcessTree } from "./process-tree.mjs";
+var OWNER_ENV_VAR = "FRONTMCP_OWNER";
+var OWNER_ARG_PREFIX = "--frontmcp-owner=";
+var MARKER_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+var DEFAULT_REAP_GRACE_MS = 2e3;
+var KILL_WAIT_MS = 1e3;
+var OwnedProcessError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OwnedProcessError";
+  }
+};
+function assertMarker(marker) {
+  if (!MARKER_PATTERN.test(marker)) {
+    throw new OwnedProcessError(
+      `Invalid process marker "${marker}": use up to 64 letters, digits, ".", "_" and "-", starting with a letter or digit`
+    );
+  }
+}
+function spawnOwned(command, args, options) {
+  const { marker, ...spawnOptions } = options;
+  assertMarker(marker);
+  const owner = `${marker}:${process.pid}`;
+  const child = getChildProcess().spawn(command, [...args, `${OWNER_ARG_PREFIX}${owner}`], {
+    ...spawnOptions,
+    env: { ...spawnOptions.env ?? process.env, [OWNER_ENV_VAR]: owner }
+  });
+  const stopsTree = spawnOptions.detached === true || process.platform === "win32";
+  return {
+    child,
+    stop: (signal = "SIGTERM", graceMs = 5e3) => stopsTree ? stopProcessTree(child, signal, graceMs) : stopChild(child, signal, graceMs)
+  };
+}
+function exitsWithin(child, timeoutMs) {
+  if (child.exitCode !== null || child.signalCode !== null) return Promise.resolve(true);
+  return new Promise((resolve) => {
+    const onExit = () => {
+      clearTimeout(timer);
+      resolve(true);
+    };
+    const timer = setTimeout(() => {
+      child.removeListener("exit", onExit);
+      resolve(false);
+    }, timeoutMs);
+    child.once("exit", onExit);
+  });
+}
+async function stopChild(child, signal, graceMs) {
+  if (child.pid === void 0) return true;
+  child.kill(signal);
+  if (await exitsWithin(child, graceMs)) return true;
+  child.kill("SIGKILL");
+  return exitsWithin(child, KILL_WAIT_MS);
+}
+function parseProcessList(output) {
+  const processes = [];
+  for (const line of output.split("\n")) {
+    const match = /^\s*(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(.*)$/.exec(line);
+    if (match) {
+      processes.push({
+        pid: Number(match[1]),
+        ppid: Number(match[2]),
+        pgid: Number(match[3]),
+        zombie: match[4].startsWith("Z"),
+        command: match[5]
+      });
+    }
+  }
+  return processes;
+}
+function listProcesses() {
+  const result = getChildProcess().spawnSync("ps", ["-A", "-ww", "-o", "pid=,ppid=,pgid=,stat=,command="], {
+    encoding: "utf8"
+  });
+  if (result.error || result.status !== 0) {
+    const reason = result.error?.message ?? (String(result.stderr).trim() || `exit code ${result.status}`);
+    throw new OwnedProcessError(`Could not list processes with ps: ${reason}`);
+  }
+  return parseProcessList(String(result.stdout));
+}
+function ownerPidOf(command, marker) {
+  const prefix = `${OWNER_ARG_PREFIX}${marker}:`;
+  const tag = command.split(/\s+/).find((token) => token.startsWith(prefix));
+  const pid = tag?.slice(prefix.length);
+  return pid && /^\d+$/.test(pid) ? Number(pid) : void 0;
+}
+function ownLineage(processes) {
+  const byPid = new Map(processes.map((info) => [info.pid, info]));
+  const lineage = /* @__PURE__ */ new Set([process.pid]);
+  const self = byPid.get(process.pid);
+  let ancestor = self && byPid.get(self.ppid);
+  while (ancestor && !lineage.has(ancestor.pid)) {
+    lineage.add(ancestor.pid);
+    ancestor = byPid.get(ancestor.ppid);
+  }
+  if (self) lineage.add(self.pgid);
+  return lineage;
+}
+function treesOf(orphans, processes, spared) {
+  const members = /* @__PURE__ */ new Set();
+  const pending = orphans.map((orphan) => orphan.pid);
+  for (const orphan of orphans) {
+    if (orphan.pgid === orphan.pid) {
+      for (const info of processes) if (info.pgid === orphan.pid) pending.push(info.pid);
+    }
+  }
+  while (pending.length > 0) {
+    const pid = pending.pop();
+    if (members.has(pid) || spared.has(pid)) continue;
+    members.add(pid);
+    for (const info of processes) if (info.ppid === pid) pending.push(info.pid);
+  }
+  return members;
+}
+function signalEach(pids, signal, d) {
+  for (const pid of pids) {
+    try {
+      d.kill(pid, signal);
+    } catch {
+    }
+  }
+}
+function stillRunning(pids, d) {
+  const signalled = pids.filter((pid) => isPidRunning(pid, d));
+  if (signalled.length === 0) return signalled;
+  const zombies = new Set(
+    d.listProcesses().filter((info) => info.zombie).map((info) => info.pid)
+  );
+  return signalled.filter((pid) => !zombies.has(pid));
+}
+async function waitForExit(pids, timeoutMs, d) {
+  const deadline = Date.now() + timeoutMs;
+  let running = stillRunning(pids, d);
+  while (running.length > 0 && Date.now() < deadline) {
+    await d.sleep(50);
+    running = stillRunning(running, d);
+  }
+  return running;
+}
+async function reapOrphans(marker, options = {}, deps) {
+  assertMarker(marker);
+  const d = {
+    platform: process.platform,
+    kill: (pid, signal) => process.kill(pid, signal),
+    sleep,
+    listProcesses,
+    ...deps
+  };
+  if (d.platform === "win32") return [];
+  const processes = d.listProcesses();
+  const lineage = ownLineage(processes);
+  const orphans = processes.filter((info) => {
+    const owner = ownerPidOf(info.command, marker);
+    return owner !== void 0 && !lineage.has(info.pid) && !isPidRunning(owner, d);
+  });
+  if (orphans.length === 0) return [];
+  const tree = [...treesOf(orphans, processes, lineage)];
+  signalEach(tree, "SIGTERM", d);
+  const survivors = await waitForExit(tree, options.graceMs ?? DEFAULT_REAP_GRACE_MS, d);
+  if (survivors.length > 0) {
+    signalEach(survivors, "SIGKILL", d);
+    await waitForExit(survivors, KILL_WAIT_MS, d);
+  }
+  const orphanPids = orphans.map((orphan) => orphan.pid);
+  const left = new Set(stillRunning(orphanPids, d));
+  return orphanPids.filter((pid) => !left.has(pid));
+}
+export {
+  OwnedProcessError,
+  parseProcessList,
+  reapOrphans,
+  spawnOwned
+};

package/browser/process/process-tree.mjs

@@ -0,0 +1,149 @@
+// libs/utils/src/process/process-tree.ts
+import { getChildProcess } from "./child-process.mjs";
+function runTaskkill(pid, force) {
+  const result = getChildProcess().spawnSync("taskkill", ["/pid", String(pid), "/T", ...force ? ["/F"] : []], {
+    stdio: "ignore",
+    windowsHide: true
+  });
+  return !result.error && result.status === 0;
+}
+function queryChildPids(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return [];
+  const result = getChildProcess().spawnSync(
+    "powershell.exe",
+    [
+      "-NoProfile",
+      "-NonInteractive",
+      "-Command",
+      // Single quotes: a double quote inside an argument would need Windows command-line escaping
+      `Get-CimInstance Win32_Process -Filter 'ParentProcessId=${pid}' | ForEach-Object { $_.ProcessId }`
+    ],
+    { encoding: "utf8", windowsHide: true, timeout: 15e3 }
+  );
+  if (result.error || result.status !== 0) return [];
+  return parsePidList(String(result.stdout ?? ""));
+}
+function parsePidList(output) {
+  return output.split(/\r?\n/).map((line) => line.trim()).filter((line) => /^\d+$/.test(line)).map(Number).filter((pid) => pid > 0);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function withDefaults(deps) {
+  return {
+    platform: process.platform,
+    kill: (pid, signal) => process.kill(pid, signal),
+    taskkill: runTaskkill,
+    childPids: queryChildPids,
+    sleep,
+    ...deps
+  };
+}
+function processTreeSpawnOptions(platform = process.platform) {
+  return platform === "win32" ? {} : { detached: true };
+}
+function hasExited(child) {
+  return child.exitCode !== null || child.signalCode !== null;
+}
+function isPidRunning(pid, d) {
+  try {
+    d.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function windowsOrphans(pid, d) {
+  if (isPidRunning(pid, d)) return [];
+  return d.childPids(pid);
+}
+function taskkillTree(child, pid, force, d) {
+  const roots = hasExited(child) ? windowsOrphans(pid, d) : [pid];
+  let delivered = false;
+  for (const root of roots) {
+    if (d.taskkill(root, force)) delivered = true;
+  }
+  return delivered;
+}
+function signalProcessTree(child, signal, deps) {
+  const d = withDefaults(deps);
+  const pid = child?.pid;
+  if (!child || pid === void 0) return false;
+  if (d.platform === "win32") return taskkillTree(child, pid, signal === "SIGKILL", d);
+  try {
+    d.kill(-pid, signal);
+    return true;
+  } catch {
+  }
+  if (hasExited(child)) return false;
+  try {
+    return child.kill(signal);
+  } catch {
+    return false;
+  }
+}
+function isProcessTreeAlive(child, deps) {
+  const d = withDefaults(deps);
+  const pid = child?.pid;
+  if (!child || pid === void 0) return false;
+  if (d.platform === "win32") return !hasExited(child) || windowsOrphans(pid, d).length > 0;
+  try {
+    d.kill(-pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function stopProcessTree(child, signal, graceMs, deps) {
+  const d = withDefaults(deps);
+  if (!child) return true;
+  if (d.platform === "win32") return stopWindowsTree(child, signal, graceMs, d);
+  signalProcessTree(child, signal, d);
+  if (await waitForProcessTreeExit(child, graceMs, d)) return true;
+  signalProcessTree(child, "SIGKILL", d);
+  return waitForProcessTreeExit(child, 1e3, d);
+}
+async function waitForProcessTreeExit(child, timeoutMs, d) {
+  const deadline = Date.now() + timeoutMs;
+  while (isProcessTreeAlive(child, d)) {
+    if (Date.now() >= deadline) return false;
+    await d.sleep(50);
+  }
+  return true;
+}
+async function stopWindowsTree(child, signal, graceMs, d) {
+  const pid = child.pid;
+  if (pid === void 0) return true;
+  if (hasExited(child) && windowsOrphans(pid, d).length === 0) return true;
+  if (signal !== "SIGKILL") {
+    const asked = taskkillTree(child, pid, false, d);
+    if (asked && await waitForWindowsTreeExit(child, pid, graceMs, d)) return true;
+  }
+  const rootWasRunning = !hasExited(child);
+  const forced = taskkillTree(child, pid, true, d);
+  return waitForWindowsTreeExit(child, pid, 1e3, d, !(forced && rootWasRunning));
+}
+async function waitForWindowsTreeExit(child, pid, timeoutMs, d, checkOrphans = true) {
+  const deadline = Date.now() + timeoutMs;
+  while (!hasExited(child)) {
+    if (Date.now() >= deadline) return false;
+    await d.sleep(50);
+  }
+  if (!checkOrphans) return true;
+  for (; ; ) {
+    if (windowsOrphans(pid, d).length === 0) return true;
+    if (Date.now() >= deadline) return false;
+    await d.sleep(250);
+  }
+}
+export {
+  isPidRunning,
+  isProcessTreeAlive,
+  parsePidList,
+  processTreeSpawnOptions,
+  queryChildPids,
+  runTaskkill,
+  signalProcessTree,
+  sleep,
+  stopProcessTree
+};