@smoothbricks/cli 0.1.0 → 0.2.0

package/src/release/__tests__/bootstrap-npm-packages.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, it } from 'bun:test';
+import {
+  type BootstrapNpmPackagesShell,
+  bootstrapNpmPackages,
+  NPM_BOOTSTRAP_DIST_TAG,
+  NPM_BOOTSTRAP_VERSION,
+} from '../bootstrap-npm-packages.js';
+import type { ReleasePackageInfo } from '../core.js';
+
+const stable: ReleasePackageInfo = {
+  name: '@scope/stable',
+  projectName: 'stable',
+  path: 'packages/stable',
+  version: '1.2.3',
+};
+const missing: ReleasePackageInfo = {
+  name: '@scope/missing',
+  projectName: 'missing',
+  path: 'packages/missing',
+  version: '2.0.0',
+};
+
+describe('bootstrap npm packages', () => {
+  it('publishes placeholders only for selected packages missing from npm', async () => {
+    const shell = new RecordingBootstrapShell({
+      packages: [stable, missing],
+      existing: [stable.name],
+      otps: ['123456'],
+    });
+
+    const bootstrapped = await bootstrapNpmPackages(shell, {
+      dryRun: false,
+      skipLogin: false,
+      packages: [missing.name],
+    });
+
+    expect(bootstrapped.map((pkg) => pkg.name)).toEqual([missing.name]);
+    expect(shell.logins).toBe(1);
+    expect(shell.published).toEqual([{ name: missing.name, otp: '123456' }]);
+    expect(shell.logs.join('\n')).toContain(NPM_BOOTSTRAP_VERSION);
+    expect(shell.logs.join('\n')).toContain(NPM_BOOTSTRAP_DIST_TAG);
+  });
+
+  it('dry-run reports missing packages without login or publish', async () => {
+    const shell = new RecordingBootstrapShell({ packages: [stable, missing], existing: [stable.name] });
+
+    const bootstrapped = await bootstrapNpmPackages(shell, { dryRun: true, skipLogin: false, packages: [] });
+
+    expect(bootstrapped.map((pkg) => pkg.name)).toEqual([missing.name]);
+    expect(shell.logins).toBe(0);
+    expect(shell.published).toEqual([]);
+    expect(shell.logs).toContain(`${stable.name}: already exists on npm; skipping placeholder bootstrap.`);
+  });
+
+  it('supports skipping npm login when an existing session is already authenticated', async () => {
+    const shell = new RecordingBootstrapShell({ packages: [missing], existing: [], otps: ['654321'] });
+
+    await bootstrapNpmPackages(shell, { dryRun: false, skipLogin: true, packages: [] });
+
+    expect(shell.logins).toBe(0);
+    expect(shell.published).toEqual([{ name: missing.name, otp: '654321' }]);
+  });
+
+  it('passes explicit OTP to placeholder publishes without prompting', async () => {
+    const shell = new RecordingBootstrapShell({ packages: [missing], existing: [] });
+
+    await bootstrapNpmPackages(shell, { dryRun: false, skipLogin: true, packages: [], otp: '111222' });
+
+    expect(shell.published).toEqual([{ name: missing.name, otp: '111222' }]);
+    expect(shell.prompts).toEqual([]);
+  });
+
+  it('rejects unknown package selections before npm login', async () => {
+    const shell = new RecordingBootstrapShell({ packages: [stable], existing: [] });
+
+    await expect(
+      bootstrapNpmPackages(shell, { dryRun: false, skipLogin: false, packages: ['@scope/unknown'] }),
+    ).rejects.toThrow('Unknown owned release package selection: @scope/unknown');
+    expect(shell.logins).toBe(0);
+    expect(shell.published).toEqual([]);
+  });
+});
+
+class RecordingBootstrapShell implements BootstrapNpmPackagesShell<ReleasePackageInfo> {
+  readonly logs: string[] = [];
+  readonly published: Array<{ name: string; otp: string }> = [];
+  readonly prompts: string[] = [];
+  logins = 0;
+  private readonly packages: ReleasePackageInfo[];
+  private readonly existing: Set<string>;
+  private readonly otps: string[];
+
+  constructor(options: { packages: ReleasePackageInfo[]; existing: string[]; otps?: string[] }) {
+    this.packages = options.packages;
+    this.existing = new Set(options.existing);
+    this.otps = [...(options.otps ?? [])];
+  }
+
+  listReleasePackages(): ReleasePackageInfo[] {
+    return this.packages;
+  }
+
+  async packageExists(name: string): Promise<boolean> {
+    return this.existing.has(name);
+  }
+
+  async login(): Promise<void> {
+    this.logins += 1;
+  }
+
+  async publishPlaceholder(pkg: ReleasePackageInfo, env?: Record<string, string>): Promise<void> {
+    this.published.push({ name: pkg.name, otp: env?.NPM_CONFIG_OTP ?? '' });
+  }
+
+  async promptOtp(packageName: string): Promise<string> {
+    this.prompts.push(packageName);
+    const otp = this.otps.shift();
+    if (!otp) {
+      throw new Error(`unexpected OTP prompt for ${packageName}`);
+    }
+    return otp;
+  }
+
+  log(message: string): void {
+    this.logs.push(message);
+  }
+}

