@modulify/conventional-release 0.1.0 → 0.1.2

package/dist/cli/reporter.mjs

@@ -0,0 +1,127 @@
+//#region src/cli/reporter.ts
+function createReporter({ output, git, showTags = false, verbosity = "summary" }) {
+	if (verbosity === "detailed") return new DetailedReporter({
+		output,
+		git,
+		showTags
+	});
+	return new SummaryReporter({
+		output,
+		git,
+		showTags
+	});
+}
+var SummaryReporter = class {
+	output;
+	git;
+	showTags;
+	scope = null;
+	position = /* @__PURE__ */ new Map();
+	constructor({ output, git, showTags }) {
+		this.output = output;
+		this.git = git;
+		this.showTags = showTags;
+	}
+	async onStart(context) {
+		this.output.info(context.dry ? "Starting dry release" : "Starting release");
+	}
+	async onScope(scope, context) {
+		this.scope = scope;
+		this.position = new Map(scope.slices.map((slice, index) => [slice.id, index + 1]));
+	}
+	async onSliceStart(slice) {
+		this.output.info("Running slice %s", [this.describeProgress(slice)]);
+	}
+	async onSuccess(result) {
+		if (!result.changed) {
+			this.output.success("No changes since last release");
+			return;
+		}
+		const changed = result.slices.filter((slice) => slice.changed);
+		const primary = changed[0];
+		const packages = collectPackages(changed);
+		this.output.success("Release slices: %s", [String(changed.length)]);
+		this.output.success("Updated packages: %s", [String(packages.length)]);
+		if (primary) this.output.success("Next version: %s", [primary.nextVersion]);
+		if (result.dry) {
+			this.output.info("No committing or tagging since this was a dry run");
+			return;
+		}
+		this.output.success("Committed %s staged files", [String(result.files.length)]);
+		if (this.showTags) {
+			const tags = collectTags(changed);
+			if (tags.length) this.output.success("Tags: %s", [tags.join(", ")]);
+		}
+		this.output.info("Run `%s` to publish", [`git push --follow-tags origin ${await this.resolveBranch()}`]);
+	}
+	async onError(error) {
+		const message = error instanceof Error ? error.message : String(error);
+		this.output.error(message);
+	}
+	describeProgress(slice) {
+		const position = this.position.get(slice.id);
+		const total = this.scope?.slices.length;
+		const label = describeSlice(slice);
+		return position && total ? `${position}/${total}: ${label}` : label;
+	}
+	async resolveBranch() {
+		try {
+			return await this.git.revParse("HEAD", { abbrevRef: true });
+		} catch {
+			return "%branch%";
+		}
+	}
+};
+var DetailedReporter = class extends SummaryReporter {
+	async onScope(scope, context) {
+		await super.onScope(scope, context);
+		this.output.info("%s scope: %s packages, %s affected, %s slices", [
+			scope.mode,
+			String(scope.packages.length),
+			String(scope.affected.length),
+			String(scope.slices.length)
+		]);
+	}
+	async onSliceSuccess(slice) {
+		if (!slice.changed) {
+			this.output.warn("Completed slice %s without version changes (%s)", [describeSlice(slice), slice.currentVersion]);
+			return;
+		}
+		this.output.success("Completed slice %s: %s -> %s (%s)", [
+			describeSlice(slice),
+			slice.currentVersion,
+			slice.nextVersion,
+			slice.releaseType
+		]);
+		if (this.showTags && slice.tag) this.output.info("Tag: %s", [slice.tag]);
+	}
+	async onSuccess(result) {
+		await super.onSuccess(result);
+		if (!result.changed) return;
+		const packages = collectPackages(result.slices.filter((slice) => slice.changed));
+		this.output.info("Updated packages: %s", [describePackages(packages)]);
+	}
+};
+function describeSlice(slice) {
+	if (slice.partition) return `${slice.partition} [${describePackages(slice.packages)}]`;
+	return describePackages(slice.packages);
+}
+function describePackages(packages) {
+	return packages.map((pkg) => pkg.name ?? pkg.path).join(", ");
+}
+function collectTags(slices) {
+	return slices.map((slice) => slice.tag).filter((tag) => !!tag);
+}
+function collectPackages(slices) {
+	const packages = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const slice of slices) for (const pkg of slice.packages) {
+		const identity = pkg.name ?? pkg.path;
+		if (seen.has(identity)) continue;
+		seen.add(identity);
+		packages.push(pkg);
+	}
+	return packages;
+}
+//#endregion
+export { createReporter };

