Files
PaperClipAI/scripts/release-lib.test.mjs
T
DottaandClaude Opus 5.5 d16c06308d perf(release): number canaries by master position and confirm them outside the release lock (#21917)
## Thinking Path

> - Paperclip is the open source app people use to manage AI agents for
work
> - Every master push runs a canary, and only one canary at a time may
run the release workflow
> - After #21554 and #21555 a canary held that lock for 35.5 min, and
13-16 min of it was waiting for npm to show the new packages
> - The wait was required: the next canary computed `canary.N` from
npm's version list, so starting before npm showed the previous canary
would reuse its number
> - This pull request numbers a canary by its commit's position on
master and moves the registry confirmation, the git tag, the Docker
dispatch and the onboarding smoke to a separate `canary-finalize.yml`
run
> - The benefit is that the release lock is held for about 20-25 min per
canary instead of 35, with the same checks before a canary is tagged

## Linked Issues or Issue Description

**What existing behavior does this improve?**
Canary throughput. In run 43715037497 (2026-11-15) `publish_canary` took
23.7 min, and 13.3 min of that was "Waiting for registry visibility"
(13:08:50 to 13:22:11). The next canary could not start until that run
ended.

**Current behavior**
`release.sh canary` sets `N` to (highest published `-canary.N` for
today) + 1, then publishes, waits for npm to show every package, checks
dist-tags, installs `paperclipai@canary`, and creates
`canary/v<version>`. `publish_canary` pushes the tag, dispatches
`docker.yml`, and `smoke_canary_onboarding` runs in the same run.

**Proposed behavior**
`N` = `git rev-list --count HEAD` (full history required), or the
registry number + 1 when that is higher (a rerun of the same commit).
`release.sh canary --defer-registry-confirmation` ends after npm accepts
every publish. `publish_canary` dispatches `canary-finalize.yml`, which
does the confirmation, tag, Docker dispatch and smoke outside the
release lock. Nightly, beta and stable numbering and flow are unchanged.

Refs #21554, #21555

## What Changed

- `scripts/release-lib.sh`: `next_canary_version_from_source`. A
publishing canary refuses a shallow checkout; a dry run (the PR Canary
Dry Run job) falls back to the registry number.
- `scripts/release.sh`: canary uses the new number; new canary-only
`--defer-registry-confirmation` flag skips the registry wait, the
dist-tag check and the local tag, and writes the version to
`PAPERCLIP_RELEASE_VERSION_FILE`.
- `scripts/confirm-canary-publication.sh` (new): waits for registry
visibility, checks provenance, checks dist-tags with
`--allow-newer-canary`, installs `paperclipai@<version>`, then creates
and pushes `canary/v<version>`. A tag already on the same commit is
accepted, so reruns are safe.
- `scripts/verify-canary-provenance.mjs` (new): every package's npm SLSA
provenance must name `.github/workflows/release.yml` on
`refs/heads/master` in `paperclipai/paperclip` at the source commit. A
dispatch with invented inputs cannot tag anything.
- `scripts/verify-release-registry-state.mjs`: `--allow-newer-canary`
accepts a `canary` dist-tag that a newer canary already moved; older,
foreign or missing tags still fail.
- `.github/workflows/canary-finalize.yml` (new, `workflow_dispatch`,
master only): `confirm_canary` (contents: write, actions: write) and
`smoke_canary_onboarding` (downloads the publisher's lockfile artifact
by run id). Inputs reach shell steps only through a validating step.
- `.github/workflows/release.yml`: `publish_canary` hands off to
`canary-finalize.yml` and drops to `contents: read`; its tag push,
Docker dispatch and smoke job move to `canary-finalize.yml`.
- Tests and `doc/RELEASING.md`.

## Verification

- `node --test .github/scripts/tests/*.test.mjs
scripts/release-lib.test.mjs
scripts/verify-release-registry-state.test.mjs
scripts/verify-canary-provenance.test.mjs`: 846 pass.
`scripts/__tests__/release-verify-workflow.test.mjs`: 73 pass.
- New tests: numbering by master position, rerun moves past a published
number, shallow refusal and dry-run fallback; newer/older/foreign
dist-tags; provenance from another commit, workflow, branch, repository
or package is rejected; finalize wiring, permissions and input handling.
- Real npm data: `verify-canary-provenance.mjs 2026.1116.0-canary.7
b4fa1c7f... paperclipai @paperclipai/shared @paperclipai/server` passes;
the same version with another commit fails.
- `confirm-canary-publication.sh 2026.1116.0-canary.7 b4fa1c7f...` from
a checkout of that commit ran all steps against npm in 61 s and ended
with "canary/v2026.1116.0-canary.7 already points at b4fa1c7f...",
pushing nothing.
- `release.sh canary --dry-run --defer-registry-confirmation` and
`release.sh nightly --defer-registry-confirmation` both stop with "only
applies to a published canary".
- `actionlint` reports no new findings compared with master.
- Not verified before merge: a full publish through
`canary-finalize.yml`. It can run only from master. The first canary
after merge is the check.

## Risks

- Canary numbers jump from `canary.7` to about `canary.8144` (master has
8,143 commits). This is valid semver and still higher than every earlier
canary; users install through the `canary` dist-tag.
- The `canary/v` tag, Docker image and smoke now finish after the
release run ends. Nightly selects only tagged canaries, as before. If
finalize fails, that canary is on npm without a tag, so nightly skips
it, as it skips any canary whose old in-run verification failed.
- A canary can now publish while the previous one is still being
confirmed. Publishing itself is still serialized, so the `canary`
dist-tag only moves forward.

## Model Used

- Claude Opus 5.5 (`claude-opus-5-5`), Anthropic, in Claude Code with
tool use and code execution.

## Checklist

- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used (with version and capability
details)
- [x] I have checked ROADMAP.md and confirmed this PR does not duplicate
planned core work
- [x] I have searched GitHub for duplicate or related PRs and linked
them above
- [x] I have either (a) linked existing issues with `Fixes: #` / `Closes
#` / `Refs #` OR (b) described the issue in-PR following the relevant
issue template
- [x] I have not referenced internal/instance-local Paperclip issues or
links (only public GitHub `#NNN` / `github.com/paperclipai/paperclip`
URLs)
- [x] My branch name describes the change (e.g. `docs/...`, `fix/...`)
and contains no internal Paperclip ticket id or instance-derived details
- [x] I have run tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] I have updated relevant documentation to reflect my changes
- [x] I have considered and documented any risks above
- [ ] All Paperclip CI gates are green
- [ ] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [ ] I will address all Greptile and reviewer comments before
requesting merge

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 11:37:20 -06:00

