@joshuafolkken/kit 1.1050.0 → 1.1094.0

package/scripts/propagate/propagate-targets.ts

@@ -159,11 +159,7 @@ function resolve_targets(
 }
 
 const propagate_targets = {
-	has_checkout,
 	read_manifest,
-	classify_manifest_absence,
-	classify_before_dependency,
-	declared_range,
 	installed_version,
 	classify_target,
 	resolve_targets,

package/scripts/propagate/propagate.ts

@@ -279,16 +279,12 @@ async function main(argv: ReadonlyArray<string>): Promise<void> {
 }
 
 const propagate = {
-	DRY_RUN_REASON,
 	KNOWN_FLAGS,
 	TARGET_FLAG,
 	parse_options,
 	refuse_outside_source_repository,
 	resolve_target_version,
 	resolve_run_version,
-	announce_run_version,
-	run,
-	main,
 }
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))

package/scripts/refactor/import-graph.ts

@@ -173,7 +173,6 @@ const import_graph = {
 	expand,
 	expand_scope,
 	invert,
-	neighbors_of,
 	parse_imports,
 	resolve_spec,
 	MAX_STAGES,

package/scripts/refactor/refactor-lint.ts

@@ -241,8 +241,6 @@ const refactor_lint = {
 	parse_results,
 	scan_categories,
 	CATEGORIES,
-	HIGH,
-	MEDIUM,
 	LOW,
 }
 

package/scripts/refactor/refactor-scan.ts

@@ -111,7 +111,6 @@ const refactor_scan = {
 	render,
 	render_result,
 	run_scan,
-	scan,
 	convergence_candidates,
 	verdict_line,
 	verdict_token,

package/scripts/refactor/refactor-targets.ts

@@ -95,7 +95,6 @@ const refactor_targets = {
 	collect_targets,
 	has_ignore_marker,
 	is_path_excluded,
-	keep_target,
 	scripts_files,
 	select_scope,
 }

package/scripts/registry-migration/migrate-logic.ts

@@ -221,8 +221,6 @@ const migrate_logic = {
 	github_tarballs,
 	is_github_tarball,
 	rewrite_kit_lockfile,
-	registry_of,
-	scoped_packages,
 	scoped_versions,
 }
 

package/scripts/registry-migration/migrate.ts

@@ -2,6 +2,8 @@ import { existsSync, rmSync, writeFileSync } from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { file_reader } from '#scripts/lib/read-file'
+import { timed_fetch } from '#scripts/lib/timed-fetch'
+import { COMMAND_TIMEOUT_MS, INSTALL_TIMEOUT_MS } from '#scripts/lib/timeouts'
 import { execa } from 'execa'
 import { z } from 'zod'
 import { migrate_logic, type MigrationPlan } from './migrate-logic'
@@ -11,7 +13,6 @@ const NPMRC = '.npmrc'
 const LOCKFILE = 'pnpm-lock.yaml'
 const WORKSPACE = 'pnpm-workspace.yaml'
 const PUBLIC_REGISTRY = 'https://registry.npmjs.org/'
-const FETCH_TIMEOUT_MS = 10_000
 const SCOPE = '@joshuafolkken/'
 const manifest_schema = z.looseObject({
 	dependencies: z.record(z.string(), z.string()).optional(),
@@ -104,11 +105,16 @@ async function verify_public_versions(
 	lockfile: string,
 	probe_version: MigrationDependencies['fetch_version'],
 ): Promise<VersionCheck> {
+	const versions = migrate_logic.scoped_versions(lockfile)
+	// Each probe reads its own package, so they run together; the report keeps the lockfile's order.
+	const probed = await Promise.all(
+		versions.map(async ([name, version]) => await probe_integrity(name, version, probe_version)),
+	)
 	const missing: Array<string> = []
 	const integrities = new Map<string, string>()
 
-	for (const [name, version] of migrate_logic.scoped_versions(lockfile)) {
-		const integrity = await probe_integrity(name, version, probe_version)
+	for (const [index, [name, version]] of versions.entries()) {
+		const integrity = probed[index]
 		if (integrity === undefined) missing.push(`${name}@${version}`)
 		else integrities.set(version, integrity)
 	}
@@ -238,9 +244,7 @@ async function migrate(cwd: string, dependencies: MigrationDependencies): Promis
 
 async function fetch_version(name: string, version: string): Promise<string | undefined> {
 	const encoded = encodeURIComponent(name)
-	const response = await fetch(`${PUBLIC_REGISTRY}${encoded}/${encodeURIComponent(version)}`, {
-		signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
-	})
+	const response = await timed_fetch(`${PUBLIC_REGISTRY}${encoded}/${encodeURIComponent(version)}`)
 
 	if (!response.ok) return undefined
 	const parsed = version_schema.safeParse(await response.json())
@@ -250,11 +254,17 @@ async function fetch_version(name: string, version: string): Promise<string | un
 }
 
 async function install(cwd: string): Promise<void> {
-	await execa('pnpm', ['install', '--lockfile-only', '--ignore-scripts', '--force'], { cwd })
+	await execa('pnpm', ['install', '--lockfile-only', '--ignore-scripts', '--force'], {
+		cwd,
+		timeout: INSTALL_TIMEOUT_MS,
+	})
 }
 
 async function effective_registry(cwd: string): Promise<string> {
-	const result = await execa('pnpm', ['config', 'get', '@joshuafolkken:registry'], { cwd })
+	const result = await execa('pnpm', ['config', 'get', '@joshuafolkken:registry'], {
+		cwd,
+		timeout: COMMAND_TIMEOUT_MS,
+	})
 
 	return result.stdout.trim()
 }
@@ -275,7 +285,7 @@ async function main(): Promise<void> {
 
 if (process.argv[1] === fileURLToPath(import.meta.url)) await main()
 
-const registry_migration = { migrate }
+const registry_migration = { migrate, install, effective_registry }
 
 export { registry_migration }
 export type { MigrationDependencies }

package/scripts/release/github-release-cli.ts

@@ -1,11 +1,13 @@
 import { execFileSync } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
 import { github_release } from './github-release'
+import { github_release_environment } from './github-release-environment'
 
-const token = process.env['GH_TOKEN']
-const tag = process.env['RELEASE_TAG']
+async function main(): Promise<void> {
+	const { token, tag, settings } = github_release_environment.read_release_input(process.env)
+	const tags = execFileSync('git', ['tag', '--list'], { encoding: 'utf8' }).trim().split('\n')
 
-if (!token || !tag) throw new Error('GH_TOKEN and RELEASE_TAG are required')
+	console.info(await github_release.publish(fetch, token, tag, { ...settings, tags }))
+}
 
-const tags = execFileSync('git', ['tag', '--list'], { encoding: 'utf8' }).trim().split('\n')
-
-console.info(await github_release.publish(fetch, token, tag, { tags }))
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main()

package/scripts/release/github-release-environment.ts

@@ -0,0 +1,46 @@
+import type { ReleaseSettings } from './github-release'
+
+interface ReleaseInput {
+	token: string
+	tag: string
+	settings: ReleaseSettings
+}
+
+type Environment = Readonly<Record<string, string | undefined>>
+
+// A workflow expression renders an unset input as the empty string, so empty means "not given".
+function optional(value: string | undefined): string | undefined {
+	return value === undefined || value === '' ? undefined : value
+}
+
+function job_names(value: string | undefined): ReadonlyArray<string> {
+	return (optional(value) ?? '')
+		.split(',')
+		.map((name) => name.trim())
+		.filter((name) => name !== '')
+}
+
+function read_release_input(environment: Environment): ReleaseInput {
+	const token = optional(environment['GH_TOKEN'])
+	const tag = optional(environment['RELEASE_TAG'])
+	const repository = optional(environment['GITHUB_REPOSITORY'])
+
+	if (!token || !tag || !repository) {
+		throw new Error('GH_TOKEN, RELEASE_TAG and GITHUB_REPOSITORY are required')
+	}
+
+	return {
+		token,
+		tag,
+		settings: {
+			repository,
+			start_tag: optional(environment['RELEASE_START_TAG']),
+			workflow: optional(environment['RELEASE_WORKFLOW']),
+			jobs: job_names(environment['RELEASE_JOBS']),
+		},
+	}
+}
+
+const github_release_environment = { read_release_input }
+
+export { github_release_environment }

package/scripts/release/github-release.ts

@@ -2,15 +2,15 @@ import { setTimeout } from 'node:timers/promises'
 import semver from 'semver'
 import { z } from 'zod'
 
-const API_URL = 'https://api.github.com/repos/joshuafolkken/kit/releases'
-const WORKFLOW_RUNS_URL =
-	'https://api.github.com/repos/joshuafolkken/kit/actions/workflows/publish.yml/runs?per_page=100'
-const WORKFLOW_JOBS_URL = 'https://api.github.com/repos/joshuafolkken/kit/actions/runs'
+const API_ROOT = 'https://api.github.com/repos'
+const LATEST_PATH = '/releases/latest'
+const REPOSITORY_PATTERN = /^[\w.-]+\/[\w.-]+$/u
 const TAG_PATTERN = /^v\d+\.\d+\.\d+(?:[.-][0-9A-Za-z.-]+)?$/u
 const REQUEST_TIMEOUT_MS = 30_000
 const NOT_FOUND_STATUS = 404
-// Tags through v1.887.0 predate automatic GitHub Releases and must not block the first new release.
-const AUTOMATION_START_TAG = 'v1.887.0'
+// A job skipped by its `if:` (or neutral) belongs to a run that succeeded; counting it would skip a
+// lower tag whose release is still on its way.
+const FAILED_CONCLUSIONS = new Set(['failure', 'cancelled', 'timed_out', 'startup_failure'])
 const POLL_INTERVAL_MS = 30_000
 const MAX_WAIT_ATTEMPTS = 120
 const RELEASE_SCHEMA = z.object({ tag_name: z.string().min(1) })
@@ -23,16 +23,42 @@ const JOB_SCHEMA = z.object({
 })
 const RUNS_SCHEMA = z.object({ workflow_runs: z.array(RUN_SCHEMA) })
 const JOBS_SCHEMA = z.object({ jobs: z.array(JOB_SCHEMA) })
-const PREREQUISITES = ['publish-github', 'publish-npm', 'update-production']
 
 type ReleaseRequest = (url: string, init: RequestInit) => Promise<Response>
 type Wait = () => Promise<void>
 
-interface PublishOptions {
+// What differs between repositories. `start_tag` is the last tag that predates automatic releases;
+// without it the latest existing release is the floor. `workflow` names the publish workflow whose
+// failed run lets a lower tag be skipped, and `jobs` the jobs in it that count (empty: every job).
+interface ReleaseSettings {
+	repository: string
+	start_tag?: string | undefined
+	workflow?: string | undefined
+	jobs?: ReadonlyArray<string> | undefined
+}
+
+interface PublishOptions extends ReleaseSettings {
 	tags?: ReadonlyArray<string>
 	wait?: Wait
 }
 
+interface Client {
+	request: ReleaseRequest
+	token: string
+	url: string
+	workflow: string | undefined
+	jobs: ReadonlyArray<string>
+}
+
+// `fallback` answers when no tag sits between the floor and the target; without one the floor itself
+// is the latest release and the answer.
+interface Ladder {
+	tags: ReadonlyArray<string>
+	floor: string | undefined
+	fallback?: () => Promise<string>
+	wait: Wait
+}
+
 function request_options(token: string, method: string, body?: object): RequestInit {
 	return {
 		method,
@@ -46,21 +72,22 @@ function request_options(token: string, method: string, body?: object): RequestI
 	}
 }
 
+async function api_get(client: Client, path: string): Promise<Response> {
+	return await client.request(`${client.url}${path}`, request_options(client.token, 'GET'))
+}
+
+async function api_post(client: Client, path: string, body: object): Promise<Response> {
+	return await client.request(`${client.url}${path}`, request_options(client.token, 'POST', body))
+}
+
 async function read_response(response: Response): Promise<unknown> {
 	if (!response.ok) throw new Error(`GitHub Releases API returned HTTP ${String(response.status)}`)
 
 	return await response.json()
 }
 
-async function existing_release(
-	request: ReleaseRequest,
-	token: string,
-	tag: string,
-): Promise<boolean> {
-	const response = await request(
-		`${API_URL}/tags/${encodeURIComponent(tag)}`,
-		request_options(token, 'GET'),
-	)
+async function existing_release(client: Client, tag: string): Promise<boolean> {
+	const response = await api_get(client, `/releases/tags/${encodeURIComponent(tag)}`)
 	if (response.status === NOT_FOUND_STATUS) return false
 
 	RELEASE_SCHEMA.parse(await read_response(response))
@@ -68,153 +95,183 @@ async function existing_release(
 	return true
 }
 
-async function previous_tag(request: ReleaseRequest, token: string): Promise<string> {
-	const response = await request(`${API_URL}/latest`, request_options(token, 'GET'))
-	const release = RELEASE_SCHEMA.parse(await read_response(response))
+async function previous_tag(client: Client): Promise<string> {
+	const response = await api_get(client, LATEST_PATH)
 
-	return release.tag_name
+	return RELEASE_SCHEMA.parse(await read_response(response)).tag_name
 }
 
-function predecessor(tags: ReadonlyArray<string>, target: string): string | undefined {
+async function latest_release(client: Client): Promise<string | undefined> {
+	const response = await api_get(client, LATEST_PATH)
+	if (response.status === NOT_FOUND_STATUS) return undefined
+
+	return RELEASE_SCHEMA.parse(await read_response(response)).tag_name
+}
+
+function predecessor(
+	tags: ReadonlyArray<string>,
+	target: string,
+	floor: string | undefined,
+): string | undefined {
 	return tags
 		.filter(
-			(tag) => semver.valid(tag) && semver.gt(tag, AUTOMATION_START_TAG) && semver.lt(tag, target),
+			(tag) =>
+				semver.valid(tag) &&
+				(floor === undefined || semver.gt(tag, floor)) &&
+				semver.lt(tag, target),
 		)
 		.toSorted((left, right) => semver.compare(right, left))[0]
 }
 
-function is_failed_job(job: z.infer<typeof JOB_SCHEMA>): boolean {
-	if (job.status !== 'completed' || job.conclusion === 'success') return false
+function is_failed_job(job: z.infer<typeof JOB_SCHEMA>, names: ReadonlyArray<string>): boolean {
+	if (job.status !== 'completed' || !FAILED_CONCLUSIONS.has(job.conclusion ?? '')) return false
+	if (names.length === 0) return true
 
-	return PREREQUISITES.some((name) => job.name === name || job.name.startsWith(`${name} /`))
+	return names.some((name) => job.name === name || job.name.startsWith(`${name} /`))
 }
 
-function publication_failed(jobs: Array<z.infer<typeof JOB_SCHEMA>>): boolean {
-	return jobs.some((job) => is_failed_job(job))
-}
+async function failed_publication(client: Client, tag: string): Promise<boolean> {
+	if (client.workflow === undefined) return false
 
-async function failed_publication(
-	request: ReleaseRequest,
-	token: string,
-	tag: string,
-): Promise<boolean> {
-	const runs_response = await request(WORKFLOW_RUNS_URL, request_options(token, 'GET'))
+	const workflow = encodeURIComponent(client.workflow)
+	const runs_response = await api_get(client, `/actions/workflows/${workflow}/runs?per_page=100`)
 	const runs = RUNS_SCHEMA.parse(await read_response(runs_response)).workflow_runs
 	const run = runs.find((item) => item.display_title === `Publish ${tag}`)
 	if (!run) return false
 
-	const url = `${WORKFLOW_JOBS_URL}/${String(run.id)}/jobs?per_page=100`
-	const jobs_response = await request(url, request_options(token, 'GET'))
+	const jobs_response = await api_get(client, `/actions/runs/${String(run.id)}/jobs?per_page=100`)
+	const { jobs } = JOBS_SCHEMA.parse(await read_response(jobs_response))
 
-	return publication_failed(JOBS_SCHEMA.parse(await read_response(jobs_response)).jobs)
+	return jobs.some((job) => is_failed_job(job, client.jobs))
 }
 
 async function default_wait(): Promise<void> {
 	await setTimeout(POLL_INTERVAL_MS)
 }
 
-async function release_state(
-	request: ReleaseRequest,
-	token: string,
-	tag: string,
-): Promise<'ready' | 'failed' | 'pending'> {
-	if (await existing_release(request, token, tag)) return 'ready'
-	if (await failed_publication(request, token, tag)) return 'failed'
+async function release_state(client: Client, tag: string): Promise<'ready' | 'failed' | 'pending'> {
+	if (await existing_release(client, tag)) return 'ready'
+	if (await failed_publication(client, tag)) return 'failed'
 
 	return 'pending'
 }
 
-async function wait_for_release(
-	request: ReleaseRequest,
-	token: string,
-	tag: string,
-	wait: Wait,
-): Promise<boolean> {
+async function wait_for_release(client: Client, tag: string, wait: Wait): Promise<boolean> {
 	for (let attempt = 0; attempt < MAX_WAIT_ATTEMPTS; attempt += 1) {
-		const state = await release_state(request, token, tag)
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
+		const state = await release_state(client, tag)
 		if (state !== 'pending') return state === 'ready'
 
+		// eslint-disable-next-line no-await-in-loop -- polling: each read waits on the state the previous one saw
 		await wait()
 	}
 
 	throw new Error(`Timed out waiting for previous GitHub Release ${tag}`)
 }
 
+async function ladder_end(ladder: Ladder): Promise<string | undefined> {
+	return ladder.fallback ? await ladder.fallback() : ladder.floor
+}
+
+// With no floor the repository has no release at all, so no lower tag will ever gain one: the
+// nearest lower tag is the baseline as it stands, and none means notes without a baseline.
 async function baseline_tag(
-	request: ReleaseRequest,
-	token: string,
+	client: Client,
 	tag: string,
-	options: PublishOptions,
-): Promise<string> {
-	const prior = predecessor(options.tags ?? [], tag)
-	if (!prior) return await previous_tag(request, token)
+	ladder: Ladder,
+): Promise<string | undefined> {
+	const prior = predecessor(ladder.tags, tag, ladder.floor)
+	if (ladder.floor === undefined) return prior
+	if (!prior) return await ladder_end(ladder)
+
+	return (await wait_for_release(client, prior, ladder.wait))
+		? prior
+		: await baseline_tag(client, prior, ladder)
+}
 
-	if (!(await wait_for_release(request, token, prior, options.wait ?? default_wait))) {
-		return await baseline_tag(request, token, prior, options)
+function assert_older(previous: string | undefined, tag: string): void {
+	if (previous !== undefined && !semver.lt(previous, tag)) {
+		throw new Error(`Latest release ${previous} is not older than ${tag}`)
+	}
+}
+
+async function build_ladder(client: Client, options: PublishOptions): Promise<Ladder> {
+	const tags = options.tags ?? []
+	const wait = options.wait ?? default_wait
+	const { start_tag } = options
+
+	if (start_tag !== undefined) {
+		return { tags, wait, floor: start_tag, fallback: async () => await previous_tag(client) }
 	}
 
-	return prior
+	return { tags, wait, floor: await latest_release(client) }
 }
 
 async function generate_notes(
-	request: ReleaseRequest,
-	token: string,
+	client: Client,
 	tag: string,
-	previous: string,
+	previous: string | undefined,
 ): Promise<z.infer<typeof NOTES_SCHEMA>> {
-	const response = await request(
-		`${API_URL}/generate-notes`,
-		request_options(token, 'POST', {
-			tag_name: tag,
-			previous_tag_name: previous,
-			configuration_file_path: '.github/release.yml',
-		}),
-	)
+	const response = await api_post(client, '/releases/generate-notes', {
+		tag_name: tag,
+		...(previous !== undefined && { previous_tag_name: previous }),
+		configuration_file_path: '.github/release.yml',
+	})
 
 	return NOTES_SCHEMA.parse(await read_response(response))
 }
 
 async function create_release(
-	request: ReleaseRequest,
-	token: string,
+	client: Client,
 	tag: string,
-	previous: string,
+	previous: string | undefined,
 ): Promise<void> {
-	const notes = await generate_notes(request, token, tag, previous)
-	const response = await request(
-		API_URL,
-		request_options(token, 'POST', {
-			tag_name: tag,
-			name: notes.name,
-			body: notes.body,
-			draft: false,
-			prerelease: false,
-		}),
-	)
+	const notes = await generate_notes(client, tag, previous)
+	const response = await api_post(client, '/releases', {
+		tag_name: tag,
+		name: notes.name,
+		body: notes.body,
+		draft: false,
+		prerelease: false,
+	})
 
 	RELEASE_SCHEMA.parse(await read_response(response))
 }
 
+function create_client(request: ReleaseRequest, token: string, settings: ReleaseSettings): Client {
+	if (!REPOSITORY_PATTERN.test(settings.repository)) {
+		throw new Error(`Invalid repository: ${settings.repository}`)
+	}
+
+	return {
+		request,
+		token,
+		url: `${API_ROOT}/${settings.repository}`,
+		workflow: settings.workflow,
+		jobs: settings.jobs ?? [],
+	}
+}
+
 async function publish(
 	request: ReleaseRequest,
 	token: string,
 	tag: string,
-	options: PublishOptions = {},
+	options: PublishOptions,
 ): Promise<string> {
 	if (!TAG_PATTERN.test(tag)) throw new Error(`Invalid release tag: ${tag}`)
-	if (await existing_release(request, token, tag)) return 'already-published'
 
-	const previous = await baseline_tag(request, token, tag, options)
+	const client = create_client(request, token, options)
+	if (await existing_release(client, tag)) return 'already-published'
 
-	if (!semver.lt(previous, tag)) {
-		throw new Error(`Latest release ${previous} is not older than ${tag}`)
-	}
+	const previous = await baseline_tag(client, tag, await build_ladder(client, options))
 
-	await create_release(request, token, tag, previous)
+	assert_older(previous, tag)
+	await create_release(client, tag, previous)
 
-	return `published ${tag} from ${previous}`
+	return `published ${tag} from ${previous ?? 'the first commit'}`
 }
 
 const github_release = { publish }
 
+export type { ReleaseSettings }
 export { github_release }

package/scripts/release/release-history.ts

@@ -125,7 +125,6 @@ const release_history = {
 	read_current_version,
 	read_release_plan,
 	BASE_SEARCH_LIMIT,
-	DEFAULT_TIP,
 }
 
 export { release_history }

package/scripts/release/release-plan.ts

@@ -123,7 +123,6 @@ const release_plan = {
 	format_plan,
 	next_version,
 	short_sha,
-	PENDING_ICON,
 }
 
 export { release_plan }

package/scripts/release/release-publish.ts

@@ -1,6 +1,6 @@
+import { git_gh_command } from '#scripts/gh/git-gh-command'
+import { git_pr_checks } from '#scripts/gh/git-pr-checks'
 import { git_command } from '#scripts/git/git-command'
-import { git_gh_command } from '#scripts/git/git-gh-command'
-import { git_pr_checks } from '#scripts/git/git-pr-checks'
 import { git_remote_branch } from '#scripts/git/git-remote-branch'
 import { write_version } from '#scripts/version/bump-version'
 import { version_targets } from '#scripts/version/version-targets'
@@ -150,7 +150,6 @@ const release_publish = {
 	publish,
 	pull_request_body,
 	unreachable_remote_message,
-	FAILURE_EXIT_CODE,
 	SUCCESS_EXIT_CODE,
 }
 

package/scripts/release/release-scope-cli.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
-import { git_followup_pending } from '#scripts/git/git-followup-pending'
+import { git_followup_pending } from '#scripts/followup/git-followup-pending'
 import { path_decision } from '#scripts/josh/path-decision'
 import { release_plan } from './release-plan'
 
@@ -87,7 +87,6 @@ const release_scope_cli = {
 	main,
 	run,
 	JSON_KEY,
-	KNOWN_FLAGS,
 	NOTHING_PENDING_REASON,
 	RELEASE_HINT,
 	REQUIRED_SCOPE,

package/scripts/release/release-tag.ts

@@ -1,5 +1,5 @@
-import { git_gh_api_path } from '#scripts/git/git-gh-api-path'
-import { git_gh_exec } from '#scripts/git/git-gh-exec'
+import { git_gh_api_path } from '#scripts/gh/git-gh-api-path'
+import { git_gh_exec } from '#scripts/gh/git-gh-exec'
 import { poll, type PollOptions } from '#scripts/lib/poll'
 
 // **The release is not finished when the pull request merges — it is finished when the tag exists.**
@@ -82,12 +82,10 @@ const release_tag = {
 	attempts_for,
 	configured_timeout_seconds,
 	format_result,
-	tag_exists,
 	tag_name,
 	wait_for_tag,
 	DEFAULT_TIMEOUT_SECONDS,
 	TAG_POLL_INTERVAL_MS,
-	TIMEOUT_ENV,
 }
 
 export { release_tag }