@mawesome/npm-vm 0.0.0-alpha.0 → 0.1.0

package/dist/runtime/messages-vUDkl1-0.cjs

@@ -0,0 +1,174 @@
+//#region src/errors.ts
+/** Exit codes of `npm-vm` itself and of the shim before npm starts (spec section 10). */
+const EXIT = {
+	ok: 0,
+	problems: 1,
+	partial: 2,
+	resolution: 3,
+	transport: 4,
+	verification: 5,
+	abi: 6,
+	usage: 64
+};
+/** A failure with a message id from spec section 12 and the exit code it maps to. */
+var NpmVmError = class extends Error {
+	name = "NpmVmError";
+	id;
+	exitCode;
+	constructor(id, exitCode, message) {
+		super(message);
+		this.id = id;
+		this.exitCode = exitCode;
+	}
+};
+function isNpmVmError(error) {
+	return error instanceof NpmVmError;
+}
+//#endregion
+//#region src/messages.ts
+/** Message builders for spec section 12; every message names the cause and one fix. */
+/** Every URL in `text` with its user info replaced, so a registry token never reaches a terminal (spec SEC-10). */
+function redactUrls(text) {
+	return text.replace(/\b([a-z][a-z0-9+.-]*:\/\/)([^\s/]*)@/gi, "$1***@");
+}
+function describeSpecs(specs) {
+	return specs.map((spec) => spec.hash ? `${spec.exact}+${spec.hash.algorithm}.${spec.hash.hex.slice(0, 8)}…` : spec.range).join(" or ");
+}
+function engineMessage(version, enginesNode, nodeVersion) {
+	return [`npm ${version} needs Node ${enginesNode}, but the active Node is ${nodeVersion}.`, `Switch Node with \`nvm install <version>\` or \`fnm use <version>\`, or relax the npm range in package.json.`].join("\n");
+}
+function noMatchMessage(specs, file, reason) {
+	return [`No npm version satisfies ${describeSpecs(specs)} (${file}): ${reason}.`, `Run \`npm-vm which\` to see the resolution.`].join("\n");
+}
+function transportMessage(ownVersion, detail) {
+	return [`Cannot download npm: ${ownVersion === null ? "no npm beside the active Node" : `Node's own npm ${ownVersion}`} (${detail}); npm 8 or newer is needed as the transport.`, `Reinstall Node or run \`npm-vm install <version>\` from a Node whose npm works.`].join("\n");
+}
+function keyMessage(keyid) {
+	return [`The registry signed npm with key ${keyid}, which npm-vm does not know.`, `Run \`npm-vm self-update\` to pick up new registry keys.`].join("\n");
+}
+function unsignedMessage(registry, version) {
+	return [`${redactUrls(registry)} serves npm ${version} without a registry signature.`, `Pin a tarball hash in devEngines.packageManager (\`${version}+sha512.<hex>\`) to allow unsigned registries.`].join("\n");
+}
+function integrityMessage(expected, actual, detail) {
+	return [`npm tarball verification failed: ${detail}.`, `Expected ${expected}, got ${actual}. Clear the entry with \`npm-vm cache prune\` and retry.`].join("\n");
+}
+function abiMessage(detail) {
+	return [`npm-vm launcher mismatch: ${detail}.`, `Run \`npx --prefix ~ -y @mawesome/npm-vm setup\` to reinstall the launchers.`].join("\n");
+}
+/** M-LOCKED: names the file, the holder, and the one recovery that is safe for where the holder runs. */
+function lockedMessage(path, holder, live, foreign) {
+	if (holder === null) return `${path} is locked by an unreadable owner. If no npm-vm command is running, delete that file and retry.`;
+	const who = `PID ${holder.pid} on ${holder.host} since ${holder.createdAt || "an unknown time"}`;
+	if (foreign) return [`${path} is locked by ${who}, which cannot be verified from this machine.`, `Confirm on ${holder.host} that no npm-vm command runs, then delete ${path} and retry.`].join("\n");
+	if (live) return `${path} is locked by ${who}, which is still running. Wait for it to finish and retry.`;
+	return `${path} is locked by ${who}, which is no longer running. Delete ${path} and retry.`;
+}
+function provenanceMessage(name, version, detail) {
+	return [`${name}@${version} failed provenance verification: ${detail}.`, "The installed version is unchanged. Retry later, or install the release by hand after checking it at https://www.npmjs.com/package/@mawesome/npm-vm."].join("\n");
+}
+function dirPermsMessage(dir, problem, fix) {
+	return [`${dir} ${problem}.`, `Run \`${fix}\` and retry, or point NPM_VM_HOME at a private directory.`].join("\n");
+}
+function changedMessage(file, what) {
+	return `${file} changed since npm-vm wrote it; left untouched. Remove the ${what} by hand if you still want it gone.`;
+}
+function restartMessage() {
+	return "Restart open terminals and IDEs so they pick up the new PATH.";
+}
+//#endregion
+Object.defineProperty(exports, "EXIT", {
+	enumerable: true,
+	get: function() {
+		return EXIT;
+	}
+});
+Object.defineProperty(exports, "NpmVmError", {
+	enumerable: true,
+	get: function() {
+		return NpmVmError;
+	}
+});
+Object.defineProperty(exports, "abiMessage", {
+	enumerable: true,
+	get: function() {
+		return abiMessage;
+	}
+});
+Object.defineProperty(exports, "changedMessage", {
+	enumerable: true,
+	get: function() {
+		return changedMessage;
+	}
+});
+Object.defineProperty(exports, "dirPermsMessage", {
+	enumerable: true,
+	get: function() {
+		return dirPermsMessage;
+	}
+});
+Object.defineProperty(exports, "engineMessage", {
+	enumerable: true,
+	get: function() {
+		return engineMessage;
+	}
+});
+Object.defineProperty(exports, "integrityMessage", {
+	enumerable: true,
+	get: function() {
+		return integrityMessage;
+	}
+});
+Object.defineProperty(exports, "isNpmVmError", {
+	enumerable: true,
+	get: function() {
+		return isNpmVmError;
+	}
+});
+Object.defineProperty(exports, "keyMessage", {
+	enumerable: true,
+	get: function() {
+		return keyMessage;
+	}
+});
+Object.defineProperty(exports, "lockedMessage", {
+	enumerable: true,
+	get: function() {
+		return lockedMessage;
+	}
+});
+Object.defineProperty(exports, "noMatchMessage", {
+	enumerable: true,
+	get: function() {
+		return noMatchMessage;
+	}
+});
+Object.defineProperty(exports, "provenanceMessage", {
+	enumerable: true,
+	get: function() {
+		return provenanceMessage;
+	}
+});
+Object.defineProperty(exports, "redactUrls", {
+	enumerable: true,
+	get: function() {
+		return redactUrls;
+	}
+});
+Object.defineProperty(exports, "restartMessage", {
+	enumerable: true,
+	get: function() {
+		return restartMessage;
+	}
+});
+Object.defineProperty(exports, "transportMessage", {
+	enumerable: true,
+	get: function() {
+		return transportMessage;
+	}
+});
+Object.defineProperty(exports, "unsignedMessage", {
+	enumerable: true,
+	get: function() {
+		return unsignedMessage;
+	}
+});

package/dist/runtime/p-map-b8pXdaFZ.cjs

@@ -0,0 +1,105 @@
+const require_rolldown_runtime = require("./rolldown-runtime-BGT596CS.cjs");
+//#region ../../node_modules/.pnpm/p-map@7.0.4/node_modules/p-map/index.js
+async function pMap(iterable, mapper, { concurrency = Number.POSITIVE_INFINITY, stopOnError = true, signal } = {}) {
+	return new Promise((resolve_, reject_) => {
+		if (iterable[Symbol.iterator] === void 0 && iterable[Symbol.asyncIterator] === void 0) throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`);
+		if (typeof mapper !== "function") throw new TypeError("Mapper function is required");
+		if (!(Number.isSafeInteger(concurrency) && concurrency >= 1 || concurrency === Number.POSITIVE_INFINITY)) throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
+		const result = [];
+		const errors = [];
+		const skippedIndexesMap = /* @__PURE__ */ new Map();
+		let isRejected = false;
+		let isResolved = false;
+		let isIterableDone = false;
+		let resolvingCount = 0;
+		let currentIndex = 0;
+		const iterator = iterable[Symbol.iterator] === void 0 ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
+		const signalListener = () => {
+			reject(signal.reason);
+		};
+		const cleanup = () => {
+			signal?.removeEventListener("abort", signalListener);
+		};
+		const resolve = (value) => {
+			resolve_(value);
+			cleanup();
+		};
+		const reject = (reason) => {
+			isRejected = true;
+			isResolved = true;
+			reject_(reason);
+			cleanup();
+		};
+		if (signal) {
+			if (signal.aborted) reject(signal.reason);
+			signal.addEventListener("abort", signalListener, { once: true });
+		}
+		const next = async () => {
+			if (isResolved) return;
+			const nextItem = await iterator.next();
+			const index = currentIndex;
+			currentIndex++;
+			if (nextItem.done) {
+				isIterableDone = true;
+				if (resolvingCount === 0 && !isResolved) {
+					if (!stopOnError && errors.length > 0) {
+						reject(new AggregateError(errors));
+						return;
+					}
+					isResolved = true;
+					if (skippedIndexesMap.size === 0) {
+						resolve(result);
+						return;
+					}
+					const pureResult = [];
+					for (const [index, value] of result.entries()) {
+						if (skippedIndexesMap.get(index) === pMapSkip) continue;
+						pureResult.push(value);
+					}
+					resolve(pureResult);
+				}
+				return;
+			}
+			resolvingCount++;
+			(async () => {
+				try {
+					const element = await nextItem.value;
+					if (isResolved) return;
+					const value = await mapper(element, index);
+					if (value === pMapSkip) skippedIndexesMap.set(index, value);
+					result[index] = value;
+					resolvingCount--;
+					await next();
+				} catch (error) {
+					if (stopOnError) reject(error);
+					else {
+						errors.push(error);
+						resolvingCount--;
+						try {
+							await next();
+						} catch (error) {
+							reject(error);
+						}
+					}
+				}
+			})();
+		};
+		(async () => {
+			for (let index = 0; index < concurrency; index++) {
+				try {
+					await next();
+				} catch (error) {
+					reject(error);
+					break;
+				}
+				if (isIterableDone || isRejected) break;
+			}
+		})();
+	});
+}
+var pMapSkip;
+//#endregion
+require_rolldown_runtime.__esmMin((() => {
+	pMapSkip = Symbol("skip");
+}))();
+exports.default = pMap;

package/dist/runtime/proc-hB8N9WjN.cjs

@@ -0,0 +1,127 @@
+const require_rolldown_runtime = require("./rolldown-runtime-BGT596CS.cjs");
+let node_child_process = require("node:child_process");
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+//#region src/state/proc.ts
+var proc_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	isLive: () => isLive,
+	ownIdentity: () => ownIdentity,
+	powershellPath: () => powershellPath,
+	shellBinary: () => shellBinary,
+	startIdentity: () => startIdentity
+});
+function powershellPath(env = process.env) {
+	return (0, node_path.join)(env["SystemRoot"] ?? "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+}
+const SHELL_DIRS = [
+	"/bin",
+	"/usr/bin",
+	"/usr/local/bin",
+	"/opt/homebrew/bin",
+	"/snap/bin"
+];
+/**
+* An absolute path for a shell to probe (spec SEC-8): the login shell when `$SHELL` is absolute, else system dirs.
+* Never PATH, which inside an npm script starts with `node_modules/.bin`.
+*/
+function shellBinary(shell, env = process.env, platform = process.platform) {
+	const name = shell === "powershell" ? "pwsh" : shell;
+	if (platform === "win32") {
+		const pwsh = (0, node_path.join)(env["ProgramFiles"] ?? "C:\\Program Files", "PowerShell", "7", "pwsh.exe");
+		return shell === "powershell" && (0, node_fs.existsSync)(pwsh) ? pwsh : null;
+	}
+	const login = env["SHELL"];
+	return [...login !== void 0 && (0, node_path.isAbsolute)(login) && (0, node_path.basename)(login) === name ? [login] : [], ...SHELL_DIRS.map((dir) => (0, node_path.join)(dir, name))].find((candidate) => (0, node_fs.existsSync)(candidate)) ?? null;
+}
+/** The start identity of `pid`, or null when the lookup fails or is ambiguous. */
+function startIdentity(pid, platform = process.platform, env = process.env) {
+	try {
+		if (platform === "linux") {
+			const stat = (0, node_fs.readFileSync)(`/proc/${pid}/stat`, "utf8");
+			const start = stat.slice(stat.lastIndexOf(")") + 1).trim().split(/\s+/)[19];
+			return start !== void 0 && /^\d+$/.test(start) ? start : null;
+		}
+		if (platform === "darwin") {
+			const out = (0, node_child_process.execFileSync)("/bin/ps", [
+				"-o",
+				"lstart=",
+				"-p",
+				String(pid)
+			], {
+				encoding: "utf8",
+				env: {
+					LC_ALL: "C",
+					PATH: "/usr/bin:/bin"
+				}
+			}).trim();
+			return out === "" || out.includes("\n") ? null : out;
+		}
+		if (platform === "win32") {
+			const out = (0, node_child_process.execFileSync)(powershellPath(env), [
+				"-NoProfile",
+				"-NonInteractive",
+				"-Command",
+				`(Get-Process -Id ${pid}).StartTime.ToFileTimeUtc()`
+			], {
+				encoding: "utf8",
+				windowsHide: true
+			}).trim();
+			return /^\d+$/.test(out) ? out : null;
+		}
+	} catch {
+		return null;
+	}
+	return null;
+}
+function ownIdentity(platform, env) {
+	return {
+		pid: process.pid,
+		start: startIdentity(process.pid, platform, env)
+	};
+}
+/**
+* Whether the recorded process still runs: dead only when the PID is gone or its start identity differs.
+* Any failure to look up means live, so nothing ever expires a process that merely cannot be inspected.
+*/
+function isLive(identity, platform = process.platform) {
+	try {
+		process.kill(identity.pid, 0);
+	} catch (error) {
+		if (error.code === "ESRCH") return false;
+		return true;
+	}
+	if (identity.start === null) return true;
+	const current = startIdentity(identity.pid, platform);
+	return current === null || current === identity.start;
+}
+//#endregion
+Object.defineProperty(exports, "isLive", {
+	enumerable: true,
+	get: function() {
+		return isLive;
+	}
+});
+Object.defineProperty(exports, "ownIdentity", {
+	enumerable: true,
+	get: function() {
+		return ownIdentity;
+	}
+});
+Object.defineProperty(exports, "powershellPath", {
+	enumerable: true,
+	get: function() {
+		return powershellPath;
+	}
+});
+Object.defineProperty(exports, "proc_exports", {
+	enumerable: true,
+	get: function() {
+		return proc_exports;
+	}
+});
+Object.defineProperty(exports, "shellBinary", {
+	enumerable: true,
+	get: function() {
+		return shellBinary;
+	}
+});

package/dist/runtime/provenance-B4bajGXQ.cjs

@@ -0,0 +1,2 @@
+const require_dispatch = require("./dispatch-B9OSfqsn.cjs");
+exports.verifyBundleHere = require_dispatch.verifyBundleHere;

package/dist/runtime/rolldown-runtime-BGT596CS.cjs

@@ -0,0 +1,64 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res, err) => () => {
+	if (err) throw err[0];
+	try {
+		return fn && (res = fn(fn = 0)), res;
+	} catch (e) {
+		throw err = [e], e;
+	}
+};
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+Object.defineProperty(exports, "__commonJSMin", {
+	enumerable: true,
+	get: function() {
+		return __commonJSMin;
+	}
+});
+Object.defineProperty(exports, "__esmMin", {
+	enumerable: true,
+	get: function() {
+		return __esmMin;
+	}
+});
+Object.defineProperty(exports, "__exportAll", {
+	enumerable: true,
+	get: function() {
+		return __exportAll;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/dist/runtime/runtime.cjs

@@ -0,0 +1,143 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_messages = require("./messages-vUDkl1-0.cjs");
+const require_install = require("./install-C_M5WK98.cjs");
+const require_src = require("./src-SpeGbMJx.cjs");
+let node_child_process = require("node:child_process");
+let node_path = require("node:path");
+//#region src/runtime.ts
+/** The launcher ABI this runtime needs; a launcher runs runtimes of its own ABI or one below (spec RUN-2). */
+const abi = 1;
+/** Entry point `bootstrap.cjs` calls; returns the exit code. */
+async function main(selector, argv, options) {
+	try {
+		if (selector === "cli") {
+			const { run } = await Promise.resolve().then(() => require("./dispatch-B9OSfqsn.cjs"));
+			return await run(argv, {
+				home: options.home,
+				env: process.env
+			});
+		}
+		return await launch(selector, argv, options.home);
+	} catch (error) {
+		if (require_messages.isNpmVmError(error)) {
+			process.stderr.write(`npm-vm: ${error.message}\n`);
+			return error.exitCode;
+		}
+		process.stderr.write(`npm-vm: ${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
+		return require_messages.EXIT.problems;
+	}
+}
+/**
+* Finishes journals left by a crashed command before anything else runs (spec RUN-2, MUT-2).
+* The lock is tried once without waiting: npm must never wait on a setup, and `current` is always runnable.
+*/
+async function recoverLeftovers(home) {
+	const { resolveDirs } = await Promise.resolve().then(() => require("./home-BaoZZSBy.cjs")).then((n) => n.home_exports);
+	const { hasJournals, recoverDeadJournals } = await Promise.resolve().then(() => require("./journal-_bs-eJRJ.cjs")).then((n) => n.journal_exports);
+	const { lockOwnerLive, readLock, tryLock } = await Promise.resolve().then(() => require("./lock-DBeYN-Zg.cjs")).then((n) => n.lock_exports);
+	const { ownerRecord } = await Promise.resolve().then(() => require("./lease-HBD4CmBx.cjs")).then((n) => n.lease_exports);
+	const dirs = resolveDirs(process.env, home);
+	if (!hasJournals(dirs.journal)) return;
+	const owner = ownerRecord(dirs.machine.id);
+	const lock = tryLock(dirs.state, owner);
+	if (lock === null) {
+		const holder = readLock(dirs.state);
+		if (!lockOwnerLive(holder, dirs.machine.id)) process.stderr.write(`npm-vm: ${require_messages.lockedMessage((0, node_path.join)(dirs.state, "lock"), holder, false, false)}\n`);
+		return;
+	}
+	try {
+		const report = recoverDeadJournals(dirs.journal, dirs.machine.id);
+		for (const id of report.changed) process.stderr.write(`npm-vm: ${require_messages.changedMessage(id, "leftover change")}\n`);
+	} finally {
+		lock.release();
+	}
+}
+/** Resolves and runs npm or npx for the current directory (spec RUN-3 to RUN-7). */
+async function launch(selector, argv, home) {
+	const env = process.env;
+	await recoverLeftovers(home);
+	let installer = null;
+	const lazy = () => {
+		installer ??= Promise.resolve().then(() => require("./install-C_M5WK98.cjs")).then((n) => n.install_exports).then((install) => install.createInstaller(install.createContext(env, home)));
+		return installer;
+	};
+	const providers = {
+		nodeVersion: process.version,
+		ownNpm: () => require_install.findOwnNpm(),
+		cached: async (specs) => (await lazy()).cached(specs),
+		registry: async (specs) => (await lazy()).registry(specs),
+		entryPathFor: (candidate) => (0, node_path.join)(home, "pending", candidate.version)
+	};
+	const result = await require_src.resolveNpmWith(argv, process.cwd(), { env }, providers);
+	if (result.warning !== null) process.stderr.write(`npm-vm: ${result.warning}\n`);
+	const script = selector === "npx" ? "npx-cli.js" : "npm-cli.js";
+	if (result.kind === "own" || result.selection === null) return runChild((0, node_path.join)((0, node_path.dirname)(result.cliPath), script), argv, null);
+	const ensured = await (await lazy()).ensure(result.selection);
+	const { createLease, ownerRecord } = await Promise.resolve().then(() => require("./lease-HBD4CmBx.cjs")).then((n) => n.lease_exports);
+	const { startIdentity } = await Promise.resolve().then(() => require("./proc-hB8N9WjN.cjs")).then((n) => n.proc_exports);
+	const { resolveDirs } = await Promise.resolve().then(() => require("./home-BaoZZSBy.cjs")).then((n) => n.home_exports);
+	const machineId = resolveDirs(env, home).machine.id;
+	const leaseForChild = (child) => {
+		const pid = child.pid;
+		return createLease(ensured.entryPath, ownerRecord(machineId, {
+			pid,
+			start: startIdentity(pid)
+		})).release;
+	};
+	return runChild((0, node_path.join)(ensured.entryPath, "bin", script), argv, ensured.lease.release, leaseForChild);
+}
+const FORWARD_NOW = ["SIGTERM", "SIGHUP"];
+const FORWARD_LATER = ["SIGINT", "SIGQUIT"];
+const LATER_DELAY_MS = 1e3;
+function alive(child) {
+	return child.exitCode === null && child.signalCode === null;
+}
+/**
+* Spawns npm with inherited stdio and mirrors its exit (spec RUN-3 to RUN-5).
+* SIGTERM and SIGHUP are forwarded at once; SIGINT and SIGQUIT only if the child outlives them by a second, since a terminal already hit the whole group.
+*/
+function runChild(script, argv, release, onSpawn = null) {
+	return new Promise((resolve) => {
+		const child = (0, node_child_process.spawn)(process.execPath, [script, ...argv], {
+			stdio: "inherit",
+			env: process.env
+		});
+		const releaseChild = child.pid === void 0 ? null : onSpawn?.(child) ?? null;
+		const handlers = [];
+		const timers = [];
+		if (process.platform !== "win32") {
+			for (const signal of FORWARD_NOW) handlers.push([signal, () => child.kill(signal)]);
+			for (const signal of FORWARD_LATER) handlers.push([signal, () => {
+				const timer = setTimeout(() => {
+					if (alive(child)) child.kill(signal);
+				}, LATER_DELAY_MS);
+				timer.unref();
+				timers.push(timer);
+			}]);
+			for (const [signal, handler] of handlers) process.on(signal, handler);
+		}
+		const cleanup = () => {
+			for (const [signal, handler] of handlers) process.removeListener(signal, handler);
+			for (const timer of timers) clearTimeout(timer);
+			releaseChild?.();
+			release?.();
+		};
+		child.on("error", (error) => {
+			cleanup();
+			process.stderr.write(`npm-vm: cannot start ${script}: ${error.message}\n`);
+			resolve(require_messages.EXIT.problems);
+		});
+		child.on("exit", (code, signal) => {
+			cleanup();
+			if (signal !== null) {
+				process.kill(process.pid, signal);
+				return;
+			}
+			resolve(code ?? require_messages.EXIT.problems);
+		});
+	});
+}
+//#endregion
+exports.abi = abi;
+exports.main = main;
+exports.runChild = runChild;