Skip to content

An open source design system that's fully customizable and agent ready

TypeScript
50.7 KB
Raw Blame
// Copyright (c) Meta Platforms, Inc. and affiliates.

/**
 * @file Release branch authority regression tests.
 *
 * @input  synthetic active markers, plans, package versions, and branch heads
 * @output proofs that only one exact marked release branch can gate or publish
 * @position focused safety suite for the release-branch CI contract
 */

import crypto from 'node:crypto';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import {execFileSync} from 'node:child_process';
import {afterEach, describe, expect, it} from 'vitest';
import {
  createRepository,
  importCommits,
  workingTreeFiles,
} from '../lib/git-fixture.mjs';
import {isValidatedPreviousReleaseMergeBack} from './changeset-coverage.mjs';
import {
  buildMarker,
  buildPlan,
  canaryEligibility,
  changedStatementsFromDiff,
  declaredVersionAtRef,
  isReleaseTestRepairPath,
  latestStableVersion,
  mergeBackEntries,
  nextPlannedVersion,
  validateReleaseDiff,
  validateReleaseTestRepair,
  validateHistoricalReleaseMergeBack,
  validateReleaseMergeBack,
  validateReleaseState,
  writeAuthority,
} from './active-release.mjs';

const CUT = '1'.repeat(40);
const HEAD = '2'.repeat(40);
const NEXT_HEAD = '3'.repeat(40);
const BRANCH = 'release/v0.6.5';
const roots = [];

function fixture({withChangeset = false, changesetText = null} = {}) {
  const root = fs.mkdtempSync(
    path.join(os.tmpdir(), 'astryx-release-authority-'),
  );
  roots.push(root);
  fs.mkdirSync(path.join(root, '.changeset'), {recursive: true});
  fs.mkdirSync(path.join(root, 'packages/core'), {recursive: true});
  fs.writeFileSync(
    path.join(root, 'pnpm-workspace.yaml'),
    "packages:\n  - 'packages/*'\n",
  );
  fs.writeFileSync(
    path.join(root, 'packages/core/package.json'),
    JSON.stringify({name: '@astryxdesign/core', version: '0.6.5'}, null, 2),
  );
  fs.writeFileSync(path.join(root, '.changeset/README.md'), '# Changesets\n');
  if (withChangeset) {
    fs.writeFileSync(
      path.join(root, '.changeset/in-cut.md'),
      changesetText ??
        "---\n'@astryxdesign/core': patch\n---\n\n[fix] Included\n@person\n",
    );
  }
  const plan = buildPlan({root, version: '0.6.5', branch: BRANCH, cutSha: CUT});
  const marker = buildMarker(plan);
  if (withChangeset) fs.rmSync(path.join(root, '.changeset/in-cut.md'));
  return {root, plan, marker};
}

function git(root, ...args) {
  return execFileSync('git', args, {cwd: root, encoding: 'utf8'}).trim();
}

/**
 * A committed fixture whose fixed group declares `version` at the cut commit,
 * the way main's package.json does at a release cut.
 */
function cutFixture(version = '0.6.5') {
  const state = fixture({withChangeset: true});
  const {root} = state;
  fs.writeFileSync(
    path.join(root, '.changeset/config.json'),
    JSON.stringify({fixed: [['@astryxdesign/core']]}),
  );
  fs.writeFileSync(
    path.join(root, 'packages/core/package.json'),
    JSON.stringify({name: '@astryxdesign/core', version}, null, 2),
  );
  fs.writeFileSync(
    path.join(root, '.changeset/in-cut.md'),
    "---\n'@astryxdesign/core': patch\n---\n\n[fix] Included\n@person\n",
  );
  const {cut} = createRepository(root, [
    {
      ref: 'refs/heads/main',
      name: 'cut',
      message: 'cut',
      snapshot: true,
      files: workingTreeFiles(root),
    },
  ]);
  return {...state, cutSha: cut};
}

function validate(state, overrides = {}) {
  return validateReleaseState({
    ...state,
    mode: 'check',
    releaseBranch: BRANCH,
    releaseVersion: state.marker.version,
    releaseTag: `v${state.marker.version}`,
    expectedPlanDigest: state.marker.planDigest,
    refName: BRANCH,
    expectedHead: HEAD,
    checkoutSha: HEAD,
    remoteHead: HEAD,
    activeBranches: [BRANCH],
    ...overrides,
  });
}

afterEach(() => {
  for (const root of roots.splice(0))
    fs.rmSync(root, {recursive: true, force: true});
});

describe('generated cut-time release description', () => {
  it('freezes the authoring data already present in each Changeset', () => {
    const changesetText = `---
'@astryxdesign/core': minor
'@astryxdesign/cli': minor
---

[breaking] Remove the old surface

The old surface stops working; use the replacement.

Migration: run the upgrade command.

@person @other
`;
    const {plan} = fixture({withChangeset: true, changesetText});

    expect(plan.schemaVersion).toBe(2);
    expect(plan.changesets).toEqual([
      {
        path: '.changeset/in-cut.md',
        sha256: expect.stringMatching(/^[0-9a-f]{64}$/),
        packages: [
          {name: '@astryxdesign/core', bump: 'minor'},
          {name: '@astryxdesign/cli', bump: 'minor'},
        ],
        category: 'breaking',
        headline: 'Remove the old surface',
        contributors: ['person', 'other'],
        body:
          'The old surface stops working; use the replacement.\n\n' +
          'Migration: run the upgrade command.',
      },
    ]);
  });

  it('fails closed when frozen authoring data is incomplete', () => {
    const state = fixture({withChangeset: true});
    const plan = {
      ...state.plan,
      changesets: [{...state.plan.changesets[0], headline: ''}],
    };
    const marker = buildMarker(plan);

    expect(validate({...state, plan, marker})).toContain(
      'plan has no headline for .changeset/in-cut.md',
    );
  });
});