500 lines
20 KiB
JavaScript

import assert from "node:assert/strict";
import { execFileSync } from "node:child_process";
import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { join } from "node:path";
import test from "node:test";
const repoRoot = new URL("..", import.meta.url).pathname.replace(/\/$/, "");
const releaseWorkflow = readFileSync(new URL("../.github/workflows/release.yml", import.meta.url), "utf8");
function workflowVerifyBudget() {
return {
verifyAttempts: Number(releaseWorkflow.match(/^ NPM_PUBLISH_VERIFY_ATTEMPTS: "(\d+)"$/m)?.[1]),
verifyDelaySeconds: Number(releaseWorkflow.match(/^ NPM_PUBLISH_VERIFY_DELAY_SECONDS: "(\d+)"$/m)?.[1]),
};
}
function writeExecutable(path, body) {
writeFileSync(path, body, { mode: 0o755 });
}
function runPublishHelper({
pnpmMode,
npmVersionExists = false,
distTag = "canary",
callerPipefail = true,
publishTool = "pnpm",
waitForRegistry = false,
npmVersionExistsAfterChecks = 0,
verifyAttempts = 1,
verifyDelaySeconds = 0,
visibilityPackages = null,
}) {
const fixtureDir = mkdtempSync(join(tmpdir(), "paperclip-release-lib-"));
const binDir = join(fixtureDir, "bin");
const stateDir = join(fixtureDir, "state");
const callLog = join(fixtureDir, "calls.log");
mkdirSync(binDir);
mkdirSync(stateDir);
writeFileSync(callLog, "");
writeExecutable(
join(binDir, "pnpm"),
`#!/usr/bin/env bash
set -euo pipefail
printf 'pnpm %s\\n' "$*" >> "$FAKE_CALL_LOG"
case "$PNPM_MODE" in
success)
echo "published"
exit 0
;;
tlog-then-success)
if [ ! -f "$FAKE_STATE_DIR/pnpm-called" ]; then
touch "$FAKE_STATE_DIR/pnpm-called"
echo "npm error code TLOG_CREATE_ENTRY_ERROR"
echo "npm error error creating tlog entry - (409) an equivalent entry already exists in the transparency log with UUID abc"
exit 1
fi
case " $* " in
*" --provenance=false "*)
echo "published without provenance"
exit 0
;;
*)
echo "retry did not disable provenance"
exit 1
;;
esac
;;
tlog-always-fails)
echo "npm error code TLOG_CREATE_ENTRY_ERROR"
echo "npm error error creating tlog entry - (409) an equivalent entry already exists in the transparency log with UUID abc"
exit 1
;;
non-tlog-failure)
echo "npm error code E500"
exit 1
;;
esac
exit 1
`,
);
writeExecutable(
join(binDir, "npm"),
`#!/usr/bin/env bash
set -euo pipefail
printf 'npm %s\\n' "$*" >> "$FAKE_CALL_LOG"
if [ "$1" = "view" ]; then
if [ "\${NPM_VIEW_CROSS:-}" = "true" ]; then
# Cross-visibility mode: a package resolves only after every OTHER
# package has been polled at least once. Mutually dependent visibility
# can only converge when the polls run concurrently.
spec="$2"
name="\${spec%@*}"
safe="$(printf '%s' "$name" | tr '/@' '__')"
touch "$FAKE_STATE_DIR/seen-$safe"
all_seen=true
for other in $CROSS_PACKAGES; do
osafe="$(printf '%s' "$other" | tr '/@' '__')"
[ "$osafe" = "$safe" ] && continue
[ -f "$FAKE_STATE_DIR/seen-$osafe" ] || all_seen=false
done
if [ "$all_seen" = "true" ]; then
echo "1.2.3"
exit 0
fi
exit 1
fi
checks=0
if [ -f "$FAKE_STATE_DIR/view-checks" ]; then
read -r checks < "$FAKE_STATE_DIR/view-checks"
fi
checks=$((checks + 1))
echo "$checks" > "$FAKE_STATE_DIR/view-checks"
if [ "$NPM_VERSION_EXISTS" = "true" ] ||
{ [ "$NPM_VERSION_EXISTS_AFTER_CHECKS" -gt 0 ] && [ "$checks" -ge "$NPM_VERSION_EXISTS_AFTER_CHECKS" ]; }; then
echo "1.2.3"
exit 0
fi
fi
if [ "$1" = "publish" ]; then
case "$PNPM_MODE" in
success)
echo "published"
exit 0
;;
tlog-then-success)
if [ ! -f "$FAKE_STATE_DIR/npm-called" ]; then
touch "$FAKE_STATE_DIR/npm-called"
echo "npm error code TLOG_CREATE_ENTRY_ERROR"
echo "npm error error creating tlog entry - (409) an equivalent entry already exists in the transparency log with UUID abc"
exit 1
fi
case " $* " in
*" --provenance=false "*)
echo "published without provenance"
exit 0
;;
esac
;;
tlog-always-fails)
echo "npm error code TLOG_CREATE_ENTRY_ERROR"
echo "npm error error creating tlog entry - (409) an equivalent entry already exists in the transparency log with UUID abc"
exit 1
;;
non-tlog-failure)
echo "npm error code E500"
exit 1
;;
esac
fi
exit 1
`,
);
writeExecutable(
join(binDir, "npx"),
`#!/usr/bin/env bash
set -euo pipefail
printf 'npx %s\n' "$*" >> "$FAKE_CALL_LOG"
[ "$1" = "--yes" ] && shift
case "$1" in
npm@10.9.7|npm@11.18.0) shift ;;
esac
exec npm "$@"
`,
);
const shellOptions = callerPipefail ? "set -euo pipefail" : "set -eu";
// The cross-visibility concurrency test needs real (fractional-second)
// sleeps so slower-starting sibling polls get a chance to run; every other
// test records virtual waiting so registry-delay tests stay fast/offline.
const sleepStub = visibilityPackages
? ""
: `sleep() { printf 'sleep %s\\n' "$*" >> "$FAKE_CALL_LOG"; }`;
const packageInfo = (
visibilityPackages ?? ["@paperclipai/example"]
)
.map((name) => `packages/example\\t${name}\\t1.2.3`)
.join("\\n");
const script = `
${shellOptions}
source "${repoRoot}/scripts/release-lib.sh"
${sleepStub}
${
visibilityPackages
? `PACKAGE_INFO="$(printf '${packageInfo}')"
wait_for_npm_package_versions "$VERIFY_ATTEMPTS" "$VERIFY_DELAY_SECONDS" "$PACKAGE_INFO"`
: waitForRegistry
? `publish_package_to_npm ${distTag} @paperclipai/example 1.2.3 ${publishTool}
PACKAGE_INFO="$(printf '${packageInfo}')"
wait_for_npm_package_versions "$VERIFY_ATTEMPTS" "$VERIFY_DELAY_SECONDS" "$PACKAGE_INFO"`
: `publish_package_to_npm ${distTag} @paperclipai/example 1.2.3 ${publishTool}`
}
`;
let status = 0;
let output = "";
try {
output = execFileSync("bash", ["-c", script], {
cwd: fixtureDir,
encoding: "utf8",
env: {
...process.env,
PATH: `${binDir}:${process.env.PATH}`,
FAKE_CALL_LOG: callLog,
FAKE_STATE_DIR: stateDir,
NPM_VERSION_EXISTS: npmVersionExists ? "true" : "false",
NPM_VERSION_EXISTS_AFTER_CHECKS: String(npmVersionExistsAfterChecks),
VERIFY_ATTEMPTS: String(verifyAttempts),
VERIFY_DELAY_SECONDS: String(verifyDelaySeconds),
NPM_VIEW_CROSS: visibilityPackages ? "true" : "false",
CROSS_PACKAGES: (visibilityPackages ?? []).join(" "),
PNPM_MODE: pnpmMode,
REPO_ROOT: fixtureDir,
},
stdio: ["ignore", "pipe", "pipe"],
});
} catch (error) {
status = error.status ?? 1;
output = `${error.stdout ?? ""}${error.stderr ?? ""}`;
}
return {
calls: readFileSync(callLog, "utf8"),
output,
status,
};
}
test("publish_package_to_npm returns after a successful pnpm publish", () => {
const result = runPublishHelper({ pnpmMode: "success" });
assert.equal(result.status, 0);
assert.match(result.calls, /^pnpm publish --no-git-checks --tag canary --access public$/m);
assert.doesNotMatch(result.calls, /npm view/);
assert.doesNotMatch(result.calls, /--provenance=false/);
});
test("publish_package_to_npm uses trusted publishing from the bundled staging directory", () => {
const result = runPublishHelper({ pnpmMode: "success", publishTool: "npm" });
assert.equal(result.status, 0);
assert.match(
result.calls,
/^npx --yes npm@11\.18\.0 publish --tag canary --access public --ignore-scripts --loglevel verbose$/m,
);
assert.match(
result.calls,
/^npm publish --tag canary --access public --ignore-scripts --loglevel verbose$/m,
);
assert.doesNotMatch(result.calls, / pack /);
assert.doesNotMatch(result.calls, /^pnpm publish/m);
});
test("publish_package_to_npm retries bundled directory tlog failures without provenance", () => {
const result = runPublishHelper({ pnpmMode: "tlog-then-success", publishTool: "npm" });
assert.equal(result.status, 0);
assert.match(result.calls, /^npm view @paperclipai\/example@1\.2\.3 version$/m);
assert.match(
result.calls,
/^npm publish --tag canary --access public --provenance=false --ignore-scripts --loglevel verbose$/m,
);
});
test("publish_package_to_npm retries duplicate tlog failures without provenance", () => {
const result = runPublishHelper({ pnpmMode: "tlog-then-success" });
assert.equal(result.status, 0);
assert.match(result.calls, /^npm view @paperclipai\/example@1\.2\.3 version$/m);
assert.match(
result.calls,
/^pnpm publish --no-git-checks --tag canary --access public --provenance=false$/m,
);
});
test("publish_package_to_npm treats a duplicate tlog failure as complete when npm exposes the version", () => {
const result = runPublishHelper({ pnpmMode: "tlog-always-fails", npmVersionExists: true });
assert.equal(result.status, 0);
assert.match(result.calls, /^npm view @paperclipai\/example@1\.2\.3 version$/m);
assert.doesNotMatch(result.calls, /--provenance=false/);
});
test("publish_package_to_npm does not retry unrelated publish failures", () => {
const result = runPublishHelper({ pnpmMode: "non-tlog-failure" });
assert.notEqual(result.status, 0);
assert.doesNotMatch(result.calls, /npm view/);
assert.doesNotMatch(result.calls, /--provenance=false/);
});
test("publish_package_to_npm does not mask failures when caller has no pipefail", () => {
const result = runPublishHelper({ pnpmMode: "non-tlog-failure", callerPipefail: false });
assert.notEqual(result.status, 0);
assert.doesNotMatch(result.calls, /npm view/);
assert.doesNotMatch(result.calls, /--provenance=false/);
});
test("publish_package_to_npm does not retry stable publishes without provenance", () => {
const result = runPublishHelper({ pnpmMode: "tlog-then-success", distTag: "latest" });
assert.notEqual(result.status, 0);
assert.match(result.calls, /^npm view @paperclipai\/example@1\.2\.3 version$/m);
assert.doesNotMatch(result.calls, /--provenance=false/);
});
test("wait_for_npm_package_versions confirms registry visibility after a publish", () => {
const result = runPublishHelper({
pnpmMode: "success",
npmVersionExists: true,
waitForRegistry: true,
});
assert.equal(result.status, 0);
assert.match(result.calls, /^pnpm publish --no-git-checks --tag canary --access public$/m);
assert.match(result.calls, /^npm view @paperclipai\/example@1\.2\.3 version$/m);
});
test("wait_for_npm_package_versions blocks the release and names the straggler", () => {
const result = runPublishHelper({ pnpmMode: "success", waitForRegistry: true });
assert.notEqual(result.status, 0);
assert.match(result.calls, /^npm view @paperclipai\/example@1\.2\.3 version$/m);
assert.match(result.output, /did not become registry-visible: @paperclipai\/example@1\.2\.3/);
});
test("wait_for_npm_package_versions polls every package concurrently", () => {
// In cross-visibility mode each fake package resolves only after the OTHER
// package has been polled at least once. Waiting out one package's full
// budget before polling the next can never satisfy the first package;
// only concurrent polling converges.
const result = runPublishHelper({
pnpmMode: "success",
visibilityPackages: ["@paperclipai/alpha", "@paperclipai/beta"],
verifyAttempts: 50,
verifyDelaySeconds: 0.2,
});
assert.equal(result.status, 0, result.output);
assert.match(result.output, /@paperclipai\/alpha@1\.2\.3 is registry-visible/);
assert.match(result.output, /@paperclipai\/beta@1\.2\.3 is registry-visible/);
});
test("the workflow budget tolerates the observed 15-minute 20-second registry delay", () => {
const budget = workflowVerifyBudget();
assert.ok(budget.verifyDelaySeconds > 0);
const delayedCheck = Math.ceil((15 * 60 + 20) / budget.verifyDelaySeconds) + 1;
const result = runPublishHelper({
pnpmMode: "success",
waitForRegistry: true,
npmVersionExistsAfterChecks: delayedCheck,
...budget,
});
assert.equal(result.status, 0, result.output);
assert.equal(result.calls.match(/^pnpm publish /gm)?.length, 1);
assert.equal(result.calls.match(/^npm view /gm)?.length, delayedCheck);
assert.deepEqual(
result.calls.split("\n").filter((call) => call.startsWith("sleep ")),
Array(delayedCheck - 1).fill(`sleep ${budget.verifyDelaySeconds}`),
);
});
test("the workflow budget does not delay an immediately visible publish", () => {
const result = runPublishHelper({
pnpmMode: "success",
npmVersionExists: true,
waitForRegistry: true,
...workflowVerifyBudget(),
});
assert.equal(result.status, 0, result.output);
assert.equal(result.calls.match(/^npm view /gm)?.length, 1);
assert.doesNotMatch(result.calls, /^sleep /m);
});
test("the workflow budget fails closed after the last registry check", () => {
const budget = workflowVerifyBudget();
assert.ok(budget.verifyAttempts > 0);
const result = runPublishHelper({
pnpmMode: "success",
waitForRegistry: true,
npmVersionExistsAfterChecks: budget.verifyAttempts + 1,
...budget,
});
assert.notEqual(result.status, 0);
assert.match(result.output, /did not become registry-visible/);
assert.equal(result.calls.match(/^pnpm publish /gm)?.length, 1);
assert.equal(result.calls.match(/^npm view /gm)?.length, budget.verifyAttempts);
assert.equal(result.calls.match(/^sleep /gm)?.length, budget.verifyAttempts - 1);
});
test("every publish job budgets for build time and four delayed packages", () => {
const { verifyAttempts, verifyDelaySeconds } = workflowVerifyBudget();
const pollingSeconds = (verifyAttempts - 1) * verifyDelaySeconds;
const requiredSeconds = 30 * 60 + 4 * pollingSeconds;
for (const job of ["publish_canary", "publish_nightly", "publish_beta", "publish_stable"]) {
const body = releaseWorkflow.split(`\n ${job}:\n`)[1]?.split(/\n [a-z_]+:\n/)[0] ?? "";
const timeoutMinutes = Number(body.match(/^ timeout-minutes: (\d+)$/m)?.[1]);
assert.ok(timeoutMinutes * 60 > requiredSeconds, `${job} must leave time beyond build and polling`);
}
});
function canaryNumberFixture({ commits, publishedVersions, shallow = false }) {
const dir = mkdtempSync(join(tmpdir(), "paperclip-canary-number-"));
const source = join(dir, "source");
mkdirSync(source);
const git = (cwd, ...args) => execFileSync("git", args, { cwd, encoding: "utf8", env: { ...process.env, GIT_AUTHOR_NAME: "t", GIT_AUTHOR_EMAIL: "t@example.test", GIT_COMMITTER_NAME: "t", GIT_COMMITTER_EMAIL: "t@example.test" } });
git(source, "init", "-q", "-b", "master");
for (let index = 0; index < commits; index += 1) git(source, "commit", "-q", "--allow-empty", "-m", `c${index}`);
let repo = source;
if (shallow) {
repo = join(dir, "shallow");
git(dir, "clone", "-q", "--depth", "1", `file://${source}`, repo);
}
const versionsFile = join(dir, "versions.json");
writeFileSync(versionsFile, JSON.stringify({ "@paperclipai/shared": publishedVersions, paperclipai: publishedVersions }));
return { dir, repo, versionsFile, git };
}
function nextCanary(fixture, { allowFallback = false, attempt = "1" } = {}) {
const script = `source "${repoRoot}/scripts/release-lib.sh"; next_canary_version_from_source "$1" "$2" 2026.1116.0 "$3" @paperclipai/shared paperclipai`;
return execFileSync("bash", ["-c", script, "next-canary", fixture.repo, String(allowFallback), attempt], {
encoding: "utf8", env: { ...process.env, RELEASE_PACKAGE_VERSIONS_FILE: fixture.versionsFile }, stdio: ["ignore", "pipe", "pipe"],
}).trim();
}
test("a canary is numbered from its master position and run attempt, ignoring other commits' numbers", () => {
const fixture = canaryNumberFixture({ commits: 25, publishedVersions: ["2026.1116.0-canary.2600", "2026.1116.0-canary.9999"] });
assert.equal(nextCanary(fixture), "2026.1116.0-canary.2500");
assert.equal(nextCanary(fixture, { attempt: "2" }), "2026.1116.0-canary.2501");
assert.equal(nextCanary(fixture, { attempt: "99" }), "2026.1116.0-canary.2598");
});
test("publishing the same commit again outside a rerun moves to the next free number in its own range", () => {
const fixture = canaryNumberFixture({ commits: 25, publishedVersions: ["2026.1116.0-canary.2500", "2026.1116.0-canary.2501", "2026.1116.0-canary.2600", "2026.1115.0-canary.2502"] });
assert.equal(nextCanary(fixture), "2026.1116.0-canary.2502");
assert.equal(nextCanary(fixture, { attempt: "3" }), "2026.1116.0-canary.2502");
assert.equal(nextCanary(fixture, { attempt: "4" }), "2026.1116.0-canary.2503");
const full = canaryNumberFixture({ commits: 25, publishedVersions: Array.from({ length: 100 }, (_, index) => `2026.1116.0-canary.${2500 + index}`) });
assert.throws(() => nextCanary(full), /every canary number for master position 25 is already published/);
});
test("reruns of one commit never reach the next commit's numbers", () => {
const earlier = canaryNumberFixture({ commits: 25, publishedVersions: [] });
const later = canaryNumberFixture({ commits: 26, publishedVersions: [] });
const earlierNumbers = new Set(Array.from({ length: 99 }, (_, index) => nextCanary(earlier, { attempt: String(index + 1) })));
assert.equal(earlierNumbers.size, 99);
assert.equal(earlierNumbers.has(nextCanary(later)), false);
});
test("an invalid run attempt is refused", () => {
const fixture = canaryNumberFixture({ commits: 3, publishedVersions: [] });
for (const attempt of ["0", "100", "", "1a"]) assert.throws(() => nextCanary(fixture, { attempt }), /run attempt from 1 to 99/);
});
test("a publishing canary refuses a shallow checkout, and a dry run falls back to the registry number", () => {
const fixture = canaryNumberFixture({ commits: 5, publishedVersions: ["2026.1116.0-canary.7"], shallow: true });
assert.throws(() => nextCanary(fixture), /needs the full master history/);
assert.equal(nextCanary(fixture, { allowFallback: true }), "2026.1116.0-canary.8");
});
test("a canary tag is pushed once, accepted again on the same commit, and refused on another commit", () => {
const fixture = canaryNumberFixture({ commits: 2, publishedVersions: [] });
const remote = join(fixture.dir, "remote.git");
fixture.git(fixture.dir, "init", "-q", "--bare", remote);
fixture.git(fixture.repo, "remote", "add", "origin", remote);
const [head, parent] = fixture.git(fixture.repo, "rev-list", "-2", "HEAD").trim().split("\n");
const pushTag = (sha) => execFileSync("bash", ["-c", `REPO_ROOT="$1"; source "${repoRoot}/scripts/release-lib.sh"; push_release_tag_at origin canary/v2026.1116.0-canary.200 "$2"`, "push-tag", fixture.repo, sha],
{ encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
assert.match(pushTag(head), /Pushed canary\/v2026\.1116\.0-canary\.200/);
assert.equal(fixture.git(fixture.dir, "--git-dir", remote, "rev-parse", "canary/v2026.1116.0-canary.200").trim(), head);
assert.match(pushTag(head), /already points at/);
fixture.git(fixture.repo, "tag", "-d", "canary/v2026.1116.0-canary.200");
assert.throws(() => pushTag(parent), /already exists on [0-9a-f]{40}, not/);
assert.equal(fixture.git(fixture.dir, "--git-dir", remote, "rev-parse", "canary/v2026.1116.0-canary.200").trim(), head);
});
test("a canary version is accepted only for the master commit whose position numbered it", () => {
const fixture = canaryNumberFixture({ commits: 25, publishedVersions: [] });
const head = fixture.git(fixture.repo, "rev-parse", "HEAD").trim();
fixture.git(fixture.repo, "update-ref", "refs/remotes/origin/master", head);
const confirm = (version, sha) => execFileSync("bash", ["-c", `REPO_ROOT="$1"; source "${repoRoot}/scripts/release-lib.sh"; require_canary_number_from_master_commit "$2" "$3"`, "confirm", fixture.repo, version, sha],
{ encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
assert.match(confirm("2026.1116.0-canary.2500", head), /numbered from .* \(master position 25\)/);
assert.match(confirm("2026.1116.0-canary.2503", head), /master position 25/);
assert.throws(() => confirm("2026.1116.0-canary.2600", head), /was not numbered from/);
assert.throws(() => confirm("2026.1116.0-canary.7", head), /was not numbered from/);
fixture.git(fixture.repo, "checkout", "-q", "-b", "side");
fixture.git(fixture.repo, "commit", "-q", "--allow-empty", "-m", "side");
const side = fixture.git(fixture.repo, "rev-parse", "HEAD").trim();
assert.throws(() => confirm("2026.1116.0-canary.2600", side), /is not on origin\/master/);
});