package/dist/config.cjs

@@ -0,0 +1,54 @@
+require("./_virtual/_rolldown/runtime.cjs");
+const require_constants = require("./constants.cjs");
+let node_fs = require("node:fs");
+let node_path = require("node:path");
+let node_url = require("node:url");
+//#region src/config.ts
+/**
+* Resolves repository release configuration from `package.json`, `release.config.*`,
+* and inline overrides using the public precedence rules.
+*/
+async function resolveConfig(cwd, inline) {
+	const root = cwd ?? process.cwd();
+	const fromPackage = loadPackageJsonConfig(root);
+	const fromFile = await loadFileConfig(root);
+	return {
+		...fromPackage,
+		...fromFile,
+		...inline ?? {}
+	};
+}
+/** Converts repository configuration to executor-ready release options. */
+function toScopeOptions(config) {
+	const options = { ...config };
+	delete options.changelogFile;
+	return options;
+}
+/** Extracts inline overrides from high-level run options. */
+function toInlineConfig(options) {
+	const config = { ...options };
+	delete config.cwd;
+	delete config.dry;
+	delete config.reporter;
+	return config;
+}
+function loadPackageJsonConfig(cwd) {
+	const file = (0, node_path.join)(cwd, "package.json");
+	if (!(0, node_fs.existsSync)(file)) return {};
+	const content = JSON.parse((0, node_fs.readFileSync)(file, "utf-8"));
+	return isRecord(content.release) ? content.release : {};
+}
+async function loadFileConfig(cwd) {
+	const configFile = require_constants.RELEASE_CONFIG_FILENAMES.map((file) => (0, node_path.join)(cwd, file)).find((file) => (0, node_fs.existsSync)(file));
+	if (!configFile) return {};
+	const module = await import((0, node_url.pathToFileURL)(configFile).href);
+	const config = module.default ?? module;
+	return isRecord(config) ? config : {};
+}
+function isRecord(value) {
+	return !!value && typeof value === "object";
+}
+//#endregion
+exports.resolveConfig = resolveConfig;
+exports.toInlineConfig = toInlineConfig;
+exports.toScopeOptions = toScopeOptions;

package/dist/config.mjs

@@ -0,0 +1,51 @@
+import { RELEASE_CONFIG_FILENAMES } from "./constants.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+//#region src/config.ts
+/**
+* Resolves repository release configuration from `package.json`, `release.config.*`,
+* and inline overrides using the public precedence rules.
+*/
+async function resolveConfig(cwd, inline) {
+	const root = cwd ?? process.cwd();
+	const fromPackage = loadPackageJsonConfig(root);
+	const fromFile = await loadFileConfig(root);
+	return {
+		...fromPackage,
+		...fromFile,
+		...inline ?? {}
+	};
+}
+/** Converts repository configuration to executor-ready release options. */
+function toScopeOptions(config) {
+	const options = { ...config };
+	delete options.changelogFile;
+	return options;
+}
+/** Extracts inline overrides from high-level run options. */
+function toInlineConfig(options) {
+	const config = { ...options };
+	delete config.cwd;
+	delete config.dry;
+	delete config.reporter;
+	return config;
+}
+function loadPackageJsonConfig(cwd) {
+	const file = join(cwd, "package.json");
+	if (!existsSync(file)) return {};
+	const content = JSON.parse(readFileSync(file, "utf-8"));
+	return isRecord(content.release) ? content.release : {};
+}
+async function loadFileConfig(cwd) {
+	const configFile = RELEASE_CONFIG_FILENAMES.map((file) => join(cwd, file)).find((file) => existsSync(file));
+	if (!configFile) return {};
+	const module = await import(pathToFileURL(configFile).href);
+	const config = module.default ?? module;
+	return isRecord(config) ? config : {};
+}
+function isRecord(value) {
+	return !!value && typeof value === "object";
+}
+//#endregion
+export { resolveConfig, toInlineConfig, toScopeOptions };

