@modulify/conventional-release 0.1.0 → 0.1.2

package/dist/plan.cjs

@@ -0,0 +1,260 @@
+require("./_virtual/_rolldown/runtime.cjs");
+require("./constants.cjs");
+let node_path = require("node:path");
+let _modulify_conventional_git = require("@modulify/conventional-git");
+let _modulify_pkg = require("@modulify/pkg");
+//#region src/plan.ts
+function toScope(scope, cwd) {
+	return {
+		mode: scope.mode,
+		packages: scope.packages.map((pkg) => toScopePackage(pkg, cwd)),
+		affected: scope.affected.map((pkg) => toScopePackage(pkg, cwd)),
+		slices: scope.slices.map((slice) => toSlice(slice, cwd))
+	};
+}
+/** Discovers packages, affected scope, and ordered release slices without side effects. */
+async function discover(runtime, options) {
+	const root = (0, _modulify_pkg.read)(runtime.cwd);
+	const packages = [];
+	await (0, _modulify_pkg.walk)([root], async (pkg) => {
+		packages.push(pkg);
+	});
+	const discovered = sortPackages(uniquePackages(applyWorkspaceFilters(packages, runtime.cwd, options.workspaces)), runtime.cwd);
+	const mode = options.mode ?? "sync";
+	const affectedPaths = mode === "hybrid" ? null : await detectAffectedPackages({
+		cwd: runtime.cwd,
+		root,
+		packages: discovered,
+		history: runtime.history,
+		range: {
+			fromTag: options.fromTag,
+			tagPrefix: options.tagPrefix
+		}
+	});
+	const affected = affectedPaths ? sortPackages(uniquePackages(discovered.filter((pkg) => affectedPaths.has(pkg.path))), runtime.cwd) : [];
+	const slices = mode === "hybrid" ? await createHybridSlices({
+		root,
+		packages: discovered,
+		cwd: runtime.cwd,
+		history: runtime.history,
+		fromTag: options.fromTag,
+		tagPrefix: options.tagPrefix,
+		partitions: options.partitions
+	}) : createSlices({
+		mode,
+		packages: discovered,
+		affected,
+		cwd: runtime.cwd,
+		fromTag: options.fromTag,
+		tagPrefix: options.tagPrefix
+	});
+	return {
+		mode,
+		packages: discovered,
+		affected: mode === "hybrid" ? sortPackages(uniquePackages(slices.flatMap((slice) => slice.packages)), runtime.cwd) : affected,
+		slices
+	};
+}
+function toScopePackage(pkg, cwd) {
+	return {
+		name: pkg.manifest.name ?? pkg.name,
+		version: pkg.manifest.version,
+		path: toPublicPath(pkg, cwd)
+	};
+}
+function toSlice(slice, cwd) {
+	return {
+		id: slice.id,
+		kind: slice.kind,
+		mode: slice.mode,
+		partition: slice.partition,
+		packages: slice.packages.map((pkg) => toScopePackage(pkg, cwd)),
+		range: slice.range
+	};
+}
+function uniquePackages(packages) {
+	const seen = /* @__PURE__ */ new Set();
+	return packages.filter((pkg) => {
+		if (seen.has(pkg.path)) return false;
+		seen.add(pkg.path);
+		return true;
+	});
+}
+function uniqueStrings(values) {
+	return [...new Set(values)];
+}
+function packageIdentity(pkg, cwd) {
+	const name = pkg.manifest.name ?? pkg.name;
+	if (name) return name;
+	const path = packagePath(pkg, cwd);
+	return path === "" || path === "." ? "root" : path;
+}
+function createSlices({ mode, packages, affected, cwd, fromTag, tagPrefix }) {
+	if (mode === "sync") return affected.length ? [{
+		id: "sync:default",
+		kind: "sync",
+		mode: "sync",
+		packages,
+		range: {
+			fromTag,
+			tagPrefix
+		}
+	}] : [];
+	return affected.map((pkg) => ({
+		id: `async:${packageIdentity(pkg, cwd)}`,
+		kind: "async",
+		mode: "async",
+		packages: [pkg],
+		range: {
+			fromTag,
+			tagPrefix
+		}
+	}));
+}
+async function createHybridSlices({ root, packages, cwd, history, fromTag, tagPrefix, partitions }) {
+	const partitionEntries = Object.entries(partitions ?? {}).sort(([a], [b]) => a.localeCompare(b));
+	const partitioned = [];
+	const usedPaths = /* @__PURE__ */ new Set();
+	for (const [partition, definition] of partitionEntries) {
+		const matched = sortPackages(packages.filter((pkg) => {
+			if (usedPaths.has(pkg.path)) return false;
+			return definition.workspaces.some((selector) => matchesPackageSelector(pkg, cwd, selector));
+		}), cwd);
+		for (const pkg of matched) usedPaths.add(pkg.path);
+		const affectedPaths = await detectAffectedPackages({
+			cwd,
+			root,
+			packages: matched,
+			history,
+			range: resolvePartitionRange({
+				fromTag,
+				tagPrefix,
+				partition: definition
+			})
+		});
+		const scoped = matched.filter((pkg) => affectedPaths.has(pkg.path));
+		if (!scoped.length) continue;
+		const resolvedRange = resolvePartitionRange({
+			fromTag,
+			tagPrefix,
+			partition: definition
+		});
+		if (definition.mode === "sync") {
+			partitioned.push({
+				id: `partition:${partition}`,
+				kind: "partition",
+				mode: "sync",
+				partition,
+				packages: scoped,
+				range: resolvedRange
+			});
+			continue;
+		}
+		partitioned.push(...scoped.map((pkg) => ({
+			id: `partition:${partition}:${packageIdentity(pkg, cwd)}`,
+			kind: "partition",
+			mode: "async",
+			partition,
+			packages: [pkg],
+			range: resolvedRange
+		})));
+	}
+	const fallbackCandidates = sortPackages(packages.filter((pkg) => !usedPaths.has(pkg.path)), cwd);
+	const fallbackPaths = await detectAffectedPackages({
+		cwd,
+		root,
+		packages: fallbackCandidates,
+		history,
+		range: {
+			fromTag,
+			tagPrefix
+		}
+	});
+	const fallback = fallbackCandidates.filter((pkg) => fallbackPaths.has(pkg.path)).map((pkg) => ({
+		id: `hybrid:${packageIdentity(pkg, cwd)}`,
+		kind: "async",
+		mode: "async",
+		packages: [pkg],
+		range: {
+			fromTag,
+			tagPrefix
+		}
+	}));
+	return [...partitioned, ...fallback];
+}
+function resolvePartitionRange({ fromTag, tagPrefix, partition }) {
+	return {
+		fromTag: partition.fromTag ?? fromTag,
+		tagPrefix: partition.tagPrefix ?? tagPrefix
+	};
+}
+async function detectAffectedPackages({ cwd, root, packages, history, range }) {
+	const touched = await readCommitRangePaths(history, range);
+	if (touched === null) return new Set(packages.map((pkg) => pkg.path));
+	if (!touched.length) return /* @__PURE__ */ new Set();
+	const normalizedRoot = normalizePath((0, node_path.relative)(cwd, root.path));
+	const children = packages.filter((pkg) => pkg.path !== root.path).map((pkg) => ({
+		packagePath: pkg.path,
+		relativePath: normalizePath((0, node_path.relative)(cwd, pkg.path))
+	})).sort((a, b) => b.relativePath.length - a.relativePath.length);
+	const affected = /* @__PURE__ */ new Set();
+	for (const path of touched.map(normalizePath)) {
+		if (!isPathInside(path, normalizedRoot)) continue;
+		const child = children.find((entry) => isPathInside(path, entry.relativePath));
+		affected.add(child?.packagePath ?? root.path);
+	}
+	return affected;
+}
+function applyWorkspaceFilters(packages, cwd, selector) {
+	if (!selector?.include?.length && !selector?.exclude?.length) return packages;
+	return packages.filter((pkg) => {
+		if (!(selector.include?.length ? selector.include.some((entry) => matchesPackageSelector(pkg, cwd, entry)) : true)) return false;
+		return !(selector.exclude?.some((entry) => matchesPackageSelector(pkg, cwd, entry)) ?? false);
+	});
+}
+function sortPackages(packages, cwd) {
+	return [...packages].sort((a, b) => packagePath(a, cwd).localeCompare(packagePath(b, cwd)));
+}
+function packagePath(pkg, cwd) {
+	return normalizePath((0, node_path.relative)(cwd, pkg.path));
+}
+function toPublicPath(pkg, cwd) {
+	return packagePath(pkg, cwd) || ".";
+}
+function matchesPackageSelector(pkg, cwd, selector) {
+	const name = pkg.manifest.name ?? pkg.name ?? "";
+	const path = packagePath(pkg, cwd);
+	return matchesGlob(name, selector) || matchesGlob(path, selector);
+}
+function matchesGlob(input, pattern) {
+	if (!pattern) return false;
+	if (pattern === "*") return true;
+	const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "__DOUBLE_STAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLE_STAR__/g, ".*");
+	return new RegExp(`^${escaped}$`).test(input);
+}
+async function readCommitRangePaths(history, range) {
+	try {
+		return (await history.traverse({
+			fromTag: range.fromTag,
+			tagPrefix: range.tagPrefix,
+			changeset: true,
+			traversers: [(0, _modulify_conventional_git.createChangesetTraverser)()]
+		})).results.get("changeset").paths;
+	} catch {
+		return null;
+	}
+}
+function normalizePath(path) {
+	return path.replace(/\\/g, "/");
+}
+function isPathInside(path, root) {
+	return !root || root === "." || root === path || path.startsWith(`${root}/`);
+}
+//#endregion
+exports.discover = discover;
+exports.packageIdentity = packageIdentity;
+exports.toScope = toScope;
+exports.toScopePackage = toScopePackage;
+exports.toSlice = toSlice;
+exports.uniquePackages = uniquePackages;
+exports.uniqueStrings = uniqueStrings;