describe('one branch per release lifecycle', () => {
  const identity = cutSha => ({
    version: '0.6.5',
    branch: BRANCH,
    'cut-sha': cutSha,
  });

  it('allows an explicit plan revision only within the same active identity', () => {
    const {root, cutSha} = cutFixture();
    const values = identity(cutSha);
    writeAuthority(root, values, false);
    const original = JSON.parse(
      fs.readFileSync(path.join(root, '.release/active.json'), 'utf8'),
    );

    fs.writeFileSync(
      path.join(root, '.changeset/authorized-revision.md'),
      "---\n'@astryxdesign/core': patch\n---\n\n[fix] Authorized revision\n@person\n",
    );
    writeAuthority(root, values, true);
    const revised = JSON.parse(
      fs.readFileSync(path.join(root, '.release/active.json'), 'utf8'),
    );
    expect(revised.planDigest).not.toBe(original.planDigest);
    expect(() =>
      writeAuthority(
        root,
        {...values, version: '0.6.6', branch: 'release/v0.6.6'},
        true,
      ),
    ).toThrow(
      /main declares 0\.6\.5 at the cut|release refresh cannot change version/,
    );
    const {later} = importCommits(root, [
      {
        ref: 'refs/heads/main',
        name: 'later',
        parent: 'refs/heads/main',
        message: 'later',
      },
    ]);
    expect(() =>
      writeAuthority(root, {...values, 'cut-sha': later}, true),
    ).toThrow('release refresh cannot change cutSha');
  });

  it('never revives or recreates a closed branch lifecycle', () => {
    const {root, cutSha} = cutFixture();
    const values = identity(cutSha);
    writeAuthority(root, values, false);
    const markerPath = path.join(root, '.release/active.json');
    const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
    fs.writeFileSync(
      markerPath,
      `${JSON.stringify({...marker, state: 'closed'})}\n`,
    );

    expect(() => writeAuthority(root, values, true)).toThrow(
      'marker state must be active',
    );
    expect(() => writeAuthority(root, values, false)).toThrow(
      'release branch cannot be reused',
    );
  });

  it('requires a new version when the immutable tag already exists', () => {
    const {root, cutSha} = cutFixture();
    git(root, 'tag', 'v0.6.5');

    expect(() => writeAuthority(root, identity(cutSha), false)).toThrow(
      'use a new release branch and version',
    );
  });

  it("binds the release version to main's declared version at the cut", () => {
    // A pre-bumped main that declares 0.7.0 cuts 0.7.0. Nothing may compute a
    // different version from the pending Changesets.
    const {root, cutSha} = cutFixture('0.7.0');
    expect(declaredVersionAtRef(root, cutSha)).toEqual({
      version: '0.7.0',
      errors: [],
    });
    expect(() =>
      writeAuthority(
        root,
        {version: '0.8.0', branch: 'release/v0.8.0', 'cut-sha': cutSha},
        false,
      ),
    ).toThrow(
      'main declares 0.7.0 at the cut, so the release is 0.7.0, not 0.8.0',
    );
    expect(() =>
      writeAuthority(
        root,
        {version: '0.6.5', branch: BRANCH, 'cut-sha': cutSha},
        false,
      ),
    ).toThrow('main declares 0.7.0 at the cut');
    expect(fs.existsSync(path.join(root, '.release/active.json'))).toBe(false);

    writeAuthority(
      root,
      {version: '0.7.0', branch: 'release/v0.7.0', 'cut-sha': cutSha},
      false,
    );
    const marker = JSON.parse(
      fs.readFileSync(path.join(root, '.release/active.json'), 'utf8'),
    );
    expect(marker.version).toBe('0.7.0');
  });
});