package/dist/constants.cjs

@@ -0,0 +1,16 @@
+//#region src/constants.ts
+var DEFAULT_CHANGELOG_FILE = "CHANGELOG.md";
+var DEFAULT_RELEASE_PREFIX = "chore(release): ";
+var DEFAULT_RELEASE_MODE = "sync";
+var DEFAULT_DEPENDENCY_POLICY_INTERNAL = "preserve";
+var RELEASE_CONFIG_FILENAMES = [
+	"release.config.ts",
+	"release.config.mjs",
+	"release.config.js"
+];
+//#endregion
+exports.DEFAULT_CHANGELOG_FILE = DEFAULT_CHANGELOG_FILE;
+exports.DEFAULT_DEPENDENCY_POLICY_INTERNAL = DEFAULT_DEPENDENCY_POLICY_INTERNAL;
+exports.DEFAULT_RELEASE_MODE = DEFAULT_RELEASE_MODE;
+exports.DEFAULT_RELEASE_PREFIX = DEFAULT_RELEASE_PREFIX;
+exports.RELEASE_CONFIG_FILENAMES = RELEASE_CONFIG_FILENAMES;

package/dist/constants.mjs

@@ -0,0 +1,12 @@
+//#region src/constants.ts
+var DEFAULT_CHANGELOG_FILE = "CHANGELOG.md";
+var DEFAULT_RELEASE_PREFIX = "chore(release): ";
+var DEFAULT_RELEASE_MODE = "sync";
+var DEFAULT_DEPENDENCY_POLICY_INTERNAL = "preserve";
+var RELEASE_CONFIG_FILENAMES = [
+	"release.config.ts",
+	"release.config.mjs",
+	"release.config.js"
+];
+//#endregion
+export { DEFAULT_CHANGELOG_FILE, DEFAULT_DEPENDENCY_POLICY_INTERNAL, DEFAULT_RELEASE_MODE, DEFAULT_RELEASE_PREFIX, RELEASE_CONFIG_FILENAMES };

package/dist/execute.cjs

