@joshuafolkken/kit 1.1514.0 → 1.1784.0

package/scripts/gh/git-pr-checks-parse.ts

@@ -1,5 +1,6 @@
 import { pr_raw_schema, type RollupItemData } from '#scripts/git/git-schemas'
 import { json_value } from '#scripts/lib/json-value'
+import type { z } from 'zod'
 
 const CHECK_STATUS_PASS = 'pass'
 const CHECK_STATUS_PENDING = 'pending'
@@ -9,8 +10,8 @@ const CHECK_STATUS_MISSING = 'missing'
 // GitHub reports a job whose `if:` condition was false as COMPLETED with conclusion `skipped`, and
 // counts it as satisfied for branch protection — a pull request reaches CLEAN with such jobs in its
 // rollup. Recording them as `fail` would disagree with GitHub itself, and it would disable the
-// CodeRabbit non-blocking exemption: `is_unstable_only_from_coderabbit` opens the gate only when
-// every non-passing check is CodeRabbit's, so kit's own conditional jobs (`auto-merge`, `E2E`,
+// CodeRabbit non-blocking exemption: `is_unstable_only_from_optional` opens the gate only when
+// every non-passing check is CodeRabbit's or an optional one still running, so kit's own conditional jobs (`auto-merge`, `E2E`,
 // `Notify Auto Tag`) would keep a slow review blocking the merge until the wait loop timed out. That
 // is invisible on fast reviews, where CLEAN short-circuits the predicate — it surfaces only on the
 // exact path the exemption exists to protect.
