@decohere/ci-tools 0.0.1-dev.119 → 0.0.1-dev.12

package/tests/bench/history.test.mjs

@@ -1,279 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	appendRun,
-	assertValid,
-	compare,
-	contextId,
-	compareRounds,
-	latestRun,
-	pruneStale,
-	formatComparison,
-	fromVitest,
-	getContext,
-	normalize,
-	parseResults,
-	previousRun,
-	RESULT_PREFIX,
-} from "../../src/bench/history.mjs";
-
-const fakeOs = {
-	cpus: () => [{ model: " Test CPU " }, { model: "Test CPU" }],
-	platform: () => "linux",
-	arch: () => "x64",
-	totalmem: () => 16 * 1024 ** 3,
-};
-const ctx = getContext(
-	fakeOs,
-	{ BENCH_ENV: "gh-actions" },
-	"v24.1.0",
-	new Date("2026-10-20T03:17:00Z"),
-);
-
-const result = (id, median, extra = {}) => ({
-	id,
-	label: id,
-	unit: "ms",
-	median,
-	p90: median * 1.2,
-	min: median * 0.9,
-	max: median * 1.3,
-	samples: 5,
-	...extra,
-});
-
-const vitestOutput = {
-	files: [
-		{
-			groups: [
-				{
-					benchmarks: [
-						{
-							name: "forge build es6 + types (18 files)",
-							mean: 70,
-							median: 64,
-							min: 60,
-							max: 80,
-							sampleCount: 5,
-						},
-						{
-							name: "forge build es6 only (18 files)",
-							mean: 10,
-							min: 8,
-							max: 12,
-							sampleCount: 5,
-						},
-					],
-				},
-			],
-		},
-	],
-};
-
-describe("getContext / contextId", () => {
-	it("describes the machine and names the CI environment with the Node major", () => {
-		expect(ctx).toEqual({
-			benchEnv: "gh-actions-node24",
-			date: "2026-10-20T03:17:00.000Z",
-			os: { platform: "linux", arch: "x64" },
-			cpu: { model: "Test CPU", count: 2 },
-			memoryGb: 16,
-			node: "v24.1.0",
-		});
-		expect(getContext(fakeOs, {}, "v24.1.0").benchEnv).toBe("(local)");
-	});
-
-	it("gives the same id to the same machine regardless of date or env label", () => {
-		const later = getContext(fakeOs, {}, "v24.1.0", new Date("2027-01-01"));
-		expect(contextId(later)).toBe(contextId(ctx));
-		expect(contextId({ ...ctx, cpu: { ...ctx.cpu, count: 4 } })).not.toBe(contextId(ctx));
-	});
-});
-
-describe("parseResults", () => {
-	it("reads the last result line among other output", () => {
-		const results = [result("flux.load.cold", 250)];
-		const output = `flux load: median 250 ms\n${RESULT_PREFIX}[]\n${RESULT_PREFIX}${JSON.stringify(results)}\n`;
-		expect(parseResults(output, "flux-load")).toEqual(results);
-	});
-
-	it("fails, naming the suite, when there is no result line", () => {
-		expect(() => parseResults("crashed\n", "flux-serve")).toThrow(/flux-serve/);
-	});
-});
-
-describe("fromVitest", () => {
-	it("maps forge benchmarks to stable ids, keeping the file count out of the label", () => {
-		expect(fromVitest(vitestOutput)).toEqual([
-			{
-				id: "forge.build.local",
-				label: "forge build es6 + types",
-				unit: "ms",
-				median: 64,
-				min: 60,
-				max: 80,
-				samples: 5,
-				files: 18,
-			},
-			// No median from vitest: the mean stands in.
-			expect.objectContaining({ id: "forge.build.debug", median: 10, files: 18 }),
-		]);
-	});
-
-	it("fails on a benchmark it has no id for, instead of charting it under a moving name", () => {
-		const output = {
-			files: [{ groups: [{ benchmarks: [{ name: "something new", mean: 1 }] }] }],
-		};
-		expect(() => fromVitest(output)).toThrow(/something new/);
-	});
-});
-
-describe("assertValid", () => {
-	it("passes real results and rejects NaN or empty ones, naming them", () => {
-		expect(() => assertValid([result("a", 1)])).not.toThrow();
-		expect(() =>
-			assertValid([result("a", 1), result("b", Number.NaN), result("c", 2, { samples: 0 })]),
-		).toThrow(/b, c/);
-	});
-});
-
-describe("normalize", () => {
-	it("keeps a version 2 history as it is", () => {
-		const history = { version: 2, contexts: { x: { context: ctx, runs: [] } } };
-		expect(normalize(history)).toBe(history);
-	});
-
-	it("converts version 1 forge runs so their trend carries on", () => {
-		const v1 = {
-			runs: {
-				abc: {
-					context: ctx,
-					runs: [{ date: "2026-08-12T14:18:10Z", context: ctx, vitestOutput }],
-				},
-				empty: { context: ctx, runs: [] },
-			},
-		};
-		const history = normalize(v1);
-		expect(Object.keys(history.contexts)).toEqual(["abc"]);
-		expect(history.contexts.abc.runs[0]).toMatchObject({
-			date: "2026-08-12T14:18:10Z",
-			sha: null,
-			results: [{ id: "forge.build.local" }, { id: "forge.build.debug" }],
-		});
-	});
-
-	it("starts empty when there is no history", () => {
-		expect(normalize(null)).toEqual({ version: 2, contexts: {} });
-	});
-});
-
-describe("appendRun / previousRun", () => {
-	const run = (day) => ({
-		date: `2026-10-${day}T03:17:00Z`,
-		sha: `sha${day}`,
-		results: [result("a", Number(day))],
-	});
-
-	it("puts the new run first, trims to the limit, and leaves the input untouched", () => {
-		const empty = normalize(null);
-		const one = appendRun(empty, ctx, run("18"), 2);
-		const two = appendRun(one, ctx, run("19"), 2);
-		const three = appendRun(two, ctx, run("20"), 2);
-
-		expect(empty.contexts).toEqual({});
-		expect(one.contexts[contextId(ctx)].runs).toHaveLength(1);
-		expect(three.contexts[contextId(ctx)].runs.map((r) => r.sha)).toEqual(["sha20", "sha19"]);
-		expect(previousRun(three, contextId(ctx))?.sha).toBe("sha20");
-		expect(previousRun(three, "other-machine")).toBeUndefined();
-	});
-});
-
-describe("compare / formatComparison", () => {
-	it("reports the change in median against the previous run, and n/a for new benchmarks", () => {
-		const rows = compare([result("a", 120), result("new", 5)], {
-			results: [result("a", 100)],
-		});
-		expect(rows).toEqual([
-			{ id: "a", current: 120, previous: 100, delta: 20, percent: 20 },
-			{ id: "new", current: 5 },
-		]);
-
-		const table = formatComparison(rows).split("\n");
-		expect(table[0]).toMatch(/^Benchmark \| +Median \| Previous \| +Delta \| +%$/);
-		expect(table[2]).toMatch(/^a +\| +120\.0 ms \| +100\.0 ms \| +\+20\.0 ms \| \+20\.0%$/);
-		expect(table[3]).toMatch(/^new +\| +5\.0 ms \| +n\/a \| +n\/a \| +n\/a$/);
-	});
-
-	it("compares against nothing on a machine's first run", () => {
-		expect(compare([result("a", 1)], undefined)).toEqual([{ id: "a", current: 1 }]);
-	});
-});
-
-describe("compareRounds", () => {
-	const round = (...medians) => medians.map((median, index) => result(`b${index}`, median));
-
-	it("flags a benchmark slower on head than base in every round, with both rounds' numbers", () => {
-		const [regression] = compareRounds([round(130, 50)], [round(100, 50)], {
-			threshold: 0.2,
-			rounds: 1,
-		});
-		expect(regression).toMatchObject({
-			id: "b0",
-			base: 100,
-			head: 130,
-			rounds: [{ base: 100, head: 130 }],
-		});
-		expect(regression.percent).toBeCloseTo(30);
-	});
-
-	it("needs every round slower: one slow round is as likely the runner as the code", () => {
-		expect(compareRounds([round(130), round(105)], [round(100), round(100)])).toEqual([]);
-		expect(compareRounds([round(130), round(126)], [round(100), round(100)])).toHaveLength(1);
-	});
-
-	it("ignores slowdowns within the threshold", () => {
-		expect(compareRounds([round(115), round(118)], [round(100), round(100)])).toEqual([]);
-	});
-
-	it("skips benchmarks only one side has, and compares nothing without enough rounds", () => {
-		const head = [
-			[result("new", 500), result("old", 100)],
-			[result("new", 500), result("old", 100)],
-		];
-		const base = [[result("old", 100)], [result("old", 100)]];
-		expect(compareRounds(head, base)).toEqual([]);
-		expect(compareRounds([round(200)], [round(100)])).toEqual([]);
-	});
-});
-
-describe("pruneStale / latestRun", () => {
-	const at = (date, sha) => ({ date, sha, results: [] });
-	const history = {
-		version: 2,
-		contexts: {
-			old: { context: ctx, runs: [at("2026-08-12T03:17:00Z", "aaa")] },
-			recent: {
-				context: ctx,
-				runs: [at("2026-10-20T03:17:00Z", "ccc"), at("2026-10-19T03:17:00Z", "bbb")],
-			},
-		},
-	};
-
-	it("drops machine types with no run in the last 30 days", () => {
-		expect(
-			Object.keys(pruneStale(history, new Date("2026-10-21T00:00:00Z")).contexts),
-		).toEqual(["recent"]);
-		expect(
-			Object.keys(pruneStale(history, new Date("2026-09-01T00:00:00Z")).contexts),
-		).toEqual(["old", "recent"]);
-	});
-
-	it("prunes when a run is appended", () => {
-		const next = appendRun(history, ctx, at("2026-10-21T03:17:00Z", "ddd"));
-		expect(Object.keys(next.contexts)).not.toContain("old");
-	});
-
-	it("finds the newest run on any machine: the commit the previous nightly measured", () => {
-		expect(latestRun(history)?.sha).toBe("ccc");
-		expect(latestRun({ version: 2, contexts: {} })).toBeUndefined();
-	});
-});

