@williamthorsen/release-kit 14.2.2 → 14.2.4

package/dist/esm/releasePrepareTargets.js

@@ -1,18 +1,19 @@
-import { chainError } from '@williamthorsen/toolbelt.errors/candidate';
+import { formatStaleOverrideKeyWarning } from "./applyChangelogOverrides.js";
 import { assertTaggedBaseline } from "./assertTaggedBaseline.js";
 import { buildDependencyGraph } from "./buildDependencyGraph.js";
 import { buildReleaseSummary } from "./buildReleaseSummary.js";
-import { createOverrideContext, formatStaleOverrideKeyWarning } from "./changelogOverrides.js";
+import { createOverrideContext } from "./changelogOverrides.js";
+import { decideDirectReleases, reportUnroutedEntryScopes } from "./decideDirectReleases.js";
 import { deriveDependenciesHeader, deriveSectionOrder } from "./deriveReleaseNotesConfig.js";
-import { detectUndeclaredTagPrefixes } from "./detectUndeclaredTagPrefixes.js";
 import { findTransitiveDependents } from "./findTransitiveDependents.js";
-import { findUnroutedEntryScopes } from "./findUnroutedEntryScopes.js";
-import { getAllTagPrefixes } from "./generateChangelogs.js";
 import { hasPrettierConfig } from "./hasPrettierConfig.js";
-import { resolveWorkTypes } from "./loadConfig.js";
-import { buildSkippedTargetResult, decideTargetRelease, isRepoRoot, planTargetRelease, readTargetHistory, } from "./prepareTarget.js";
+import { resolveWorkTypes } from "./mergeConfig.js";
+import { describeCompositeSkip, prepareComposite } from "./prepareComposite.js";
+import { collect, describeStage, isRepoRootTarget, readHistory, runStage, } from "./prepareRunContext.js";
+import { buildSkippedTargetResult, planTargetRelease } from "./prepareTarget.js";
 import { propagateBumps } from "./propagateBumps.js";
-import { isSinglePackageTargets, PROJECT_TARGET_ID } from "./resolveReleaseTargets.js";
+import { isSinglePackageTargets } from "./resolveReleaseTargets.js";
+import { topologicalSort } from "./topologicalSort.js";
 const PREVIEWS_REQUIRE_JSON_WARNING = '--with-release-notes requires changelogJson.enabled; skipping preview generation';
 export function releasePrepareTargets(config, options) {
     const { settings } = config;
@@ -107,12 +108,6 @@ export function releasePrepareTargets(config, options) {
         ...(allWarnings.length > 0 && { warnings: allWarnings }),
     };
 }