@@ -0,0 +1,192 @@
+const require_runtime = require("./_virtual/_rolldown/runtime.cjs");
+const require_reporter = require("./reporter.cjs");
+const require_constants = require("./constants.cjs");
+const require_plan = require("./plan.cjs");
+let node_path = require("node:path");
+let _modulify_conventional_changelog = require("@modulify/conventional-changelog");
+let _modulify_pkg = require("@modulify/pkg");
+let _modulify_conventional_bump = require("@modulify/conventional-bump");
+let semver = require("semver");
+semver = require_runtime.__toESM(semver, 1);
+//#region src/execute.ts
+async function runScope(runtime, scope, options, reporting) {
+	const slices = [];
+	for (const slice of scope.slices) {
+		if (reporting) await require_reporter.reportSliceStart(reporting.reporter, require_plan.toSlice(slice, runtime.cwd), reporting.context);
+		const result = await executeSlice(runtime, slice, options);
+		if (reporting) await require_reporter.reportSliceSuccess(reporting.reporter, result, reporting.context);
+		slices.push(result);
+	}
+	const files = require_plan.uniqueStrings(slices.flatMap((slice) => slice.files));
+	const changed = slices.some((slice) => slice.changed);
+	return {
+		mode: scope.mode,
+		changed,
+		dry: runtime.dry,
+		packages: scope.packages.map((pkg) => require_plan.toScopePackage(pkg, runtime.cwd)),
+		affected: scope.affected.map((pkg) => require_plan.toScopePackage(pkg, runtime.cwd)),
+		slices,
+		files
+	};
+}
+async function executeSlice(runtime, slice, options) {
+	const normalizedSlice = {
+		...slice,
+		packages: require_plan.uniquePackages(slice.packages)
+	};
+	const currentVersion = resolveSliceCurrentVersion(normalizedSlice, runtime.cwd);
+	const releaseMeta = await collectSliceMeta(runtime, normalizedSlice);
+	const release = (0, _modulify_conventional_bump.resolveNextVersion)(currentVersion, {
+		recommendation: releaseMeta.recommendation,
+		type: options.releaseAs,
+		prerelease: options.prerelease,
+		preMajor: options.releaseAs ? false : options.preMajor ?? isPreMajorVersion(currentVersion)
+	});
+	const releaseType = String(release.type);
+	const nextVersion = release.version;
+	const base = require_plan.toSlice(normalizedSlice, runtime.cwd);
+	if (nextVersion === currentVersion) return {
+		...base,
+		currentVersion,
+		nextVersion,
+		releaseType,
+		changed: false,
+		dry: runtime.dry,
+		files: []
+	};
+	const files = await applySlice(runtime, normalizedSlice, nextVersion, options, (0, _modulify_conventional_changelog.renderChangelog)(nextVersion, {
+		notes: releaseMeta.notes,
+		url: await runtime.history.url()
+	}));
+	const context = createTagContext(normalizedSlice, nextVersion, releaseType, runtime.cwd);
+	const tag = options.tagName ? options.tagName(context) : createDefaultTagName(normalizedSlice, nextVersion, runtime.cwd);
+	if (runtime.dry) return {
+		...base,
+		currentVersion,
+		nextVersion,
+		releaseType,
+		changed: true,
+		dry: true,
+		tag,
+		files
+	};
+	const messageContext = {
+		...context,
+		tag
+	};
+	const commitMessage = options.commitMessage ? options.commitMessage(messageContext) : require_constants.DEFAULT_RELEASE_PREFIX + tag;
+	const tagMessage = options.tagMessage ? options.tagMessage(messageContext) : require_constants.DEFAULT_RELEASE_PREFIX + tag;
+	await runtime.git.add(files);
+	await runtime.git.commit({
+		files,
+		message: commitMessage
+	});
+	await runtime.git.tag({
+		name: tag,
+		message: tagMessage
+	});
+	return {
+		...base,
+		currentVersion,
+		nextVersion,
+		releaseType,
+		changed: true,
+		dry: false,
+		files,
+		tag,
+		commitMessage,
+		tagMessage
+	};
+}
+async function applySlice(runtime, slice, nextVersion, options, changes) {
+	const bumpedPackageNames = slice.packages.reduce((all, pkg) => {
+		const name = pkg.manifest.name ?? pkg.name;
+		if (name) all.add(name);
+		return all;
+	}, /* @__PURE__ */ new Set());
+	const dependencyPolicy = options.dependencyPolicy ?? "preserve";
+	const files = [];
+	for (const pkg of slice.packages) {
+		const diff = { version: nextVersion };
+		const manifest = pkg.manifest;
+		if (hasDependencies(manifest.peerDependencies)) diff.peerDependencies = actualizeDependencies(manifest.peerDependencies, nextVersion, bumpedPackageNames, dependencyPolicy);
+		if (hasDependencies(manifest.dependencies)) diff.dependencies = actualizeDependencies(manifest.dependencies, nextVersion, bumpedPackageNames, dependencyPolicy);
+		if (hasDependencies(manifest.optionalDependencies)) diff.optionalDependencies = actualizeDependencies(manifest.optionalDependencies, nextVersion, bumpedPackageNames, dependencyPolicy);
+		if (hasDependencies(manifest.devDependencies)) diff.devDependencies = actualizeDependencies(manifest.devDependencies, nextVersion, bumpedPackageNames, dependencyPolicy);
+		files.push((0, node_path.relative)(runtime.cwd, (0, _modulify_pkg.update)(pkg.path, diff, runtime.dry)));
+	}
+	const installArgs = resolveInstallArgs(runtime, options.install);
+	if (!runtime.dry && installArgs) await runtime.sh.exec(runtime.packageManager.command, ["install", ...installArgs]);
+	if (!runtime.dry) await runtime.writeChangelog(changes);
+	files.push((0, node_path.relative)(runtime.cwd, (0, node_path.join)(runtime.cwd, runtime.packageManager.lockfile)));
+	files.push((0, node_path.relative)(runtime.cwd, (0, node_path.join)(runtime.cwd, runtime.changelogFile)));
+	return require_plan.uniqueStrings(files);
+}
+async function collectSliceMeta(runtime, slice) {
+	const result = await runtime.history.traverse({
+		...slice.range,
+		traversers: [(0, _modulify_conventional_bump.createRecommendationAnalyzer)({ strict: true }), (0, _modulify_conventional_changelog.createChangelogCapacitor)()]
+	});
+	return {
+		recommendation: result.results.get("recommendation"),
+		notes: result.results.get("changelog")
+	};
+}
+function resolveInstallArgs(runtime, install) {
+	if (install === false) return null;
+	if (Array.isArray(install)) return install;
+	if (runtime.packageManager.command === "yarn") return ["--no-immutable"];
+	return [];
+}
+function createTagContext(slice, version, releaseType, cwd) {
+	return {
+		id: slice.id,
+		kind: slice.kind,
+		mode: slice.mode,
+		partition: slice.partition,
+		packages: slice.packages.map((pkg) => require_plan.toScopePackage(pkg, cwd)),
+		version,
+		releaseType
+	};
+}
+function resolveSliceCurrentVersion(slice, cwd) {
+	const versions = require_plan.uniqueStrings(slice.packages.map((pkg) => pkg.manifest.version ?? "0.0.0"));
+	if (slice.mode === "sync" && versions.length > 1) {
+		const packageList = slice.packages.map((pkg) => require_plan.packageIdentity(pkg, cwd)).join(", ");
+		throw new Error(`Sync release slice "${slice.id}" requires aligned package versions: ${packageList}`);
+	}
+	return versions[0];
+}
+function isPreMajorVersion(version) {
+	return semver.default.valid(version) ? semver.default.lt(version, "1.0.0") : false;
+}
+function createDefaultTagName(slice, version, cwd) {
+	if (slice.kind === "sync") return `v${version}`;
+	if (slice.partition) return `${slice.partition}@${version}`;
+	return `${require_plan.packageIdentity(slice.packages[0], cwd)}@${version}`;
+}
+function hasDependencies(dependencies) {
+	return !!dependencies && Object.keys(dependencies).length > 0;
+}
+function actualizeDependencies(dependencies, nextVersion, bumpedPackages, internalPolicy) {
+	return Object.keys(dependencies).reduce((all, name) => ({
+		...all,
+		[name]: bumpedPackages.has(name) ? updateDependencyRange(dependencies[name], nextVersion, internalPolicy) : dependencies[name]
+	}), {});
+}
+function updateDependencyRange(current, nextVersion, policy) {
+	if (policy === "caret") return "^" + nextVersion;
+	if (policy === "exact") return nextVersion;
+	if (current.startsWith("workspace:")) {
+		const value = current.slice(10);
+		if (value === "*") return "workspace:*";
+		if (value.startsWith("^")) return `workspace:^${nextVersion}`;
+		if (value.startsWith("~")) return `workspace:~${nextVersion}`;
+		return `workspace:${nextVersion}`;
+	}
+	if (current.startsWith("^")) return "^" + nextVersion;
+	if (current.startsWith("~")) return "~" + nextVersion;
+	return nextVersion;
+}
+//#endregion
+exports.runScope = runScope;