package/src/release/__tests__/candidates.test.ts

@@ -0,0 +1,217 @@
+import { describe, expect, it } from 'bun:test';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { $ } from 'bun';
+import { isRecord } from '../../lib/json.js';
+import { type AutoReleaseCandidateShell, autoReleaseCandidatePackages } from '../candidates.js';
+import type { ReleasePackageInfo } from '../core.js';
+import { git, tag, withFixtureRepo, writePackage } from './helpers/fixture-repo.js';
+
+const a: ReleasePackageInfo = { name: '@scope/a', projectName: 'a', path: 'packages/a', version: '1.0.0' };
+const b: ReleasePackageInfo = { name: '@scope/b', projectName: 'b', path: 'packages/b', version: '1.0.0' };
+const c: ReleasePackageInfo = { name: '@scope/c', projectName: 'c', path: 'packages/c', version: '0.1.0' };
+const d: ReleasePackageInfo = { name: '@scope/d', projectName: 'd', path: 'packages/d', version: '0.1.0' };
+
+describe('auto release candidate filtering', () => {
+  it('selects tagged packages only when their package path changed', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, a.name, a.path, a.version);
+      await writePackage(root, b.name, b.path, b.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'initial packages']);
+      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+      await tag(root, '@scope/b@1.0.0', '2025-01-01T00:00:01Z');
+
+      await writeFile(join(root, 'README.md'), 'root-only change\n');
+      await git(root, ['add', 'README.md']);
+      await git(root, ['commit', '-m', 'docs: root only']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [a, b])).resolves.toEqual([]);
+
+      await mkdir(join(root, a.path, 'src'), { recursive: true });
+      await writeFile(join(root, a.path, 'src/index.ts'), 'export const changed = true;\n');
+      await git(root, ['add', join(a.path, 'src/index.ts')]);
+      await git(root, ['commit', '-m', 'feat(a): package local']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [a, b])).resolves.toEqual([a]);
+    });
+  });
+
+  it('ignores package-local config changes that do not affect published users', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, a.name, a.path, a.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'initial package']);
+      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+
+      await mkdir(join(root, a.path), { recursive: true });
+      await writeFile(
+        join(root, a.path, 'package.json'),
+        `${JSON.stringify(
+          {
+            name: a.name,
+            version: a.version,
+            scripts: { test: 'nx run a:test' },
+            devDependencies: { typescript: '^5.9.3' },
+            nx: { name: 'a' },
+          },
+          null,
+          2,
+        )}\n`,
+      );
+      await writeFile(join(root, a.path, 'tsconfig.test.json'), `${JSON.stringify({ compilerOptions: {} })}\n`);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'chore(a): normalize package config']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [a])).resolves.toEqual([]);
+    });
+  });
+
+  it('selects package manifest changes that affect published users', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, a.name, a.path, a.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'initial package']);
+      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+
+      await writeFile(
+        join(root, a.path, 'package.json'),
+        `${JSON.stringify(
+          {
+            name: a.name,
+            version: a.version,
+            exports: { '.': './dist/index.js' },
+            dependencies: { '@scope/shared': '^1.0.0' },
+          },
+          null,
+          2,
+        )}\n`,
+      );
+      await git(root, ['add', join(a.path, 'package.json')]);
+      await git(root, ['commit', '-m', 'fix(a): update public entrypoint']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [a])).resolves.toEqual([a]);
+    });
+  });
+
+  it('selects files included by package manifest files entries', async () => {
+    await withFixtureRepo(async (root) => {
+      await mkdir(join(root, a.path), { recursive: true });
+      await writeFile(
+        join(root, a.path, 'package.json'),
+        `${JSON.stringify({ name: a.name, version: a.version, files: ['schema'] }, null, 2)}\n`,
+      );
+      await mkdir(join(root, a.path, 'schema'), { recursive: true });
+      await writeFile(join(root, a.path, 'schema/index.json'), '{}\n');
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'initial package']);
+      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+
+      await writeFile(join(root, a.path, 'schema/index.json'), '{"changed":true}\n');
+      await git(root, ['add', join(a.path, 'schema/index.json')]);
+      await git(root, ['commit', '-m', 'fix(a): update shipped schema']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [a])).resolves.toEqual([a]);
+    });
+  });
+
+  it('selects package changes from Nx build input patterns', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, a.name, a.path, a.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'initial package']);
+      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+
+      await mkdir(join(root, a.path, 'generated'), { recursive: true });
+      await writeFile(join(root, a.path, 'generated/schema.ts'), 'export const schema = 1;\n');
+      await git(root, ['add', join(a.path, 'generated/schema.ts')]);
+      await git(root, ['commit', '-m', 'fix(a): update generated build input']);
+
+      await expect(
+        autoReleaseCandidatePackages(gitCandidateShell(root, { buildInputPatterns: ['generated/**/*'] }), [a]),
+      ).resolves.toEqual([a]);
+    });
+  });
+
+  it('uses precise Nx production inputs to ignore config and test-only package paths', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, a.name, a.path, a.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'initial package']);
+      await tag(root, '@scope/a@1.0.0', '2025-01-01T00:00:00Z');
+
+      const shell = gitCandidateShell(root, { buildInputPatterns: ['src/**/*.ts', '!src/**/*.test.ts'] });
+
+      await mkdir(join(root, a.path, 'src'), { recursive: true });
+      await writeFile(join(root, a.path, 'vite.config.ts'), 'export default {};\n');
+      await writeFile(join(root, a.path, 'src/index.test.ts'), 'export const testOnly = true;\n');
+      await git(root, ['add', join(a.path, 'vite.config.ts'), join(a.path, 'src/index.test.ts')]);
+      await git(root, ['commit', '-m', 'test(a): update local-only inputs']);
+
+      await expect(autoReleaseCandidatePackages(shell, [a])).resolves.toEqual([]);
+
+      await writeFile(join(root, a.path, 'src/index.ts'), 'export const shipped = true;\n');
+      await git(root, ['add', join(a.path, 'src/index.ts')]);
+      await git(root, ['commit', '-m', 'fix(a): update production input']);
+
+      await expect(autoReleaseCandidatePackages(shell, [a])).resolves.toEqual([a]);
+    });
+  });
+
+  it('includes untagged packages only when their package path has history', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, c.name, c.path, c.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'feat(c): add package']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [c, d])).resolves.toEqual([c]);
+    });
+  });
+});
+
+function gitCandidateShell(root: string, options: { buildInputPatterns?: string[] } = {}): AutoReleaseCandidateShell {
+  return {
+    gitRefExists: async (ref) => {
+      const result = await $`git rev-parse --verify ${ref}`.cwd(root).quiet().nothrow();
+      return result.exitCode === 0;
+    },
+    packageChangedFilesSince: async (ref, packagePath) => {
+      const result = await $`git diff --name-only ${`${ref}..HEAD`} -- ${packagePath}`.cwd(root).quiet().nothrow();
+      if (result.exitCode === 0) {
+        const packagePrefix = `${packagePath}/`;
+        return new TextDecoder()
+          .decode(result.stdout)
+          .split('\n')
+          .map((path) => path.trim())
+          .filter(Boolean)
+          .map((path) => (path.startsWith(packagePrefix) ? path.slice(packagePrefix.length) : path));
+      }
+      throw new Error(`Unable to inspect package changes under ${packagePath}.`);
+    },
+    packageJsonAtRef: async (ref, packagePath) => {
+      const result = await $`git show ${`${ref}:${packagePath}/package.json`}`.cwd(root).quiet().nothrow();
+      if (result.exitCode !== 0) {
+        return null;
+      }
+      return parseJsonObject(new TextDecoder().decode(result.stdout));
+    },
+    currentPackageJson: async (packagePath) =>
+      parseJsonObject(await readFile(join(root, packagePath, 'package.json'), 'utf8')),
+    packageBuildInputPatterns: async () => options.buildInputPatterns ?? ['**/*'],
+    packageHasHistory: async (packagePath) => {
+      const result = await $`git log --format=%H -- ${packagePath}`.cwd(root).quiet().nothrow();
+      if (result.exitCode !== 0) {
+        throw new Error(`Unable to inspect package history under ${packagePath}.`);
+      }
+      return new TextDecoder().decode(result.stdout).trim().length > 0;
+    },
+  };
+}
+
+function parseJsonObject(text: string): Record<string, unknown> {
+  const parsed = JSON.parse(text);
+  if (!isRecord(parsed)) {
+    throw new Error('expected JSON object');
+  }
+  return parsed;
+}