describe('active release branch authority', () => {
  it('accepts one marked active branch at its exact head', () => {
    expect(validate(fixture())).toEqual([]);
  });

  it('requires explicit version and plan authority for the final branch gate', () => {
    const state = fixture();
    expect(validate(state, {releaseVersion: undefined})).toContain(
      'release check requires release-version',
    );
    expect(validate(state, {expectedPlanDigest: undefined})).toContain(
      'release check requires plan-digest',
    );
  });

  it('ignores post-cut main package and Changeset activity', () => {
    const state = fixture();
    fs.mkdirSync(path.join(state.root, 'moving-main-snapshot/.changeset'), {
      recursive: true,
    });
    fs.writeFileSync(
      path.join(state.root, 'moving-main-snapshot/package.json'),
      JSON.stringify({version: '9.9.9'}),
    );
    fs.writeFileSync(
      path.join(state.root, 'moving-main-snapshot/.changeset/later.md'),
      'later main input',
    );
    expect(validate(state)).toEqual([]);
  });

  it('rejects main and an unmarked or wrong release branch', () => {
    const state = fixture();
    expect(validate(state, {refName: 'main'})).toContain(
      'release validation must run from the marked release branch',
    );
    expect(validate(state, {releaseBranch: 'release/v0.6.4'})).toContain(
      'release-branch input does not match marker',
    );
  });

  it('rejects missing or ambiguous active branches', () => {
    const state = fixture();
    expect(validate(state, {activeBranches: []})[0]).toMatch(
      /exactly one active release branch/,
    );
    expect(
      validate(state, {activeBranches: [BRANCH, 'release/v0.6.4']})[0],
    ).toMatch(/exactly one active release branch/);
  });

  it('rejects stale expected heads', () => {
    const state = fixture();
    expect(validate(state, {checkoutSha: NEXT_HEAD})).toContain(
      'checked-out commit does not match expected head',
    );
    expect(validate(state, {remoteHead: NEXT_HEAD})).toContain(
      'release branch moved after the expected head was recorded',
    );
  });

  it('accepts an explicitly updated branch head only with a new receipt', () => {
    const state = fixture();
    expect(validate(state, {remoteHead: NEXT_HEAD})).not.toEqual([]);
    expect(
      validate(state, {
        expectedHead: NEXT_HEAD,
        checkoutSha: NEXT_HEAD,
        remoteHead: NEXT_HEAD,
      }),
    ).toEqual([]);
  });

  it('accepts publication only from the matching immutable tag', () => {
    const state = fixture();
    expect(validate(state, {mode: 'publish', refName: 'v0.6.5'})).toEqual([]);
    expect(validate(state, {mode: 'publish', refName: BRANCH})).toContain(
      'stable publish must run from the version tag',
    );
    expect(validate(state, {mode: 'publish', refName: 'main'})).toContain(
      'stable publish must run from the version tag',
    );
  });

  it('does not let dispatch inputs override marker authority', () => {
    const state = fixture();
    expect(
      validate(state, {
        mode: 'publish',
        refName: 'v0.6.5',
        releaseVersion: '0.6.4',
      }),
    ).toContain('release-version input does not match marker');
    expect(
      validate(state, {
        mode: 'publish',
        refName: 'v0.6.5',
        releaseTag: 'v0.6.4',
      }),
    ).toEqual(
      expect.arrayContaining([
        'release-tag input does not match marker version',
        'checked-out tag does not match release-tag input',
      ]),
    );
    expect(
      validate(state, {
        mode: 'publish',
        refName: 'v0.6.5',
        expectedPlanDigest: 'f'.repeat(64),
      }),
    ).toContain('plan-digest input does not match marker');
  });

  it('rejects package versions that do not match the marked release', () => {
    const state = fixture();
    fs.writeFileSync(
      path.join(state.root, 'packages/core/package.json'),
      JSON.stringify({name: '@astryxdesign/core', version: '0.6.4'}, null, 2),
    );
    expect(validate(state, {mode: 'publish', refName: 'v0.6.5'})).toContain(
      'packages/core/package.json is 0.6.4, expected 0.6.5',
    );
  });

  it('keeps the fast bump lane generated-only', () => {
    expect(
      validateReleaseDiff([
        'D\t.changeset/in-cut.md',
        'M\tpackages/core/package.json',
        'M\tpackages/core/CHANGELOG.md',
        'A\tpackages/cli/assets/codemods/transforms/v0.6.5/index.mjs',
        'M\tpnpm-lock.yaml',
      ]),
    ).toEqual([]);
    expect(
      validateReleaseDiff(['M\tpackages/core/src/Button/Button.tsx']),
    ).toContain(
      'release bump contains a non-generated path: packages/core/src/Button/Button.tsx',
    );
    expect(validateReleaseDiff(['A\t.changeset/post-cut.md'])).toContain(
      'release bump may only delete planned Changesets: .changeset/post-cut.md',
    );
    expect(
      validateReleaseDiff([
        'R100\tpackages/core/CHANGELOG.md\tpackages/core/src/release.ts',
      ]),
    ).toContain(
      'release bump contains a non-generated path: packages/core/src/release.ts',
    );
    expect(
      validateReleaseDiff([
        'R100\tpackages/core/src/release.ts\tpackages/core/CHANGELOG.md',
      ]),
    ).toContain(
      'release bump contains a non-generated path: packages/core/src/release.ts',
    );
    expect(
      validateReleaseDiff([
        'R100\tpackages/core/CHANGELOG.md\tpackages/cli/CHANGELOG.md',
      ]),
    ).toEqual([]);
  });

  it('admits one post-bump test repair whose patch already merged on main', () => {
    const patchId = 'a'.repeat(40);
    const changeDigest = 'c'.repeat(64);
    const sourceCommit = 'b'.repeat(40);
    const valid = {
      entries: [
        'M\tpackages/core/src/BottomSheet/__tests__/BottomSheetRelease.a11y.chromium.spec.ts',
      ],
      changedLines: ['await mouseDrag(page, {duration: 50});'],
      commitCount: 1,
      mergeCommitCount: 0,
      patchId,
      changeDigest,
      mainPatches: new Map([
        [patchId, [{commit: sourceCommit, changeDigest, presentAtMain: true}]],
      ]),
      baseChangesets: new Map(),
    };
    expect(isReleaseTestRepairPath(valid.entries[0].split('\t')[1])).toBe(true);
    expect(
      isReleaseTestRepairPath(
        'packages/cli/assets/codemods/transforms/v0.7.12/__tests__/remove-old-api.test.mjs',
      ),
    ).toBe(false);
    expect(
      isReleaseTestRepairPath(
        'packages/cli/assets/codemods/__tests__/registry.test.mjs',
      ),
    ).toBe(false);
    expect(validateReleaseTestRepair(valid)).toEqual({
      errors: [],
      sourceCommit,
    });
  });

  it('fails closed for any broader or unproven release test repair', () => {
    const patchId = 'a'.repeat(40);
    const changeDigest = 'c'.repeat(64);
    const sourceCommit = 'b'.repeat(40);
    const repair = overrides =>
      validateReleaseTestRepair({
        entries: ['M\tinternal/interaction-harness/runner.ts'],
        changedLines: ['const release = event.timeStamp;'],
        commitCount: 1,
        mergeCommitCount: 0,
        patchId,
        changeDigest,
        mainPatches: new Map([
          [
            patchId,
            [{commit: sourceCommit, changeDigest, presentAtMain: true}],
          ],
        ]),
        baseChangesets: new Map(),
        ...overrides,
      }).errors;

    expect(
      repair({
        entries: [
          'R100\tpackages/core/src/BottomSheet/__tests__/BottomSheetScrimClock.a11y.browser.spec.ts\tpackages/core/src/BottomSheet/__tests__/BottomSheetScrimClock.a11y.browser.spec.ts.disabled',
        ],
      }),
    ).toContain(
      'release test repair may only modify an existing test: R100\tpackages/core/src/BottomSheet/__tests__/BottomSheetScrimClock.a11y.browser.spec.ts\tpackages/core/src/BottomSheet/__tests__/BottomSheetScrimClock.a11y.browser.spec.ts.disabled',
    );
    expect(
      repair({entries: ['A\tpackages/core/src/Button/Button.test.tsx']}),
    ).toContain(
      'release test repair may only modify an existing test: A\tpackages/core/src/Button/Button.test.tsx',
    );
    expect(
      repair({entries: ['M\tpackages/core/src/Button/Button.tsx']}),
    ).toContain(
      'release test repair contains a non-test path: packages/core/src/Button/Button.tsx',
    );
    expect(
      repair({
        entries: ['M\tpackages/core/src/Button/__snapshots__/Button.snap'],
      }),
    ).toContain(
      'release test repair contains a non-test path: packages/core/src/Button/__snapshots__/Button.snap',
    );
    expect(
      repair({
        entries: ['M\tapps/docsite/e2e/theme-showcase.spec.ts'],
      }),
    ).toContain(
      'release test repair contains a non-test path: apps/docsite/e2e/theme-showcase.spec.ts',
    );
    expect(
      repair({
        entries: ['M\tapps/docsite/src/__tests__/routing.test.ts'],
      }),
    ).toContain(
      'release test repair contains a non-test path: apps/docsite/src/__tests__/routing.test.ts',
    );
    for (const line of [
      'expect(dialog).toBeHidden();',
      '.toBeHidden({visible: false});',
      'expectNoA11yViolations(page);',
      'test.skip(true, "flaky");',
      'test.fail();',
      'test.slow();',
      'skip();',
      'ctx.fixme();',
      'testInfo.skip();',
      'test.info().fail();',
      'it.skipIf(process.platform === "darwin")();',
      'describe.runIf(false)();',
      'const timeoutMs = 2_000;',
      'retries: 3,',
      'axe.disableRules(["color-contrast"]);',
      'return;',
      'expect(tree).toMatchSnapshot();',
    ]) {
      expect(repair({changedLines: [line]})).toContain(
        `release test repair changes an assertion, test control, timeout, retry, or snapshot: ${line}`,
      );
    }
    const statementCases = [
      {
        diff: `diff --git a/test.mjs b/test.mjs
--- a/test.mjs
+++ b/test.mjs
@@ -1,6 +1,6 @@
 before();
 await expect.poll(() => count).toBeGreaterThan(
-  0,
+  1,
 );
 after();`,
        expected:
          'await expect.poll(() => count).toBeGreaterThan(\n  1,\n);',
      },
      {
        diff: `diff --git a/test.mjs b/test.mjs
--- a/test.mjs
+++ b/test.mjs
@@ -1,6 +1,6 @@
 before();
 await expect(result).toEqual({
-  value: 1,
+  value: 2,
 });
 after();`,
        expected: 'await expect(result).toEqual({\n  value: 2,\n});',
      },
      {
        diff: `diff --git a/test.mjs b/test.mjs
--- a/test.mjs
+++ b/test.mjs
@@ -1,7 +1,7 @@
 before();
 await expect.poll(() => {
-  return ready;
+  return settled;
 }).toBe(true);
 after();`,
        expected:
          'await expect.poll(() => {\n  return settled;\n}).toBe(true);',
      },
      {
        diff: `diff --git a/test.mjs b/test.mjs
--- a/test.mjs
+++ b/test.mjs
@@ -84,5 +84,5 @@
       children: [
         {type: 'paragraph'},
       ],
-      ordered: false,
+      ordered: true,
     });`,
        expected: '<unbounded changed statement>',
      },
      {
        diff: `diff --git a/test.mjs b/test.mjs
--- a/test.mjs
+++ b/test.mjs
@@ -493,5 +493,5 @@
       brand: {
         light: {
-          accent: neutralPalettes.green.light[25],
+          accent: neutralPalettes.green.light[30],
         },
       },`,
        expected: '<unbounded changed statement>',
      },
    ];
    for (const {diff, expected} of statementCases) {
      const changedStatements = changedStatementsFromDiff(diff);
      expect(changedStatements).toContain(expected);
      expect(repair({changedLines: undefined, changedStatements})).toContain(
        `release test repair changes an assertion, test control, timeout, retry, or snapshot: ${expected}`,
      );
    }
    const portStatements = changedStatementsFromDiff(`diff --git a/test.mjs b/test.mjs
--- a/test.mjs
+++ b/test.mjs
@@ -1,7 +1,7 @@
 /**
  * @file BottomSheetRelease.a11y.chromium.spec.ts
- * @input Built BottomSheet stories and real Chromium touch input (CDP), each
- *   event with its own timestamp
+ * @input Built BottomSheet stories and real Chromium touch and mouse input
+ *   (CDP), each event with its own timestamp
  * @output Browser evidence for the touch release.
  */
@@ -20,5 +20,8 @@
 setup();
+const cdp = await page.context().newCDPSession(page);
+// 150 px in 50 ms is 3,000 px/s, so the mouse release projects past the
+// dismiss line even when event delivery is slow.
+await mouseDrag(cdp, sheet, 150, 50);
 cleanup();`);
    expect(portStatements).not.toContain('<unbounded changed statement>');

    const multiStatementChange = changedStatementsFromDiff(`diff --git a/test.mjs b/test.mjs
--- a/test.mjs
+++ b/test.mjs
@@ -1 +1 @@
-safe(); expect(value).toBe(true);
+safe(); expect(value).toBe(false);`);
    expect(multiStatementChange).toContain('expect(value).toBe(false);');
    expect(
      repair({changedLines: undefined, changedStatements: multiStatementChange}),
    ).toContain(
      'release test repair changes an assertion, test control, timeout, retry, or snapshot: expect(value).toBe(false);',
    );

    expect(
      changedStatementsFromDiff(`diff --git a/test.mjs b/test.mjs
--- a/test.mjs
+++ b/test.mjs
@@ -1 +1 @@
-// @vitest-environment node
+// @vitest-environment jsdom`),
    ).toContain('<unbounded changed statement>');

    expect(repair({commitCount: 2})).toContain(
      'release test repair must contain exactly one non-merge commit',
    );
    expect(repair({mergeCommitCount: 1})).toContain(
      'release test repair must contain exactly one non-merge commit',
    );
    expect(repair({mainPatches: new Map()})).toContain(
      'release test repair does not exactly match a non-merge commit still present on main',
    );
    expect(repair({changeDigest: 'd'.repeat(64)})).toContain(
      'release test repair does not exactly match a non-merge commit still present on main',
    );
    expect(
      repair({
        mainPatches: new Map([
          [
            patchId,
            [
              {
                commit: sourceCommit,
                changeDigest,
                presentAtMain: false,
              },
            ],
          ],
        ]),
      }),
    ).toContain(
      'release test repair does not exactly match a non-merge commit still present on main',
    );
    expect(
      repair({
        baseChangesets: new Map([['.changeset/frozen.md', 'c'.repeat(64)]]),
      }),
    ).toContain(
      'release test repair requires the generated version bump to be merged first',
    );
  });

  it('proves the real git patch against current main before the CLI admits it', () => {
    const root = fs.mkdtempSync(
      path.join(os.tmpdir(), 'astryx-release-test-repair-'),
    );
    roots.push(root);
    const testFile =
      'packages/core/src/BottomSheet/__tests__/BottomSheetRelease.a11y.chromium.spec.ts';
    const before =
      'const ready = true;\nawait page.mouse.move(0, 150);\n\n';
    const after = 'const ready = true;\nawait mouseDrag(page);\n\n';
    const {cut} = createRepository(root, [
      {
        ref: 'refs/heads/main',
        name: 'cut',
        snapshot: true,
        files: {
          '.changeset/README.md': '# Changesets\n',
          'pnpm-workspace.yaml': "packages:\n  - 'packages/*'\n",
          'packages/core/package.json': JSON.stringify({
            name: '@astryxdesign/core',
            version: '0.6.5',
          }),
          [testFile]: before,
        },
      },
    ]);
    const plan = {
      schemaVersion: 2,
      version: '0.6.5',
      branch: BRANCH,
      cutSha: cut,
      changesets: [],
    };
    const marker = buildMarker(plan);
    const {
      mainRepair,
      largeMain,
      mixedMain,
      mainRevert,
      releaseBase,
      releaseRepair,
      whitespaceRepair,
    } = importCommits(root, [
      {
        ref: 'refs/heads/main',
        name: 'mainRepair',
        parent: cut,
        files: {[testFile]: after},
      },
      {
        ref: 'refs/heads/main',
        name: 'largeMain',
        parent: 'mainRepair',
        files: {
          [testFile]: `${after}// later main context\n`,
          'large-unrelated.txt': 'x'.repeat(2 * 1024 * 1024),
        },
      },
      {
        ref: 'refs/heads/mixed-main',
        name: 'mixedMain',
        parent: cut,
        files: {
          [testFile]: after,
          'packages/core/src/Button/Button.tsx':
            'export const productChange = true;\n',
        },
      },
      {
        ref: `refs/heads/${BRANCH}`,
        name: 'releaseBase',
        parent: cut,
        files: {
          '.release/active.json': `${JSON.stringify(marker)}\n`,
          '.release/plan.json': `${JSON.stringify(plan)}\n`,
        },
      },
      {
        ref: 'refs/heads/repair',
        name: 'releaseRepair',
        parent: 'releaseBase',
        files: {[testFile]: after},
      },
      {
        ref: 'refs/heads/whitespace-repair',
        name: 'whitespaceRepair',
        parent: 'releaseBase',
        files: {
          [testFile]:
            'const ready = true;\nawait mouse Drag(page);\n\n',
        },
      },
      {
        ref: 'refs/heads/reverted-main',
        name: 'mainRevert',
        parent: 'mainRepair',
        files: {[testFile]: before},
      },
    ]);
    const validator = path.join(import.meta.dirname, 'active-release.mjs');
    const run = (head, mainRef) =>
      execFileSync(
        process.execPath,
        [
          validator,
          'validate-diff',
          '--root',
          root,
          '--base',
          releaseBase,
          '--head',
          head,
          '--main-ref',
          mainRef,
        ],
        {encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe']},
      );

    expect(JSON.parse(run(releaseRepair, largeMain))).toMatchObject({
      kind: 'test-repair',
      sourceCommit: mainRepair,
      files: 1,
    });
    for (const [head, mainRef] of [
      [whitespaceRepair, mainRepair],
      [releaseRepair, mainRevert],
      [releaseRepair, mixedMain],
    ]) {
      try {
        run(head, mainRef);
        throw new Error('expected validation to fail');
      } catch (error) {
        expect(error.stderr).toContain(
          'does not exactly match a non-merge commit still present on main',
        );
      }
    }
  });

  it('admits only an exact reviewed policy bundle onto a predating release branch', () => {
    const root = fs.mkdtempSync(
      path.join(os.tmpdir(), 'astryx-release-policy-carry-'),
    );
    roots.push(root);
    const validatorFile = 'scripts/release/active-release.mjs';
    const activeTestFile = 'scripts/release/active-release.test.mjs';
    const touchedTestFile = '.github/scripts/touched-components.test.mjs';
    const workflowFile = '.github/workflows/ci.yml';
    const manifestPath = 'scripts/release/policy-carry/v0.6.5.json';
    const patchPath = 'scripts/release/policy-carry/v0.6.5.diff';
    const digest = value =>
      crypto.createHash('sha256').update(value).digest('hex');
    const {cut} = createRepository(root, [
      {
        ref: 'refs/heads/main',
        name: 'cut',
        snapshot: true,
        files: {
          [validatorFile]: 'main generated only\n',
          [activeTestFile]: 'main validator tests\n',
          [touchedTestFile]: 'main workflow contract tests\n',
          [workflowFile]: 'main trusted base\n',
          'packages/core/src/Button/Button.tsx': 'export const Button = 1;\n',
        },
      },
    ]);
    const policyFiles = {
      [validatorFile]: 'generated or proven test repair\n',
      [workflowFile]: 'trusted base plus current main\n',
    };
    const {releaseBase, policyCarry, wrongContent, productCarry} =
      importCommits(root, [
        {
          ref: `refs/heads/${BRANCH}`,
          name: 'releaseBase',
          parent: cut,
          files: {
            [validatorFile]: 'release generated only\n',
            [workflowFile]: 'release trusted base\n',
          },
        },
        {
          ref: 'refs/heads/policy-carry',
          name: 'policyCarry',
          parent: 'releaseBase',
          files: policyFiles,
        },
        {
          ref: 'refs/heads/wrong-content',
          name: 'wrongContent',
          parent: 'releaseBase',
          files: {
            ...policyFiles,
            [workflowFile]: 'almost trusted base plus current main\n',
          },
        },
        {
          ref: 'refs/heads/product-carry',
          name: 'productCarry',
          parent: 'releaseBase',
          files: {
            ...policyFiles,
            'packages/core/src/Button/Button.tsx': 'export const Button = 2;\n',
          },
        },
      ]);
    const patch = execFileSync(
      'git',
      ['diff', '--binary', releaseBase, policyCarry],
      {cwd: root, encoding: 'utf8'},
    );
    const targets = Object.fromEntries(
      Object.keys(policyFiles)
        .sort()
        .map(file => [
          file,
          digest(
            execFileSync('git', ['show', `${policyCarry}:${file}`], {
              cwd: root,
            }),
          ),
        ]),
    );
    const manifest = {
      schemaVersion: 1,
      releaseBranch: BRANCH,
      base: releaseBase,
      patch: patchPath,
      patchSha256: digest(patch),
      targets,
    };
    const {mainPolicy} = importCommits(root, [
      {
        ref: 'refs/heads/main',
        name: 'mainPolicy',
        parent: cut,
        files: {
          [manifestPath]: `${JSON.stringify(manifest)}\n`,
          [patchPath]: patch,
        },
      },
    ]);
    const validator = path.join(import.meta.dirname, 'active-release.mjs');
    const run = (head, {base = releaseBase, source = mainPolicy} = {}) =>
      execFileSync(
        process.execPath,
        [
          validator,
          'validate-policy-carry',
          '--root',
          root,
          '--base',
          base,
          '--head',
          head,
          '--source',
          source,
          '--main-ref',
          source,
          '--manifest',
          manifestPath,
          '--release-branch',
          BRANCH,
        ],
        {encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe']},
      );

    expect(JSON.parse(run(policyCarry))).toMatchObject({
      kind: 'policy-carry',
      source: mainPolicy,
      manifest: manifestPath,
      files: 2,
    });

    const secondPolicyFiles = {
      [validatorFile]: 'bounded validator output\n',
      [activeTestFile]: 'validator regression tests\n',
      [touchedTestFile]: 'fallback workflow contract tests\n',
    };
    const {secondCarry} = importCommits(root, [
      {
        ref: 'refs/heads/second-policy-carry',
        name: 'secondCarry',
        parent: policyCarry,
        files: secondPolicyFiles,
      },
    ]);
    const secondPatch = execFileSync(
      'git',
      ['diff', '--binary', policyCarry, secondCarry],
      {cwd: root, encoding: 'utf8'},
    );
    const secondManifest = {
      schemaVersion: 1,
      releaseBranch: BRANCH,
      base: policyCarry,
      patch: patchPath,
      patchSha256: digest(secondPatch),
      targets: Object.fromEntries(
        Object.keys(secondPolicyFiles)
          .sort()
          .map(file => [
            file,
            digest(
              execFileSync('git', ['show', `${secondCarry}:${file}`], {
                cwd: root,
              }),
            ),
          ]),
      ),
    };
    const {mainSecondPolicy} = importCommits(root, [
      {
        ref: 'refs/heads/main',
        name: 'mainSecondPolicy',
        parent: mainPolicy,
        files: {
          [manifestPath]: `${JSON.stringify(secondManifest)}\n`,
          [patchPath]: secondPatch,
        },
      },
    ]);
    expect(
      JSON.parse(
        run(secondCarry, {
          base: policyCarry,
          source: mainSecondPolicy,
        }),
      ),
    ).toMatchObject({
      kind: 'policy-carry',
      source: mainSecondPolicy,
      manifest: manifestPath,
      files: 3,
    });

    try {
      run(wrongContent);
      throw new Error('expected validation to fail');
    } catch (error) {
      expect(error.stderr).toContain(
        `release policy carry file does not match its reviewed bundle: ${workflowFile}`,
      );
    }
    try {
      run(productCarry);
      throw new Error('expected validation to fail');
    } catch (error) {
      expect(error.stderr).toContain(
        'release policy carry contains an unauthorized path: packages/core/src/Button/Button.tsx',
      );
    }
  });

  it('binds generated-only deletion to the frozen plan paths and hashes', () => {
    const digest = value => value.repeat(64).slice(0, 64);
    const plan = {
      changesets: [{path: '.changeset/frozen.md', sha256: digest('a')}],
    };
    expect(
      validateReleaseDiff(['D\t.changeset/frozen.md'], {
        plan,
        baseChangesets: new Map([['.changeset/frozen.md', digest('a')]]),
      }),
    ).toEqual([]);
    expect(
      validateReleaseDiff(['D\t.changeset/not-frozen.md'], {
        plan,
        baseChangesets: new Map([
          ['.changeset/frozen.md', digest('b')],
          ['.changeset/not-frozen.md', digest('c')],
        ]),
      }),
    ).toEqual(
      expect.arrayContaining([
        'release bump deletes an unplanned Changeset: .changeset/not-frozen.md',
        'frozen Changeset differs or is missing at branch base: .changeset/frozen.md',
        'release bump did not delete frozen Changeset: .changeset/frozen.md',
        'release branch contains an unplanned Changeset: .changeset/not-frozen.md',
      ]),
    );
  });

  it('binds the plan to the exact Changesets recorded at cut', () => {
    const state = fixture({withChangeset: true});
    expect(validate(state)).toEqual([]);
    fs.writeFileSync(path.join(state.root, '.changeset/later.md'), 'post-cut');
    expect(validate(state)).toContain(
      'versioned release must consume every branch Changeset',
    );
  });
});

describe('published release merge-back (FR50)', () => {
  const digest = value => value.repeat(64).slice(0, 64);
  const corePath = 'packages/core/package.json';
  const themePath = 'packages/themes/neutral/package.json';
  const labPath = 'packages/lab/package.json';
  const fixedNames = new Set([
    '@astryxdesign/core',
    '@astryxdesign/theme-neutral',
  ]);
  const core = version => ({
    name: '@astryxdesign/core',
    version,
    exports: {'.': './dist/index.js', './fonts.css': './dist/fonts.css'},
    files: ['dist', 'fonts.css'],
  });
  const theme = version => ({
    name: '@astryxdesign/theme-neutral',
    version,
    peerDependencies: {'@astryxdesign/core': version, react: '^19.0.0'},
  });
  const lab = pin => ({
    name: '@astryxdesign/lab',
    version: '0.1.9',
    private: true,
    peerDependencies: {'@astryxdesign/core': pin},
  });
  const mainAt = (version, labPin = version) =>
    new Map([
      [corePath, core(version)],
      [themePath, theme(version)],
      [labPath, lab(labPin)],
    ]);
  const plan = {
    changesets: [{path: '.changeset/frozen.md', sha256: digest('a')}],
  };

  function mergeBack({release = '0.7.0', base, head, ...overrides}) {
    return validateReleaseMergeBack({
      entries: ['D\t.changeset/frozen.md', 'M\tpackages/core/CHANGELOG.md'],
      plan,
      baseChangesets: new Map([
        ['.changeset/frozen.md', digest('a')],
        ['.changeset/post-cut.md', digest('c')],
      ]),
      headChangesets: new Map([['.changeset/post-cut.md', digest('c')]]),
      releaseOutputs: new Map([['packages/core/CHANGELOG.md', digest('e')]]),
      headOutputs: new Map([['packages/core/CHANGELOG.md', digest('e')]]),
      releaseVersion: release,
      fixedNames,
      cutManifests: new Map(),
      releaseManifests: new Map(),
      baseManifests: base,
      headManifests: head,
      ...overrides,
    });
  }

  it('returns exact published outputs while leaving main at the released version', () => {
    expect(mergeBack({base: mainAt('0.7.0'), head: mainAt('0.7.0')})).toEqual(
      [],
    );
  });

  it('rejects folding the next plan into merge-back', () => {
    expect(
      mergeBack({base: mainAt('0.7.0'), head: mainAt('0.7.1'), entries: []}),
    ).toEqual(
      expect.arrayContaining([
        `release merge-back changed a current-main manifest outside the published branch: ${corePath}`,
        "release merge-back must preserve main's declaration 0.7.0; found 0.7.1",
      ]),
    );
  });

  it('preserves a newer main plan that landed before merge-back', () => {
    expect(
      mergeBack({base: mainAt('0.7.1'), head: mainAt('0.7.1'), entries: []}),
    ).toEqual([]);
  });

  it('rejects resetting a newer main plan to the released version', () => {
    expect(
      mergeBack({base: mainAt('0.7.1'), head: mainAt('0.7.0'), entries: []}),
    ).toEqual(
      expect.arrayContaining([
        `release merge-back changed a current-main manifest outside the published branch: ${corePath}`,
        "release merge-back must preserve main's declaration 0.7.1; found 0.7.0",
      ]),
    );
  });

  it('rejects a main declaration below the published release', () => {
    expect(
      mergeBack({base: mainAt('0.6.9'), head: mainAt('0.6.9'), entries: []}),
    ).toContain(
      'release merge-back requires current main at or above published v0.7.0; found 0.6.9',
    );
  });

  it('preserves a newer main declaration while applying a published manifest delta', () => {
    const base = mainAt('0.7.1');
    base.set(themePath, {...theme('0.7.1'), scripts: {test: 'post-cut'}});
    const head = structuredClone(base);
    expect(
      mergeBack({
        base,
        head,
        entries: [
          'D\t.changeset/frozen.md',
          `M\t${themePath}`,
          'M\tpackages/core/CHANGELOG.md',
        ],
        cutManifests: new Map([[themePath, theme('0.6.9')]]),
        releaseManifests: new Map([[themePath, theme('0.7.0')]]),
      }),
    ).toEqual([]);
  });

  it('accepts only published release-output renames', () => {
    const from = 'packages/cli/assets/codemods/transforms/next/transform.mjs';
    const to = 'packages/cli/assets/codemods/transforms/v0.7.0/transform.mjs';
    const entries = [
      'D\t.changeset/frozen.md',
      'M\tpackages/core/CHANGELOG.md',
      `R100\t${from}\t${to}`,
    ];
    const releaseOutputs = new Map([
      ['packages/core/CHANGELOG.md', digest('e')],
      [to, digest('g')],
    ]);
    const headOutputs = new Map(releaseOutputs);

    expect(
      mergeBack({
        entries,
        releaseOutputs,
        headOutputs,
        releaseRenames: new Set([`${from}\t${to}`]),
        base: mainAt('0.7.0'),
        head: mainAt('0.7.0'),
      }),
    ).toEqual([]);
    expect(
      mergeBack({
        entries,
        releaseOutputs,
        headOutputs,
        base: mainAt('0.7.0'),
        head: mainAt('0.7.0'),
      }),
    ).toContain(
      `release merge-back rename does not match published branch: ${from} -> ${to}`,
    );
  });

  it('rejects unlisted manifests, lifecycle files, and non-release paths', () => {
    expect(
      mergeBack({
        base: mainAt('0.7.0'),
        head: mainAt('0.7.0'),
        entries: [
          `M\t${corePath}`,
          'M\t.release/active.json',
          'M\tpackages/core/src/Button/Button.tsx',
        ],
      }),
    ).toEqual(
      expect.arrayContaining([
        `release merge-back changed a manifest not changed on the published branch: ${corePath}`,
        'release merge-back contains a non-release path: .release/active.json',
        'release merge-back contains a non-release path: packages/core/src/Button/Button.tsx',
      ]),
    );
  });

  it('rejects a published manifest with non-version release changes', () => {
    expect(
      mergeBack({
        base: mainAt('0.7.0'),
        head: mainAt('0.7.0'),
        entries: [`M\t${corePath}`],
        cutManifests: new Map([[corePath, core('0.7.0')]]),
        releaseManifests: new Map([
          [corePath, {...core('0.7.0'), sideEffects: false}],
        ]),
      }),
    ).toContain(
      `published manifest contains a non-version release change: ${corePath}`,
    );
  });

  it('accepts a frozen Changeset already removed from current main', () => {
    expect(
      mergeBack({
        base: mainAt('0.7.0'),
        head: mainAt('0.7.0'),
        entries: ['M\tpackages/core/CHANGELOG.md'],
        baseChangesets: new Map([['.changeset/post-cut.md', digest('c')]]),
        headChangesets: new Map([['.changeset/post-cut.md', digest('c')]]),
      }),
    ).toEqual([]);
  });

  it('preserves a changed frozen path as post-cut work', () => {
    expect(
      mergeBack({
        base: mainAt('0.7.0'),
        head: mainAt('0.7.0'),
        entries: ['M\tpackages/core/CHANGELOG.md'],
        baseChangesets: new Map([
          ['.changeset/frozen.md', digest('z')],
          ['.changeset/post-cut.md', digest('c')],
        ]),
        headChangesets: new Map([
          ['.changeset/frozen.md', digest('z')],
          ['.changeset/post-cut.md', digest('c')],
        ]),
      }),
    ).toEqual([]);
  });

  it('rejects changed post-cut Changesets', () => {
    expect(
      mergeBack({
        base: mainAt('0.7.0'),
        head: mainAt('0.7.0'),
        entries: ['M\t.changeset/post-cut.md'],
        baseChangesets: new Map([
          ['.changeset/frozen.md', digest('z')],
          ['.changeset/post-cut.md', digest('c')],
        ]),
        headChangesets: new Map([['.changeset/post-cut.md', digest('f')]]),
      }),
    ).toEqual(
      expect.arrayContaining([
        'release merge-back may only delete frozen Changesets: .changeset/post-cut.md',
        'release merge-back changed post-cut Changeset: .changeset/frozen.md',
        'release merge-back changed post-cut Changeset: .changeset/post-cut.md',
      ]),
    );
  });

  describe('compared with the merge commit it was built on', () => {
    // A merge-back pull request's merge commit, built on an older main, while
    // main has since gained a file.
    function movedMain() {
      const root = fs.mkdtempSync(path.join(os.tmpdir(), 'astryx-merge-back-'));
      roots.push(root);
      const write = (file, text) => {
        fs.mkdirSync(path.dirname(path.join(root, file)), {recursive: true});
        fs.writeFileSync(path.join(root, file), text);
      };
      git(root, 'init', '-q', '-b', 'main');
      git(root, 'config', 'user.name', 'Release Test');
      git(root, 'config', 'user.email', '[email protected]');
      write('.changeset/frozen.md', 'frozen\n');
      write('packages/core/CHANGELOG.md', '# Changelog\n');
      git(root, 'add', '.');
      git(root, 'commit', '-qm', 'main the merge was built on');
      const builtOn = git(root, 'rev-parse', 'HEAD');
      git(root, 'checkout', '-q', '-b', 'chore/merge-v0.7.0-to-main');
      fs.rmSync(path.join(root, '.changeset/frozen.md'));
      write('packages/core/CHANGELOG.md', '# Changelog\n\n## 0.7.0\n');
      git(root, 'add', '-A');
      git(root, 'commit', '-qm', 'merge back v0.7.0');
      git(root, 'checkout', '-q', 'main');
      write('packages/core/src/Later.tsx', 'export {};\n');
      git(root, 'add', '.');
      git(root, 'commit', '-qm', 'main moves on');
      git(root, 'update-ref', 'refs/remotes/origin/main', 'HEAD');
      git(root, 'checkout', '-q', '--detach', builtOn);
      git(
        root,
        'merge',
        '-q',
        '--no-ff',
        '-m',
        'merge ref',
        'chore/merge-v0.7.0-to-main',
      );
      return root;
    }

    it('lists only the merge-back changes against the first parent', () => {
      const root = movedMain();
      const entries = mergeBackEntries(root, 'HEAD^1');
      expect(entries).toEqual([
        'D\t.changeset/frozen.md',
        'M\tpackages/core/CHANGELOG.md',
      ]);
      expect(
        mergeBack({base: mainAt('0.7.0'), head: mainAt('0.7.0'), entries}),
      ).toEqual([]);
    });

    it("reads a later main's new file as a deletion, which fails merge-back", () => {
      const root = movedMain();
      const entries = mergeBackEntries(root, 'origin/main');
      expect(entries).toContain('D\tpackages/core/src/Later.tsx');
      expect(
        mergeBack({
          base: mainAt('0.7.0'),
          head: mainAt('0.7.0'),
          entries,
        }).join('\n'),
      ).toContain('packages/core/src/Later.tsx');
    });

    it.each(['.github/workflows/ci.yml', '.github/workflows/lint.yml'])(
      '%s validates against the merge commit first parent',
      file => {
        const text = fs.readFileSync(
          path.join(import.meta.dirname, '../..', file),
          'utf8',
        );
        const call = text.slice(text.indexOf('validate-merge-back \\'));
        expect(call).toMatch(
          /^validate-merge-back \\\n\s+--root "\$GITHUB_WORKSPACE" \\\n\s+--base HEAD\^1 \\/,
        );
        expect(text).not.toContain('--base origin/main');
      },
    );
  });

  it('replays a closed trusted merge-back against its immutable tag', () => {
    const root = fs.mkdtempSync(
      path.join(os.tmpdir(), 'astryx-historical-merge-back-'),
    );
    roots.push(root);
    const write = (file, text) => {
      fs.mkdirSync(path.dirname(path.join(root, file)), {recursive: true});
      fs.writeFileSync(path.join(root, file), text);
    };
    git(root, 'init', '-q', '-b', 'main');
    git(root, 'config', 'user.name', 'Release Test');
    git(root, 'config', 'user.email', '[email protected]');
    write('pnpm-workspace.yaml', "packages:\n  - 'packages/*'\n");
    write(
      '.changeset/config.json',
      JSON.stringify({fixed: [['@astryxdesign/core']]}),
    );
    write(
      '.changeset/frozen.md',
      "---\n'@astryxdesign/core': patch\n---\n\n[fix] Included\n\n@person\n",
    );
    write(
      'packages/core/package.json',
      JSON.stringify({name: '@astryxdesign/core', version: '0.7.8'}),
    );
    write('packages/core/CHANGELOG.md', '# Changelog\n');
    git(root, 'add', '.');
    git(root, 'commit', '-qm', 'cut');
    const cutSha = git(root, 'rev-parse', 'HEAD');

    const plan = buildPlan({
      root,
      version: '0.7.8',
      branch: 'release/v0.7.8',
      cutSha,
    });
    const marker = buildMarker(plan);
    git(root, 'checkout', '-qb', 'release/v0.7.8');
    write('.release/plan.json', JSON.stringify(plan));
    write('.release/active.json', JSON.stringify(marker));
    fs.rmSync(path.join(root, '.changeset/frozen.md'));
    write('packages/core/CHANGELOG.md', '# Changelog\n\n## 0.7.8\n');
    git(root, 'add', '-A');
    git(root, 'commit', '-qm', 'version packages');
    git(root, 'tag', 'v0.7.8');
    git(root, 'tag', 'v0.7.7');

    git(root, 'checkout', '-q', 'main');
    fs.rmSync(path.join(root, '.changeset/frozen.md'));
    write('packages/core/CHANGELOG.md', '# Changelog\n\n## 0.7.8\n');
    git(root, 'add', '-A');
    git(
      root,
      'commit',
      '-qm',
      'chore: merge v0.7.8 release outputs to main (#1)',
    );
    const head = git(root, 'rev-parse', 'HEAD');

    git(root, 'checkout', '-qb', 'invalid-merge-back', `${head}^`);
    fs.rmSync(path.join(root, '.changeset/frozen.md'));
    write('packages/core/CHANGELOG.md', '# Changelog\n\n## 0.7.8\n');
    write(
      'packages/core/src/Unexpected.tsx',
      'export const unexpected = true;\n',
    );
    git(root, 'add', '-A');
    git(
      root,
      'commit',
      '-qm',
      'chore: merge v0.7.8 release outputs to main (#2)',
    );
    const invalidHead = git(root, 'rev-parse', 'HEAD');
    const subject = 'chore: merge v0.7.8 release outputs to main (#1)';

    // The replay must use the requested historical head, not the current HEAD.
    expect(
      validateHistoricalReleaseMergeBack(root, {
        head,
        releaseRef: 'v0.7.8',
      }),
    ).toEqual([]);
    expect(
      isValidatedPreviousReleaseMergeBack(root, {
        sha: head,
        subject,
        releasedRef: 'v0.7.8',
      }),
    ).toBe(true);
    expect(
      isValidatedPreviousReleaseMergeBack(root, {
        sha: invalidHead,
        subject: 'chore: merge v0.7.8 release outputs to main (#2)',
        releasedRef: 'v0.7.8',
      }),
    ).toBe(false);
    expect(
      isValidatedPreviousReleaseMergeBack(root, {
        sha: head,
        subject: 'chore: merge v0.7.7 release outputs to main (#1)',
        releasedRef: 'v0.7.7',
      }),
    ).toBe(false);
  });

  it('rejects missing frozen deletions and exact-output drift', () => {
    expect(
      mergeBack({
        base: mainAt('0.7.0'),
        head: mainAt('0.7.0'),
        headChangesets: new Map([
          ['.changeset/frozen.md', digest('a')],
          ['.changeset/post-cut.md', digest('c')],
        ]),
        headOutputs: new Map([['packages/core/CHANGELOG.md', digest('f')]]),
      }),
    ).toEqual(
      expect.arrayContaining([
        'release merge-back did not delete frozen Changeset: .changeset/frozen.md',
        'release merge-back output differs from published branch: packages/core/CHANGELOG.md',
      ]),
    );
  });

  it('defaults the separate next plan to patch and admits only an explicit minor', () => {
    expect(nextPlannedVersion('0.7.0')).toBe('0.7.1');
    expect(nextPlannedVersion('0.7.0', '0.7.1')).toBe('0.7.1');
    expect(nextPlannedVersion('0.7.0', '0.8.0')).toBe('0.8.0');
    expect(nextPlannedVersion('0.7.0', '0.7.2')).toBeNull();
    expect(nextPlannedVersion('0.7.0-canary.1')).toBeNull();
  });
});

describe('canary eligibility during release merge-back (FR46)', () => {
  const fixed = new Set(['@astryxdesign/core', '@astryxdesign/cli']);
  const at = (core, cli = core) =>
    new Map([
      ['@astryxdesign/core', {name: '@astryxdesign/core', version: core}],
      ['@astryxdesign/cli', {name: '@astryxdesign/cli', version: cli}],
    ]);

  it('publishes above stable and suppresses the transient equal state', () => {
    expect(
      canaryEligibility({
        fixed,
        releasedVersion: '0.6.8',
        manifests: at('0.6.9'),
      }),
    ).toMatchObject({errors: [], publish: true, declaredVersion: '0.6.9'});
    expect(
      canaryEligibility({
        fixed,
        releasedVersion: '0.6.8',
        manifests: at('0.6.8'),
      }),
    ).toMatchObject({errors: [], publish: false, declaredVersion: '0.6.8'});
  });

  it('refuses a lower or split declaration instead of silently skipping', () => {
    expect(
      canaryEligibility({
        fixed,
        releasedVersion: '0.6.8',
        manifests: at('0.6.7'),
      }).errors,
    ).toContain('canary declaration 0.6.7 is below newest stable v0.6.8');
    expect(
      canaryEligibility({
        fixed,
        releasedVersion: '0.6.8',
        manifests: at('0.6.8', '0.6.9'),
      }).errors[0],
    ).toMatch(/canary needs one plain fixed-group version/);
  });
});

describe('newest stable release selection', () => {
  it('selects the highest vX.Y.Z tag and ignores non-release tags', () => {
    const {root} = cutFixture('0.7.0');
    for (const tag of ['v0.6.5', 'v0.6.7', 'v0.6.6', 'canary-0.8.0'])
      git(root, 'tag', tag);
    expect(latestStableVersion(root)).toBe('0.6.7');
  });
});