package/tests/bench/regression-issue.test.mjs

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { issueBody, issueTitle } from "../../src/bench/regression-issue.mjs";
-
-const regression = {
-	id: "flux.load.cold",
-	label: "flux load, first import (cold process)",
-	base: 300,
-	head: 400,
-	percent: 33.3,
-	rounds: [
-		{ base: 300, head: 395 },
-		{ base: 300, head: 405 },
-	],
-};
-const context = {
-	repoUrl: "https://github.com/typesmiths/decohere",
-	runUrl: "https://github.com/typesmiths/decohere/actions/runs/1",
-	machine: "gh-actions-node24, Test CPU × 4",
-	threshold: 0.2,
-	base: "aaaaaaaaaaaaaaaa",
-	head: "cccccccccccccccc",
-};
-
-describe("regression issue", () => {
-	it("has one stable title per benchmark, so the nightly run finds and updates it", () => {
-		expect(issueTitle(regression)).toBe("perf(bench): flux.load.cold is slower");
-	});
-
-	it("gives both rounds, the commit range and how to reproduce", () => {
-		const body = issueBody(regression, context);
-		expect(body).toContain(
-			"is 33% slower on [`ccccccc`](https://github.com/typesmiths/decohere/commit/cccccccccccccccc)",
-		);
-		expect(body).toContain("| 1 | 300.0 ms | 395.0 ms |");
-		expect(body).toContain("| 2 | 300.0 ms | 405.0 ms |");
-		expect(body).toContain(
-			"(https://github.com/typesmiths/decohere/compare/aaaaaaaaaaaaaaaa...cccccccccccccccc)",
-		);
-		expect(body).toContain("check out `aaaaaaa`, run `pnpm bench:save`");
-		expect(body).toContain(context.runUrl);
-	});
-});

