@modulify/conventional-release 0.1.0

package/dist/index.cjs

@@ -0,0 +1,712 @@
+"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;
+}
+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;
+  }
+}
+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);
+}
+exports.createScope = createScope;
+exports.resolveConfig = resolveConfig;
+exports.run = run;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import { Scope, Result, RunOptions } from '../types/index';
+import { resolveConfig } from './config';
+export type { Manifest, Mode, Options, Package, Partition, Range, Reporter, Result, RunContext, RunOptions, Scope, ScopePackage, Slice, SliceKind, SliceMode, SliceResult, TagContext, WorkspaceSelector, } from '../types/index';
+export { resolveConfig, };
+/** Resolves config, creates a runtime, and executes the release in one high-level call. */
+export declare function run(options?: RunOptions): Promise<Result>;
+/** Resolves config, creates a runtime, and returns a deterministic release scope. */
+export declare function createScope(options?: RunOptions): Promise<Scope>;