vite-plus 1.3.0 → 1.5.0

package/dist/script-watch.js

@@ -0,0 +1,2002 @@
+import path, { isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseEnv } from "node:util";
+import { existsSync, lstatSync, readFileSync, readdirSync, readlinkSync, realpathSync, statSync, unlinkSync, unwatchFile, watch, watchFile } from "node:fs";
+import process$1 from "node:process";
+import { isatty } from "node:tty";
+import { randomBytes } from "node:crypto";
+import os, { constants as constants$1 } from "node:os";
+import { execFileSync, spawn } from "node:child_process";
+import { createServer } from "node:net";
+// ../../oxc-node/packages/cli/src/watch/help.ts
+const DEFAULT_NAMES = {
+	name: "oxnode watch",
+	label: "oxnode",
+	nodeWatch: "oxnode --watch"
+};
+/** The names for `name`. Only oxnode's own name points to `oxnode --watch`. */
+function namesFor(name = DEFAULT_NAMES.name) {
+	if (name === DEFAULT_NAMES.name) return DEFAULT_NAMES;
+	return {
+		name,
+		label: name.split(" ")[0],
+		nodeWatch: null
+	};
+}
+const usage = (n = DEFAULT_NAMES) => `Usage: ${n.name} [options] [node options] [--] <entry> [script args...]`;
+const help = (n = DEFAULT_NAMES) => `${usage(n)}
+
+Run <entry> with oxc-node and run it again when a file it uses changes.
+
+Options:
+  --include <glob>         Also watch files matching <glob> (repeatable; "!x" excludes)
+  --exclude <glob>         Never watch files matching <glob> (repeatable)
+  --clear-screen=<bool>    Clear the screen before each rerun (default: true, TTY only)
+  --no-clear-screen        Same as --clear-screen=false
+  --kill-signal <signal>   Signal that stops the app before a rerun (default: SIGTERM)
+  --kill-timeout <ms>      Force kill the app if it is still running after <ms> (default: 5000)
+  --rerun-on-enter=<bool>  Rerun when Return is pressed (default: true on a terminal)
+  --no-rerun-on-enter      Never read the terminal; the app keeps stdin to itself
+  --poll[=<ms>]            Poll files instead of using file system events (Docker, WSL, network drives)
+  --tsconfig <path>        Use this tsconfig (same as OXC_TSCONFIG_PATH)
+  -h, --help               Show this help
+
+Node.js options go before <entry> (use --flag=value); everything after <entry> goes to the script.
+Globs are relative to the current folder. node_modules is not watched unless --include names it.
+
+Watched: every file the app imports or requires (worker threads on Node 24+), the tsconfig files
+oxc-node read (with "extends"), files the resolver looked for and did not find, --env-file files,
+Node.js config files (--experimental-config-file).
+
+Keys:  Return        rerun now (press again while stopping to force kill)
+       Ctrl+C        stop (press again to force kill)
+
+Examples:
+  ${n.name} ./src/server.ts
+  ${n.name} --include "./config/*.json" --exclude "src/**/*.test.ts" ./src/server.ts --port 3000
+  ${n.name} --inspect --clear-screen=false ./src/index.ts
+${n.nodeWatch ? `\n\`${n.nodeWatch} <entry>\` still runs Node.js' own watch mode.\n` : ""}`;
+// ../../oxc-node/packages/cli/src/watch/args.ts
+/**
+* Node.js options that take their value as the next token: those `node --help` shows as
+* `--name=...` on Node.js 22, 24 and 26, less test, bench and build-only ones.
+*/
+const NODE_VALUE_FLAGS = /* @__PURE__ */ new Set([
+	"-r",
+	"--require",
+	"--import",
+	"--loader",
+	"--experimental-loader",
+	"-C",
+	"--conditions",
+	"--env-file",
+	"--env-file-if-exists",
+	"--input-type",
+	"--inspect-port",
+	"--debug-port",
+	"--title",
+	"--disable-warning",
+	"--redirect-warnings",
+	"--report-dir",
+	"--report-directory",
+	"--diagnostic-dir",
+	"--allow-fs-read",
+	"--allow-fs-write",
+	"--cpu-prof-dir",
+	"--cpu-prof-interval",
+	"--cpu-prof-name",
+	"--disable-proto",
+	"--dns-result-order",
+	"--experimental-config-file",
+	"--experimental-default-type",
+	"--experimental-package-map",
+	"--heap-prof-dir",
+	"--heap-prof-interval",
+	"--heap-prof-name",
+	"--heapsnapshot-near-heap-limit",
+	"--heapsnapshot-signal",
+	"--icu-data-dir",
+	"--inspect-publish-uid",
+	"--localstorage-file",
+	"--max-http-header-size",
+	"--max-old-space-size-percentage",
+	"--network-family-autoselection-attempt-timeout",
+	"--openssl-config",
+	"--report-filename",
+	"--report-signal",
+	"--secure-heap",
+	"--secure-heap-min",
+	"--security-revert",
+	"--snapshot-blob",
+	"--tls-cipher-list",
+	"--tls-keylog",
+	"--trace-event-categories",
+	"--trace-event-file-pattern",
+	"--trace-require-module",
+	"--unhandled-rejections",
+	"--use-largepages",
+	"--v8-pool-size",
+	"--vfs-load",
+	"--watch-kill-signal"
+]);
+const DEFAULT_POLL_MS = 300;
+const MAX_TIMER_MS = 2 ** 31 - 1;
+const MAX_POLL_MS = Math.floor(MAX_TIMER_MS / 10);
+const needsEntry = (n) => n.nodeWatch ? `${n.name} needs an entry file; for tests use \`${n.nodeWatch} --test\`` : `${n.name} needs an entry file`;
+const REJECTED = {
+	"--watch": "use --include",
+	"--watch-path": "use --include",
+	"-e": null,
+	"--eval": null,
+	"-p": null,
+	"--print": null,
+	"-pe": null,
+	"-i": null,
+	"--interactive": null,
+	"--test": null,
+	"--run": null
+};
+function parseBool(name, value) {
+	if (value === void 0 || value === "true") return true;
+	if (value === "false") return false;
+	return { error: `${name} takes true or false, got "${value}"` };
+}
+/** NODE_OPTIONS split as Node.js does: at spaces, but not inside `"…"`, where `\` escapes. */
+function nodeOptionsTokens(s) {
+	const out = [];
+	let cur;
+	let quoted = false;
+	for (let i = 0; i < s.length; i++) {
+		let c = s[i];
+		if (c === "\\" && quoted) c = s[++i] ?? "";
+		else if (c === " " && !quoted) {
+			if (cur !== void 0) out.push(cur);
+			cur = void 0;
+			continue;
+		} else if (c === "\"") {
+			quoted = !quoted;
+			continue;
+		}
+		cur = (cur ?? "") + c;
+	}
+	if (cur !== void 0) out.push(cur);
+	return out;
+}
+const NO_WATCH = /^--no[-_]watch(=|$)/;
+/**
+* The last word on watch mode in NODE_OPTIONS: true for --watch or --watch-path (which implies
+* --watch), false for --no-watch. Node.js applies them in order, so the last one wins.
+*/
+function watchFlag(nodeOptions) {
+	let on;
+	for (const t of nodeOptionsTokens(nodeOptions ?? "")) if (/^--watch([-_]path)?(=|$)/.test(t)) on = true;
+	else if (NO_WATCH.test(t)) on = false;
+	return on;
+}
+const NESTED = "NODE_OPTIONS contains --watch, which would start a nested watcher";
+const readEnvFile = (file) => {
+	try {
+		return readFileSync(file, "utf8");
+	} catch {
+		return;
+	}
+};
+const NODE_VERSION = process.versions.node;
+const majorOf = (version) => Number(version.split(".")[0]);
+/** Whether `version` has a change released in each `[major, minor]` given, and every later major. */
+const atLeast = (version, ...mins) => {
+	const [major, minor] = version.split(".").map(Number);
+	return mins.some(([m, n]) => major === m && minor >= n) || major > mins[mins.length - 1][0];
+};
+/** Node.js 24.19 and 26.1 read a bare `--experimental-config-file` as `node.config.json`. */
+const bareConfigFlag = (version) => atLeast(version, [24, 19], [26, 1]);
+/** Before 26.12, Node.js reads a config flag anywhere in argv: after the entry and `--` too. */
+const configFlagsAnywhere = (version) => !atLeast(version, [26, 12]);
+/** Node.js 24.16 and 26.1 apply NODE_OPTIONS from an env file over the config file. */
+const dotenvBeatsConfig = (version) => atLeast(version, [24, 16], [26, 1]);
+/** Node.js 25.4 turns a flag on when the config file has a section named after it. */
+const sectionTurnsOn = (version) => atLeast(version, [25, 4], [26, 0]);
+function parseWatchArgs(argv, env, read = readEnvFile, nodeVersion = NODE_VERSION, names = DEFAULT_NAMES) {
+	const out = {
+		include: [],
+		exclude: [],
+		clearScreen: true,
+		killSignal: "SIGTERM",
+		killTimeout: 5e3,
+		rerunOnEnter: void 0,
+		poll: env.CHOKIDAR_USEPOLLING === "1" || env.CHOKIDAR_USEPOLLING === "true" ? DEFAULT_POLL_MS : false,
+		help: false,
+		nodeArgs: [],
+		entry: "",
+		envFiles: [],
+		configFiles: [],
+		noWatch: false,
+		notes: []
+	};
+	const configs = [];
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg === "--") {
+			if (i + 1 < argv.length) {
+				out.entry = argv[i + 1];
+				out.nodeArgs.push(...argv.slice(i));
+			}
+			if (configFlagsAnywhere(nodeVersion)) scanConfigs(argv.slice(i + 1), nodeVersion, configs);
+			break;
+		}
+		if (arg === "-") return { error: `- (stdin): ${needsEntry(names)}` };
+		if (!arg.startsWith("-")) {
+			out.entry = arg;
+			out.nodeArgs.push(...argv.slice(i));
+			if (configFlagsAnywhere(nodeVersion)) scanConfigs(argv.slice(i + 1), nodeVersion, configs);
+			break;
+		}
+		const eq = arg.indexOf("=");
+		const name = eq === -1 ? arg : arg.slice(0, eq);
+		const inline = eq === -1 ? void 0 : arg.slice(eq + 1);
+		const nodeName = name.startsWith("--") ? `--${name.slice(2).replaceAll("_", "-")}` : name;
+		const value = () => inline ?? argv[++i];
+		switch (nodeName) {
+			case "-h":
+			case "--help":
+				out.help = true;
+				continue;
+			case "--include":
+			case "--exclude":
+			case "--ignore": {
+				const glob = value();
+				if (!glob) return { error: `${name} needs a glob` };
+				const negated = glob.startsWith("!") && !glob.startsWith("!(");
+				if (nodeName === "--include" && !negated) out.include.push(glob);
+				else out.exclude.push(nodeName === "--include" ? glob.slice(1) : glob);
+				continue;
+			}
+			case "--clear-screen": {
+				const b = parseBool(name, inline);
+				if (typeof b !== "boolean") return b;
+				out.clearScreen = b;
+				continue;
+			}
+			case "--no-clear-screen":
+			case "--watch-preserve-output":
+				out.clearScreen = false;
+				continue;
+			case "--rerun-on-enter": {
+				const b = parseBool(name, inline);
+				if (typeof b !== "boolean") return b;
+				out.rerunOnEnter = b;
+				continue;
+			}
+			case "--no-rerun-on-enter":
+				out.rerunOnEnter = false;
+				continue;
+			case "--kill-signal":
+			case "--watch-kill-signal": {
+				const sig = value();
+				if (!sig || !Object.hasOwn(constants$1.signals, sig)) return { error: `${name} needs a signal name such as SIGTERM, got "${sig ?? ""}"` };
+				out.killSignal = sig;
+				continue;
+			}
+			case "--kill-timeout": {
+				const ms = value();
+				if (!ms || !/^\d+$/.test(ms)) return { error: `${name} needs a whole number of milliseconds, got "${ms ?? ""}"` };
+				out.killTimeout = Number(ms);
+				if (out.killTimeout > MAX_TIMER_MS) return { error: `${name} must be at most ${MAX_TIMER_MS} ms, got "${ms}"` };
+				continue;
+			}
+			case "--poll":
+				if (inline !== void 0 && !/^\d+$/.test(inline)) return { error: `--poll takes a whole number of milliseconds, got "${inline}"` };
+				out.poll = inline === void 0 ? DEFAULT_POLL_MS : Number(inline);
+				if (out.poll < 1 || out.poll > MAX_POLL_MS) return { error: `--poll takes 1 to ${MAX_POLL_MS} ms, got "${inline}"` };
+				continue;
+			case "--tsconfig": {
+				const p = value();
+				if (!p) return { error: "--tsconfig needs a path" };
+				out.tsconfig = p;
+				continue;
+			}
+			case "--no-cache":
+				out.notes.push("oxc-node has no transform cache");
+				continue;
+		}
+		if (Object.hasOwn(REJECTED, nodeName)) {
+			const why = REJECTED[nodeName] ?? needsEntry(names);
+			return { error: `${name} is not supported by ${names.name}: ${why}` };
+		}
+		out.nodeArgs.push(arg);
+		if (NO_WATCH.test(nodeName)) out.noWatch = true;
+		let nodeValue = inline;
+		const configFlag = nodeName === "--experimental-config-file" || nodeName === "--config-file" || nodeName === "--experimental-default-config-file";
+		if (inline === void 0 && takesNextWord(nodeName, nodeVersion) && i + 1 < argv.length) {
+			nodeValue = argv[++i];
+			out.nodeArgs.push(nodeValue);
+		}
+		if ((nodeName === "--env-file" || nodeName === "--env-file-if-exists") && nodeValue !== void 0) out.envFiles.push(nodeValue);
+		if (configFlag) addConfig(configs, nodeName, nodeValue);
+	}
+	if (!out.entry && !out.help) return { error: "missing <entry>" };
+	out.configFiles = pickConfig(configs, nodeVersion);
+	const nested = out.help ? void 0 : nestedWatcher(out, env, read, nodeVersion);
+	return nested ? { error: nested } : out;
+}
+function addConfig(configs, nodeName, nodeValue) {
+	if (nodeValue === "") return;
+	const file = nodeName === "--experimental-default-config-file" ? void 0 : nodeValue;
+	configs.push({
+		file: file ?? "node.config.json",
+		named: file !== void 0
+	});
+}
+/**
+* The one config file Node.js reads. From 24.19 and 26.1 the last config flag wins. Before, the
+* first file named wins, and the default one counts only when none is named.
+*/
+function pickConfig(configs, nodeVersion) {
+	const config = bareConfigFlag(nodeVersion) ? configs.at(-1) : configs.find((c) => c.named) ?? configs[0];
+	return config ? [config.file] : [];
+}
+/** Normalized long flag name and inline value: `--watch_path=x` is `--watch-path`, `x`. */
+/** Whether Node.js takes the next word as the value of `arg`, a flag with no `=value`. */
+function takesNextWord(arg, nodeVersion = NODE_VERSION) {
+	if (arg.includes("=")) return false;
+	const name = arg.startsWith("--") ? `--${arg.slice(2).replaceAll("_", "-")}` : arg;
+	return NODE_VALUE_FLAGS.has(name) && !(name === "--experimental-config-file" && bareConfigFlag(nodeVersion));
+}
+function splitFlag(arg) {
+	const eq = arg.indexOf("=");
+	return [`--${(eq === -1 ? arg : arg.slice(0, eq)).slice(2).replaceAll("_", "-")}`, eq === -1 ? void 0 : arg.slice(eq + 1)];
+}
+const isConfigFlag = (name) => name === "--experimental-config-file" || name === "--config-file" || name === "--experimental-default-config-file";
+/** Add the config flags in `args`, read as `nodeVersion` reads them. */
+function scanConfigs(args, nodeVersion, configs) {
+	for (let i = 0; i < args.length; i++) {
+		if (!args[i].startsWith("--")) continue;
+		const [name, inline] = splitFlag(args[i]);
+		if (!isConfigFlag(name)) continue;
+		let value = inline;
+		const takesValue = name === "--experimental-config-file" && !bareConfigFlag(nodeVersion);
+		if (value === void 0 && takesValue && i + 1 < args.length) value = args[++i];
+		addConfig(configs, name, value);
+	}
+}
+/**
+* Why the child would start a watcher of its own. The command line beats NODE_OPTIONS, which
+* beats the config file. NODE_OPTIONS from an env file beats the config file from 24.16 and 26.1;
+* before, the config file wins. Checked before each start too, as the files may change.
+*/
+function nestedWatcher(args, env, read = readEnvFile, nodeVersion = NODE_VERSION) {
+	if (args.noWatch) return void 0;
+	const fromEnv = watchFlag(env.NODE_OPTIONS);
+	if (fromEnv !== void 0) return fromEnv ? NESTED : void 0;
+	const fromFile = env.NODE_OPTIONS === void 0 ? watchFlag(childNodeOptions(env, args.envFiles, read)) : void 0;
+	const config = configFileWatch(args.configFiles, read, nodeVersion);
+	if (dotenvBeatsConfig(nodeVersion) ? fromFile !== void 0 : config === void 0) return fromFile ? `${NESTED} (from --env-file)` : void 0;
+	return config?.on ? configNested(config.file) : void 0;
+}
+/**
+* What the Node.js config file says about watch mode: on, off, or nothing (undefined). It applies
+* `nodeOptions` and the `watch` section as flags, and from 25.4 a `watch` section turns on --watch
+* by being there (unless it holds `"watch": false`). With `configs`, Node.js takes the first entry
+* for its major version.
+*/
+function configFileWatch(configFiles, read = readEnvFile, nodeVersion = NODE_VERSION) {
+	const nodeMajor = majorOf(nodeVersion);
+	const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+	const watchOf = (config) => {
+		if (!isObject(config)) return void 0;
+		const { nodeOptions, watch } = config;
+		const last = (o) => {
+			let on;
+			for (const [k, v] of Object.entries(o)) if (/^watch([-_]path)?$/.test(k) && v != null) on = v !== false;
+			return on;
+		};
+		const sets = [nodeOptions, watch].filter(isObject).map(last);
+		if (sets.includes(true)) return true;
+		if (sectionTurnsOn(nodeVersion) && isObject(watch) && watch.watch !== false) return true;
+		return sets.includes(false) ? false : void 0;
+	};
+	for (const file of configFiles) {
+		const text = read(file);
+		if (text === void 0) continue;
+		let config;
+		try {
+			config = JSON.parse(text.replace(/^\uFEFF/, ""));
+		} catch {
+			continue;
+		}
+		if (isObject(config) && Array.isArray(config.configs)) {
+			const entry = config.configs.find((c) => isObject(c) && c.nodeVersion === nodeMajor);
+			config = isObject(entry) ? entry.config : void 0;
+		}
+		const on = watchOf(config);
+		if (on !== void 0) return {
+			file,
+			on
+		};
+	}
+}
+const configNested = (file) => `the Node.js config file ${file} turns on --watch, which would start a nested watcher`;
+/** NODE_OPTIONS as the child gets it: from --env-file unless it is set already; the last file wins. */
+function childNodeOptions(env, envFiles, read) {
+	if (env.NODE_OPTIONS !== void 0) return env.NODE_OPTIONS;
+	let fromFiles;
+	for (const file of envFiles) {
+		const text = read(file);
+		const value = text === void 0 ? void 0 : parseEnv(text).NODE_OPTIONS;
+		if (value !== void 0) fromFiles = value;
+	}
+	return fromFiles;
+}
+/**
+* The child env for `--tsconfig`. oxc-node reads TS_NODE_PROJECT before OXC_TSCONFIG_PATH,
+* so both name the config: Node.js keeps a variable the environment already has, so an
+* `--env-file` that sets either one cannot override it (issue #876).
+*/
+function tsconfigEnv(tsconfig, cwd) {
+	if (!tsconfig) return {};
+	const path = resolve(cwd, tsconfig);
+	return {
+		OXC_TSCONFIG_PATH: path,
+		TS_NODE_PROJECT: path
+	};
+}
+// ../../oxc-node/packages/cli/src/run.ts
+/** The signals oxnode passes on to the app. On Windows it only listens, so it outlives the app. */
+const FORWARDED = process$1.platform === "win32" ? [
+	"SIGINT",
+	"SIGBREAK",
+	"SIGHUP"
+] : [
+	"SIGINT",
+	"SIGTERM",
+	"SIGHUP"
+];
+/**
+* A unix socket the child writes "I" to when the terminal already sent it SIGINT
+* (`@oxc-node/core/signal-ack.mjs`), so oxnode does not send it a second one.
+*/
+function createSignalAck() {
+	const callbacks = [];
+	const none = {
+		env: {},
+		onAck: () => {},
+		close: () => {}
+	};
+	if (process$1.platform === "win32") return none;
+	const path = join(os.tmpdir(), `oxnode-${process$1.pid}-${randomBytes(4).toString("hex")}.sock`);
+	if (Buffer.byteLength(path) > 100) return none;
+	const server = createServer((socket) => {
+		socket.unref();
+		socket.on("error", () => {});
+		socket.on("data", (data) => {
+			for (const byte of data) if (byte === 73) for (const cb of callbacks) cb();
+		});
+	});
+	let closed = false;
+	const close = () => {
+		if (closed) return;
+		closed = true;
+		process$1.off("exit", close);
+		process$1.off("SIGQUIT", onQuit);
+		server.close();
+		try {
+			unlinkSync(path);
+		} catch {}
+	};
+	server.on("error", close);
+	try {
+		server.listen(path);
+	} catch {
+		return none;
+	}
+	server.unref();
+	process$1.on("exit", close);
+	function onQuit() {
+		close();
+		process$1.kill(process$1.pid, "SIGQUIT");
+	}
+	process$1.once("SIGQUIT", onQuit);
+	return {
+		env: { OXNODE_SIGNAL_ACK: path },
+		onAck: (cb) => void callbacks.push(cb),
+		close
+	};
+}
+/** Whether oxnode is in the terminal's foreground group: reading stdin from the background stops it (SIGTTIN). */
+function isForeground() {
+	try {
+		if (process$1.platform === "win32") return true;
+		if (process$1.platform === "linux") {
+			const stat = readFileSync("/proc/self/stat", "utf8");
+			const f = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/);
+			return f[2] === f[5];
+		}
+		const [pgid, tpgid] = execFileSync("ps", [
+			"-o",
+			"pgid=,tpgid=",
+			"-p",
+			String(process$1.pid)
+		], { encoding: "utf8" }).trim().split(/\s+/);
+		return pgid === tpgid;
+	} catch {
+		return false;
+	}
+}
+/**
+* Whether a SIGINT oxnode gets comes from the terminal's Ctrl+C, which signals the whole
+* foreground group, the child included. Ask it once the SIGINT is in: a Ctrl+C during the
+* check also kills the `ps` it runs on macOS, and the answer would be false.
+*/
+const sigintFromTerminal = () => isatty(0) && isForeground();
+/** Decides whether a signal oxnode got goes on to the child. Pure: the caller owns the timers. */
+var SignalGate = class {
+	#nodeWatch;
+	#platform;
+	#terminal;
+	#waitMs;
+	#recentMs;
+	#coalesceMs;
+	#last = /* @__PURE__ */ new Map();
+	#lastAck = -Infinity;
+	#waiting = false;
+	constructor(o) {
+		this.#nodeWatch = o.nodeWatch;
+		this.#platform = o.platform;
+		const terminal = o.terminal ?? false;
+		this.#terminal = typeof terminal === "function" ? terminal : () => terminal;
+		this.#waitMs = o.waitMs ?? 50;
+		this.#recentMs = o.recentMs ?? 100;
+		this.#coalesceMs = o.coalesceMs ?? 500;
+	}
+	onSignal(sig, now) {
+		if (this.#platform === "win32") return { action: "skip" };
+		const prev = this.#last.get(sig);
+		this.#last.set(sig, now);
+		if (prev !== void 0 && now - prev < this.#coalesceMs) return { action: "skip" };
+		if (sig === "SIGINT") {
+			if (this.#terminal()) return { action: "skip" };
+			if (now - this.#lastAck <= this.#recentMs) return { action: "skip" };
+			this.#waiting = true;
+			return {
+				action: "wait",
+				ms: this.#waitMs
+			};
+		}
+		if (sig === "SIGHUP" && this.#nodeWatch) return {
+			action: "forward",
+			as: "SIGTERM"
+		};
+		return {
+			action: "forward",
+			as: sig
+		};
+	}
+	onAck(now) {
+		this.#lastAck = now;
+		this.#waiting = false;
+	}
+	onWaitExpired() {
+		if (!this.#waiting) return { action: "skip" };
+		this.#waiting = false;
+		return {
+			action: "forward",
+			as: "SIGINT"
+		};
+	}
+};
+/** Runs `onSignal` decisions against a child, including the SIGINT wait. */
+function gateSignals(gate, ack, kill, debug = () => {}) {
+	let timer;
+	const act = (r) => {
+		if (r.action === "forward") {
+			debug(`forward ${r.as}`);
+			kill(r.as);
+		} else if (r.action === "wait") {
+			clearTimeout(timer);
+			timer = setTimeout(() => {
+				timer = void 0;
+				act(gate.onWaitExpired());
+			}, r.ms);
+		}
+	};
+	ack.onAck(() => {
+		debug("ack");
+		gate.onAck(Date.now());
+		clearTimeout(timer);
+		timer = void 0;
+	});
+	return {
+		signal: (sig) => act(gate.onSignal(sig, Date.now())),
+		dispose: () => clearTimeout(timer)
+	};
+}
+// ../../oxc-node/packages/cli/src/watch/glob.ts
+const GLOB_CHARS = /[*?[\]{}]|[+@!]\(/;
+const MAX_EXPANSIONS = 64;
+/**
+* `a/{b,c/d}/e` → `a/b/e`, `a/c/d/e`. Groups without a comma (`{1..3}`) stay. Too many
+* alternatives: the pattern as it is. `\\` escapes, except on Windows, where it is a separator.
+*/
+function expandBraces(pattern, win) {
+	let depth = 0;
+	let start = -1;
+	for (let i = 0; i < pattern.length; i++) {
+		const c = pattern[i];
+		if (c === "\\" && !win) i++;
+		else if (c === "{") {
+			if (depth++ === 0) start = i;
+		} else if (c === "}" && depth > 0 && --depth === 0) {
+			const alts = splitTop(pattern.slice(start + 1, i), win);
+			if (alts.length < 2) continue;
+			const [pre, post] = [pattern.slice(0, start), pattern.slice(i + 1)];
+			const out = [];
+			for (const alt of alts) for (const one of expandBraces(pre + alt + post, win)) {
+				out.push(one);
+				if (out.length > MAX_EXPANSIONS) return [pattern];
+			}
+			return out;
+		}
+	}
+	return [pattern];
+}
+function splitTop(body, win) {
+	const out = [];
+	let depth = 0;
+	let from = 0;
+	for (let i = 0; i < body.length; i++) {
+		const c = body[i];
+		if (c === "\\" && !win) i++;
+		else if (c === "{") depth++;
+		else if (c === "}" && depth > 0) depth--;
+		else if (c === "," && depth === 0) {
+			out.push(body.slice(from, i));
+			from = i + 1;
+		}
+	}
+	out.push(body.slice(from));
+	return out;
+}
+const isDirOnDisk = (p) => {
+	try {
+		return statSync(p).isDirectory();
+	} catch {
+		return false;
+	}
+};
+function makeMatcher(opts) {
+	const win = opts.platform === "win32";
+	const native = win ? path.win32 : path.posix;
+	const dirGlob = (p) => GLOB_CHARS.test(p) && (win ? /[\\/]$/ : /\/$/).test(p) ? `${p}**` : p;
+	const include = opts.include.map(dirGlob);
+	const exclude = opts.exclude.map(dirGlob);
+	const isDir = opts.isDir ?? isDirOnDisk;
+	const norm = (p) => win ? p.replaceAll("\\", "/").toLowerCase() : p;
+	const cwd = norm(opts.cwd);
+	const drive = win ? native.resolve(opts.cwd, "/").replace(/[\\/]$/, "") : "";
+	const rooted = (pattern) => !win ? pattern : /^[\\/](?![\\/])/.test(pattern) ? drive + pattern : /^[A-Za-z]:(?![\\/])/.test(pattern) ? native.resolve(opts.cwd, pattern) : pattern;
+	const absolute = (pattern) => {
+		const abs = win ? norm(native.resolve(opts.cwd, rooted(pattern))) : path.posix.isAbsolute(pattern) ? pattern : path.posix.join(cwd, pattern);
+		return /^([a-z]:)?\/+$/i.test(abs) ? abs : abs.replace(/\/+$/, "");
+	};
+	const globs = [...include, ...exclude].filter((p) => GLOB_CHARS.test(p));
+	const matchesGlob = path.posix.matchesGlob;
+	if (globs.length && typeof matchesGlob !== "function") throw new Error(`--include and --exclude globs need Node.js 22.5 or later (path.matchesGlob)`);
+	const literal = (lit) => {
+		const below = lit.endsWith("/") ? lit : `${lit}/`;
+		return (n) => n === lit || n.startsWith(below);
+	};
+	const glob = (pattern) => {
+		if (native.isAbsolute(rooted(pattern))) {
+			const g = norm(rooted(pattern));
+			return (n) => matchesGlob(n, g);
+		}
+		const g = path.posix.normalize(norm(pattern));
+		return (n) => matchesGlob(path.posix.relative(cwd, n), g);
+	};
+	const excludes = exclude.map((p) => GLOB_CHARS.test(p) ? glob(p) : literal(absolute(p)));
+	const treeExcludes = exclude.filter((p) => /[\\/]\*\*$/.test(p)).map(glob);
+	const includes = [];
+	const named = [];
+	const roots = [];
+	const literals = [];
+	for (const pattern of include) {
+		if (!GLOB_CHARS.test(pattern)) {
+			const abs = native.resolve(opts.cwd, pattern);
+			if (isDir(abs)) {
+				includes.push(literal(norm(abs)));
+				roots.push({
+					base: abs,
+					depth: Infinity
+				});
+			} else {
+				includes.push(literal(norm(abs)));
+				literals.push(abs);
+				roots.push({
+					base: abs,
+					depth: Infinity
+				});
+			}
+			continue;
+		}
+		includes.push(glob(pattern));
+		for (const one of expandBraces(pattern, win)) {
+			const parts = one.split(win ? /[\\/]/ : "/");
+			let baseLen = 0;
+			while (baseLen < parts.length - 1 && !GLOB_CHARS.test(parts[baseLen])) baseLen++;
+			const rest = parts.slice(baseLen);
+			const fixed = baseLen === 0 ? "." : parts.slice(0, baseLen).join("/") || "/";
+			const base = native.resolve(opts.cwd, /^[A-Za-z]:$/.test(fixed) ? `${fixed}/` : fixed);
+			named.push({
+				base: norm(base),
+				parts: rest.map(norm)
+			});
+			roots.push({
+				base,
+				depth: rest.includes("**") ? Infinity : rest.length
+			});
+		}
+	}
+	const ignoreDirs = (opts.ignoreDirs ?? []).map(norm);
+	const excluded = (n) => excludes.some((m) => m(n));
+	return {
+		classify(absPath, source) {
+			const n = norm(absPath);
+			if (excluded(n)) return "exclude";
+			if (includes.some((m) => m(n))) return "watch";
+			if (source === "literal") return "watch";
+			if (source === "walk") return "default-ignore";
+			if (source !== "oxc" && n.split("/").includes("node_modules") || ignoreDirs.some((d) => literal(d)(n))) return "default-ignore";
+			return "watch";
+		},
+		roots: () => roots,
+		literals: () => literals,
+		pruneDir(absDir) {
+			const n = norm(absDir);
+			const name = path.posix.basename(n);
+			const fits = (dirs, parts, i = 0, j = 0) => {
+				if (i === dirs.length) return true;
+				const part = parts[j];
+				if (part === void 0 || j === parts.length - 1 && part !== "**") return false;
+				const last = i === dirs.length - 1;
+				if (part === "**") return fits(dirs, parts, i, j + 1) || !last && fits(dirs, parts, i + 1, j);
+				return (GLOB_CHARS.test(part) ? matchesGlob(dirs[i], part) && !(last && matchesGlob("oxnode-any-name", part)) : part === dirs[i]) && fits(dirs, parts, i + 1, j + 1);
+			};
+			return (name === "node_modules" || name.startsWith(".")) && !named.some((include) => n === include.base || n.startsWith(include.base.endsWith("/") ? include.base : `${include.base}/`) && fits(n.slice(include.base.replace(/\/$/, "").length + 1).split("/"), include.parts)) || excluded(n) || treeExcludes.some((m) => m(`${n}/__probe__`));
+		}
+	};
+}
+// ../../oxc-node/packages/cli/src/watch/dirs.ts
+function isRealDir(p) {
+	try {
+		return lstatSync(p).isDirectory();
+	} catch {
+		return false;
+	}
+}
+function isLink(p) {
+	try {
+		return lstatSync(p).isSymbolicLink();
+	} catch {
+		return false;
+	}
+}
+function sigOf(p) {
+	try {
+		const s = statSync(p, { bigint: true });
+		if (s.isDirectory()) return null;
+		return {
+			ino: s.ino,
+			size: s.size,
+			mtimeNs: s.mtimeNs,
+			ctimeNs: s.ctimeNs
+		};
+	} catch {
+		return null;
+	}
+}
+/** The links between a link and the file it ends at: `a -> b -> c -> file` gives `b`, `c`. */
+function linkHops(p) {
+	const hops = [];
+	let cur = p;
+	for (let n = 0; n < 32; n++) {
+		try {
+			cur = path.resolve(path.dirname(cur), readlinkSync(cur));
+		} catch {
+			break;
+		}
+		if (!isLink(cur)) break;
+		hops.push(cur);
+	}
+	return hops;
+}
+/** The stat of a link itself: it changes when the link is removed or pointed elsewhere. */
+function linkSigOf(p) {
+	try {
+		const s = lstatSync(p, { bigint: true });
+		return {
+			ino: s.ino,
+			size: s.size,
+			mtimeNs: s.mtimeNs,
+			ctimeNs: s.ctimeNs
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Whether a file changed, from its stat before and after. `event`: an event named it, rather
+* than a look made without one.
+*/
+function changed(prev, next, event = true) {
+	if (!prev || !next) return prev !== next;
+	if (prev.ino !== next.ino || prev.size !== next.size || prev.mtimeNs !== next.mtimeNs || prev.ctimeNs !== next.ctimeNs) return true;
+	return event && next.mtimeNs % 1000000000n === 0n;
+}
+function idOf(dir) {
+	try {
+		const s = statSync(dir, { bigint: true });
+		return `${s.ino}:${s.birthtimeNs}`;
+	} catch {
+		return;
+	}
+}
+/**
+* One non-recursive `fs.watch` per folder that holds a wanted file. A file whose folder does
+* not exist yet is watched at the nearest existing ancestor, one level deeper as folders appear.
+* `--include` roots are walked, and new folders in them are walked as they appear.
+*/
+var DirWatcher = class {
+	#o;
+	#win;
+	/**
+	* `shown` is the name a change is reported under: a link, for a link's target.
+	* `own`: wanted itself, for the whole session or only by the current run's imports.
+	* `target` is the key of the file a link points to; `links`, the keys of the links a target is
+	* watched for.
+	*/
+	#files = /* @__PURE__ */ new Map();
+	#byDir = /* @__PURE__ */ new Map();
+	#roots = [];
+	#walked = /* @__PURE__ */ new Map();
+	#handles = /* @__PURE__ */ new Map();
+	#awaited = /* @__PURE__ */ new Set();
+	#dropped = [];
+	#droppedSigs = /* @__PURE__ */ new Map();
+	#dropping;
+	#failed = /* @__PURE__ */ new Set();
+	#warned = /* @__PURE__ */ new Set();
+	#syncTimer;
+	#pollTimer;
+	#settleTimer;
+	#closed = false;
+	constructor(o) {
+		this.#o = o;
+		this.#win = o.platform === "win32";
+		if (o.poll !== false) this.#pollTimer = setInterval(() => this.#rewalk(), o.poll * 10);
+	}
+	#key(p) {
+		return this.#win ? p.toLowerCase() : p;
+	}
+	/**
+	* Watch one file, which may not exist yet. `run`: only the current run's imports want it, so
+	* `dropRun` drops it. `keepGone`: once deleted, it stays until it is back, for a file the next
+	* run looks for but cannot report (a discovered tsconfig.json). A link's target is watched for
+	* as long as the link points to it.
+	*/
+	add(file, run = false, keepGone = false) {
+		const have = this.#files.get(this.#key(file));
+		if (have) {
+			if (have.own !== "static") have.own = run ? "run" : "static";
+			have.shown = file;
+			if (keepGone) have.keepGone = true;
+			if (have.target === void 0 && isLink(file)) this.#follow(have);
+			return;
+		}
+		if (this.#closed) return;
+		const entry = this.#put(file, file, run ? "run" : "static");
+		if (keepGone) entry.keepGone = true;
+		if (isLink(file)) this.#follow(entry);
+	}
+	/** Drop what only the last run's imports wanted: the next run reports its own. */
+	dropRun() {
+		const dirs = /* @__PURE__ */ new Set();
+		const sigs = /* @__PURE__ */ new Map();
+		this.#dropping = {
+			sigs,
+			dirs
+		};
+		for (const [k, f] of this.#files) {
+			if (f.own !== "run") continue;
+			if (f.gone && f.keepGone) continue;
+			f.own = void 0;
+			const [link] = f.links ?? [];
+			if (link !== void 0) {
+				f.shown = this.#files.get(link)?.path ?? f.shown;
+				continue;
+			}
+			this.#remove(k);
+		}
+		this.#dropping = void 0;
+		this.#droppedSigs = sigs;
+		if (this.#dropped.length > 0 && this.#o.poll === false) this.#scheduleSync();
+		this.#dropped = [...dirs];
+	}
+	#put(file, shown, own) {
+		const k = this.#key(file);
+		const entry = {
+			path: file,
+			shown,
+			sig: sigOf(file),
+			own
+		};
+		this.#files.set(k, entry);
+		if (this.#droppedSigs.has(k)) {
+			const before = this.#droppedSigs.get(k);
+			this.#droppedSigs.delete(k);
+			if (changed(before, entry.sig, false)) queueMicrotask(() => this.#closed || this.#o.onChange(shown));
+		}
+		const dk = this.#key(path.dirname(file));
+		const set = this.#byDir.get(dk);
+		if (set) set.add(k);
+		else this.#byDir.set(dk, /* @__PURE__ */ new Set([k]));
+		this.#o.debug(`watch ${file}`);
+		if (this.#o.poll === false) {
+			this.#scheduleSync();
+			return entry;
+		}
+		watchFile(file, {
+			interval: this.#o.poll,
+			bigint: true
+		}, () => {
+			if (this.#files.has(k)) this.#check(k);
+		});
+		return entry;
+	}
+	/** Walk `base` to `depth` levels for files the matcher accepts, now and as they appear. */
+	addRoot(base, depth) {
+		const root = {
+			base,
+			depth,
+			missing: false
+		};
+		this.#roots.push(root);
+		this.#walkRoot(root);
+		if (this.#o.poll === false) this.#scheduleSync();
+	}
+	close() {
+		this.#closed = true;
+		clearTimeout(this.#syncTimer);
+		clearInterval(this.#pollTimer);
+		clearTimeout(this.#settleTimer);
+		for (const h of this.#handles.values()) h.w.close();
+		this.#handles.clear();
+		if (this.#o.poll !== false) for (const f of this.#files.values()) unwatchFile(f.path);
+	}
+	#scheduleSync() {
+		if (!this.#syncTimer && !this.#closed) this.#syncTimer = setTimeout(() => this.#sync(), 20);
+	}
+	#walkRoot(root) {
+		if (!isDirOnDisk(root.base)) {
+			root.missing = true;
+			return false;
+		}
+		this.#walk(root.base, 0, root.depth, root.missing);
+		root.missing = false;
+		return true;
+	}
+	#walk(dir, level, depth, fire) {
+		const k = this.#key(dir);
+		const seen = this.#walked.get(k);
+		if (seen && seen.depth - seen.level >= depth - level) return;
+		this.#walked.set(k, {
+			dir,
+			depth,
+			level
+		});
+		let entries;
+		try {
+			entries = readdirSync(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const e of entries) {
+			const full = path.join(dir, e.name);
+			if (e.isDirectory()) {
+				if (level + 1 < depth && !this.#o.matcher.pruneDir(full)) this.#walk(full, level + 1, depth, fire);
+			} else this.#found(full, fire);
+		}
+	}
+	#found(file, fire) {
+		const have = this.#files.get(this.#key(file));
+		if (have?.own === "static") return;
+		try {
+			if (!statSync(file).isFile()) return;
+		} catch {
+			return;
+		}
+		if (this.#o.matcher.classify(file, "walk") !== "watch") return;
+		this.add(file);
+		if (have) return;
+		this.#follow(this.#files.get(this.#key(file)));
+		if (fire) this.#o.onChange(file);
+	}
+	#follow(entry) {
+		let real;
+		try {
+			real = realpathSync.native(entry.path);
+		} catch {}
+		const next = real && this.#key(real) !== this.#key(entry.path) ? this.#key(real) : void 0;
+		entry.linkSig = next ? linkSigOf(entry.path) : void 0;
+		const hops = next ? linkHops(entry.path).filter((h) => this.#key(h) !== next) : [];
+		const hopKeys = hops.map((h) => this.#key(h));
+		if (next === entry.target && hopKeys.join("\0") === (entry.hops ?? []).join("\0")) return;
+		const link = this.#key(entry.path);
+		for (const k of entry.hops ?? []) this.#release(k, link);
+		if (entry.target !== void 0) this.#release(entry.target, link);
+		entry.target = next;
+		entry.hops = hopKeys;
+		if (real && next && !this.#closed) {
+			const target = this.#files.get(next) ?? this.#put(real, entry.path, void 0);
+			(target.links ??= /* @__PURE__ */ new Set()).add(link);
+			hops.forEach((h, i) => {
+				const hop = this.#files.get(hopKeys[i]) ?? this.#put(h, entry.path, void 0);
+				hop.linkSig ??= linkSigOf(h);
+				(hop.links ??= /* @__PURE__ */ new Set()).add(link);
+			});
+		}
+	}
+	#release(k, link) {
+		const target = this.#files.get(k);
+		if (!target?.links) return;
+		target.links.delete(link);
+		if (target.own) return;
+		const [rest] = target.links;
+		if (rest === void 0) this.#remove(k);
+		else target.shown = this.#files.get(rest)?.path ?? target.shown;
+	}
+	#remove(k) {
+		const entry = this.#files.get(k);
+		if (!entry) return;
+		this.#files.delete(k);
+		if (this.#dropping) {
+			this.#dropping.sigs.set(k, entry.sig);
+			this.#dropping.dirs.add(path.dirname(entry.path));
+		}
+		for (const h of entry.hops ?? []) this.#release(h, k);
+		if (entry.target !== void 0) this.#release(entry.target, k);
+		const dk = this.#key(path.dirname(entry.path));
+		const set = this.#byDir.get(dk);
+		set?.delete(k);
+		if (set?.size === 0) this.#byDir.delete(dk);
+		if (this.#o.poll !== false) unwatchFile(entry.path);
+		else this.#scheduleSync();
+	}
+	#rewalk() {
+		for (const k of this.#files.keys()) this.#check(k, false);
+		this.#walked.clear();
+		for (const root of this.#roots) {
+			root.missing = true;
+			this.#walkRoot(root);
+		}
+	}
+	#sync() {
+		this.#syncTimer = void 0;
+		if (this.#closed) return;
+		const exists = /* @__PURE__ */ new Map();
+		const cachedExists = (d) => {
+			let e = exists.get(d);
+			if (e === void 0) exists.set(d, e = existsSync(d));
+			return e;
+		};
+		const needed = /* @__PURE__ */ new Map();
+		const awaited = /* @__PURE__ */ new Set();
+		const place = (dir) => {
+			let d = dir;
+			let below;
+			while (!cachedExists(d)) {
+				const up = path.dirname(d);
+				if (up === d) return;
+				below = d;
+				d = up;
+			}
+			if (below) awaited.add(this.#key(below));
+			needed.set(this.#key(d), d);
+		};
+		for (const [k, w] of this.#walked) if (!existsSync(w.dir)) this.#walked.delete(k);
+		for (const root of this.#roots) if (!this.#walkRoot(root)) place(root.base);
+		for (const f of this.#files.values()) place(path.dirname(f.path));
+		for (const d of this.#dropped) place(d);
+		for (const [k, w] of this.#walked) needed.set(k, w.dir);
+		this.#awaited = awaited;
+		for (const [k, h] of this.#handles) if (!needed.has(k) || idOf(h.dir) !== h.id) this.#drop(k, h);
+		const fresh = [];
+		for (const [k, dir] of needed) if (!this.#handles.has(k) && !this.#failed.has(k) && this.#open(k, dir)) fresh.push(dir);
+		for (const dir of fresh) {
+			this.#checkDir(dir, false);
+			const walked = this.#walked.get(this.#key(dir));
+			if (walked) this.#rescan(walked);
+		}
+	}
+	#drop(k, h) {
+		h.w.close();
+		this.#handles.delete(k);
+		this.#restarted();
+		this.#checkDir(h.dir, false);
+	}
+	#restarted() {
+		if (this.#o.platform !== "darwin" || this.#closed) return;
+		clearTimeout(this.#settleTimer);
+		this.#settleTimer = setTimeout(() => {
+			this.#settleTimer = void 0;
+			for (const k of this.#files.keys()) this.#check(k, false);
+			this.#scheduleSync();
+		}, 250);
+	}
+	#rescan(walked) {
+		let entries;
+		try {
+			entries = readdirSync(walked.dir);
+		} catch {
+			return;
+		}
+		for (const name of entries) this.#onWalkedEntry(walked, path.join(walked.dir, name));
+	}
+	#open(k, dir) {
+		try {
+			const id = idOf(dir);
+			const w = (this.#o.watch ?? watch)(dir, (_type, name) => this.#onEvent(dir, w, name));
+			const h = {
+				w,
+				dir,
+				id
+			};
+			w.on("error", () => {
+				if (this.#handles.get(k) === h) this.#drop(k, h);
+				else w.close();
+				this.#scheduleSync();
+			});
+			this.#handles.set(k, h);
+			this.#restarted();
+			this.#o.debug(`ready ${dir}`);
+			return true;
+		} catch (error) {
+			const code = error.code ?? String(error);
+			if (code === "ENOENT") {
+				this.#scheduleSync();
+				return false;
+			}
+			this.#failed.add(k);
+			if (!this.#warned.has(code)) {
+				this.#warned.add(code);
+				const hint = code === "ENOSPC" || code === "EMFILE" ? " — raise fs.inotify.max_user_watches, or use --poll" : "";
+				this.#o.warn(`cannot watch ${dir}: ${code}${hint}`);
+			}
+			return false;
+		}
+	}
+	#onEvent(dir, w, name) {
+		if (this.#closed) return;
+		if (name === null) {
+			this.#checkDir(dir);
+			const walked = this.#walked.get(this.#key(dir));
+			if (walked) this.#rescan(walked);
+			this.#scheduleSync();
+			return;
+		}
+		const full = path.join(dir, name);
+		const k = this.#key(full);
+		if (this.#files.has(k)) this.#check(k);
+		else {
+			const walked = this.#walked.get(this.#key(dir));
+			if (walked) this.#onWalkedEntry(walked, full);
+		}
+		if (this.#awaited.has(k) || this.#handles.has(k) || this.#walked.has(k)) this.#scheduleSync();
+		if (name === path.basename(dir) && !this.#files.has(k) && !existsSync(full)) {
+			const dk = this.#key(dir);
+			const h = this.#handles.get(dk);
+			if (h?.w === w && this.#o.platform === "linux") this.#drop(dk, h);
+			this.#scheduleSync();
+		}
+		const dk = this.#key(dir);
+		const h = this.#handles.get(dk);
+		if (h?.w !== w) return;
+		if (idOf(dir) !== h.id) {
+			this.#drop(dk, h);
+			this.#scheduleSync();
+		} else if (!existsSync(full)) this.#scheduleSync();
+	}
+	#onWalkedEntry(walked, full) {
+		if (isRealDir(full)) {
+			if (walked.level + 1 < walked.depth && !this.#o.matcher.pruneDir(full)) {
+				this.#walk(full, walked.level + 1, walked.depth, true);
+				this.#scheduleSync();
+			}
+		} else this.#found(full, true);
+	}
+	#checkDir(dir, event = true) {
+		for (const k of this.#byDir.get(this.#key(dir)) ?? []) this.#check(k, event);
+	}
+	#check(k, event = true) {
+		const entry = this.#files.get(k);
+		const next = sigOf(entry.path);
+		if (!changed(entry.sig, next, event)) {
+			if (entry.linkSig !== void 0 && changed(entry.linkSig, linkSigOf(entry.path), false)) {
+				let moved = false;
+				const follow = (link) => {
+					const before = link.target;
+					this.#follow(link);
+					if (next !== null && link.target !== before) moved = true;
+				};
+				if (entry.target !== void 0) follow(entry);
+				else entry.linkSig = linkSigOf(entry.path);
+				for (const l of Array.from(entry.links ?? [])) {
+					const through = this.#files.get(l);
+					if (through?.hops?.includes(k)) follow(through);
+				}
+				if (moved) this.#o.onChange(entry.shown);
+			}
+			return;
+		}
+		if (entry.sig && !next) entry.gone = true;
+		else if (next) entry.gone = false;
+		entry.sig = next;
+		for (const l of entry.links ?? []) {
+			const link = this.#files.get(l);
+			if (link) link.sig = sigOf(link.path);
+		}
+		if (entry.own && (entry.target !== void 0 || isLink(entry.path))) this.#follow(entry);
+		if (entry.links) {
+			const link = isLink(entry.path);
+			for (const l of Array.from(entry.links)) {
+				const through = this.#files.get(l);
+				if (through && (link || next && through.hops?.includes(k))) this.#follow(through);
+			}
+		}
+		this.#o.onChange(entry.shown);
+	}
+};
+// ../../oxc-node/packages/cli/src/watch/kill-tree.ts
+/** One `/proc/<pid>/stat` line. The name in parentheses may hold spaces and `)`. */
+function parseProcStat(text) {
+	const close = text.lastIndexOf(")");
+	if (close === -1) return null;
+	const pid = Number.parseInt(text, 10);
+	const fields = text.slice(close + 1).trim().split(/\s+/);
+	const ppid = Number(fields[1]);
+	if (!Number.isInteger(pid) || !Number.isInteger(ppid)) return null;
+	return {
+		pid,
+		ppid,
+		zombie: /^[ZXx]/.test(fields[0]) || void 0,
+		start: fields[19]
+	};
+}
+/** The output of `ps -A -o pid=,ppid=,stat=,lstart=`, or of `ps -A -o pid=,ppid=`. */
+function parsePs(text) {
+	const rows = [];
+	for (const line of text.split("\n")) {
+		const m = /^\s*(\d+)\s+(\d+)(?:\s+(\S+)(?:\s+(\S.*?))?)?\s*$/.exec(line);
+		if (m) rows.push({
+			pid: Number(m[1]),
+			ppid: Number(m[2]),
+			zombie: m[3]?.startsWith("Z") || void 0,
+			start: m[4]
+		});
+	}
+	return rows;
+}
+/** Every process below `pid`, parents before their children. */
+function descendants(table, pid) {
+	const children = /* @__PURE__ */ new Map();
+	for (const row of table) {
+		const list = children.get(row.ppid);
+		if (list) list.push(row.pid);
+		else children.set(row.ppid, [row.pid]);
+	}
+	const out = [];
+	const seen = /* @__PURE__ */ new Set([pid]);
+	const queue = [pid];
+	while (queue.length) for (const child of children.get(queue.shift()) ?? []) {
+		if (seen.has(child)) continue;
+		seen.add(child);
+		out.push(child);
+		queue.push(child);
+	}
+	return out;
+}
+/** The rows of every process below `pid`, parents first. */
+function subtree(table, pid) {
+	const byPid = new Map(table.map((r) => [r.pid, r]));
+	return descendants(table, pid).map((p) => byPid.get(p));
+}
+/** Every process on the machine: `/proc` on Linux, where `ps` may be missing (slim containers), `ps` elsewhere. */
+function processTable() {
+	if (process.platform === "linux") try {
+		const rows = [];
+		for (const name of readdirSync("/proc")) {
+			if (!/^\d+$/.test(name)) continue;
+			try {
+				const row = parseProcStat(readFileSync(`/proc/${name}/stat`, "utf8"));
+				if (row) rows.push(row);
+			} catch {}
+		}
+		return rows;
+	} catch {
+		return [];
+	}
+	for (const columns of ["pid=,ppid=,stat=,lstart=", "pid=,ppid="]) try {
+		return parsePs(execFileSync("ps", [
+			"-A",
+			"-o",
+			columns
+		], {
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}));
+	} catch {}
+	return [];
+}
+/**
+* Which of `rows` still run, by `table`, plus what they started since, parents first.
+* Gone: no row, a zombie, or another start (the PID was reused). A failed read (`[]`) means none.
+*/
+function stillRunning(rows, table) {
+	const now = new Map(table.map((r) => [r.pid, r]));
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const r of rows) {
+		const row = now.get(r.pid);
+		if (!row || row.start !== r.start || seen.has(r.pid)) continue;
+		for (const p of [row.pid, ...descendants(table, row.pid)]) {
+			const found = now.get(p);
+			if (seen.has(p) || found.zombie) continue;
+			seen.add(p);
+			out.push(found);
+		}
+	}
+	return out;
+}
+/** Send `sig` to each, and keep the ones it reached: ESRCH is gone, EPERM is not ours to wait on. */
+function signalAll(rows, sig) {
+	return rows.filter((r) => {
+		try {
+			process.kill(r.pid, sig);
+			return true;
+		} catch {
+			return false;
+		}
+	});
+}
+/**
+* SIGKILL the child, everything it started, and what is left of `known` with what that
+* started since, so a grandchild cannot keep a port busy. Returns what it reached besides
+* the child.
+*/
+function killTree(child, known = []) {
+	const pid = child?.pid;
+	if (process.platform === "win32") {
+		if (child && pid !== void 0) spawn("taskkill", [
+			"/pid",
+			String(pid),
+			"/T",
+			"/F"
+		], {
+			stdio: "ignore",
+			windowsHide: true
+		}).on("error", () => child.kill());
+		return [];
+	}
+	const table = processTable();
+	const rows = stillRunning(pid === void 0 ? known : [...subtree(table, pid), ...known], table);
+	child?.kill("SIGKILL");
+	return signalAll(rows, "SIGKILL");
+}
+// ../../oxc-node/packages/cli/src/watch/log.ts
+let color;
+const pad = (n) => String(n).padStart(2, "0");
+/** A logger printing `HH:MM:SS [label] msg` on stdout, like tsx and Node.js. */
+function createLog(label) {
+	return (msg) => {
+		const d = /* @__PURE__ */ new Date();
+		const time = `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+		color ??= Boolean(process$1.stdout.isTTY && process$1.stdout.hasColors?.());
+		process$1.stdout.write(color ? `\x1b[90m${time}\x1b[39m \x1b[36m[${label}]\x1b[39m ${msg}\n` : `${time} [${label}] ${msg}\n`);
+	};
+}
+const debugOn = Boolean(process$1.env.OXNODE_WATCH_DEBUG);
+/** Lines on stderr that tests wait for (OXNODE_WATCH_DEBUG=1). */
+function debug(line) {
+	if (debugOn) process$1.stderr.write(`${line}\n`);
+}
+const ms = (n) => n >= 1e3 && n % 1e3 === 0 ? `${n / 1e3}s` : `${n}ms`;
+function exitReason(code, signal) {
+	if (signal) return `killed by ${signal}`;
+	return code ? `exited with code ${code}` : "completed";
+}
+function trigger(s, reason, cfg) {
+	const clear = cfg.clear ? [{ e: "clearScreen" }] : [];
+	if (s.k === "idle") return {
+		state: { k: "running" },
+		effects: [
+			...clear,
+			{
+				e: "log",
+				msg: `${reason}, rerunning`
+			},
+			{ e: "spawn" }
+		]
+	};
+	const effects = [...clear, {
+		e: "log",
+		msg: `${reason}, restarting`
+	}];
+	if (cfg.killTimeout === 0) effects.push({ e: "killTree" });
+	else effects.push({
+		e: "kill",
+		sig: cfg.killSignal
+	}, {
+		e: "startTimer",
+		id: "kill",
+		ms: cfg.killTimeout
+	});
+	return {
+		state: {
+			k: "stopping",
+			after: "restart"
+		},
+		effects
+	};
+}
+function step(s, ev, cfg) {
+	const same = {
+		state: s,
+		effects: []
+	};
+	const hint = cfg.enter ? " (Enter to rerun)" : "";
+	if (s.k === "done") return same;
+	if (ev.t === "spawnError") return {
+		state: { k: "done" },
+		effects: [
+			{
+				e: "clearTimer",
+				id: "kill"
+			},
+			{
+				e: "log",
+				msg: `cannot start: ${ev.err}`
+			},
+			{
+				e: "exit",
+				code: 1
+			}
+		]
+	};
+	switch (s.k) {
+		case "idle":
+		case "running": switch (ev.t) {
+			case "start":
+				if (s.k !== "idle") return same;
+				return {
+					state: { k: "running" },
+					effects: [{
+						e: "log",
+						msg: `watching for changes${hint}`
+					}, { e: "spawn" }]
+				};
+			case "change": {
+				const db = s.debounce;
+				if (!db) return {
+					state: {
+						...s,
+						debounce: {
+							firstAt: ev.now,
+							paths: [ev.path]
+						}
+					},
+					effects: [{
+						e: "startTimer",
+						id: "debounce",
+						ms: 100
+					}]
+				};
+				const paths = db.paths.includes(ev.path) ? db.paths : [...db.paths, ev.path];
+				const left = Math.max(0, 500 - (ev.now - db.firstAt));
+				return {
+					state: {
+						...s,
+						debounce: {
+							firstAt: db.firstAt,
+							paths
+						}
+					},
+					effects: [{
+						e: "startTimer",
+						id: "debounce",
+						ms: Math.min(100, left)
+					}]
+				};
+			}
+			case "debounceFired": {
+				const db = s.debounce;
+				if (!db) return same;
+				const more = db.paths.length > 1 ? ` (+${db.paths.length - 1} more)` : "";
+				return trigger(s, `change in ${db.paths[0]}${more}`, cfg);
+			}
+			case "enter": {
+				const r = trigger(s, "Enter", cfg);
+				return s.debounce ? {
+					...r,
+					effects: [{
+						e: "clearTimer",
+						id: "debounce"
+					}, ...r.effects]
+				} : r;
+			}
+			case "childExit": {
+				if (s.k !== "running") return same;
+				const lastExit = exitReason(ev.code, ev.signal);
+				return {
+					state: {
+						k: "idle",
+						debounce: s.debounce
+					},
+					effects: [{
+						e: "log",
+						msg: `${lastExit} — waiting for changes${hint}`
+					}]
+				};
+			}
+			case "signal":
+				if (s.k === "idle") return {
+					state: { k: "done" },
+					effects: [{
+						e: "exit",
+						code: 0
+					}]
+				};
+				return {
+					state: {
+						k: "stopping",
+						after: "exit",
+						firstSig: ev.sig,
+						firstSigAt: ev.now
+					},
+					effects: [
+						{
+							e: "clearTimer",
+							id: "debounce"
+						},
+						{
+							e: "forwardSignal",
+							sig: ev.sig
+						},
+						{
+							e: "startTimer",
+							id: "kill",
+							ms: cfg.killTimeout
+						}
+					]
+				};
+			default: return same;
+		}
+		case "stopping": switch (ev.t) {
+			case "change": return same;
+			case "enter": return {
+				state: s,
+				effects: [{
+					e: "log",
+					msg: "force killing"
+				}, { e: "killTree" }]
+			};
+			case "killTimeout": return {
+				state: s,
+				effects: [{
+					e: "log",
+					msg: `still running after ${ms(cfg.killTimeout)}, force killing`
+				}, { e: "killTree" }]
+			};
+			case "childExit":
+				if (s.after === "restart") return {
+					state: { k: "running" },
+					effects: [{
+						e: "clearTimer",
+						id: "kill"
+					}, { e: "spawn" }]
+				};
+				return {
+					state: { k: "done" },
+					effects: [{
+						e: "clearTimer",
+						id: "kill"
+					}, {
+						e: "exit",
+						code: ev.code ?? 0
+					}]
+				};
+			case "signal": {
+				if (s.after === "restart") return {
+					state: {
+						...s,
+						after: "exit",
+						firstSig: ev.sig,
+						firstSigAt: ev.now
+					},
+					effects: [{
+						e: "forwardSignal",
+						sig: ev.sig
+					}]
+				};
+				const since = ev.now - (s.firstSigAt ?? ev.now);
+				if (ev.sig === "SIGINT" && since > 500) return {
+					state: s,
+					effects: [{
+						e: "log",
+						msg: "force killing"
+					}, { e: "killTree" }]
+				};
+				if (ev.sig === s.firstSig && since <= 500) return same;
+				return {
+					state: s,
+					effects: [{
+						e: "forwardSignal",
+						sig: ev.sig
+					}]
+				};
+			}
+			default: return same;
+		}
+	}
+}
+// ../../oxc-node/packages/cli/src/watch/messages.ts
+/** Whether oxc-node sent this report: a tsconfig it read or a path a failed resolve tried. */
+function fromOxcNode(msg) {
+	return typeof msg === "object" && msg !== null && msg["oxc-node"] === true;
+}
+/**
+* The paths in a `watch:require` / `watch:import` message, or null when it is not one.
+* Each entry is read on its own: Node.js drops the whole array when one entry is bad.
+*/
+function parseWatchMessage(msg) {
+	if (typeof msg !== "object" || msg === null) return null;
+	const record = msg;
+	const lists = [record["watch:require"], record["watch:import"]];
+	if (lists.every((list) => list === void 0)) return null;
+	const paths = [];
+	for (const list of lists) {
+		if (!Array.isArray(list)) continue;
+		for (const entry of list) try {
+			if (typeof entry !== "string" || entry === "") continue;
+			if (entry.startsWith("file:")) {
+				paths.push(fileURLToPath(entry));
+				continue;
+			}
+			if (/^[a-z][a-z\d+.-]+:/i.test(entry)) continue;
+			if (!isAbsolute(entry)) continue;
+			paths.push(resolve(entry));
+		} catch {}
+	}
+	return paths;
+}
+// ../../oxc-node/packages/cli/src/watch/command.ts
+const isBareReturn = (chunk) => /[\r\n]/.test(chunk) && chunk.replace(/[\r\n]/g, "") === "";
+/** How soon a rerun looks again for what the app left running: fast first, then every 250 ms. */
+const TREE_POLL_MS = 25;
+const TREE_POLL_MAX_MS = 250;
+/** How long after a force kill oxnode waits for what is left: SIGKILL cannot end a process stuck on a hung mount. */
+const FORCE_WAIT_MS = 1e3;
+/**
+* Run the watcher until it stops, and resolve with the exit code. Until then it owns
+* SIGINT, SIGTERM and SIGHUP, stdin (for Return) and the process's IPC channel.
+*/
+function runWatch(argv, options = {}) {
+	const names = namesFor(options.name);
+	const log = createLog(names.label);
+	const args = parseWatchArgs(argv, process$1.env, void 0, void 0, names);
+	if ("error" in args) {
+		process$1.stderr.write(`${names.name}: ${args.error}\n${usage(names)}\nRun "${names.name} --help" for the options.\n`);
+		return Promise.resolve(1);
+	}
+	if (args.help) {
+		process$1.stdout.write(help(names));
+		return Promise.resolve(0);
+	}
+	const cwd = process$1.cwd();
+	let { loaderArgs, ignoreDirs: given = [] } = options;
+	if (!loaderArgs) {
+		const registerURL = import.meta.resolve("@oxc-node/core/register");
+		loaderArgs = [
+			`--enable-source-maps`,
+			`--import`,
+			registerURL
+		];
+		if (!options.ignoreDirs) given = [path.dirname(fileURLToPath(registerURL))];
+	}
+	const ignoreDirs = [];
+	for (const dir of given) {
+		ignoreDirs.push(dir);
+		try {
+			const real = realpathSync.native(dir);
+			if (real !== dir) ignoreDirs.push(real);
+		} catch {}
+	}
+	let matcher;
+	try {
+		matcher = makeMatcher({
+			cwd,
+			include: args.include,
+			exclude: args.exclude,
+			platform: process$1.platform,
+			ignoreDirs
+		});
+	} catch (error) {
+		process$1.stderr.write(`${names.name}: ${error.message}\n`);
+		return Promise.resolve(1);
+	}
+	for (const note of args.notes) log(note);
+	return new Promise((resolve) => {
+		const ack = createSignalAck();
+		let child;
+		let latest;
+		const signals = gateSignals(new SignalGate({
+			nodeWatch: false,
+			platform: process$1.platform,
+			terminal: sigintFromTerminal
+		}), ack, (sig) => child?.kill(sig), debug);
+		const enter = args.rerunOnEnter ?? sigintFromTerminal();
+		const cfg = {
+			killSignal: args.killSignal,
+			killTimeout: args.killTimeout,
+			clear: args.clearScreen && Boolean(process$1.stdout.isTTY),
+			enter
+		};
+		const env = {
+			...process$1.env,
+			WATCH_REPORT_DEPENDENCIES: "1",
+			...ack.env,
+			...tsconfigEnv(args.tsconfig, cwd)
+		};
+		const nodeArgs = [...loaderArgs, ...args.nodeArgs];
+		const timers = /* @__PURE__ */ new Map();
+		let state = { k: "idle" };
+		let tree = [];
+		let forcedAt;
+		let treeTimer;
+		/** Signal what is left of `tree` once, and call `then` when all of it is gone. */
+		const afterTree = (then, tick = 0) => {
+			if (tree.length) {
+				tree = stillRunning(tree, processTable());
+				if (tick === 0 || forcedAt !== void 0) {
+					const sig = forcedAt === void 0 ? cfg.killSignal : "SIGKILL";
+					tree = signalAll(tree, sig);
+				}
+			}
+			if (tree.length && forcedAt !== void 0 && Date.now() - forcedAt >= FORCE_WAIT_MS) {
+				log(`${tree.map((r) => r.pid).join(" ")} did not stop after a force kill, going on`);
+				tree = [];
+			}
+			if (tree.length === 0) return then();
+			if (tick === 0) debug(`waiting for ${tree.map((r) => r.pid).join(" ")}`);
+			treeTimer = setTimeout(() => afterTree(then, tick + 1), Math.min(TREE_POLL_MAX_MS, TREE_POLL_MS * 2 ** tick));
+		};
+		const display = (p) => {
+			const rel = path.relative(cwd, p);
+			return rel && !rel.startsWith("..") && !path.isAbsolute(rel) ? `.${path.sep}${rel}` : p;
+		};
+		const fold = (p) => process$1.platform === "win32" ? p.toLowerCase() : p;
+		const reported = /* @__PURE__ */ new Map();
+		const runAliases = /* @__PURE__ */ new Set();
+		const watcher = new DirWatcher({
+			poll: args.poll,
+			platform: process$1.platform,
+			matcher,
+			onChange: (p) => dispatch({
+				t: "change",
+				path: display(reported.get(fold(p)) ?? p),
+				now: Date.now()
+			}),
+			debug,
+			warn: log
+		});
+		const seen = /* @__PURE__ */ new Set();
+		const runSeen = /* @__PURE__ */ new Set();
+		const want = (p, source) => {
+			const key = source === "oxc" ? `oxc:${p}` : p;
+			if (seen.has(p) || runSeen.has(key)) return;
+			const run = source === "graph" || source === "oxc";
+			(run ? runSeen : seen).add(key);
+			const verdict = matcher.classify(p, source);
+			if (verdict === "watch") watcher.add(p, run, source === "oxc");
+			else debug(`skip ${p} (${verdict === "exclude" ? "exclude" : "default"})`);
+			if (verdict === "exclude") return;
+			try {
+				const real = realpathSync.native(p);
+				if (real !== p) {
+					if (!reported.has(fold(real))) {
+						reported.set(fold(real), p);
+						if (run) runAliases.add(fold(real));
+					}
+					if (source === "literal" && lstatSync(p).isSymbolicLink()) return;
+					want(real, source);
+				}
+			} catch {}
+		};
+		const newRun = () => {
+			runSeen.clear();
+			for (const k of runAliases) reported.delete(k);
+			runAliases.clear();
+			watcher.dropRun();
+		};
+		const spawnChild = () => {
+			const nested = nestedWatcher(args, process$1.env);
+			if (nested) {
+				queueMicrotask(() => dispatch({
+					t: "spawnError",
+					err: nested
+				}));
+				return;
+			}
+			tree = [];
+			forcedAt = void 0;
+			newRun();
+			const c = spawn(process$1.execPath, nodeArgs, {
+				env,
+				stdio: [
+					"inherit",
+					"inherit",
+					"inherit",
+					"ipc"
+				],
+				windowsHide: false
+			});
+			child = c;
+			latest = c;
+			c.on("message", (msg) => {
+				const paths = parseWatchMessage(msg);
+				if (paths) {
+					const source = fromOxcNode(msg) ? "oxc" : "graph";
+					if (c === latest) for (const p of paths) want(p, source);
+				} else if (process$1.send && process$1.connected) process$1.send(msg, () => {});
+			});
+			c.on("error", (error) => {
+				if (c.pid === void 0 && child === c) {
+					child = void 0;
+					dispatch({
+						t: "spawnError",
+						err: error.message
+					});
+				}
+			});
+			c.on("exit", (code, signal) => {
+				if (child !== c) return;
+				child = void 0;
+				afterTree(() => dispatch({
+					t: "childExit",
+					code,
+					signal
+				}));
+			});
+			if (c.pid !== void 0) debug(`spawn ${c.pid}`);
+		};
+		const run = (e) => {
+			switch (e.e) {
+				case "spawn":
+					spawnChild();
+					break;
+				case "kill":
+					if (!child) break;
+					if (process$1.platform === "win32") killTree(child);
+					else {
+						if (child.pid !== void 0) tree = subtree(processTable(), child.pid);
+						child.kill(e.sig);
+					}
+					break;
+				case "killTree":
+					forcedAt ??= Date.now();
+					tree = killTree(child, tree);
+					break;
+				case "clearScreen":
+					process$1.stdout.write("\x1Bc");
+					break;
+				case "log":
+					log(e.msg);
+					break;
+				case "startTimer": {
+					clearTimeout(timers.get(e.id));
+					const ev = e.id === "debounce" ? { t: "debounceFired" } : { t: "killTimeout" };
+					timers.set(e.id, setTimeout(() => {
+						timers.delete(e.id);
+						dispatch(ev);
+					}, e.ms));
+					break;
+				}
+				case "clearTimer":
+					clearTimeout(timers.get(e.id));
+					timers.delete(e.id);
+					break;
+				case "forwardSignal":
+					signals.signal(e.sig);
+					break;
+				case "exit": finish(e.code);
+			}
+		};
+		function dispatch(ev) {
+			const r = step(state, ev, cfg);
+			state = r.state;
+			for (const e of r.effects) run(e);
+		}
+		const onSignal = (sig) => dispatch({
+			t: "signal",
+			sig,
+			now: Date.now()
+		});
+		const onParentMessage = (msg) => {
+			if (child?.connected) child.send(msg, () => {});
+		};
+		let reading = false;
+		const onData = (chunk) => {
+			if (isBareReturn(chunk)) dispatch({ t: "enter" });
+		};
+		const stopReading = () => {
+			if (!reading) return;
+			reading = false;
+			process$1.stdin.off("data", onData).off("end", stopReading).off("error", stopReading);
+			process$1.stdin.pause();
+			process$1.stdin.unref?.();
+		};
+		function finish(code) {
+			clearTimeout(treeTimer);
+			tree = [];
+			for (const t of timers.values()) clearTimeout(t);
+			timers.clear();
+			signals.dispose();
+			ack.close();
+			watcher.close();
+			stopReading();
+			for (const sig of FORWARDED) process$1.off(sig, onSignal);
+			process$1.off("message", onParentMessage);
+			resolve(code);
+		}
+		for (const sig of FORWARDED) process$1.on(sig, onSignal);
+		if (process$1.send) process$1.on("message", onParentMessage);
+		if (enter) {
+			reading = true;
+			process$1.stdin.setEncoding("utf8");
+			process$1.stdin.on("data", onData).on("end", stopReading).on("error", stopReading);
+		}
+		want(path.resolve(cwd, args.entry), "literal");
+		for (const file of args.envFiles) want(path.resolve(cwd, file), "literal");
+		for (const file of args.configFiles) want(path.resolve(cwd, file), "literal");
+		if (args.tsconfig) want(path.resolve(cwd, args.tsconfig), "literal");
+		for (const file of matcher.literals()) want(file, "literal");
+		for (const root of matcher.roots()) watcher.addRoot(root.base, root.depth);
+		dispatch({ t: "start" });
+	});
+}
+// src/script-watch.ts
+/**
+* `vpx --watch`: oxc-node's watcher (`@oxc-node/cli/watch`), bundled from the vendored
+* source, running the script with the `vpx <script>` loader instead of Node.js' own watch
+* mode. Built to `dist/script-watch.js`.
+*
+* The global `vpx` runs `node dist/script-watch.js <args>`, and the project-local bin
+* imports it in process; either way the watcher's arguments are `process.argv.slice(2)`,
+* the `vpx` arguments without `--watch` and `--tsconfig`, which the CLIs pass on as
+* `VP_SCRIPT_TSCONFIG`, as for a script. The watcher owns SIGINT, SIGTERM, SIGHUP,
+* stdin, and the IPC channel until it stops.
+*/
+const dist = path.dirname(fileURLToPath(import.meta.url));
+process.exitCode = await runWatch(process.argv.slice(2), {
+	name: "vpx --watch",
+	loaderArgs: [
+		"--require",
+		path.join(dist, "script-preload.cjs"),
+		"--import",
+		new URL("./script-register.js", import.meta.url).href
+	],
+	ignoreDirs: [path.dirname(dist)]
+});
+export {};