@modulify/conventional-release 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -1,712 +1,56 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const node_fs = require("node:fs");
-const node_path = require("node:path");
-const node_url = require("node:url");
-const conventionalGit = require("@modulify/conventional-git");
-const conventionalChangelog = require("@modulify/conventional-changelog");
-const gitToolkit = require("@modulify/git-toolkit");
-const shell = require("@modulify/git-toolkit/shell");
-const pkg = require("@modulify/pkg");
-const conventionalBump = require("@modulify/conventional-bump");
-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);
-}
-const DEFAULT_CHANGELOG_FILE = "CHANGELOG.md";
-const DEFAULT_RELEASE_PREFIX = "chore(release): ";
-const DEFAULT_RELEASE_MODE = "sync";
-const DEFAULT_DEPENDENCY_POLICY_INTERNAL = "preserve";
-const RELEASE_CONFIG_FILENAMES = [
-  "release.config.ts",
-  "release.config.mjs",
-  "release.config.js"
-];
-async function resolveConfig(cwd, inline) {
-  const root = cwd ?? process.cwd();
-  const fromPackage = loadPackageJsonConfig(root);
-  const fromFile = await loadFileConfig(root);
-  return {
-    ...fromPackage,
-    ...fromFile,
-    ...inline ?? {}
-  };
-}
-function toScopeOptions(config) {
-  const options = { ...config };
-  delete options.changelogFile;
-  return options;
-}
-function toInlineConfig(options) {
-  const config = { ...options };
-  delete config.cwd;
-  delete config.dry;
-  delete config.reporter;
-  return config;
-}
-function loadPackageJsonConfig(cwd) {
-  const file = node_path.join(cwd, "package.json");
-  if (!node_fs.existsSync(file)) {
-    return {};
-  }
-  const content = JSON.parse(node_fs.readFileSync(file, "utf-8"));
-  return isRecord(content.release) ? content.release : {};
-}
-async function loadFileConfig(cwd) {
-  const configFile = RELEASE_CONFIG_FILENAMES.map((file) => node_path.join(cwd, file)).find((file) => node_fs.existsSync(file));
-  if (!configFile) {
-    return {};
-  }
-  const module2 = await import(node_url.pathToFileURL(configFile).href);
-  const config = module2.default ?? module2;
-  return isRecord(config) ? config : {};
-}
-function isRecord(value) {
-  return !!value && typeof value === "object";
-}
-function createRuntime({
-  cwd = process.cwd(),
-  dry = false,
-  changelogFile = DEFAULT_CHANGELOG_FILE
-} = {}) {
-  const sh = new shell.Runner(cwd);
-  return {
-    cwd,
-    dry,
-    changelogFile,
-    packageManager: resolvePackageManager(cwd),
-    history: new conventionalGit.Client({ cwd }),
-    writeChangelog: (changes) => conventionalChangelog.writeChangelog(changes, {
-      file: dry ? void 0 : node_path.join(cwd, changelogFile)
-    }),
-    sh,
-    git: createGit(sh)
-  };
-}
-function createGit(sh) {
-  const git = new gitToolkit.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 = node_path.join(cwd, "package.json");
-  if (!node_fs.existsSync(file)) {
-    return null;
-  }
-  const content = JSON.parse(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 (node_fs.existsSync(node_path.join(cwd, "yarn.lock"))) return "yarn";
-  if (node_fs.existsSync(node_path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (node_fs.existsSync(node_path.join(cwd, "package-lock.json"))) return "npm";
-  if (node_fs.existsSync(node_path.join(cwd, "bun.lock"))) return "bun";
-  if (node_fs.existsSync(node_path.join(cwd, "bun.lockb"))) return "bun";
-  return null;
-}
-function resolveLockfile(cwd, command) {
-  if (command === "bun" && node_fs.existsSync(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";
-}
-function toScope(scope, cwd) {
-  return {
-    mode: scope.mode,
-    packages: scope.packages.map((pkg2) => toScopePackage(pkg2, cwd)),
-    affected: scope.affected.map((pkg2) => toScopePackage(pkg2, cwd)),
-    slices: scope.slices.map((slice) => toSlice(slice, cwd))
-  };
-}
-async function discover(runtime, options) {
-  const root = pkg.read(runtime.cwd);
-  const packages = [];
-  await pkg.walk([root], async (pkg2) => {
-    packages.push(pkg2);
-  });
-  const discovered = sortPackages(
-    uniquePackages(
-      applyWorkspaceFilters(packages, runtime.cwd, options.workspaces)
-    ),
-    runtime.cwd
-  );
-  const mode = options.mode ?? DEFAULT_RELEASE_MODE;
-  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((pkg2) => affectedPaths.has(pkg2.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,
-    affected,
-    cwd: runtime.cwd,
-    fromTag: options.fromTag,
-    tagPrefix: options.tagPrefix
-  });
-  const discoveredAffected = mode === "hybrid" ? sortPackages(
-    uniquePackages(
-      slices.flatMap((slice) => slice.packages)
-    ),
-    runtime.cwd
-  ) : affected;
-  return {
-    mode,
-    packages: discovered,
-    affected: discoveredAffected,
-    slices
-  };
-}
-function toScopePackage(pkg2, cwd) {
-  return {
-    name: pkg2.manifest.name ?? pkg2.name,
-    version: pkg2.manifest.version,
-    path: toPublicPath(pkg2, cwd)
-  };
-}
-function toSlice(slice, cwd) {
-  return {
-    id: slice.id,
-    kind: slice.kind,
-    mode: slice.mode,
-    partition: slice.partition,
-    packages: slice.packages.map((pkg2) => toScopePackage(pkg2, cwd)),
-    range: slice.range
-  };
-}
-function uniquePackages(packages) {
-  const seen = /* @__PURE__ */ new Set();
-  return packages.filter((pkg2) => {
-    if (seen.has(pkg2.path)) {
-      return false;
-    }
-    seen.add(pkg2.path);
-    return true;
-  });
-}
-function uniqueStrings(values) {
-  return [...new Set(values)];
-}
-function packageIdentity(pkg2, cwd) {
-  const name = pkg2.manifest.name ?? pkg2.name;
-  if (name) {
-    return name;
-  }
-  const path = packagePath(pkg2, cwd);
-  return path === "" || path === "." ? "root" : path;
-}
-function createSlices({
-  mode,
-  affected,
-  cwd,
-  fromTag,
-  tagPrefix
-}) {
-  const touched = affected;
-  if (mode === "sync") {
-    return touched.length ? [{
-      id: "sync:default",
-      kind: "sync",
-      mode: "sync",
-      packages: touched,
-      range: {
-        fromTag,
-        tagPrefix
-      }
-    }] : [];
-  }
-  return touched.map((pkg2) => ({
-    id: `async:${packageIdentity(pkg2, cwd)}`,
-    kind: "async",
-    mode: "async",
-    packages: [pkg2],
-    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((pkg2) => {
-        if (usedPaths.has(pkg2.path)) {
-          return false;
-        }
-        return definition.workspaces.some((selector) => matchesPackageSelector(pkg2, cwd, selector));
-      }),
-      cwd
-    );
-    for (const pkg2 of matched) {
-      usedPaths.add(pkg2.path);
-    }
-    const affectedPaths = await detectAffectedPackages({
-      cwd,
-      root,
-      packages: matched,
-      history,
-      range: resolvePartitionRange({ fromTag, tagPrefix, partition: definition })
-    });
-    const scoped = matched.filter((pkg2) => affectedPaths.has(pkg2.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((pkg2) => ({
-      id: `partition:${partition}:${packageIdentity(pkg2, cwd)}`,
-      kind: "partition",
-      mode: "async",
-      partition,
-      packages: [pkg2],
-      range: resolvedRange
-    })));
-  }
-  const fallbackCandidates = sortPackages(
-    packages.filter((pkg2) => !usedPaths.has(pkg2.path)),
-    cwd
-  );
-  const fallbackPaths = await detectAffectedPackages({
-    cwd,
-    root,
-    packages: fallbackCandidates,
-    history,
-    range: {
-      fromTag,
-      tagPrefix
-    }
-  });
-  const remainder = fallbackCandidates.filter((pkg2) => fallbackPaths.has(pkg2.path));
-  const fallback = remainder.map((pkg2) => ({
-    id: `hybrid:${packageIdentity(pkg2, cwd)}`,
-    kind: "async",
-    mode: "async",
-    packages: [pkg2],
-    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((pkg2) => pkg2.path));
-  }
-  if (!touched.length) {
-    return /* @__PURE__ */ new Set();
-  }
-  const normalizedRoot = normalizePath(node_path.relative(cwd, root.path));
-  const children = packages.filter((pkg2) => pkg2.path !== root.path).map((pkg2) => ({
-    packagePath: pkg2.path,
-    relativePath: normalizePath(node_path.relative(cwd, pkg2.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((pkg2) => {
-    const included = selector.include?.length ? selector.include.some((entry) => matchesPackageSelector(pkg2, cwd, entry)) : true;
-    if (!included) {
-      return false;
-    }
-    return !(selector.exclude?.some((entry) => matchesPackageSelector(pkg2, cwd, entry)) ?? false);
-  });
-}
-function sortPackages(packages, cwd) {
-  return [...packages].sort((a, b) => packagePath(a, cwd).localeCompare(packagePath(b, cwd)));
-}
-function packagePath(pkg2, cwd) {
-  return normalizePath(node_path.relative(cwd, pkg2.path));
-}
-function toPublicPath(pkg2, cwd) {
-  return packagePath(pkg2, cwd) || ".";
-}
-function matchesPackageSelector(pkg2, cwd, selector) {
-  const name = pkg2.manifest.name ?? pkg2.name ?? "";
-  const path = packagePath(pkg2, 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 {
-    const result = await history.traverse({
-      fromTag: range.fromTag,
-      tagPrefix: range.tagPrefix,
-      changeset: true,
-      traversers: [conventionalGit.createChangesetTraverser()]
-    });
-    return result.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}/`);
-}
-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((pkg2) => toScopePackage(pkg2, runtime.cwd)),
-    affected: scope.affected.map((pkg2) => toScopePackage(pkg2, 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 = conventionalBump.resolveNextVersion(currentVersion, {
-    recommendation: releaseMeta.recommendation,
-    type: options.releaseAs,
-    prerelease: options.prerelease
-  });
-  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 changes = conventionalChangelog.renderChangelog(nextVersion, {
-    notes: releaseMeta.notes,
-    url: await runtime.history.url()
-  });
-  const files = await applySlice(runtime, normalizedSlice, nextVersion, options, changes);
-  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, pkg2) => {
-    const name = pkg2.manifest.name ?? pkg2.name;
-    if (name) {
-      all.add(name);
-    }
-    return all;
-  }, /* @__PURE__ */ new Set());
-  const dependencyPolicy = options.dependencyPolicy ?? DEFAULT_DEPENDENCY_POLICY_INTERNAL;
-  const files = [];
-  for (const pkg$1 of slice.packages) {
-    const diff = { version: nextVersion };
-    const manifest = pkg$1.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(node_path.relative(runtime.cwd, pkg.update(pkg$1.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(node_path.relative(runtime.cwd, node_path.join(runtime.cwd, runtime.packageManager.lockfile)));
-  files.push(node_path.relative(runtime.cwd, node_path.join(runtime.cwd, runtime.changelogFile)));
-  return uniqueStrings(files);
-}
-async function collectSliceMeta(runtime, slice) {
-  const result = await runtime.history.traverse({
-    ...slice.range,
-    traversers: [conventionalBump.createRecommendationAnalyzer({
-      strict: true
-    }), conventionalChangelog.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((pkg2) => toScopePackage(pkg2, cwd)),
-    version,
-    releaseType
-  };
-}
-function resolveSliceCurrentVersion(slice, cwd) {
-  const versions = uniqueStrings(
-    slice.packages.map((pkg2) => pkg2.manifest.version ?? "0.0.0")
-  );
-  if (slice.mode === "sync" && versions.length > 1) {
-    const packageList = slice.packages.map((pkg2) => packageIdentity(pkg2, cwd)).join(", ");
-    throw new Error(`Sync release slice "${slice.id}" requires aligned package versions: ${packageList}`);
-  }
-  return versions[0];
-}
-function createDefaultTagName(slice, version, cwd) {
-  if (slice.kind === "sync") {
-    return `v${version}`;
-  }
-  if (slice.partition) {
-    return `${slice.partition}@${version}`;
-  }
-  const identity = packageIdentity(slice.packages[0], cwd);
-  return `${identity}@${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("workspace:".length);
-    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;
-}
+const require_reporter = require("./reporter.cjs");
+require("./constants.cjs");
+const require_config = require("./config.cjs");
+const require_runtime = require("./runtime.cjs");
+const require_plan = require("./plan.cjs");
+const require_execute = require("./execute.cjs");
+//#region src/index.ts
+/** Resolves config, creates a runtime, and executes the release in one high-level call. */
 async function run(options = {}) {
-  const inline = toInlineConfig(options);
-  const cwd = options.cwd ?? process.cwd();
-  const context = createRunContext({
-    cwd,
-    dry: options.dry ?? false
-  });
-  try {
-    await reportStart(options.reporter, context);
-    const config = await resolveConfig(cwd, inline);
-    const scopeOptions = toScopeOptions(config);
-    const runtime = createRuntime({
-      cwd,
-      dry: context.dry,
-      changelogFile: config.changelogFile ?? DEFAULT_CHANGELOG_FILE
-    });
-    const scope = await discover(runtime, scopeOptions);
-    const publicScope = toScope(scope, runtime.cwd);
-    await reportScope(options.reporter, publicScope, context);
-    const result = await runScope(runtime, scope, scopeOptions, options.reporter ? {
-      reporter: options.reporter,
-      context
-    } : void 0);
-    await reportSuccess(options.reporter, result, context);
-    return result;
-  } catch (error) {
-    await reportError(options.reporter, error, context);
-    throw error;
-  }
-}
+	const inline = require_config.toInlineConfig(options);
+	const cwd = options.cwd ?? process.cwd();
+	const context = require_reporter.createRunContext({
+		cwd,
+		dry: options.dry ?? false
+	});
+	try {
+		await require_reporter.reportStart(options.reporter, context);
+		const config = await require_config.resolveConfig(cwd, inline);
+		const scopeOptions = require_config.toScopeOptions(config);
+		const runtime = require_runtime.createRuntime({
+			cwd,
+			dry: context.dry,
+			changelogFile: config.changelogFile ?? "CHANGELOG.md"
+		});
+		const scope = await require_plan.discover(runtime, scopeOptions);
+		const publicScope = require_plan.toScope(scope, runtime.cwd);
+		await require_reporter.reportScope(options.reporter, publicScope, context);
+		const result = await require_execute.runScope(runtime, scope, scopeOptions, options.reporter ? {
+			reporter: options.reporter,
+			context
+		} : void 0);
+		await require_reporter.reportSuccess(options.reporter, result, context);
+		return result;
+	} catch (error) {
+		await require_reporter.reportError(options.reporter, error, context);
+		throw error;
+	}
+}
+/** Resolves config, creates a runtime, and returns a deterministic release scope. */
 async function createScope(options = {}) {
-  const inline = toInlineConfig(options);
-  const cwd = options.cwd ?? process.cwd();
-  const config = await resolveConfig(cwd, inline);
-  const scopeOptions = toScopeOptions(config);
-  const runtime = createRuntime({
-    cwd,
-    dry: options.dry ?? true,
-    changelogFile: config.changelogFile ?? DEFAULT_CHANGELOG_FILE
-  });
-  const scope = await discover(runtime, scopeOptions);
-  return toScope(scope, runtime.cwd);
-}
+	const inline = require_config.toInlineConfig(options);
+	const cwd = options.cwd ?? process.cwd();
+	const config = await require_config.resolveConfig(cwd, inline);
+	const scopeOptions = require_config.toScopeOptions(config);
+	const runtime = require_runtime.createRuntime({
+		cwd,
+		dry: options.dry ?? true,
+		changelogFile: config.changelogFile ?? "CHANGELOG.md"
+	});
+	return require_plan.toScope(await require_plan.discover(runtime, scopeOptions), runtime.cwd);
+}
+//#endregion
 exports.createScope = createScope;
-exports.resolveConfig = resolveConfig;
+exports.resolveConfig = require_config.resolveConfig;
 exports.run = run;