package/dist/plan.mjs

@@ -0,0 +1,253 @@
+import "./constants.mjs";
+import { relative } from "node:path";
+import { createChangesetTraverser } from "@modulify/conventional-git";
+import { read, walk } from "@modulify/pkg";
+//#region src/plan.ts
+function toScope(scope, cwd) {
+	return {
+		mode: scope.mode,
+		packages: scope.packages.map((pkg) => toScopePackage(pkg, cwd)),
+		affected: scope.affected.map((pkg) => toScopePackage(pkg, cwd)),
+		slices: scope.slices.map((slice) => toSlice(slice, cwd))
+	};
+}
+/** Discovers packages, affected scope, and ordered release slices without side effects. */
+async function discover(runtime, options) {
+	const root = read(runtime.cwd);
+	const packages = [];
+	await walk([root], async (pkg) => {
+		packages.push(pkg);
+	});
+	const discovered = sortPackages(uniquePackages(applyWorkspaceFilters(packages, runtime.cwd, options.workspaces)), runtime.cwd);
+	const mode = options.mode ?? "sync";
+	const affectedPaths = mode === "hybrid" ? null : await detectAffectedPackages({
+		cwd: runtime.cwd,
+		root,
+		packages: discovered,
+		history: runtime.history,
+		range: {
+			fromTag: options.fromTag,
+			tagPrefix: options.tagPrefix
+		}
+	});
+	const affected = affectedPaths ? sortPackages(uniquePackages(discovered.filter((pkg) => affectedPaths.has(pkg.path))), runtime.cwd) : [];
+	const slices = mode === "hybrid" ? await createHybridSlices({
+		root,
+		packages: discovered,
+		cwd: runtime.cwd,
+		history: runtime.history,
+		fromTag: options.fromTag,
+		tagPrefix: options.tagPrefix,
+		partitions: options.partitions
+	}) : createSlices({
+		mode,
+		packages: discovered,
+		affected,
+		cwd: runtime.cwd,
+		fromTag: options.fromTag,
+		tagPrefix: options.tagPrefix
+	});
+	return {
+		mode,
+		packages: discovered,
+		affected: mode === "hybrid" ? sortPackages(uniquePackages(slices.flatMap((slice) => slice.packages)), runtime.cwd) : affected,
+		slices
+	};
+}
+function toScopePackage(pkg, cwd) {
+	return {
+		name: pkg.manifest.name ?? pkg.name,
+		version: pkg.manifest.version,
+		path: toPublicPath(pkg, cwd)
+	};
+}
+function toSlice(slice, cwd) {
+	return {
+		id: slice.id,
+		kind: slice.kind,
+		mode: slice.mode,
+		partition: slice.partition,
+		packages: slice.packages.map((pkg) => toScopePackage(pkg, cwd)),
+		range: slice.range
+	};
+}
+function uniquePackages(packages) {
+	const seen = /* @__PURE__ */ new Set();
+	return packages.filter((pkg) => {
+		if (seen.has(pkg.path)) return false;
+		seen.add(pkg.path);
+		return true;
+	});
+}
+function uniqueStrings(values) {
+	return [...new Set(values)];
+}
+function packageIdentity(pkg, cwd) {
+	const name = pkg.manifest.name ?? pkg.name;
+	if (name) return name;
+	const path = packagePath(pkg, cwd);
+	return path === "" || path === "." ? "root" : path;
+}
+function createSlices({ mode, packages, affected, cwd, fromTag, tagPrefix }) {
+	if (mode === "sync") return affected.length ? [{
+		id: "sync:default",
+		kind: "sync",
+		mode: "sync",
+		packages,
+		range: {
+			fromTag,
+			tagPrefix
+		}
+	}] : [];
+	return affected.map((pkg) => ({
+		id: `async:${packageIdentity(pkg, cwd)}`,
+		kind: "async",
+		mode: "async",
+		packages: [pkg],
+		range: {
+			fromTag,
+			tagPrefix
+		}
+	}));
+}
+async function createHybridSlices({ root, packages, cwd, history, fromTag, tagPrefix, partitions }) {
+	const partitionEntries = Object.entries(partitions ?? {}).sort(([a], [b]) => a.localeCompare(b));
+	const partitioned = [];
+	const usedPaths = /* @__PURE__ */ new Set();
+	for (const [partition, definition] of partitionEntries) {
+		const matched = sortPackages(packages.filter((pkg) => {
+			if (usedPaths.has(pkg.path)) return false;
+			return definition.workspaces.some((selector) => matchesPackageSelector(pkg, cwd, selector));
+		}), cwd);
+		for (const pkg of matched) usedPaths.add(pkg.path);
+		const affectedPaths = await detectAffectedPackages({
+			cwd,
+			root,
+			packages: matched,
+			history,
+			range: resolvePartitionRange({
+				fromTag,
+				tagPrefix,
+				partition: definition
+			})
+		});
+		const scoped = matched.filter((pkg) => affectedPaths.has(pkg.path));
+		if (!scoped.length) continue;
+		const resolvedRange = resolvePartitionRange({
+			fromTag,
+			tagPrefix,
+			partition: definition
+		});
+		if (definition.mode === "sync") {
+			partitioned.push({
+				id: `partition:${partition}`,
+				kind: "partition",
+				mode: "sync",
+				partition,
+				packages: scoped,
+				range: resolvedRange
+			});
+			continue;
+		}
+		partitioned.push(...scoped.map((pkg) => ({
+			id: `partition:${partition}:${packageIdentity(pkg, cwd)}`,
+			kind: "partition",
+			mode: "async",
+			partition,
+			packages: [pkg],
+			range: resolvedRange
+		})));
+	}
+	const fallbackCandidates = sortPackages(packages.filter((pkg) => !usedPaths.has(pkg.path)), cwd);
+	const fallbackPaths = await detectAffectedPackages({
+		cwd,
+		root,
+		packages: fallbackCandidates,
+		history,
+		range: {
+			fromTag,
+			tagPrefix
+		}
+	});
+	const fallback = fallbackCandidates.filter((pkg) => fallbackPaths.has(pkg.path)).map((pkg) => ({
+		id: `hybrid:${packageIdentity(pkg, cwd)}`,
+		kind: "async",
+		mode: "async",
+		packages: [pkg],
+		range: {
+			fromTag,
+			tagPrefix
+		}
+	}));
+	return [...partitioned, ...fallback];
+}
+function resolvePartitionRange({ fromTag, tagPrefix, partition }) {
+	return {
+		fromTag: partition.fromTag ?? fromTag,
+		tagPrefix: partition.tagPrefix ?? tagPrefix
+	};
+}
+async function detectAffectedPackages({ cwd, root, packages, history, range }) {
+	const touched = await readCommitRangePaths(history, range);
+	if (touched === null) return new Set(packages.map((pkg) => pkg.path));
+	if (!touched.length) return /* @__PURE__ */ new Set();
+	const normalizedRoot = normalizePath(relative(cwd, root.path));
+	const children = packages.filter((pkg) => pkg.path !== root.path).map((pkg) => ({
+		packagePath: pkg.path,
+		relativePath: normalizePath(relative(cwd, pkg.path))
+	})).sort((a, b) => b.relativePath.length - a.relativePath.length);
+	const affected = /* @__PURE__ */ new Set();
+	for (const path of touched.map(normalizePath)) {
+		if (!isPathInside(path, normalizedRoot)) continue;
+		const child = children.find((entry) => isPathInside(path, entry.relativePath));
+		affected.add(child?.packagePath ?? root.path);
+	}
+	return affected;
+}
+function applyWorkspaceFilters(packages, cwd, selector) {
+	if (!selector?.include?.length && !selector?.exclude?.length) return packages;
+	return packages.filter((pkg) => {
+		if (!(selector.include?.length ? selector.include.some((entry) => matchesPackageSelector(pkg, cwd, entry)) : true)) return false;
+		return !(selector.exclude?.some((entry) => matchesPackageSelector(pkg, cwd, entry)) ?? false);
+	});
+}
+function sortPackages(packages, cwd) {
+	return [...packages].sort((a, b) => packagePath(a, cwd).localeCompare(packagePath(b, cwd)));
+}
+function packagePath(pkg, cwd) {
+	return normalizePath(relative(cwd, pkg.path));
+}
+function toPublicPath(pkg, cwd) {
+	return packagePath(pkg, cwd) || ".";
+}
+function matchesPackageSelector(pkg, cwd, selector) {
+	const name = pkg.manifest.name ?? pkg.name ?? "";
+	const path = packagePath(pkg, cwd);
+	return matchesGlob(name, selector) || matchesGlob(path, selector);
+}
+function matchesGlob(input, pattern) {
+	if (!pattern) return false;
+	if (pattern === "*") return true;
+	const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "__DOUBLE_STAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLE_STAR__/g, ".*");
+	return new RegExp(`^${escaped}$`).test(input);
+}
+async function readCommitRangePaths(history, range) {
+	try {
+		return (await history.traverse({
+			fromTag: range.fromTag,
+			tagPrefix: range.tagPrefix,
+			changeset: true,
+			traversers: [createChangesetTraverser()]
+		})).results.get("changeset").paths;
+	} catch {
+		return null;
+	}
+}
+function normalizePath(path) {
+	return path.replace(/\\/g, "/");
+}
+function isPathInside(path, root) {
+	return !root || root === "." || root === path || path.startsWith(`${root}/`);
+}
+//#endregion
+export { discover, packageIdentity, toScope, toScopePackage, toSlice, uniquePackages, uniqueStrings };