@@ -45,6 +46,12 @@ interface PrStateSnapshot {
 	rollup: Array<RollupCheck>
 	merge_state_status: string | undefined
 	review_decision: string | undefined
+	// The commit `rollup` was read from — the head a merge has to name so that it lands what passed and
+	// nothing pushed since (#4036). Absent where the snapshot carried none.
+	head_sha?: string
+	// The base branch's required status check contexts (joshuafolkken/kit#4351). Absent where the
+	// branch requires none or they could not be read, which keeps the merge gate waiting for `CLEAN`.
+	required_contexts?: Array<string>
 }
 
 function read_string(value: unknown): string | undefined {
@@ -118,16 +125,39 @@ function parse_rollup_checks(raw_json: string): Array<RollupCheck> {
 	return checks
 }
 
-function parse_pr_state_snapshot(raw_json: string): PrStateSnapshot {
-	const parsed = json_value.parse_or_undefined(raw_json)
-	const result = pr_raw_schema.safeParse(parsed)
-	const data = result.success ? result.data : undefined
+function with_head_sha(snapshot: PrStateSnapshot, head_sha: string | undefined): PrStateSnapshot {
+	return head_sha === undefined ? snapshot : { ...snapshot, head_sha }
+}
+
+function with_required_contexts(
+	snapshot: PrStateSnapshot,
+	required_contexts: Array<string> | undefined,
+): PrStateSnapshot {
+	if (required_contexts === undefined || required_contexts.length === 0) return snapshot
+
+	return { ...snapshot, required_contexts }
+}
 
-	return {
+type PrRawData = Partial<z.infer<typeof pr_raw_schema>>
+
+function read_pr_raw_data(raw_json: string): PrRawData {
+	const result = pr_raw_schema.safeParse(json_value.parse_or_undefined(raw_json))
+
+	return result.success ? result.data : {}
+}
+
+function parse_pr_state_snapshot(raw_json: string): PrStateSnapshot {
+	const data = read_pr_raw_data(raw_json)
+	const snapshot = {
 		rollup: parse_rollup_checks(raw_json),
-		merge_state_status: read_string(data?.mergeStateStatus),
-		review_decision: read_string(data?.reviewDecision),
+		merge_state_status: read_string(data.mergeStateStatus),
+		review_decision: read_string(data.reviewDecision),
 	}
+
+	return with_required_contexts(
+		with_head_sha(snapshot, read_string(data.headRefOid)),
+		data.requiredContexts,
+	)
 }
 
 export {

package/scripts/gh/git-pr-merge-checked.ts

@@ -0,0 +1,80 @@
+import { git_gh_command } from './git-gh-command'
+import { git_pr_checks, type PrStateSnapshot } from './git-pr-checks'
+
+// **A merge lands the head the merge gate passed, and nothing pushed after it** (#4036).
+//
+// The gate reads the checks of one commit, and the merge request names that commit as its `sha`. A
+// push between the two moves the head, GitHub answers 409, and the wait starts over on the new head
+// — so the push is merged once its own checks pass, with nobody having to re-run anything. The
+// retries are bounded: a branch that keeps moving under every wait is not one to merge unattended.
+
+const MAX_HEAD_MOVES = 3
+const NO_CHECKED_HEAD_MESSAGE =
+	'The merge gate answered without the head commit it checked, so there is no commit to bind the merge to'
+const HEAD_MOVED_NOTE =
+	'The pull request head moved after its checks passed — waiting on the new head'
+const HEAD_KEPT_MOVING_MESSAGE = `The pull request head moved after its checks passed ${String(MAX_HEAD_MOVES)} times, so it was not merged`
+
+type WaitForGreen = () => Promise<PrStateSnapshot>
+
+interface CheckedMerge {
+	branch_name: string
+	// The wait to go back to when the head moved — the caller's own, so a re-wait watches what the
+	// first wait watched.
+	wait_for_green: WaitForGreen
+	// The snapshot the gate already passed. Absent, the merge waits for one first.
+	checked?: PrStateSnapshot | undefined
+}
+
+function checked_head(snapshot: PrStateSnapshot): string {
+	if (snapshot.head_sha === undefined) throw new Error(NO_CHECKED_HEAD_MESSAGE)
+
+	return snapshot.head_sha
+}
+
+// `false` is "the head moved"; every other failure is the caller's to see.
+async function try_merge(branch_name: string, snapshot: PrStateSnapshot): Promise<boolean> {
+	const head_sha = checked_head(snapshot)
+
+	try {
+		await git_gh_command.pr_merge(branch_name, head_sha)
+
+		return true
+	} catch (error) {
+		if (!git_gh_command.is_head_moved(error)) throw error
+
+		return false
+	}
+}
+
+async function merge_checked(input: CheckedMerge): Promise<void> {
+	let snapshot = input.checked ?? (await input.wait_for_green())
+
+	for (let move = 0; move < MAX_HEAD_MOVES; move += 1) {
+		// eslint-disable-next-line no-await-in-loop -- each merge names the head the wait before it passed
+		if (await try_merge(input.branch_name, snapshot)) return
+
+		console.info(HEAD_MOVED_NOTE)
+		// eslint-disable-next-line no-await-in-loop -- the new head has to pass before it is merged
+		snapshot = await input.wait_for_green()
+	}
+
+	throw new Error(HEAD_KEPT_MOVING_MESSAGE)
+}
+
+// The merge gate's default wait, then the bound merge.
+async function merge_when_green(branch_name: string): Promise<void> {
+	async function wait_for_green(): Promise<PrStateSnapshot> {
+		return await git_pr_checks.wait_for_pr_success(branch_name)
+	}
+
+	await merge_checked({ branch_name, wait_for_green })
+}
+
+const git_pr_merge_checked = {
+	merge_checked,
+	merge_when_green,
+}
+
+export type { CheckedMerge, WaitForGreen }
+export { git_pr_merge_checked, HEAD_KEPT_MOVING_MESSAGE, MAX_HEAD_MOVES, NO_CHECKED_HEAD_MESSAGE }

package/scripts/git/base-tree.ts

@@ -1,4 +1,4 @@
-import { mkdtemp, rm, symlink } from 'node:fs/promises'
+import { copyFile, mkdir, mkdtemp, rm, symlink } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import path from 'node:path'
 import { git_worktree } from './git-worktree'
@@ -60,7 +60,24 @@ async function with_tree<T>(
 	}
 }
 
-const base_tree = { NODE_MODULES, with_tree }
+async function copy_one(tree: string, file: string): Promise<void> {
+	const target = path.join(tree, file)
+
+	await mkdir(path.dirname(target), { recursive: true })
+	await copyFile(file, target)
+}
+
+// The caller's working-tree files into the tree at the same relative paths. Each file has its own
+// target, and a recursive `mkdir` tolerates a sibling creating the same parent.
+async function copy_in(tree: string, files: ReadonlyArray<string>): Promise<void> {
+	await Promise.all(
+		files.map(async (file) => {
+			await copy_one(tree, file)
+		}),
+	)
+}
+
+const base_tree = { NODE_MODULES, copy_in, with_tree }
 
 export type { BaseTree }
 export { base_tree }

package/scripts/git/changed-file-scope.ts

@@ -11,9 +11,10 @@ import { git_command } from './git-command'
 // nothing, and listing what was narrowed by — is identical, so it lives here once rather than in
 // each command.
 //
-// **A narrowed run is added in front of the whole check, never in place of it.** Both fallbacks
-// therefore end at the whole check, and each says which of the two it was: the one thing this must
-// never do is answer "nothing to run" quietly.
+// The narrowed unit run replaces the whole suite in the gate (joshuafolkken/kit#4065), and the
+// narrowed lint the whole-tree lint (joshuafolkken/kit#4085), each with CI's whole run behind it.
+// Either way both fallbacks end at the whole check, and each says which of the two it was: the
+// one thing this must never do is answer "nothing to run" quietly.
 
 type ScopeMode = 'all' | 'related'
 
@@ -176,7 +177,7 @@ async function resolve_command_scope(request: ScopeRequest): Promise<ChangedFile
 // describing a set the caller never handed over.
 function report_unusable_arguments(
 	command_arguments: ReadonlyArray<string>,
-	scope: ChangedFileScope,
+	scope: Pick<ChangedFileScope, 'files'>,
 	label: string,
 ): void {
 	const narrowed = new Set(scope.files)
@@ -195,6 +196,7 @@ const changed_file_scope = {
 	UNREADABLE_REASON,
 	describe_scope,
 	flags_of,
+	format_file_list,
 	is_flag,
 	read_changed_files,
 	report_unusable_arguments,

package/scripts/git/changed-paths.ts

@@ -24,6 +24,23 @@ async function read_changed_paths(is_staged: boolean): Promise<Array<string>> {
 	return [...tracked, ...untracked]
 }
 
-const changed_paths = { read_changed_paths, to_paths }
+// The same reading against any commit rather than the change base — the change since the tree a
+// test-read map was recorded on.
+async function read_changed_since(commit: string): Promise<Array<string>> {
+	const tracked = to_paths(await git_command.diff_names_since(commit))
+	const untracked = to_paths(await git_command.untracked_names())
+
+	return [...new Set([...tracked, ...untracked])]
+}
+
+// The paths among `paths` the tree of `commit` held. An empty list asks git nothing, since
+// `ls-tree` with no path lists the whole tree.
+async function read_held_at(commit: string, paths: ReadonlyArray<string>): Promise<Array<string>> {
+	if (paths.length === 0) return []
+
+	return to_paths(await git_command.tree_names_at(commit, paths))
+}
+
+const changed_paths = { read_changed_paths, read_changed_since, read_held_at, to_paths }
 
 export { changed_paths }

package/scripts/git/git-diff-reads.ts

@@ -151,18 +151,41 @@ async function change_base_commit(): Promise<string> {
 	return await git_spawn.read(['rev-parse', await change_base()])
 }
 
-async function diff_main_names(): Promise<string> {
+// The working tree against any commit, with the same flags as the branch diff. `josh test:related`
+// reads the change since the commit its test-read map was recorded on, which is not the merge base.
+async function diff_names_since(commit: string): Promise<string> {
 	return await git_spawn.read([
 		...NO_PATH_QUOTING,
 		'diff',
 		NAME_ONLY_FLAG,
 		NO_RELATIVE_PATHS,
 		NO_RENAME_DETECTION,
-		await change_base(),
+		commit,
+		'--',
+	])
+}
+
+// Which of `paths` a commit's tree holds. `josh test:related` asks it of the tree its test-read map
+// was recorded on: a file that tree held and no test read is one no test reads, while a file added
+// since is one the map knows nothing about. **Callers pass at least one path** — with none, `ls-tree`
+// lists the whole tree.
+async function tree_names_at(commit: string, paths: ReadonlyArray<string>): Promise<string> {
+	return await git_spawn.read([
+		...NO_PATH_QUOTING,
+		'ls-tree',
+		'-r',
+		NAME_ONLY_FLAG,
+		'--full-tree',
+		commit,
 		'--',
+		...paths,
 	])
 }
 
+async function diff_main_names(): Promise<string> {
+	return await diff_names_since(await change_base())
+}
+
 async function diff_cached_names(): Promise<string> {
 	return await git_spawn.read([
 		...NO_PATH_QUOTING,
@@ -224,7 +247,9 @@ const git_diff_reads = {
 	diff_main,
 	diff_main_names,
 	diff_main_numstat,
+	diff_names_since,
 	get_default_branch,
+	tree_names_at,
 	untracked_names,
 }
 

package/scripts/git/git-grep-hits.ts

@@ -0,0 +1,85 @@
+import { get_exit_code } from '#scripts/git/git-execa-error'
+import { git_spawn } from '#scripts/git/git-spawn'
+
+// One fixed-string `git grep -n` over a pathspec, read back as `file:line` hits with a short excerpt.
+// `run:prep`'s code locations and `plan:consumers` both search a name this way, so the parse and the
+// no-match-versus-failure reading live here rather than in each.
+
+const GREP_LINE = /^(?<path>[^:]+):(?<line>\d+):(?<text>.*)$/u
+const MAX_EXCERPT_LENGTH = 80
+const ELLIPSIS = '…'
+// `git grep` exits 1 for no match; any other exit is a search that never ran.
+const GREP_NO_MATCH_EXIT = 1
+
+interface Hit {
+	path: string
+	line: string
+	excerpt: string
+}
+
+interface GrepResult {
+	hits: ReadonlyArray<Hit>
+	has_failed: boolean
+}
+
+function shorten(text: string): string {
+	const trimmed = text.trim()
+
+	if (trimmed.length <= MAX_EXCERPT_LENGTH) return trimmed
+
+	return `${trimmed.slice(0, MAX_EXCERPT_LENGTH)}${ELLIPSIS}`
+}
+
+// `git grep -n` prints `path:line:text`; the text may itself hold colons, so only the first two split.
+function to_hit(output_line: string): Hit | undefined {
+	const groups = GREP_LINE.exec(output_line)?.groups
+
+	if (groups === undefined) return undefined
+
+	// All three groups are non-optional in `GREP_LINE`, so a match always carries each of them.
+	const { path, line, text } = groups as Record<'line' | 'path' | 'text', string>
+
+	return { path, line, excerpt: shorten(text) }
+}
+
+function parse(stdout: string): Array<Hit> {
+	const hits = stdout.split('\n').map((line) => to_hit(line))
+
+	return hits.filter((hit): hit is Hit => hit !== undefined)
+}
+
+// `git grep` exits 1 when nothing matches, which `git_spawn.read` raises. Only that is "no match": a
+// git without `grep -m` (older than 2.38) exits 129, and naming every target absent then would send
+// the reader away from code that is there. `root` searches that checkout rather than the working
+// directory's.
+async function search(
+	target: string,
+	flags: ReadonlyArray<string>,
+	pathspecs: ReadonlyArray<string>,
+	root?: string,
+): Promise<GrepResult> {
+	const location = root === undefined ? [] : ['-C', root]
+	const grep_arguments = [
+		...location,
+		'grep',
+		'-n',
+		'-I',
+		'-F',
+		...flags,
+		'-e',
+		target,
+		'--',
+		...pathspecs,
+	]
+
+	try {
+		return { hits: parse(await git_spawn.read(grep_arguments)), has_failed: false }
+	} catch (error) {
+		return { hits: [], has_failed: get_exit_code(error) !== GREP_NO_MATCH_EXIT }
+	}
+}
+
+const git_grep_hits = { parse, search }
+
+export type { GrepResult, Hit }
+export { git_grep_hits }

package/scripts/git/git-location-environment.ts

@@ -9,7 +9,7 @@
 //
 // The list is single-sourced here because it has three consumers that must not drift apart: the
 // probes that clear it, the fixture that clears it, and the unit-suite guard that refuses a write
-// while any of it is set (`scripts/test/test-repository-guard.ts`).
+// while any of it is set (`tools/test/test-repository-guard.ts`).
 //
 // **Only the variables that redirect where git writes are listed.** `GIT_PREFIX`, `GIT_EDITOR` and
 // the `GIT_CONFIG_*` family are exported to hooks too and are deliberately absent: clearing them

package/scripts/git/git-merge-conflicts.ts

@@ -0,0 +1,83 @@
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+import { git_spawn_sync } from './git-spawn-sync'
+
+// The paths merging another branch into this working tree would stop on, read without touching any
+// index or ref (joshuafolkken/kit#4348). **The working tree, not `HEAD`, is ours**: `josh ship` asks
+// before its commit, so the change it is about to ship is still uncommitted. Each path is merged on
+// its own, as `merge-tree` would merge its content: a side left as the merge base had it, or both
+// sides alike, merges cleanly; a side that deleted or added what the other changed differently
+// conflicts; otherwise `git merge-file` decides. Only blob ids are compared, so no content is read.
+
+const CLEAN_EXIT_CODE = 0
+const HEAD = 'HEAD'
+
+interface Sides {
+	base: string | undefined
+	ours: string | undefined
+	theirs: string | undefined
+}
+
+interface Commits {
+	base: string
+	theirs: string
+}
+
+function blob_id(revision: string, file_path: string, cwd: string): string | undefined {
+	return git_spawn_sync.read(['rev-parse', '--verify', '--quiet', `${revision}:${file_path}`], {
+		cwd,
+	})
+}
+
+// Written to the object store so `merge-file --object-id` can read it; no index or ref moves.
+function working_blob_id(file_path: string, cwd: string): string | undefined {
+	if (!existsSync(path.join(cwd, file_path))) return undefined
+
+	return git_spawn_sync.read(['hash-object', '-w', '--', file_path], { cwd })
+}
+
+function is_one_sided(sides: Sides): boolean {
+	return sides.ours === sides.theirs || sides.ours === sides.base || sides.theirs === sides.base
+}
+
+function is_complete(sides: Sides): sides is Record<keyof Sides, string> {
+	return sides.base !== undefined && sides.ours !== undefined && sides.theirs !== undefined
+}
+
+function is_merged(sides: Sides, cwd: string): boolean {
+	if (is_one_sided(sides)) return true
+	if (!is_complete(sides)) return false
+
+	const { base, ours, theirs } = sides
+	const result = git_spawn_sync.run(['merge-file', '-p', '--object-id', ours, base, theirs], {
+		cwd,
+	})
+
+	return result.exit_code === CLEAN_EXIT_CODE
+}
+
+function sides_of(file_path: string, commits: Commits, cwd: string): Sides {
+	return {
+		base: blob_id(commits.base, file_path, cwd),
+		ours: working_blob_id(file_path, cwd),
+		theirs: blob_id(commits.theirs, file_path, cwd),
+	}
+}
+
+// Of `paths` (relative to `cwd`, the working tree's root), the ones merging `theirs` would stop on;
+// `undefined` where the merge base with `theirs` could not be read.
+function working_tree_conflicts(
+	theirs: string,
+	paths: ReadonlyArray<string>,
+	cwd: string,
+): ReadonlyArray<string> | undefined {
+	const base = git_spawn_sync.read(['merge-base', HEAD, theirs], { cwd })
+
+	if (base === undefined) return undefined
+
+	return paths.filter((file_path) => !is_merged(sides_of(file_path, { base, theirs }, cwd), cwd))
+}
+
+const git_merge_conflicts = { working_tree_conflicts }
+
+export { git_merge_conflicts }

package/scripts/git/git-preflight.ts

@@ -13,6 +13,19 @@ import { git_issue, type IssueInfo } from './git-issue'
 // anything changes, and all of them are reported at once.** No rule is new: each
 // answer comes from the function the later stage refuses with, so the two cannot drift apart.
 
+// Which precondition a problem leaves unmet, so a stopped `josh ship` records the kind beside the text
+// (joshuafolkken/kit#4166).
+const PRECONDITION = {
+	ISSUE: 'issue',
+	BRANCH: 'branch',
+	CLASSIFICATION: 'classification',
+} as const
+
+interface Unmet {
+	kind: string
+	problem: string
+}
+
 interface PreflightInput {
 	cli_input: string | undefined
 	will_open_pr: boolean
@@ -26,14 +39,20 @@ interface Target {
 
 interface Resolution {
 	target: Target | undefined
-	problems: Array<string>
+	problems: Array<Unmet>
+}
+
+function unmet(kind: string, problem: string): Unmet {
+	return { kind, problem }
 }
 
 function resolve_from_branch(current_branch: string): Resolution {
 	const number = git_issue.branch_number(current_branch)
 
 	if (number === undefined) {
-		return { target: undefined, problems: [git_issue.branch_derivation_error(current_branch)] }
+		const problem = unmet(PRECONDITION.ISSUE, git_issue.branch_derivation_error(current_branch))
+
+		return { target: undefined, problems: [problem] }
 	}
 
 	return { target: { number, branch_name: current_branch }, problems: [] }
@@ -55,7 +74,10 @@ function resolve_parsed(
 	return {
 		target,
 		problems: [
-			`Branch mismatch: on "${current_branch}", but the title resolves to "${parsed.branch_name}".`,
+			unmet(
+				PRECONDITION.BRANCH,
+				`Branch mismatch: on "${current_branch}", but the title resolves to "${parsed.branch_name}".`,
+			),
 		],
 	}
 }
@@ -68,7 +90,10 @@ function resolve_from_title(
 	try {
 		return resolve_parsed(git_issue.parse(cli_input), current_branch, default_branch)
 	} catch (error) {
-		return { target: undefined, problems: [error_text.message_of(error)] }
+		return {
+			target: undefined,
+			problems: [unmet(PRECONDITION.ISSUE, error_text.message_of(error))],
+		}
 	}
 }
 
@@ -80,13 +105,13 @@ async function resolve_target(cli_input: string | undefined): Promise<Resolution
 	return resolve_from_title(cli_input, current_branch, await git_command.get_default_branch())
 }
 
-async function classification_problems(target: Target): Promise<Array<string>> {
+async function classification_problems(target: Target): Promise<Array<Unmet>> {
 	try {
 		await git_pr.release_classification(target.number, target.branch_name)
 
 		return []
 	} catch (error) {
-		return [error_text.message_of(error)]
+		return [unmet(PRECONDITION.CLASSIFICATION, error_text.message_of(error))]
 	}
 }
 
@@ -106,8 +131,8 @@ async function announce_evidence(branch_name: string): Promise<void> {
 	)
 }
 
-function refusal(problems: ReadonlyArray<string>): Error {
-	const lines = problems.map((problem) => `  - ${problem}`)
+function refusal(problems: ReadonlyArray<Unmet>): Error {
+	const lines = problems.map(({ problem }) => `  - ${problem}`)
 
 	return new Error(
 		[
@@ -119,7 +144,7 @@ function refusal(problems: ReadonlyArray<string>): Error {
 
 interface PreflightAnswer {
 	pr_target: Target | undefined
-	problems: Array<string>
+	problems: Array<Unmet>
 }
 
 async function answer(input: PreflightInput): Promise<PreflightAnswer> {
@@ -131,9 +156,9 @@ async function answer(input: PreflightInput): Promise<PreflightAnswer> {
 	return { pr_target, problems: [...problems, ...pr_problems] }
 }
 
-// The unmet preconditions as a list, so `josh ship` can ask them before its
+// The unmet preconditions as a list, each with its kind, so `josh ship` can ask them before its
 // review and gate start instead of meeting the refusal at the commit stage.
-async function problems_of(input: PreflightInput): Promise<Array<string>> {
+async function problems_of(input: PreflightInput): Promise<Array<Unmet>> {
 	const { problems } = await answer(input)
 
 	return problems
@@ -149,5 +174,5 @@ async function check(input: PreflightInput): Promise<void> {
 
 const git_preflight = { check, problems_of }
 
-export type { PreflightInput }
+export type { PreflightInput, Unmet }
 export { git_preflight }

package/scripts/git/git-push-transport.ts

@@ -1,3 +1,4 @@
+import { MS_PER_SECOND } from '#scripts/lib/timeouts'
 import { execa } from 'execa'
 import { git_utilities } from './constants'
 import {
@@ -8,8 +9,6 @@ import {
 } from './git-execa-error'
 import { git_ssh_keepalive } from './git-ssh-keepalive'
 
-const MS_PER_SECOND = 1000
-
 // The budget for one `git push`, and the reason a push can no longer wait without end.
 // Measured on PR #1244: the commit itself took 0.6 seconds and the push
 // then sat silent for 8 minutes 13 seconds before it was found by hand and killed — about 9 minutes

package/scripts/git/git-schemas.ts

@@ -2,21 +2,28 @@ import { z } from 'zod'
 
 const package_name_schema = z.object({ name: z.string().min(1) })
 
+// REST answers `null` for a field it has no value for yet — a running check run's `conclusion` above
+// all — and one rejected element fails the whole snapshot, which then reads as an empty rollup until
+// the last check completes (joshuafolkken/kit#4351). Every string field is `nullish` for that reason.
 const rollup_item_schema = z.looseObject({
 	// eslint-disable-next-line @typescript-eslint/naming-convention -- GraphQL field name from GitHub API
-	__typename: z.string().optional(),
-	state: z.string().optional(),
-	status: z.string().optional(),
-	conclusion: z.string().optional(),
-	name: z.string().optional(),
-	context: z.string().optional(),
+	__typename: z.string().nullish(),
+	state: z.string().nullish(),
+	status: z.string().nullish(),
+	conclusion: z.string().nullish(),
+	name: z.string().nullish(),
+	context: z.string().nullish(),
 	description: z.string().nullish(),
 })
 
 const pr_raw_schema = z.object({
 	statusCheckRollup: z.array(rollup_item_schema).optional(),
+	// The base branch's required status check contexts, read from its rules — empty where none are
+	// set or they could not be read (`git-gh-branch-rules.ts`).
+	requiredContexts: z.array(z.string()).optional(),
 	mergeStateStatus: z.string().optional(),
 	reviewDecision: z.string().optional(),
+	headRefOid: z.string().optional(),
 })
 
 const pull_comment_schema = z.object({
@@ -40,6 +47,8 @@ const pr_info_schema = z.object({
 const epic_issue_schema = z.object({
 	number: z.number(),
 	body: z.string().optional(),
+	// REST answers null for an issue never closed and `reopened` for one a person reopened.
+	stateReason: z.string().nullish(),
 })
 
 // One blocker as `gh` reports it inside the `blockedBy` connection. `state` comes back with the
@@ -140,6 +149,7 @@ const open_issue_schema = z.object({
 
 type RollupItemData = z.infer<typeof rollup_item_schema>
 type EpicChildData = z.infer<typeof epic_child_schema>
+type EpicIssueData = z.infer<typeof epic_issue_schema>
 type OpenIssueData = z.infer<typeof open_issue_schema>
 type RestCommentData = z.infer<typeof rest_comment_schema>
 
@@ -159,4 +169,4 @@ export {
 	blocking_issue_schema,
 	blocked_by_schema,
 }
-export type { RollupItemData, EpicChildData, OpenIssueData, RestCommentData }
+export type { RollupItemData, EpicChildData, EpicIssueData, OpenIssueData, RestCommentData }