@smoothbricks/cli 0.1.1 → 0.3.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,262 @@
+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' };
+const cli: ReleasePackageInfo = { name: '@scope/cli', projectName: 'cli', path: 'packages/cli', version: '0.2.0' };
+const next: ReleasePackageInfo = {
+  name: '@scope/next',
+  projectName: 'next',
+  path: 'packages/next',
+  version: '1.1.0-next.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, 'a@1.0.0', '2025-01-01T00:00:00Z');
+      await tag(root, '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, '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, '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, '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, '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, '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]);
+    });
+  });
+
+  it('does not auto-release an untagged next prerelease package version', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, next.name, next.path, next.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'chore(release): prepare next prerelease']);
+
+      await expect(autoReleaseCandidatePackages(gitCandidateShell(root), [next])).resolves.toEqual([]);
+    });
+  });
+
+  it('uses a repaired project-name tag as the follow-up auto release baseline for a scoped package', async () => {
+    await withFixtureRepo(async (root) => {
+      await writePackage(root, cli.name, cli.path, cli.version);
+      await git(root, ['add', '.']);
+      await git(root, ['commit', '-m', 'chore(release): publish']);
+      await tag(root, 'cli@0.2.0', '2025-01-01T00:00:00Z');
+
+      await mkdir(join(root, cli.path, 'src'), { recursive: true });
+      await writeFile(join(root, cli.path, 'src/index.ts'), 'export const fixed = true;\n');
+      await git(root, ['add', join(cli.path, 'src/index.ts')]);
+      await git(root, ['commit', '-m', 'fix(cli): repair publish flow']);
+
+      const queriedRefs: string[] = [];
+      const candidates = await autoReleaseCandidatePackages(
+        gitCandidateShell(root, { buildInputPatterns: ['src/**/*.ts'], queriedRefs }),
+        [cli],
+      );
+
+      expect(candidates).toEqual([cli]);
+      expect(queriedRefs).toEqual(['refs/tags/cli@0.2.0']);
+      expect(queriedRefs).not.toContain('refs/tags/@scope/cli@0.2.0');
+    });
+  });
+});
+
+function gitCandidateShell(
+  root: string,
+  options: { buildInputPatterns?: string[]; queriedRefs?: string[] } = {},
+): AutoReleaseCandidateShell {
+  return {
+    gitRefExists: async (ref) => {
+      options.queriedRefs?.push(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

@@ -4,9 +4,9 @@ import { groupReleaseTargets, pendingReleaseTargets, type ReleasePackageInfo, ty
 import { planPublishActions } from '../publish-plan.js';
 
 const packages: ReleasePackageInfo[] = [
-  { name: '@scope/a', path: 'packages/a', version: '1.0.0' },
-  { name: '@scope/b', path: 'packages/b', version: '2.0.0-beta.1' },
-  { name: '@scope/c', path: 'packages/c', version: '3.0.0' },
+  { 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', () => {
@@ -77,7 +77,7 @@ describe('release core properties', () => {
       fc.property(packageSubset(), packageSubset(), (npmMissingPackages, githubMissingPackages) => {
         const plan = planPublishActions({ releasePackages: packages, npmMissingPackages, githubMissingPackages });
 
-        expect(plan.buildProjects).toEqual(npmMissingPackages.map((pkg) => pkg.name));
+        expect(plan.buildProjects).toEqual(npmMissingPackages.map((pkg) => pkg.projectName));
         expect(plan.publishPackages.map((action) => action.pkg.name)).toEqual(
           npmMissingPackages.map((pkg) => pkg.name),
         );
@@ -122,7 +122,7 @@ function releaseRecords(): fc.Arbitrary<ReleaseTagRecord[]> {
         }
         seen.add(key);
         records.push({
-          tag: `${pkg.name}@${pkg.version}`,
+          tag: `${pkg.projectName}@${pkg.version}`,
           sha,
           timestamp: row.timestamp,
           pkg,
@@ -139,7 +139,7 @@ function record(pkg: ReleasePackageInfo | undefined, sha: string): ReleaseTagRec
     throw new Error('Missing test package fixture.');
   }
   return {
-    tag: `${pkg.name}@${pkg.version}`,
+    tag: `${pkg.projectName}@${pkg.version}`,
     sha,
     timestamp: 1,
     pkg,

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

@@ -10,9 +10,15 @@ import {
   type ReleaseTagRecord,
 } from '../core.js';
 
-const stablePackage: ReleasePackageInfo = { name: '@scope/stable', path: 'packages/stable', version: '1.0.0' };
+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',
 };
@@ -24,7 +30,7 @@ function record(
   needs: { npm?: boolean; github?: boolean },
 ): ReleaseTagRecord {
   return {
-    tag: `${pkg.name}@${pkg.version}`,
+    tag: `${pkg.projectName}@${pkg.version}`,
     sha,
     timestamp,
     pkg,
@@ -93,9 +99,9 @@ describe('release core scenario coverage', () => {
     ]);
     const shell: ReleasePlanningShell = {
       listReleaseTagsByCreatorDate: async () => [
-        tag('@scope/stable@1.0.0', 'reachable', 30),
+        tag('stable@1.0.0', 'reachable', 30),
         tag('@other/pkg@9.9.9', 'reachable', 20),
-        tag('@scope/stable@1.0.1', 'unreachable', 10),
+        tag('stable@1.0.1', 'unreachable', 10),
       ],
       isAncestor: async (ancestor) => ancestor === 'reachable',
       packageVersionAtRef: async (packagePath, ref) => {
@@ -109,14 +115,14 @@ describe('release core scenario coverage', () => {
     };
 
     const records = await collectOwnedReleaseTagRecords(
-      [{ name: stablePackage.name, path: stablePackage.path }],
+      [{ 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(records.map((releaseRecord) => releaseRecord.tag)).toEqual(['stable@1.0.0']);
     expect(packageVersionRefs).toEqual(['packages/stable:reachable']);
-    expect(durableTags).toEqual(['@scope/stable@1.0.0']);
+    expect(durableTags).toEqual(['stable@1.0.0']);
   });
 
   it('stops querying older package tags after the newest tag for that package is fully durable', async () => {
@@ -128,9 +134,9 @@ describe('release core scenario coverage', () => {
     ]);
     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),
+        tag('stable@1.1.0', 'newer-stable', 30),
+        tag('prerelease@2.0.0-beta.1', 'older-prerelease', 20),
+        tag('stable@1.0.0', 'older-stable', 10),
       ],
       isAncestor: async () => true,
       packageVersionAtRef: async (packagePath, ref) => versions.get(`${packagePath}:${ref}`) ?? null,
@@ -142,32 +148,33 @@ describe('release core scenario coverage', () => {
 
     const records = await collectOwnedReleaseTagRecords(
       [
-        { name: stablePackage.name, path: stablePackage.path },
-        { name: prereleasePackage.name, path: prereleasePackage.path },
+        { 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']);
+    expect(records.map((releaseRecord) => releaseRecord.tag)).toEqual(['stable@1.1.0', 'prerelease@2.0.0-beta.1']);
+    expect(durableTags).toEqual(['stable@1.1.0', '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)],
+      listReleaseTagsByCreatorDate: async () => [tag('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, path: stablePackage.path }], 'selected-ref', shell),
+      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.',
+      'Release tag stable@1.0.0 points at mismatch, but packages/stable/package.json has version 1.0.1.',
     );
   });
 });

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

@@ -1,15 +1,19 @@
 import { describe, expect, it } from 'bun:test';
 import {
+  collectOwnedReleaseTagRecords,
   groupReleaseTargets,
+  legacyReleaseTag,
   npmDistTagForVersion,
   pendingReleaseTargets,
   type ReleasePackageInfo,
   type ReleaseTagRecord,
   releasePackageForTag,
+  releaseTag,
+  releaseTagAliases,
 } from '../core.js';
 
-const a: ReleasePackageInfo = { name: '@scope/a', path: 'packages/a', version: '1.0.0' };
-const b: ReleasePackageInfo = { name: '@scope/b', path: 'packages/b', version: '2.0.0-beta.1' };
+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: '2.0.0-beta.1' };
 
 function record(
   pkg: ReleasePackageInfo,
@@ -18,7 +22,7 @@ function record(
   needs: { npm?: boolean; github?: boolean },
 ): ReleaseTagRecord {
   return {
-    tag: `${pkg.name}@${pkg.version}`,
+    tag: `${pkg.projectName}@${pkg.version}`,
     sha,
     timestamp,
     pkg,
@@ -29,8 +33,9 @@ function record(
 
 describe('release core planning', () => {
   it('matches owned release tags without semantic version parsing', () => {
-    expect(releasePackageForTag([a], '@scope/a@1.2.3')?.version).toBe('1.2.3');
-    expect(releasePackageForTag([a], '@scope/c@1.2.3')).toBeNull();
+    expect(releasePackageForTag([a], 'a@1.2.3')?.version).toBe('1.2.3');
+    expect(releasePackageForTag([a], '@scope/a@1.2.3')).toBeNull();
+    expect(releasePackageForTag([a], 'c@1.2.3')).toBeNull();
   });
 
   it('groups only repair-needed tags by commit', () => {
@@ -70,4 +75,46 @@ describe('release core planning', () => {
     expect(npmDistTagForVersion('1.0.0')).toBe('latest');
     expect(npmDistTagForVersion('1.0.0-beta.1')).toBe('next');
   });
+
+  it('keeps project-name release tags canonical while recognizing legacy package-name aliases', () => {
+    const scoped = { name: '@scope/a', projectName: 'a', version: '1.0.0' };
+
+    expect(releaseTag(scoped)).toBe('a@1.0.0');
+    expect(legacyReleaseTag(scoped)).toBe('@scope/a@1.0.0');
+    expect(releaseTagAliases(scoped)).toEqual(['a@1.0.0', '@scope/a@1.0.0']);
+  });
+
+  it('checks durable release state concurrently while preserving tag-order records', async () => {
+    const durableCalls: string[] = [];
+    let active = 0;
+    let maxActive = 0;
+    let unblockDurableCalls: (() => void) | undefined;
+    const durableCallsBlocked = new Promise<void>((resolve) => {
+      unblockDurableCalls = resolve;
+    });
+
+    const records = await collectOwnedReleaseTagRecords([a, b], 'head', {
+      listReleaseTagsByCreatorDate: async () => [
+        { name: 'a@1.0.0', sha: 'newer', timestamp: 2 },
+        { name: 'b@2.0.0-beta.1', sha: 'older', timestamp: 1 },
+      ],
+      isAncestor: async () => true,
+      packageVersionAtRef: async (packagePath) => (packagePath === a.path ? a.version : b.version),
+      durableTagState: async (_pkg, tag) => {
+        durableCalls.push(tag);
+        active += 1;
+        maxActive = Math.max(maxActive, active);
+        if (durableCalls.length === 2) {
+          unblockDurableCalls?.();
+        }
+        await durableCallsBlocked;
+        active -= 1;
+        return { npmPublished: false, githubReleaseExists: false };
+      },
+    });
+
+    expect(durableCalls).toEqual(['a@1.0.0', 'b@2.0.0-beta.1']);
+    expect(maxActive).toBeGreaterThan(1);
+    expect(records.map((releaseRecord) => releaseRecord.tag)).toEqual(['a@1.0.0', 'b@2.0.0-beta.1']);
+  });
 });