package/dist/reporter.cjs

@@ -0,0 +1,33 @@
+//#region src/reporter.ts
+function createRunContext({ cwd, dry }) {
+	return {
+		cwd,
+		dry
+	};
+}
+async function reportStart(reporter, context) {
+	await reporter?.onStart?.(context);
+}
+async function reportScope(reporter, scope, context) {
+	await reporter?.onScope?.(scope, context);
+}
+async function reportSliceStart(reporter, slice, context) {
+	await reporter?.onSliceStart?.(slice, context);
+}
+async function reportSliceSuccess(reporter, slice, context) {
+	await reporter?.onSliceSuccess?.(slice, context);
+}
+async function reportSuccess(reporter, result, context) {
+	await reporter?.onSuccess?.(result, context);
+}
+async function reportError(reporter, error, context) {
+	await reporter?.onError?.(error, context);
+}
+//#endregion
+exports.createRunContext = createRunContext;
+exports.reportError = reportError;
+exports.reportScope = reportScope;
+exports.reportSliceStart = reportSliceStart;
+exports.reportSliceSuccess = reportSliceSuccess;
+exports.reportStart = reportStart;
+exports.reportSuccess = reportSuccess;

package/dist/reporter.mjs

@@ -0,0 +1,27 @@
+//#region src/reporter.ts
+function createRunContext({ cwd, dry }) {
+	return {
+		cwd,
+		dry
+	};
+}
+async function reportStart(reporter, context) {
+	await reporter?.onStart?.(context);
+}
+async function reportScope(reporter, scope, context) {
+	await reporter?.onScope?.(scope, context);
+}
+async function reportSliceStart(reporter, slice, context) {
+	await reporter?.onSliceStart?.(slice, context);
+}
+async function reportSliceSuccess(reporter, slice, context) {
+	await reporter?.onSliceSuccess?.(slice, context);
+}
+async function reportSuccess(reporter, result, context) {
+	await reporter?.onSuccess?.(result, context);
+}
+async function reportError(reporter, error, context) {
+	await reporter?.onError?.(error, context);
+}
+//#endregion
+export { createRunContext, reportError, reportScope, reportSliceStart, reportSliceSuccess, reportStart, reportSuccess };