package/src/release/__tests__/core-properties.test.ts

@@ -0,0 +1,149 @@
+import { describe, expect, it } from 'bun:test';
+import fc from 'fast-check';
+import { groupReleaseTargets, pendingReleaseTargets, type ReleasePackageInfo, type ReleaseTagRecord } from '../core.js';
+import { planPublishActions } from '../publish-plan.js';
+
+const packages: ReleasePackageInfo[] = [
+  { name: '@scope/a', projectName: 'a', path: 'packages/a', version: '1.0.0' },
+  { name: '@scope/b', projectName: 'b', path: 'packages/b', version: '2.0.0-beta.1' },
+  { name: '@scope/c', projectName: 'c', path: 'packages/c', version: '3.0.0' },
+];
+
+describe('release core properties', () => {
+  it('groups release tags by commit while preserving repair classifications', () => {
+    fc.assert(
+      fc.property(releaseRecords(), (records) => {
+        const targets = groupReleaseTargets(records);
+
+        for (const target of targets) {
+          const recordsForTarget = records.filter((record) => record.sha === target.sha);
+          const expectedTimestamp = Math.max(...recordsForTarget.map((record) => record.timestamp));
+          const expectedPackages = recordsForTarget
+            .filter((record) => record.needsNpmPublish || record.needsGithubRelease)
+            .map((record) => record.pkg.name);
+          const expectedNpmPackages = recordsForTarget
+            .filter((record) => record.needsNpmPublish)
+            .map((record) => record.pkg.name);
+          const expectedGithubPackages = recordsForTarget
+            .filter((record) => record.needsGithubRelease)
+            .map((record) => record.pkg.name);
+
+          expect(target.timestamp).toBe(expectedTimestamp);
+          expect(target.packages.map((pkg) => pkg.name)).toEqual(expectedPackages);
+          expect(target.npmPackages.map((pkg) => pkg.name)).toEqual(expectedNpmPackages);
+          expect(target.githubPackages.map((pkg) => pkg.name)).toEqual(expectedGithubPackages);
+        }
+
+        expect(targets.map((target) => target.timestamp)).toEqual(
+          [...targets].map((target) => target.timestamp).sort((left, right) => right - left),
+        );
+      }),
+      { numRuns: 300 },
+    );
+  });
+
+  it('repairs exactly the newest incomplete non-HEAD suffix in oldest-first order', () => {
+    fc.assert(
+      fc.property(
+        releaseRecords(),
+        fc.option(fc.constantFrom('commit-0', 'commit-1', 'commit-2', 'commit-3')),
+        (records, headSha) => {
+          const newestFirst = groupReleaseTargets(records);
+          const expected: string[] = [];
+          for (const target of newestFirst) {
+            if (target.sha === headSha) {
+              continue;
+            }
+            if (target.npmPackages.length === 0 && target.githubPackages.length === 0) {
+              break;
+            }
+            expected.push(target.sha);
+          }
+
+          const pending = pendingReleaseTargets(records, headSha ?? 'not-head');
+          expect(pending.map((target) => target.sha)).toEqual(expected.reverse());
+          expect(pending.some((target) => target.sha === headSha)).toBe(false);
+          for (const target of pending) {
+            expect(target.npmPackages.length + target.githubPackages.length).toBeGreaterThan(0);
+          }
+        },
+      ),
+      { numRuns: 300 },
+    );
+  });
+
+  it('builds exactly npm-missing release packages and never builds GitHub-only repairs', () => {
+    fc.assert(
+      fc.property(packageSubset(), packageSubset(), (npmMissingPackages, githubMissingPackages) => {
+        const plan = planPublishActions({ releasePackages: packages, npmMissingPackages, githubMissingPackages });
+
+        expect(plan.buildProjects).toEqual(npmMissingPackages.map((pkg) => pkg.projectName));
+        expect(plan.publishPackages.map((action) => action.pkg.name)).toEqual(
+          npmMissingPackages.map((pkg) => pkg.name),
+        );
+        expect(plan.githubReleasePackages.map((pkg) => pkg.name)).toEqual(githubMissingPackages.map((pkg) => pkg.name));
+        for (const action of plan.publishPackages) {
+          expect(action.distTag).toBe(action.pkg.version.includes('-') ? 'next' : 'latest');
+        }
+      }),
+      { numRuns: 300 },
+    );
+  });
+});
+
+function packageSubset(): fc.Arbitrary<ReleasePackageInfo[]> {
+  return fc.subarray(packages, { minLength: 0, maxLength: packages.length });
+}
+
+function releaseRecords(): fc.Arbitrary<ReleaseTagRecord[]> {
+  return fc
+    .array(
+      fc.record({
+        shaIndex: fc.integer({ min: 0, max: 3 }),
+        pkgIndex: fc.integer({ min: 0, max: packages.length - 1 }),
+        timestamp: fc.integer({ min: 1, max: 10_000 }),
+        needsNpmPublish: fc.boolean(),
+        needsGithubRelease: fc.boolean(),
+      }),
+      { minLength: 1, maxLength: 12 },
+    )
+    .map((rows) => {
+      const seen = new Set<string>();
+      const records: ReleaseTagRecord[] = [];
+      for (const row of rows) {
+        const pkg = packages[row.pkgIndex];
+        if (!pkg) {
+          continue;
+        }
+        const sha = `commit-${row.shaIndex}`;
+        const key = `${sha}:${pkg.name}`;
+        if (seen.has(key)) {
+          continue;
+        }
+        seen.add(key);
+        records.push({
+          tag: `${pkg.name}@${pkg.version}`,
+          sha,
+          timestamp: row.timestamp,
+          pkg,
+          needsNpmPublish: row.needsNpmPublish,
+          needsGithubRelease: row.needsGithubRelease,
+        });
+      }
+      return records.length > 0 ? records : [record(packages[0], 'commit-0')];
+    });
+}
+
+function record(pkg: ReleasePackageInfo | undefined, sha: string): ReleaseTagRecord {
+  if (!pkg) {
+    throw new Error('Missing test package fixture.');
+  }
+  return {
+    tag: `${pkg.name}@${pkg.version}`,
+    sha,
+    timestamp: 1,
+    pkg,
+    needsNpmPublish: false,
+    needsGithubRelease: false,
+  };
+}