package/tests/github/credential-nudge.test.mjs

@@ -1,116 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	assessTokenLifetime,
-	buildDescription,
-	CREDENTIALS,
-	credentialProfile,
-	ghScopeFlags,
-	issueTitle,
-	parseExpiresAt,
-	rotationCommands,
-	runNudge,
-	suggestedNextExpiry,
-} from "../../src/github/credential-nudge.mjs";
-
-/** Records each upsert and answers like a newly opened issue. */
-function recordUpserts() {
-	/** @type {{ title: string, body: string }[]} */
-	const upserts = [];
-	const upsert = (options) => {
-		upserts.push(options);
-		return {
-			number: 9,
-			url: "https://github.com/typesmiths/decohere/issues/9",
-			created: true,
-		};
-	};
-	return { upserts, upsert };
-}
-
-function inDays(days) {
-	return suggestedNextExpiry(Date.now(), days);
-}
-
-describe("credential-nudge", () => {
-	it("parses YYYY-MM-DD as a UTC day", () => {
-		expect(parseExpiresAt("2026-11-19")).toBe(Date.UTC(2026, 10, 19));
-		expect(parseExpiresAt("")).toBeNull();
-	});
-
-	it("is ok more than 14 days out, warns inside the window, expires on the day", () => {
-		const expiresAtMs = Date.UTC(2026, 10, 19);
-		const now = (day) => Date.UTC(2026, 10, day, 15);
-		expect(assessTokenLifetime({ now: now(1), expiresAtMs }).kind).toBe("ok");
-		expect(assessTokenLifetime({ now: now(5), expiresAtMs })).toEqual({
-			kind: "warn",
-			daysLeft: 14,
-		});
-		expect(assessTokenLifetime({ now: now(18), expiresAtMs }).kind).toBe("warn");
-		expect(assessTokenLifetime({ now: now(19), expiresAtMs })).toEqual({
-			kind: "expired",
-			daysLeft: 0,
-		});
-		expect(assessTokenLifetime({ now: now(20), expiresAtMs }).kind).toBe("expired");
-		expect(assessTokenLifetime({ expiresAtMs: null }).kind).toBe("missing");
-	});
-
-	it("parameterizes GHCR vs npm rotate commands without duplicating date logic", () => {
-		const ghcr = credentialProfile("ghcr");
-		const npm = credentialProfile("npm");
-		expect(ghScopeFlags(ghcr)).toBe("--env ghcr-publish ");
-		expect(ghScopeFlags(npm)).toBe("");
-		expect(rotationCommands(ghcr, "2027-02-17", "typesmiths/decohere")).toContain(
-			"gh secret set GHCR_PUSH_TOKEN --env ghcr-publish --repo typesmiths/decohere",
-		);
-		expect(rotationCommands(npm, "2027-02-17", "typesmiths/decohere")).toContain(
-			"gh secret set NODE_AUTH_TOKEN --repo typesmiths/decohere",
-		);
-		expect(rotationCommands(npm, "2027-02-17", "typesmiths/decohere")).toContain(
-			"gh variable set NODE_AUTH_TOKEN_EXPIRES_AT --repo typesmiths/decohere --body 2027-02-17",
-		);
-		expect(issueTitle(npm, "2026-11-19")).toBe(
-			"chore(security): rotate NODE_AUTH_TOKEN (expires 2026-11-19)",
-		);
-		const body = buildDescription(ghcr, {
-			kind: "warn",
-			expiresYmd: "2026-11-19",
-			daysLeft: 14,
-			rejected: false,
-		});
-		expect(body).toContain("Docker login/push and the `v*` tag will **fail**");
-		expect(CREDENTIALS.npm.secret).toBe("NODE_AUTH_TOKEN");
-		expect(suggestedNextExpiry(Date.UTC(2026, 7, 21), 90)).toBe("2026-11-19");
-		expect(() => credentialProfile("nope")).toThrow(/Unknown NUDGE_CREDENTIAL/);
-	});
-
-	it("files nothing and passes while the token has more than 14 days left", async () => {
-		const { upserts, upsert } = recordUpserts();
-		const env = { NUDGE_CREDENTIAL: "npm", NODE_AUTH_TOKEN_EXPIRES_AT: inDays(30) };
-		expect(await runNudge(env, upsert)).toBe(0);
-		expect(upserts).toEqual([]);
-	});
-
-	it("files a rotation issue but lets Publish continue inside the warning window", async () => {
-		const { upserts, upsert } = recordUpserts();
-		const expires = inDays(10);
-		const env = { NUDGE_CREDENTIAL: "npm", NODE_AUTH_TOKEN_EXPIRES_AT: expires };
-		expect(await runNudge(env, upsert)).toBe(0);
-		expect(upserts).toHaveLength(1);
-		expect(upserts[0].title).toBe(
-			`chore(security): rotate NODE_AUTH_TOKEN (expires ${expires})`,
-		);
-		expect(upserts[0].body).toContain("Close this issue, then retry Publish");
-	});
-
-	it("files a rotation issue and stops Publish once the token has expired or was rejected", async () => {
-		const expired = recordUpserts();
-		const env = { NUDGE_CREDENTIAL: "ghcr", GHCR_TOKEN_EXPIRES_AT: inDays(0) };
-		expect(await runNudge(env, expired.upsert)).toBe(1);
-		expect(expired.upserts).toHaveLength(1);
-
-		const rejected = recordUpserts();
-		const rejectedEnv = { ...env, GHCR_TOKEN_EXPIRES_AT: inDays(60), NUDGE_REJECTED: "1" };
-		expect(await runNudge(rejectedEnv, rejected.upsert)).toBe(1);
-		expect(rejected.upserts[0].body).toContain(CREDENTIALS.ghcr.rejectedWhy);
-	});
-});