package/dist/execute.mjs

@@ -0,0 +1,190 @@
+import { reportSliceStart, reportSliceSuccess } from "./reporter.mjs";
+import { DEFAULT_RELEASE_PREFIX } from "./constants.mjs";
+import { packageIdentity, toScopePackage, toSlice, uniquePackages, uniqueStrings } from "./plan.mjs";
+import { join, relative } from "node:path";
+import { createChangelogCapacitor, renderChangelog } from "@modulify/conventional-changelog";
+import { update } from "@modulify/pkg";
+import { createRecommendationAnalyzer, resolveNextVersion } from "@modulify/conventional-bump";
+import semver from "semver";
+//#region src/execute.ts
+async function runScope(runtime, scope, options, reporting) {
+	const slices = [];
+	for (const slice of scope.slices) {
+		if (reporting) await reportSliceStart(reporting.reporter, toSlice(slice, runtime.cwd), reporting.context);
+		const result = await executeSlice(runtime, slice, options);
+		if (reporting) await reportSliceSuccess(reporting.reporter, result, reporting.context);
+		slices.push(result);
+	}
+	const files = uniqueStrings(slices.flatMap((slice) => slice.files));
+	const changed = slices.some((slice) => slice.changed);
+	return {
+		mode: scope.mode,
+		changed,
+		dry: runtime.dry,
+		packages: scope.packages.map((pkg) => toScopePackage(pkg, runtime.cwd)),
+		affected: scope.affected.map((pkg) => toScopePackage(pkg, runtime.cwd)),
+		slices,
+		files
+	};
+}
+async function executeSlice(runtime, slice, options) {
+	const normalizedSlice = {
+		...slice,
+		packages: uniquePackages(slice.packages)
+	};
+	const currentVersion = resolveSliceCurrentVersion(normalizedSlice, runtime.cwd);
+	const releaseMeta = await collectSliceMeta(runtime, normalizedSlice);
+	const release = resolveNextVersion(currentVersion, {
+		recommendation: releaseMeta.recommendation,
+		type: options.releaseAs,
+		prerelease: options.prerelease,
+		preMajor: options.releaseAs ? false : options.preMajor ?? isPreMajorVersion(currentVersion)
+	});
+	const releaseType = String(release.type);
+	const nextVersion = release.version;
+	const base = toSlice(normalizedSlice, runtime.cwd);
+	if (nextVersion === currentVersion) return {
+		...base,
+		currentVersion,
+		nextVersion,
+		releaseType,
+		changed: false,
+		dry: runtime.dry,
+		files: []
+	};
+	const files = await applySlice(runtime, normalizedSlice, nextVersion, options, renderChangelog(nextVersion, {
+		notes: releaseMeta.notes,
+		url: await runtime.history.url()
+	}));
+	const context = createTagContext(normalizedSlice, nextVersion, releaseType, runtime.cwd);
+	const tag = options.tagName ? options.tagName(context) : createDefaultTagName(normalizedSlice, nextVersion, runtime.cwd);
+	if (runtime.dry) return {
+		...base,
+		currentVersion,
+		nextVersion,
+		releaseType,
+		changed: true,
+		dry: true,
+		tag,
+		files
+	};
+	const messageContext = {
+		...context,
+		tag
+	};
+	const commitMessage = options.commitMessage ? options.commitMessage(messageContext) : DEFAULT_RELEASE_PREFIX + tag;
+	const tagMessage = options.tagMessage ? options.tagMessage(messageContext) : DEFAULT_RELEASE_PREFIX + tag;
+	await runtime.git.add(files);
+	await runtime.git.commit({
+		files,
+		message: commitMessage
+	});
+	await runtime.git.tag({
+		name: tag,
+		message: tagMessage
+	});
+	return {
+		...base,
+		currentVersion,
+		nextVersion,
+		releaseType,
+		changed: true,
+		dry: false,
+		files,
+		tag,
+		commitMessage,
+		tagMessage
+	};
+}
+async function applySlice(runtime, slice, nextVersion, options, changes) {
+	const bumpedPackageNames = slice.packages.reduce((all, pkg) => {
+		const name = pkg.manifest.name ?? pkg.name;
+		if (name) all.add(name);
+		return all;
+	}, /* @__PURE__ */ new Set());
+	const dependencyPolicy = options.dependencyPolicy ?? "preserve";
+	const files = [];
+	for (const pkg of slice.packages) {
+		const diff = { version: nextVersion };
+		const manifest = pkg.manifest;
+		if (hasDependencies(manifest.peerDependencies)) diff.peerDependencies = actualizeDependencies(manifest.peerDependencies, nextVersion, bumpedPackageNames, dependencyPolicy);
+		if (hasDependencies(manifest.dependencies)) diff.dependencies = actualizeDependencies(manifest.dependencies, nextVersion, bumpedPackageNames, dependencyPolicy);
+		if (hasDependencies(manifest.optionalDependencies)) diff.optionalDependencies = actualizeDependencies(manifest.optionalDependencies, nextVersion, bumpedPackageNames, dependencyPolicy);
+		if (hasDependencies(manifest.devDependencies)) diff.devDependencies = actualizeDependencies(manifest.devDependencies, nextVersion, bumpedPackageNames, dependencyPolicy);
+		files.push(relative(runtime.cwd, update(pkg.path, diff, runtime.dry)));
+	}
+	const installArgs = resolveInstallArgs(runtime, options.install);
+	if (!runtime.dry && installArgs) await runtime.sh.exec(runtime.packageManager.command, ["install", ...installArgs]);
+	if (!runtime.dry) await runtime.writeChangelog(changes);
+	files.push(relative(runtime.cwd, join(runtime.cwd, runtime.packageManager.lockfile)));
+	files.push(relative(runtime.cwd, join(runtime.cwd, runtime.changelogFile)));
+	return uniqueStrings(files);
+}
+async function collectSliceMeta(runtime, slice) {
+	const result = await runtime.history.traverse({
+		...slice.range,
+		traversers: [createRecommendationAnalyzer({ strict: true }), createChangelogCapacitor()]
+	});
+	return {
+		recommendation: result.results.get("recommendation"),
+		notes: result.results.get("changelog")
+	};
+}
+function resolveInstallArgs(runtime, install) {
+	if (install === false) return null;
+	if (Array.isArray(install)) return install;
+	if (runtime.packageManager.command === "yarn") return ["--no-immutable"];
+	return [];
+}
+function createTagContext(slice, version, releaseType, cwd) {
+	return {
+		id: slice.id,
+		kind: slice.kind,
+		mode: slice.mode,
+		partition: slice.partition,
+		packages: slice.packages.map((pkg) => toScopePackage(pkg, cwd)),
+		version,
+		releaseType
+	};
+}
+function resolveSliceCurrentVersion(slice, cwd) {
+	const versions = uniqueStrings(slice.packages.map((pkg) => pkg.manifest.version ?? "0.0.0"));
+	if (slice.mode === "sync" && versions.length > 1) {
+		const packageList = slice.packages.map((pkg) => packageIdentity(pkg, cwd)).join(", ");
+		throw new Error(`Sync release slice "${slice.id}" requires aligned package versions: ${packageList}`);
+	}
+	return versions[0];
+}
+function isPreMajorVersion(version) {
+	return semver.valid(version) ? semver.lt(version, "1.0.0") : false;
+}
+function createDefaultTagName(slice, version, cwd) {
+	if (slice.kind === "sync") return `v${version}`;
+	if (slice.partition) return `${slice.partition}@${version}`;
+	return `${packageIdentity(slice.packages[0], cwd)}@${version}`;
+}
+function hasDependencies(dependencies) {
+	return !!dependencies && Object.keys(dependencies).length > 0;
+}
+function actualizeDependencies(dependencies, nextVersion, bumpedPackages, internalPolicy) {
+	return Object.keys(dependencies).reduce((all, name) => ({
+		...all,
+		[name]: bumpedPackages.has(name) ? updateDependencyRange(dependencies[name], nextVersion, internalPolicy) : dependencies[name]
+	}), {});
+}
+function updateDependencyRange(current, nextVersion, policy) {
+	if (policy === "caret") return "^" + nextVersion;
+	if (policy === "exact") return nextVersion;
+	if (current.startsWith("workspace:")) {
+		const value = current.slice(10);
+		if (value === "*") return "workspace:*";
+		if (value.startsWith("^")) return `workspace:^${nextVersion}`;
+		if (value.startsWith("~")) return `workspace:~${nextVersion}`;
+		return `workspace:${nextVersion}`;
+	}
+	if (current.startsWith("^")) return "^" + nextVersion;
+	if (current.startsWith("~")) return "~" + nextVersion;
+	return nextVersion;
+}
+//#endregion
+export { runScope };