package/src/release/__tests__/core-scenarios.test.ts

@@ -0,0 +1,187 @@
+import { describe, expect, it } from 'bun:test';
+import {
+  collectOwnedReleaseTagRecords,
+  type GitReleaseTagInfo,
+  groupReleaseTargets,
+  npmDistTagForVersion,
+  pendingReleaseTargets,
+  type ReleasePackageInfo,
+  type ReleasePlanningShell,
+  type ReleaseTagRecord,
+} from '../core.js';
+
+const stablePackage: ReleasePackageInfo = {
+  name: '@scope/stable',
+  projectName: 'stable',
+  path: 'packages/stable',
+  version: '1.0.0',
+};
+const prereleasePackage: ReleasePackageInfo = {
+  name: '@scope/prerelease',
+  projectName: 'prerelease',
+  path: 'packages/prerelease',
+  version: '2.0.0-beta.1',
+};
+
+function record(
+  pkg: ReleasePackageInfo,
+  sha: string,
+  timestamp: number,
+  needs: { npm?: boolean; github?: boolean },
+): ReleaseTagRecord {
+  return {
+    tag: `${pkg.name}@${pkg.version}`,
+    sha,
+    timestamp,
+    pkg,
+    needsNpmPublish: needs.npm === true,
+    needsGithubRelease: needs.github === true,
+  };
+}
+
+describe('release core scenario coverage', () => {
+  it('fails loudly for duplicate release tags for the same package on one commit', () => {
+    expect(() =>
+      groupReleaseTargets([
+        record(stablePackage, 'same-commit', 10, { npm: true }),
+        record({ ...stablePackage, version: '1.0.1' }, 'same-commit', 11, { github: true }),
+      ]),
+    ).toThrow('Release target same-commit has more than one release tag for @scope/stable.');
+  });
+
+  it('groups mixed stable and prerelease npm packages while dist-tags remain package-version specific', () => {
+    const targets = groupReleaseTargets([
+      record(stablePackage, 'mixed', 10, { npm: true }),
+      record(prereleasePackage, 'mixed', 11, { npm: true }),
+    ]);
+
+    expect(targets).toHaveLength(1);
+    expect(targets[0]?.npmPackages.map((pkg) => pkg.name)).toEqual(['@scope/stable', '@scope/prerelease']);
+    expect(targets[0]?.npmPackages.map((pkg) => [pkg.name, npmDistTagForVersion(pkg.version)])).toEqual([
+      ['@scope/stable', 'latest'],
+      ['@scope/prerelease', 'next'],
+    ]);
+  });
+
+  it('skips a complete HEAD and stops at the next older complete target so older gaps are ignored', () => {
+    const pending = pendingReleaseTargets(
+      [
+        record(stablePackage, 'head', 30, {}),
+        record(stablePackage, 'complete', 20, {}),
+        record(stablePackage, 'ignored-gap', 10, { npm: true, github: true }),
+      ],
+      'head',
+    );
+
+    expect(pending).toEqual([]);
+  });
+
+  it('sorts targets by newest tag timestamp before pending reverses them oldest-first', () => {
+    const records = [
+      record(stablePackage, 'older-target', 10, { npm: true }),
+      record(prereleasePackage, 'newer-target', 30, { github: true }),
+      record({ ...stablePackage, version: '1.0.1' }, 'newer-target', 40, { npm: true }),
+    ];
+
+    expect(groupReleaseTargets(records).map((target) => target.sha)).toEqual(['newer-target', 'older-target']);
+    expect(pendingReleaseTargets(records, 'head').map((target) => target.sha)).toEqual([
+      'older-target',
+      'newer-target',
+    ]);
+  });
+
+  it('ignores unrelated tags and tags not reachable from the selected ref through shell callbacks', async () => {
+    const packageVersionRefs: string[] = [];
+    const durableTags: string[] = [];
+    const versions = new Map([
+      ['packages/stable:reachable', '1.0.0'],
+      ['packages/stable:unreachable', '1.0.1'],
+    ]);
+    const shell: ReleasePlanningShell = {
+      listReleaseTagsByCreatorDate: async () => [
+        tag('@scope/stable@1.0.0', 'reachable', 30),
+        tag('@other/pkg@9.9.9', 'reachable', 20),
+        tag('@scope/stable@1.0.1', 'unreachable', 10),
+      ],
+      isAncestor: async (ancestor) => ancestor === 'reachable',
+      packageVersionAtRef: async (packagePath, ref) => {
+        packageVersionRefs.push(`${packagePath}:${ref}`);
+        return versions.get(`${packagePath}:${ref}`) ?? null;
+      },
+      durableTagState: async (_pkg, tagName) => {
+        durableTags.push(tagName);
+        return { npmPublished: false, githubReleaseExists: true };
+      },
+    };
+
+    const records = await collectOwnedReleaseTagRecords(
+      [{ name: stablePackage.name, projectName: stablePackage.projectName, path: stablePackage.path }],
+      'selected-ref',
+      shell,
+    );
+
+    expect(records.map((releaseRecord) => releaseRecord.tag)).toEqual(['@scope/stable@1.0.0']);
+    expect(packageVersionRefs).toEqual(['packages/stable:reachable']);
+    expect(durableTags).toEqual(['@scope/stable@1.0.0']);
+  });
+
+  it('stops querying older package tags after the newest tag for that package is fully durable', async () => {
+    const durableTags: string[] = [];
+    const versions = new Map([
+      ['packages/stable:newer-stable', '1.1.0'],
+      ['packages/stable:older-stable', '1.0.0'],
+      ['packages/prerelease:older-prerelease', '2.0.0-beta.1'],
+    ]);
+    const shell: ReleasePlanningShell = {
+      listReleaseTagsByCreatorDate: async () => [
+        tag('@scope/stable@1.1.0', 'newer-stable', 30),
+        tag('@scope/prerelease@2.0.0-beta.1', 'older-prerelease', 20),
+        tag('@scope/stable@1.0.0', 'older-stable', 10),
+      ],
+      isAncestor: async () => true,
+      packageVersionAtRef: async (packagePath, ref) => versions.get(`${packagePath}:${ref}`) ?? null,
+      durableTagState: async (_pkg, tagName) => {
+        durableTags.push(tagName);
+        return { npmPublished: true, githubReleaseExists: true };
+      },
+    };
+
+    const records = await collectOwnedReleaseTagRecords(
+      [
+        { name: stablePackage.name, projectName: stablePackage.projectName, path: stablePackage.path },
+        { name: prereleasePackage.name, projectName: prereleasePackage.projectName, path: prereleasePackage.path },
+      ],
+      'selected-ref',
+      shell,
+    );
+
+    expect(records.map((releaseRecord) => releaseRecord.tag)).toEqual([
+      '@scope/stable@1.1.0',
+      '@scope/prerelease@2.0.0-beta.1',
+    ]);
+    expect(durableTags).toEqual(['@scope/stable@1.1.0', '@scope/prerelease@2.0.0-beta.1']);
+  });
+
+  it('throws when a release tag version does not match package.json at the peeled commit', async () => {
+    const shell: ReleasePlanningShell = {
+      listReleaseTagsByCreatorDate: async () => [tag('@scope/stable@1.0.0', 'mismatch', 10)],
+      isAncestor: async () => true,
+      packageVersionAtRef: async () => '1.0.1',
+      durableTagState: async () => ({ npmPublished: true, githubReleaseExists: true }),
+    };
+
+    await expect(
+      collectOwnedReleaseTagRecords(
+        [{ name: stablePackage.name, projectName: stablePackage.projectName, path: stablePackage.path }],
+        'selected-ref',
+        shell,
+      ),
+    ).rejects.toThrow(
+      'Release tag @scope/stable@1.0.0 points at mismatch, but packages/stable/package.json has version 1.0.1.',
+    );
+  });
+});
+
+function tag(name: string, sha: string, timestamp: number): GitReleaseTagInfo {
+  return { name, sha, timestamp };
+}