package/tests/github/oidc-bootstrap-nudge.test.mjs

@@ -1,89 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-	buildDescription,
-	extractGitHubReviewerLogins,
-	firstPublishCommands,
-	issueTitle,
-	needsPrereleaseTag,
-	parseUnpublished,
-	runNudge,
-} from "../../src/github/oidc-bootstrap-nudge.mjs";
-
-describe("oidc-bootstrap-nudge", () => {
-	it("parses unpublished names", () => {
-		expect(parseUnpublished(" @decohere/scaffold  @decohere/cli ")).toEqual([
-			"@decohere/scaffold",
-			"@decohere/cli",
-		]);
-		expect(issueTitle()).toBe("deploy(publish): OIDC bootstrap unpublished packages");
-	});
-
-	it("extracts GitHub user reviewers and skips teams", () => {
-		expect(
-			extractGitHubReviewerLogins({
-				protection_rules: [
-					{ type: "branch_policy", reviewers: [] },
-					{
-						type: "required_reviewers",
-						reviewers: [
-							{ type: "User", reviewer: { login: "das974" } },
-							{ type: "Team", reviewer: { slug: "publishers", login: "should-skip" } },
-						],
-					},
-				],
-			}),
-		).toEqual(["das974"]);
-	});
-
-	it("puts first-publish commands and Trusted Publisher fields in the task body", () => {
-		const pkg = { name: "@decohere/scaffold", dir: "scaffold", version: "0.0.1-dev.18" };
-		const body = buildDescription({
-			unpublished: ["@decohere/scaffold"],
-			packages: [pkg],
-			repo: "typesmiths/decohere",
-			runUrl: "https://github.com/typesmiths/decohere/actions/runs/9",
-			channel: "dev",
-		});
-		expect(needsPrereleaseTag("0.0.1-dev.18")).toBe(true);
-		expect(needsPrereleaseTag("1.2.3")).toBe(false);
-		expect(firstPublishCommands([pkg], "dev")).toEqual([
-			"npm publish ./projects/scaffold --tag dev",
-		]);
-		expect(firstPublishCommands([{ ...pkg, version: "1.0.0" }], "dev")).toEqual([
-			"npm publish ./projects/scaffold",
-		]);
-		expect(body).toContain("npm publish ./projects/scaffold --tag dev");
-		expect(body).not.toMatch(/# @decohere\/scaffold/);
-		expect(body).toContain("do **not** pass `--access public`");
-		expect(firstPublishCommands([pkg], "dev").join("\n")).not.toContain("--access public");
-		expect(body).toContain("Workflow filename: `publish.yml`");
-		expect(body).toContain("Environment: `npm-publish`");
-		expect(body).toContain("gh run rerun --failed");
-		expect(body).toContain("https://github.com/typesmiths/decohere/actions/runs/9");
-	});
-
-	it("assigns the bootstrap environment's reviewers to the issue", async () => {
-		/** @type {object[]} */
-		const upserts = [];
-		const code = await runNudge(
-			{ UNPUBLISHED: "@decohere/scaffold", GITHUB_REPOSITORY: "typesmiths/decohere" },
-			{
-				listPackages: () => [{ name: "@decohere/scaffold", dir: "scaffold" }],
-				githubReviewers: async () => ["das974"],
-				upsert: (options) => {
-					upserts.push(options);
-					return {
-						number: 5,
-						url: "https://github.com/typesmiths/decohere/issues/5",
-						created: true,
-					};
-				},
-				runUrl: "https://github.com/typesmiths/decohere/actions/runs/1",
-			},
-		);
-		expect(code).toBe(0);
-		expect(upserts[0].title).toBe(issueTitle());
-		expect(upserts[0].assignees).toEqual(["das974"]);
-		expect(upserts[0].body).toContain("`@decohere/scaffold`");
-	});
-});

package/tests/github/publish-verify.test.mjs

@@ -1,115 +0,0 @@
-import { vol } from "memfs";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-	collectPublishVerify,
-	formatGithubOutput,
-	listPublishablePackages,
-	parseGhcrRepository,
-} from "../../src/github/publish-verify.mjs";
-
-function seedWorkspace() {
-	const root = "/workspace";
-	vol.fromJSON({
-		[`${root}/package.json`]: JSON.stringify({ version: "0.0.1-dev.79" }),
-		[`${root}/projects/cli/package.json`]: JSON.stringify({
-			name: "@decohere/cli",
-			version: "0.0.1-dev.79",
-		}),
-		[`${root}/projects/scaffold/package.json`]: JSON.stringify({
-			name: "@decohere/scaffold",
-			version: "0.0.1-dev.79",
-			private: true,
-		}),
-		[`${root}/projects/create/package.json`]: JSON.stringify({
-			name: "@decohere/create",
-			version: "0.0.1-dev.79",
-			decohere: { dockerImageRepository: "ghcr.io/typesmiths/decohere/create" },
-		}),
-		[`${root}/projects/devcontainer/package.json`]: JSON.stringify({
-			name: "@decohere/devcontainer",
-			private: true,
-			decohere: { dockerImageRepository: "ghcr.io/typesmiths/decohere/devcontainer" },
-		}),
-	});
-	return root;
-}
-
-afterEach(() => {
-	vol.reset();
-});
-
-describe("publish-verify", () => {
-	it("lists non-private workspace packages", () => {
-		const root = seedWorkspace();
-		expect(listPublishablePackages(root).map((pkg) => pkg.name)).toEqual([
-			"@decohere/cli",
-			"@decohere/create",
-		]);
-	});
-
-	it("lists grouped packages (projects/<group>/<name>) and skips nested and build folders", () => {
-		const root = seedWorkspace();
-		vol.fromJSON({
-			[`${root}/projects/data/data/package.json`]: JSON.stringify({ name: "@decohere/data" }),
-			[`${root}/projects/data/data-typeorm/package.json`]: JSON.stringify({
-				name: "@decohere/data-typeorm",
-			}),
-			[`${root}/projects/cli/examples/demo/package.json`]: JSON.stringify({ name: "nested" }),
-			[`${root}/projects/__fixtures__/app/package.json`]: JSON.stringify({ name: "fixture" }),
-			[`${root}/projects/node_modules/dep/package.json`]: JSON.stringify({ name: "dep" }),
-			[`${root}/projects/dist/out/package.json`]: JSON.stringify({ name: "built" }),
-		});
-		expect(listPublishablePackages(root).map((pkg) => pkg.name)).toEqual([
-			"@decohere/cli",
-			"@decohere/create",
-			"@decohere/data",
-			"@decohere/data-typeorm",
-		]);
-	});
-
-	it("parses GHCR repository coordinates", () => {
-		expect(parseGhcrRepository("ghcr.io/typesmiths/decohere/create")).toEqual({
-			org: "typesmiths",
-			packageName: "decohere/create",
-		});
-	});
-
-	it("marks names missing from npm as unpublished and skip_npm when every version exists", async () => {
-		const root = seedWorkspace();
-		const views = [];
-		const spawnSync = (_cmd, args) => {
-			views.push(args[1]);
-			if (args[1] === "@decohere/cli") {
-				return { status: 1 };
-			}
-			return { status: 0 };
-		};
-		const result = await collectPublishVerify({
-			root,
-			spawnSync,
-			githubToken: "",
-		});
-		expect(result.unpublished).toEqual(["@decohere/cli"]);
-		expect(result.skipNpm).toBe(false);
-		expect(views).toContain("@decohere/cli");
-		expect(views).toContain("@decohere/create");
-		expect(views).toContain("@decohere/create@0.0.1-dev.79");
-	});
-
-	it("sets skip_docker when both GHCR tags exist", async () => {
-		const root = seedWorkspace();
-		const fetch = async () => ({
-			ok: true,
-			status: 200,
-			json: async () => [{ metadata: { container: { tags: ["0.0.1-dev.79"] } } }],
-		});
-		const result = await collectPublishVerify({
-			root,
-			spawnSync: () => ({ status: 0 }),
-			githubToken: "ghs_test",
-			fetch,
-		});
-		expect(result.skipDocker).toBe(true);
-		expect(formatGithubOutput(result)).toContain("skip_docker=true");
-	});
-});