package/dist/runtime.cjs

@@ -0,0 +1,68 @@
+require("./_virtual/_rolldown/runtime.cjs");
+const require_constants = require("./constants.cjs");
+let _modulify_git_toolkit = require("@modulify/git-toolkit");
+let _modulify_git_toolkit_shell = require("@modulify/git-toolkit/shell");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let _modulify_conventional_git = require("@modulify/conventional-git");
+let _modulify_conventional_changelog = require("@modulify/conventional-changelog");
+//#region src/runtime.ts
+/** Creates the default runtime used by the public planning and release APIs. */
+function createRuntime({ cwd = process.cwd(), dry = false, changelogFile = require_constants.DEFAULT_CHANGELOG_FILE } = {}) {
+	const sh = new _modulify_git_toolkit_shell.Runner(cwd);
+	return {
+		cwd,
+		dry,
+		changelogFile,
+		packageManager: resolvePackageManager(cwd),
+		history: new _modulify_conventional_git.Client({ cwd }),
+		writeChangelog: (changes) => (0, _modulify_conventional_changelog.writeChangelog)(changes, { file: dry ? void 0 : (0, node_path.join)(cwd, changelogFile) }),
+		sh,
+		git: createGit(sh)
+	};
+}
+function createGit(sh) {
+	const git = new _modulify_git_toolkit.GitCommander({ sh });
+	return {
+		add: (files) => git.add(files),
+		commit: (options) => git.commit(options),
+		tag: (options) => git.tag(options)
+	};
+}
+function resolvePackageManager(cwd) {
+	const command = readPackageManager(cwd) ?? inferPackageManagerFromLockfile(cwd) ?? "npm";
+	return {
+		command,
+		lockfile: resolveLockfile(cwd, command)
+	};
+}
+function readPackageManager(cwd) {
+	const file = (0, node_path.join)(cwd, "package.json");
+	if (!(0, node_fs.existsSync)(file)) return null;
+	const content = JSON.parse((0, node_fs.readFileSync)(file, "utf-8"));
+	if (typeof content.packageManager !== "string" || content.packageManager === "") return null;
+	const [name] = content.packageManager.split("@");
+	return isPackageManagerName(name) ? name : null;
+}
+function inferPackageManagerFromLockfile(cwd) {
+	if ((0, node_fs.existsSync)((0, node_path.join)(cwd, "yarn.lock"))) return "yarn";
+	if ((0, node_fs.existsSync)((0, node_path.join)(cwd, "pnpm-lock.yaml"))) return "pnpm";
+	if ((0, node_fs.existsSync)((0, node_path.join)(cwd, "package-lock.json"))) return "npm";
+	if ((0, node_fs.existsSync)((0, node_path.join)(cwd, "bun.lock"))) return "bun";
+	if ((0, node_fs.existsSync)((0, node_path.join)(cwd, "bun.lockb"))) return "bun";
+	return null;
+}
+function resolveLockfile(cwd, command) {
+	if (command === "bun" && (0, node_fs.existsSync)((0, node_path.join)(cwd, "bun.lockb"))) return "bun.lockb";
+	return {
+		yarn: "yarn.lock",
+		pnpm: "pnpm-lock.yaml",
+		npm: "package-lock.json",
+		bun: "bun.lock"
+	}[command];
+}
+function isPackageManagerName(value) {
+	return value === "yarn" || value === "pnpm" || value === "npm" || value === "bun";
+}
+//#endregion
+exports.createRuntime = createRuntime;