-function collect(collected, planned) {
-    collected.tags.push(planned.tag);
-    collected.writes.push(...planned.writes);
-    collected.removals.push(...planned.removals);
-    collected.modifiedFiles.push(...planned.modifiedFiles);
-}
 function composeSinglePackageWarnings(collected, overrideContext, arePreviewsBlocked, previewWarnings) {
     if (collected.tags.length === 0) {
         return [];
@@ -123,73 +118,11 @@ function composeSinglePackageWarnings(collected, overrideContext, arePreviewsBlo
         ...previewWarnings,
     ];
 }
-function decideDirectReleases(planned, settings, options, startIds) {
-    const { force, bumpOverride, setVersions } = options;
-    const direct = {
-        readings: new Map(),
-        decisions: new Map(),
-        bumps: new Map(),
-        untaggedBaselines: new Map(),
-    };
-    const hintState = { emitted: false };
-    const knownPrefixes = planned.flatMap(getAllTagPrefixes);
-    for (const target of planned) {
-        const { history, untagged } = runStage(describeStage(target), () => readTargetHistory(target, settings));
-        direct.readings.set(target.id, history);
-        if (untagged !== undefined) {
-            direct.untaggedBaselines.set(target.id, untagged);
-        }
-        if (history.previousTag === undefined && target.kind === 'package' && target.isWorkspace) {
-            maybeEmitBaselineHint(target, knownPrefixes, hintState);
-        }
-        const setVersion = setVersions?.get(target.id);
-        const decision = decideTargetRelease(target, history, {
-            force: force === true && startIds.has(target.id),
-            bumpOverride,
-            setVersion,
-        });
-        direct.decisions.set(target.id, decision);
-        if (decision.outcome === 'skip') {
-            continue;
-        }
-        direct.bumps.set(target.id, decision.setVersion === undefined
-            ? { releaseType: decision.releaseType }
-            : { releaseType: 'patch', newVersionOverride: decision.setVersion });
-    }
-    return direct;
-}
-function describeCompositeSkip(composite, only) {
-    if (only === undefined || only.includes(composite.id)) {
-        return undefined;
-    }
-    if (composite.id === PROJECT_TARGET_ID) {
-        return (`Project release skipped: --only narrows this run to ${only.join(', ')}. ` +
-            'Run `release-kit prepare` without --only to include the project release.');
-    }
-    return `Release '${composite.id}' skipped: --only does not name it. Add ${composite.id} to --only to include it.`;
-}
-function describeStage(target) {
-    switch (target.kind) {
-        case 'composite':
-            return 'project release stage';
-        case 'directory':
-            return `directory '${target.id}' release stage`;
-        case 'package':
-            return target.isWorkspace ? `workspace '${target.id}' release stage` : undefined;
+function listOverrideDirectory(target) {
+    if (target.kind === 'directory') {
+        return isRepoRootTarget(target) ? [] : [target.directoryPath];
     }
-}
-function maybeEmitBaselineHint(target, knownPrefixes, state) {
-    if (state.emitted || (target.legacyIdentities?.length ?? 0) > 0)
-        return;
-    const candidates = detectUndeclaredTagPrefixes(knownPrefixes);
-    if (candidates.length === 0)
-        return;
-    const totalTags = candidates.reduce((sum, candidate) => sum + candidate.tagCount, 0);
-    const example = candidates[0]?.exampleTags[0] ?? `${candidates[0]?.prefix ?? ''}?`;
-    process.stderr.write(`Hint: no baseline tag found for ${target.id} under '${target.tagPrefix}', but ` +
-        `${totalTags} candidate-shaped tags exist (e.g., ${example}). ` +
-        "Run 'release-kit show-tag-prefixes' to check for undeclared legacy prefixes.\n");
-    state.emitted = true;
+    return target.isWorkspace ? [target.packagePath] : [];
 }
 function planFormatCommand(configuredCommand, collected) {
     const formatCommandStr = configuredCommand ?? (hasPrettierConfig() ? 'npx prettier --write' : undefined);
@@ -199,71 +132,6 @@ function planFormatCommand(configuredCommand, collected) {
     const files = collected.modifiedFiles;
     return { command: `${formatCommandStr} ${files.join(' ')}`, files };
 }
-function prepareComposite(composite, context, options, collected, warnings) {
-    const { history, untagged } = readTargetHistory(composite, context.settings);
-    assertTaggedBaseline([untagged]);
-    const decision = decideTargetRelease(composite, history, {
-        force: options.force === true,
-        bumpOverride: options.bumpOverride,
-        setVersion: undefined,
-    });
-    if (decision.outcome === 'skip') {
-        return buildSkippedTargetResult(composite, history, decision.skipReason);
-    }
-    if (decision.setVersion !== undefined) {
-        throw new Error('A composite target cannot take --set-version');
-    }
-    const planned = planTargetRelease({
-        ...context,
-        target: composite,
-        release: { releaseType: decision.releaseType },
-        decision,
-        history,
-    });
-    collect(collected, planned);
-    warnings.push(...planned.warnings);
-    return planned.result;
-}
-function isRepoRootTarget(target) {
-    return target.kind === 'directory' && isRepoRoot(target);
-}
-function listOverrideDirectory(target) {
-    if (target.kind === 'directory') {
-        return isRepoRootTarget(target) ? [] : [target.directoryPath];
-    }
-    return target.isWorkspace ? [target.packagePath] : [];
-}
-function readHistory(readings, target) {
-    const history = readings.get(target.id);
-    if (history === undefined) {
-        throw new Error(`Target '${target.id}' was planned without a history`);
-    }
-    return history;
-}
-function reportUnroutedEntryScopes(planned, direct, settings, memberTargets) {
-    const releasing = planned.filter((target) => direct.decisions.get(target.id)?.outcome === 'release');
-    const windows = [...releasing, ...planned.filter((target) => !releasing.includes(target))].map((target) => ({
-        target,
-        history: readHistory(direct.readings, target),
-    }));
-    const findings = findUnroutedEntryScopes(windows.map(({ target, history }) => ({ dir: target.id, commits: history.unreleased.commits })), memberTargets.map((target) => target.id), settings.scopeAliases ?? {});
-    for (const { target, history } of windows) {
-        history.unreleased.diagnostics.unroutedEntryScopes = isRepoRootTarget(target)
-            ? []
-            : (findings.get(target.id) ?? []);
-    }
-}
-function runStage(stage, fn) {
-    if (stage === undefined) {
-        return fn();
-    }
-    try {
-        return fn();
-    }
-    catch (error) {
-        throw chainError(stage, error);
-    }
-}
 function selectStartIds(memberTargets, options) {
     const { only, setVersions } = options;
     if (only === undefined) {
@@ -271,63 +139,3 @@ function selectStartIds(memberTargets, options) {
     }
     return new Set([...only, ...(setVersions?.keys() ?? [])]);
 }
-function topologicalSort(releaseSet, graph) {
-    const releaseIds = new Set(releaseSet.keys());
-    if (releaseIds.size === 0) {
-        return { sorted: [], cyclicIds: [] };
-    }
-    const inDegree = new Map();
-    const forwardEdges = new Map();
-    for (const id of releaseIds) {
-        inDegree.set(id, 0);
-        forwardEdges.set(id, []);
-    }
-    for (const [packageName, dependents] of graph.dependentsOf) {
-        const dependencyId = graph.packageNameToDir.get(packageName);
-        if (dependencyId === undefined || !releaseIds.has(dependencyId)) {
-            continue;
-        }
-        for (const dependent of dependents) {
-            if (!releaseIds.has(dependent.id)) {
-                continue;
-            }
-            const edges = forwardEdges.get(dependencyId);
-            if (edges !== undefined) {
-                edges.push(dependent.id);
-            }
-            inDegree.set(dependent.id, (inDegree.get(dependent.id) ?? 0) + 1);
-        }
-    }
-    const queue = [];
-    for (const [id, degree] of inDegree) {
-        if (degree === 0) {
-            queue.push(id);
-        }
-    }
-    const sorted = [];
-    while (queue.length > 0) {
-        const id = queue.shift();
-        if (id === undefined) {
-            break;
-        }
-        sorted.push(id);
-        const dependents = forwardEdges.get(id) ?? [];
-        for (const dependent of dependents) {
-            const newDegree = (inDegree.get(dependent) ?? 1) - 1;
-            inDegree.set(dependent, newDegree);
-            if (newDegree === 0) {
-                queue.push(dependent);
-            }
-        }
-    }
-    const sortedSet = new Set(sorted);
-    const cyclicIds = [];
-    for (const id of releaseIds) {
-        if (sortedSet.has(id)) {
-            continue;
-        }
-        sorted.push(id);
-        cyclicIds.push(id);
-    }
-    return { sorted, cyclicIds };
-}

package/dist/esm/reportPrepare.js

@@ -1,8 +1,9 @@
-import { formatGlyphLine, formatStatusLine, measureGlyphColumn, STATUS_GLYPHS, truncateToWidth, } from '@williamthorsen/nmr-core';
+import { formatGlyphLine, formatStatusLine, measureGlyphColumn, STATUS_GLYPHS, } from '@williamthorsen/nmr-core';
 import { bold, dim, sectionHeader } from "./format.js";
+import { formatBumpFiles, formatChangelogFiles, formatPreviewFiles } from "./formatPrepareFiles.js";
+import { formatChangeRecordWarnings, formatPolicyViolations, formatUnparseableWarning, formatWarnings, } from "./formatPrepareWarnings.js";
 import { RELEASE_GLYPHS } from "./glyphs.js";
 import { PROJECT_TARGET_ID } from "./resolveReleaseTargets.js";
-const SUBJECT_COLUMN_BUDGET = 72;
 export function reportPrepare(plan, options) {
     const isMultiWorkspace = plan.targets.some((target) => target.kind === 'composite' || target.name !== undefined);
     if (isMultiWorkspace) {
@@ -178,116 +179,6 @@ function formatVersionLine(lines, workspace, propagatedFrom, isPropagatedOnly, s
         lines.push(`  ${formatGlyphLine(RELEASE_GLYPHS, style, 'bump', `${versions} (${workspace.releaseType}${suffix})`)}`);
     }
 }
-function formatBumpFiles(lines, workspace, dryRun, indent = '') {
-    for (const file of workspace.bumpedFiles) {
-        if (dryRun) {
-            lines.push(dim(`${indent}  [dry-run] Would bump ${file}`));
-        }
-        else {
-            lines.push(dim(`${indent}  Bumped ${file}`));
-        }
-    }
-}
-function formatChangelogFiles(lines, release, dryRun, style, indent = '') {
-    for (const file of release.changelogFiles) {
-        if (dryRun) {
-            lines.push(dim(`${indent}  [dry-run] Would generate changelog: ${file}`));
-        }
-        else {
-            lines.push(dim(`${indent}  Generating changelog: ${file}`));
-        }
-        const preservation = release.changelogPreservation?.find((candidate) => candidate.file === file);
-        if (preservation === undefined) {
-            continue;
-        }
-        if (preservation.preservedVersions.length > 0) {
-            lines.push(dim(`${indent}    Kept from the existing changelog: ${preservation.preservedVersions.join(', ')}`));
-        }
-        const dropped = preservation.droppedUnversionedHeadings;
-        if (dropped.length === 0) {
-            continue;
-        }
-        const message = `Dropped ${dropped.length} section${dropped.length === 1 ? '' : 's'} without a version: ${dropped.join(', ')}`;
-        lines.push(`${indent}    ${formatStatusLine(style, 'warning', message)}`);
-    }
-    const removedFiles = release.removedChangelogFiles ?? [];
-    for (const file of removedFiles) {
-        if (dryRun) {
-            lines.push(dim(`${indent}  [dry-run] Would remove changelog: ${file}`));
-        }
-        else {
-            lines.push(dim(`${indent}  Removing changelog: ${file}`));
-        }
-    }
-}
-function formatPreviewFiles(lines, release, dryRun, indent = '') {
-    const previewFiles = release.previewFiles ?? [];
-    for (const file of previewFiles) {
-        if (dryRun) {
-            lines.push(dim(`${indent}  [dry-run] Would write ${file}`));
-        }
-        else {
-            lines.push(dim(`${indent}  Wrote ${file}`));
-        }
-    }
-}
-function formatUnparseableWarning(lines, release, style, indent = '') {
-    const unparseable = release.unparseableCommits;
-    if (unparseable === undefined || unparseable.length === 0) {
-        return;
-    }
-    const count = unparseable.length;
-    lines.push(`${indent}  ${formatStatusLine(style, 'warning', `${count} commit${count === 1 ? '' : 's'} could not be parsed`)}`);
-    for (const commit of unparseable) {
-        const shortHash = commit.hash.slice(0, 7);
-        const truncatedSubject = truncateSubject(commit.subject);
-        lines.push(`${indent}    · ${shortHash} ${truncatedSubject}`);
-    }
-}
-function formatPolicyViolations(lines, violations, style, indent = '') {
-    if (violations === undefined || violations.length === 0) {
-        return;
-    }
-    const count = violations.length;
-    lines.push(`${indent}  ${formatStatusLine(style, 'warning', `${count} policy violation${count === 1 ? '' : 's'}:`)}`);
-    for (const violation of violations) {
-        const shortHash = violation.commitHash.slice(0, 7);
-        const subject = violation.commitSubject;
-        const truncatedSubject = truncateSubject(subject);
-        const location = violation.surface === 'entry' ? `entry ${violation.entryPosition ?? '?'}` : `${violation.surface} surface`;
-        lines.push(`${indent}    · ${shortHash} '${truncatedSubject}': type '${violation.type}' at ${location}`);
-    }
-}
-function formatChangeRecordWarnings(lines, release, style, indent = '') {
-    const { malformedBlocks = [], undeclaredEntryTypes = [], unroutedEntryScopes = [] } = release;
-    if (malformedBlocks.length > 0) {
-        const count = malformedBlocks.length;
-        const header = `${count} change-record block${count === 1 ? '' : 's'} could not be read (item taken from the title)`;
-        lines.push(`${indent}  ${formatStatusLine(style, 'warning', `${header}:`)}`);
-        for (const block of malformedBlocks) {
-            lines.push(`${indent}    · ${block.commitHash.slice(0, 7)} '${truncateSubject(block.commitSubject)}': ${block.reason}`);
-        }
-    }
-    if (undeclaredEntryTypes.length > 0) {
-        const count = undeclaredEntryTypes.length;
-        const header = `${count} change-record entr${count === 1 ? 'y has an' : 'ies have'} undeclared type${count === 1 ? '' : 's'} (no item)`;
-        lines.push(`${indent}  ${formatStatusLine(style, 'warning', `${header}:`)}`);
-        for (const entry of undeclaredEntryTypes) {
-            const shortHash = entry.commitHash.slice(0, 7);
-            lines.push(`${indent}    · ${shortHash} '${truncateSubject(entry.commitSubject)}': type '${entry.type}' at entry ${entry.entryPosition}`);
-        }
-    }
-    if (unroutedEntryScopes.length === 0) {
-        return;
-    }
-    const count = unroutedEntryScopes.length;
-    const header = `${count} change-record entry scope${count === 1 ? ' does not match' : 's do not match'} any workspace in the commit's window (no item there)`;
-    lines.push(`${indent}  ${formatStatusLine(style, 'warning', `${header}:`)}`);
-    for (const finding of unroutedEntryScopes) {
-        const shortHash = finding.commitHash.slice(0, 7);
-        lines.push(`${indent}    · ${shortHash} '${truncateSubject(finding.commitSubject)}': scope '${finding.scope}' at entry ${finding.entryPosition}`);
-    }
-}
 function formatPropagationSuffix(propagatedFrom) {
     if (propagatedFrom === undefined || propagatedFrom.length === 0) {
         return '';
@@ -295,16 +186,6 @@ function formatPropagationSuffix(propagatedFrom) {
     const names = propagatedFrom.map((p) => p.packageName).join(', ');
     return `, dependency: ${names}`;
 }
-function formatWarnings(lines, result, style) {
-    const { warnings } = result;
-    if (warnings === undefined || warnings.length === 0) {
-        return;
-    }
-    lines.push('');
-    for (const warning of warnings) {
-        lines.push(formatStatusLine(style, 'warning', warning));
-    }
-}
 function formatFormatCommand(lines, result, options) {
     if (result.formatCommand === undefined) {
         return;
@@ -320,6 +201,3 @@ function formatFormatCommand(lines, result, options) {
     const messageIndent = ' '.repeat(2 + measureGlyphColumn(STATUS_GLYPHS[options.style]) + 1);
     lines.push(`\n  ${formatStatusLine(options.style, 'warning', `Format command failed: ${result.formatCommand.command}`)}`, `${messageIndent}${options.formatError}`);
 }
-function truncateSubject(subject) {
-    return truncateToWidth(subject, { width: SUBJECT_COLUMN_BUDGET });
-}

package/dist/esm/resolveCommandTags.d.ts

@@ -1,5 +1,5 @@
+import type { ReleaseKitConfig } from './configSchema.js';
 import { type ResolvedTag } from './resolveReleaseTags.js';
-import type { ReleaseKitConfig } from './types.js';
 /**
  * Discovers workspaces, resolves release tags from HEAD, validates `--tags` names against the full resolved tag
  * names (e.g., `nmr-core-v1.3.0`), and returns the filtered tag list. Exits with an error message on any validation

package/dist/esm/resolveCommandTags.js

@@ -3,7 +3,8 @@ import { describeError } from '@williamthorsen/toolbelt.errors';
 import { deriveWorkspaceConfig } from "./deriveWorkspaceConfig.js";
 import { describeEmptyWorkspace, discoverWorkspaces } from "./discoverWorkspaces.js";
 import { formatExcludedSkip } from "./formatExcludedSkip.js";
-import { mergeMonorepoConfig, readRootPackageVersion } from "./loadConfig.js";
+import { readRootPackageVersion } from "./loadConfig.js";
+import { mergeMonorepoConfig } from "./mergeConfig.js";
 import { resolveReleaseTags } from "./resolveReleaseTags.js";
 export function resolveCommandTags(tags, userConfig) {
     let workspace;

package/dist/esm/resolveReleaseDeclaration.d.ts

@@ -1,4 +1,5 @@
-import type { ReleaseKitConfig, WorkspaceConfig } from './types.js';
+import type { ReleaseKitConfig } from './configSchema.js';
+import type { WorkspaceConfig } from './types.js';
 /** The composite that a config declares, before the defaults and the root `package.json` check of `loadConfig`. */
 export interface DeclaredComposite {
     /** Name that selects the composite; `undefined` for a `project` block. */

package/dist/esm/resolveReleaseTargets.d.ts

@@ -1,5 +1,6 @@
+import type { ReleaseKitConfig } from './configSchema.js';
 import type { WorkspaceDiscovery } from './discoverWorkspaces.js';
-import type { MonorepoReleaseConfig, ReleaseKitConfig, ReleaseSettings, ReleaseTarget } from './types.js';
+import type { MonorepoReleaseConfig, ReleaseSettings, ReleaseTarget } from './types.js';
 /** Id of the composite target that a `project` block declares. A target name is never empty, so ids cannot clash. */
 export declare const PROJECT_TARGET_ID = "";
 /** Id of the package target at the root of a single-package repo. */

package/dist/esm/resolveReleaseTargets.js

@@ -1,6 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { isPublishableManifest } from "./isPublishableManifest.js";
-import { mergeMonorepoConfig, mergeSinglePackageConfig, readRootPackageVersion } from "./loadConfig.js";
+import { readRootPackageVersion } from "./loadConfig.js";
+import { mergeMonorepoConfig, mergeSinglePackageConfig } from "./mergeConfig.js";
 import { getTargetName } from "./resolveReleaseDeclaration.js";
 export const PROJECT_TARGET_ID = '';
 export const SINGLE_PACKAGE_TARGET_ID = '.';

package/dist/esm/sync-labels/generateCommand.d.ts

@@ -1,5 +1,5 @@
 import { type OutputStyle, type StreamStyles } from '@williamthorsen/nmr-core';
-import type { RepoLabelsConfig } from '../types.js';
+import type { RepoLabelsConfig } from '../configSchema.js';
 import type { LabelDefinition } from './types.js';
 /** Output path for the generated labels file. */
 export declare const LABELS_OUTPUT_PATH = ".github/labels.yaml";

package/dist/esm/sync-labels/resolveLabels.d.ts

@@ -1,4 +1,4 @@
-import type { RepoLabelsConfig } from '../types.js';
+import type { RepoLabelsConfig } from '../configSchema.js';
 import type { LabelDefinition } from './types.js';
 /**
  * Resolves the repository's label set from a `repoLabels` config block.

package/dist/esm/topologicalSort.d.ts

@@ -0,0 +1,12 @@
+import type { DependencyGraph } from './buildDependencyGraph.js';
+import type { ReleaseEntry } from './propagateBumps.js';
+/**
+ * Sorts target ids topologically so that dependencies are processed before their dependents.
+ *
+ * Uses Kahn's algorithm. Targets not in the release set are excluded. If the graph has
+ * cycles, the remaining nodes are appended in arbitrary order and reported via `cyclicIds`.
+ */
+export declare function topologicalSort(releaseSet: Map<string, ReleaseEntry>, graph: DependencyGraph): {
+    sorted: string[];
+    cyclicIds: string[];
+};

package/dist/esm/topologicalSort.js

@@ -0,0 +1,60 @@
+export function topologicalSort(releaseSet, graph) {
+    const releaseIds = new Set(releaseSet.keys());
+    if (releaseIds.size === 0) {
+        return { sorted: [], cyclicIds: [] };
+    }
+    const inDegree = new Map();
+    const forwardEdges = new Map();
+    for (const id of releaseIds) {
+        inDegree.set(id, 0);
+        forwardEdges.set(id, []);
+    }
+    for (const [packageName, dependents] of graph.dependentsOf) {
+        const dependencyId = graph.packageNameToDir.get(packageName);
+        if (dependencyId === undefined || !releaseIds.has(dependencyId)) {
+            continue;
+        }
+        for (const dependent of dependents) {
+            if (!releaseIds.has(dependent.id)) {
+                continue;
+            }
+            const edges = forwardEdges.get(dependencyId);
+            if (edges !== undefined) {
+                edges.push(dependent.id);
+            }
+            inDegree.set(dependent.id, (inDegree.get(dependent.id) ?? 0) + 1);
+        }
+    }
+    const queue = [];
+    for (const [id, degree] of inDegree) {
+        if (degree === 0) {
+            queue.push(id);
+        }
+    }
+    const sorted = [];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (id === undefined) {
+            break;
+        }
+        sorted.push(id);
+        const dependents = forwardEdges.get(id) ?? [];
+        for (const dependent of dependents) {
+            const newDegree = (inDegree.get(dependent) ?? 1) - 1;
+            inDegree.set(dependent, newDegree);
+            if (newDegree === 0) {
+                queue.push(dependent);
+            }
+        }
+    }
+    const sortedSet = new Set(sorted);
+    const cyclicIds = [];
+    for (const id of releaseIds) {
+        if (sortedSet.has(id)) {
+            continue;
+        }
+        sorted.push(id);
+        cyclicIds.push(id);
+    }
+    return { sorted, cyclicIds };
+}