@joshuafolkken/kit 1.1471.0 → 1.1784.0

package/scripts/cases/cases-cli.ts

@@ -1,11 +1,13 @@
 #!/usr/bin/env tsx
 import { fileURLToPath } from 'node:url'
+import { cases_interaction_scan, type Findings } from './cases-interaction-scan'
 import { cases, type Boundary } from './cases-logic'
 
-// `josh cases <path...>` — print the I/O boundaries the changed paths cross and the abnormal cases
-// each owes. The boundary tokens go on stdout so `$(pnpm josh cases …)` reads
-// them; the required cases go on stderr so a person sees them without a shell parsing around them.
-// The logic and the vocabulary live in `cases-logic.ts`; everything here is the invocation.
+// `josh cases <path...>` — print the I/O boundaries the changed paths cross, the shared state and the
+// environment they depend on, and the abnormal cases each owes. The tokens go on stdout so
+// `$(pnpm josh cases …)` reads them; the required cases go on stderr so a person sees them without a
+// shell parsing around them. The logic and the vocabulary live in `cases-logic.ts` and
+// `cases-interaction.ts`; everything here is the invocation.
 
 const ARGV_OFFSET = 2
 const USAGE = 'Usage: josh cases <path...>'
@@ -13,19 +15,27 @@ const FAILURE_EXIT_CODE = 1
 
 function report_none(): number {
 	console.info(cases.NONE)
-	console.error('no network, process, filesystem or time boundary crossed')
+	console.error(
+		'no network, process, filesystem, time, shared-state or environment boundary crossed',
+	)
 
 	return 0
 }
 
-function report_boundaries(boundaries: ReadonlyArray<Boundary>): number {
-	console.info(boundaries.join(' '))
-	console.error(`required abnormal cases: ${cases.cases_for(boundaries).join(' / ')}`)
+// The interaction lines come first, as `report:template` places them at the head of "if it breaks".
+function report_crossed(boundaries: ReadonlyArray<Boundary>, findings: Findings): number {
+	console.info([...boundaries, ...cases_interaction_scan.interactions_of(findings)].join(' '))
+
+	for (const line of cases_interaction_scan.lines_for(findings)) console.error(line)
+
+	if (boundaries.length > 0) {
+		console.error(`required abnormal cases: ${cases.cases_for(boundaries).join(' / ')}`)
+	}
 
 	return 0
 }
 
-function run(argv: ReadonlyArray<string>): number {
+async function run(argv: ReadonlyArray<string>): Promise<number> {
 	if (argv.length === 0) {
 		console.error(USAGE)
 
@@ -33,16 +43,18 @@ function run(argv: ReadonlyArray<string>): number {
 	}
 
 	const boundaries = cases.boundaries_in(argv)
+	const findings = await cases_interaction_scan.scan(argv)
+	const is_crossed = boundaries.length + cases_interaction_scan.interactions_of(findings).length > 0
 
-	return boundaries.length === 0 ? report_none() : report_boundaries(boundaries)
+	return is_crossed ? report_crossed(boundaries, findings) : report_none()
 }
 
-function main(argv: ReadonlyArray<string>): void {
-	process.exitCode = run(argv)
+async function main(argv: ReadonlyArray<string>): Promise<void> {
+	process.exitCode = await run(argv)
 }
 
 const cases_cli = { run }
 
-if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET))
+if (process.argv[1] === fileURLToPath(import.meta.url)) await main(process.argv.slice(ARGV_OFFSET))
 
 export { cases_cli }

package/scripts/cases/cases-interaction-scan.ts

@@ -0,0 +1,134 @@
+import path from 'node:path'
+import { git_grep_hits, type GrepResult } from '#scripts/git/git-grep-hits'
+import { file_reader } from '#scripts/lib/read-file'
+import {
+	cases_interaction,
+	type Interaction,
+	type StatePath,
+	type Wording,
+} from './cases-interaction'
+
+// The I/O half of `josh cases`' interaction boundaries (joshuafolkken/kit#4491): read the changed
+// sources, then search the rest of the repository for each state path they name — by its literal and
+// by every constant this source binds it to — so the summary lists the other readers and writers as
+// `file:line`. Tests are left out of the search: a fixture path is not a second writer at run time.
+
+const SOURCE_EXTENSIONS: ReadonlySet<string> = new Set(['.ts', '.js', '.mjs', '.cjs', '.svelte'])
+const SOURCE_PATHSPECS: ReadonlyArray<string> = [
+	'*.ts',
+	'*.js',
+	'*.mjs',
+	'*.cjs',
+	'*.svelte',
+	':(exclude)*.test.ts',
+]
+const WHOLE_WORD = ['-w']
+const MAX_OTHERS = 10
+
+interface SharedState {
+	path: string
+	others: ReadonlyArray<string>
+	has_failed: boolean
+}
+
+interface Findings {
+	states: ReadonlyArray<SharedState>
+	variables: ReadonlyArray<string>
+	residents: ReadonlyArray<string>
+}
+
+function is_source(file: string): boolean {
+	return SOURCE_EXTENSIONS.has(path.extname(file))
+}
+
+function repo_relative(file: string): string {
+	return path.relative(process.cwd(), path.resolve(file))
+}
+
+// A module that declares its own constant of the same name holds its own state, not this one.
+async function constant_hits(name: string): Promise<GrepResult> {
+	const result = await git_grep_hits.search(name, WHOLE_WORD, SOURCE_PATHSPECS)
+	const declaration = new RegExp(String.raw`\b(?:const|let|var)\s+${name}\b`, 'u')
+	const declaring = new Set(
+		result.hits.filter((hit) => declaration.test(hit.excerpt)).map((hit) => hit.path),
+	)
+
+	return { ...result, hits: result.hits.filter((hit) => !declaring.has(hit.path)) }
+}
+
+async function shared_state(state: StatePath, own: ReadonlySet<string>): Promise<SharedState> {
+	const results = await Promise.all([
+		git_grep_hits.search(state.path, [], SOURCE_PATHSPECS),
+		...state.constants.map(async (name) => await constant_hits(name)),
+	])
+	const sites = results
+		.flatMap((result) => result.hits)
+		.filter((hit) => !own.has(hit.path))
+		.map((hit) => `${hit.path}:${hit.line}`)
+
+	return {
+		path: state.path,
+		others: [...new Set(sites)],
+		has_failed: results.some((result) => result.has_failed),
+	}
+}
+
+async function scan(paths: ReadonlyArray<string>): Promise<Findings> {
+	const content = paths
+		.filter((file) => is_source(file))
+		.map((file) => file_reader.read_if_readable(file) ?? '')
+		.join('\n')
+	const own = new Set(paths.map((file) => repo_relative(file)))
+	const states = await Promise.all(
+		cases_interaction.state_paths_in(content).map(async (state) => await shared_state(state, own)),
+	)
+
+	return { states, ...cases_interaction.environment_in(content) }
+}
+
+function interactions_of(findings: Findings): ReadonlyArray<Interaction> {
+	const has_environment = findings.variables.length + findings.residents.length > 0
+	const crossed = { state: findings.states.length > 0, env: has_environment }
+
+	return cases_interaction.INTERACTIONS.filter((interaction) => crossed[interaction])
+}
+
+function others_text(state: SharedState, words: Wording): string {
+	if (state.has_failed) return words.search_failed
+	if (state.others.length === 0) return words.no_others
+
+	const shown = state.others.slice(0, MAX_OTHERS)
+	const rest = state.others.length - shown.length
+
+	return rest > 0 ? `${shown.join(', ')}, +${String(rest)}` : shown.join(', ')
+}
+
+function line(label: string, subject: string, owed: ReadonlyArray<string>): string {
+	return `${label} ${subject}: ${owed.join(' / ')}`
+}
+
+// One line per state, variable and resident process, in that order — each carries its own subject,
+// so the reader sees whose cases they are without a second table.
+function lines_for(findings: Findings, lang?: string): ReadonlyArray<string> {
+	const words = cases_interaction.wording(lang)
+	const state_lines = findings.states.map((state) =>
+		line(
+			words.state,
+			`\`${state.path}\` (${words.others}: ${others_text(state, words)})`,
+			words.state_cases,
+		),
+	)
+	const variable_lines = findings.variables.map((name) =>
+		line(words.variable, `\`${name}\``, words.variable_cases),
+	)
+	const resident_lines = findings.residents.map((name) =>
+		line(words.resident, `\`${name}\``, words.resident_cases),
+	)
+
+	return [...state_lines, ...variable_lines, ...resident_lines]
+}
+
+const cases_interaction_scan = { scan, interactions_of, lines_for }
+
+export type { Findings, SharedState }
+export { cases_interaction_scan }

package/scripts/cases/cases-interaction.ts

@@ -0,0 +1,183 @@
+import { session_language } from '#scripts/josh/session-language'
+
+// `josh cases`' two interaction boundaries (joshuafolkken/kit#4491), read off the changed source with
+// no I/O: the persistent state paths it names (`state`) and the environment it reads (`env`). The four
+// I/O boundaries in `cases-logic.ts` name what a call can return; these name who else shares the
+// state or the environment — the breakages found only after a merge, in another component's run.
+
+type Interaction = 'state' | 'env'
+
+interface StatePath {
+	// The literal as written, cut before a template placeholder so a search finds its fixed head.
+	path: string
+	// The constants this source binds the literal to — the names another module reaches it through.
+	constants: ReadonlyArray<string>
+}
+
+interface Environment {
+	variables: ReadonlyArray<string>
+	residents: ReadonlyArray<string>
+}
+
+interface Binding {
+	name: string
+	value: string
+}
+
+interface Wording {
+	state: string
+	variable: string
+	resident: string
+	others: string
+	no_others: string
+	search_failed: string
+	state_cases: ReadonlyArray<string>
+	variable_cases: ReadonlyArray<string>
+	resident_cases: ReadonlyArray<string>
+}
+
+const INTERACTIONS: ReadonlyArray<Interaction> = ['state', 'env']
+const QUOTED_LITERAL = /(?<quote>['"`])(?<literal>[^'"`\s]+)\k<quote>/gu
+// A path under `.josh/` with something after the slash, a named lock file, or a `josh-<name>-` file
+// prefix — the temporary-directory records (lane state, ledger, run events) are named that way. The
+// bare `.josh/` root names every state at once, and a bare `.lock` suffix matches every lock in the
+// repository; a `josh-` name with no trailing hyphen is a tag or a keychain service, not a file.
+const STATE_PATH = /(?:\.josh\/[^/])|(?:[^/]\.lock$)|(?:^josh-[a-z][\w-]*-$)/u
+const PLACEHOLDER = /\$\{|<|\*/u
+const CONSTANT_BINDING =
+	/\b(?:const|let)\s+(?<name>[A-Za-z_]\w*)\s*(?::[^=\n]+)?=\s*(?<quote>['"`])(?<value>[^'"`\n]+)\k<quote>/gu
+const ENV_MARK = 'process.env'
+const ENV_LITERAL_KEY =
+	/\bprocess\.env\.(?<dotted>[A-Za-z_]\w*)|\b(?:process\.env|environment)\[\s*['"](?<quoted>\w+)['"]\s*\]/gu
+// The `environment: X = process.env` default-parameter form reads `environment[KEY]` through a
+// constant, so a key held in a constant is resolved against this source's own bindings.
+const ENV_CONSTANT_KEY = /\b(?:process\.env|environment)\[\s*(?<key>[A-Za-z_]\w*)\s*\]/gu
+const ENV_NAME = /^[A-Z][A-Z0-9_]*$/u
+// A daemon or a beacon named as an identifier or a module (`eslint-daemon`, `daemon_status`), never
+// the bare word, so prose about "the daemon" does not fire the boundary.
+const RESIDENT = /\b[\w-]*(?:[_-](?:daemon|beacon)|(?:daemon|beacon)[_-])[\w-]*/giu
+// A source names one daemon in many identifiers (`spawn_daemon`, `DAEMON_STOP`); its cases are the
+// kind's, so the kind is the subject.
+const RESIDENT_KIND = /daemon|beacon/iu
+const SLASH = '/'
+
+const JAPANESE: Wording = {
+	state: '共有状態',
+	variable: '環境変数',
+	resident: '常駐プロセス',
+	others: '他の読み書き',
+	no_others: 'なし',
+	search_failed: '検索失敗',
+	state_cases: [
+		'他の書き手との並行書き込み',
+		'他の読み手が古い形式・途中の状態を読む',
+		'自分が書く前に他の書き手が消す',
+	],
+	variable_cases: [
+		'未設定',
+		'親プロセスから継承した値（例 GIT_DIR）',
+		'lane の work tree と main で値が違う',
+	],
+	resident_cases: [
+		'常駐プロセスが古い',
+		'常駐プロセスが不在',
+		'lane の work tree と main で別のプロセスに繋がる',
+	],
+}
+
+const ENGLISH: Wording = {
+	state: 'shared state',
+	variable: 'environment variable',
+	resident: 'resident process',
+	others: 'also read or written by',
+	no_others: 'none',
+	search_failed: 'search failed',
+	state_cases: [
+		'concurrent write by another writer',
+		'another reader reads an old format or a partial state',
+		'another writer deletes it before this write',
+	],
+	variable_cases: [
+		'unset',
+		'value inherited from the parent process (e.g. GIT_DIR)',
+		'differs between the lane work tree and main',
+	],
+	resident_cases: [
+		'resident process is stale',
+		'resident process is absent',
+		'the lane work tree and main reach different processes',
+	],
+}
+
+function fixed_head(literal: string): string {
+	const placeholder = PLACEHOLDER.exec(literal)
+
+	const head = placeholder === null ? literal : literal.slice(0, placeholder.index)
+
+	// `.josh/observations/` and `.josh/observations` name one state, so both search as the latter.
+	return head.endsWith(SLASH) ? head.slice(0, -1) : head
+}
+
+function bindings(content: string): ReadonlyArray<Binding> {
+	return [...content.matchAll(CONSTANT_BINDING)].map((match) => ({
+		name: match.groups?.['name'] ?? '',
+		value: match.groups?.['value'] ?? '',
+	}))
+}
+
+function state_literals(content: string): ReadonlyArray<string> {
+	const heads = [...content.matchAll(QUOTED_LITERAL)].map((match) =>
+		fixed_head(match.groups?.['literal'] ?? ''),
+	)
+
+	return [...new Set(heads.filter((head) => STATE_PATH.test(head)))]
+}
+
+function state_paths_in(content: string): ReadonlyArray<StatePath> {
+	const declared = bindings(content)
+
+	return state_literals(content).map((path) => ({
+		path,
+		constants: declared
+			.filter((binding) => fixed_head(binding.value) === path)
+			.map((binding) => binding.name),
+	}))
+}
+
+function constant_keys(content: string): ReadonlyArray<string> {
+	const values = new Map(bindings(content).map((binding) => [binding.name, binding.value]))
+	const keys = [...content.matchAll(ENV_CONSTANT_KEY)].map((match) =>
+		values.get(match.groups?.['key'] ?? ''),
+	)
+
+	return keys.filter((name): name is string => name !== undefined && ENV_NAME.test(name))
+}
+
+// A source that hands `process.env` on whole, naming no variable, still reads the environment.
+function variables_in(content: string): ReadonlyArray<string> {
+	if (!content.includes(ENV_MARK)) return []
+
+	const literal = [...content.matchAll(ENV_LITERAL_KEY)].map(
+		(match) => match.groups?.['dotted'] ?? match.groups?.['quoted'] ?? '',
+	)
+	const names = [...new Set([...literal, ...constant_keys(content)])]
+
+	return names.length === 0 ? [ENV_MARK] : names
+}
+
+function environment_in(content: string): Environment {
+	const residents = [...content.matchAll(RESIDENT)].map((match) =>
+		(RESIDENT_KIND.exec(match[0])?.[0] ?? '').toLowerCase(),
+	)
+
+	return { variables: variables_in(content), residents: [...new Set(residents)] }
+}
+
+function wording(lang: string = session_language.DEFAULT_SESSION_LANG): Wording {
+	return session_language.is_japanese(lang) ? JAPANESE : ENGLISH
+}
+
+const cases_interaction = { INTERACTIONS, state_paths_in, environment_in, wording }
+
+export type { Environment, Interaction, StatePath, Wording }
+export { cases_interaction }

package/scripts/cases/cases-logic.ts

@@ -1,9 +1,11 @@
+import { session_language } from '#scripts/josh/session-language'
 import { file_reader } from '#scripts/lib/read-file'
+import { cases_interaction } from './cases-interaction'
 
 // `josh cases <path...>`: read the changed paths and answer which I/O
 // boundaries the code crosses — network, process start, filesystem — then name the abnormal cases
 // that boundary always owes. The unit suite blocks network by construction
-// (`scripts/test/test-network-guard.ts`), so a boundary's abnormal cases never run there; this makes
+// (`tools/test/test-network-guard.ts`), so a boundary's abnormal cases never run there; this makes
 // the declaration side name them instead, read off the diff rather than off judgement.
 // `prompts/collaboration-workflow/report-format.md` is the single source of where the answer goes —
 // the second tier of the case-based test declaration ("if it breaks").
@@ -17,6 +19,8 @@ interface BoundaryDefinition {
 	pattern: RegExp
 	// The abnormal cases this boundary always owes, so they land in the second tier.
 	cases: ReadonlyArray<string>
+	// The same cases for an English session, in the same order.
+	english_cases: ReadonlyArray<string>
 }
 
 const BOUNDARIES: ReadonlyArray<BoundaryDefinition> = [
@@ -27,6 +31,14 @@ const BOUNDARIES: ReadonlyArray<BoundaryDefinition> = [
 		// would fire `network` on every markdown edit and defeat the oracle.
 		pattern: /\b(?:fetch|axios|undici|node:https?|XMLHttpRequest)\b/u,
 		cases: ['非200', 'タイムアウト', '接続断', '空レスポンス', '不正JSON', 'レート制限'],
+		english_cases: [
+			'non-200',
+			'timeout',
+			'connection drop',
+			'empty response',
+			'invalid JSON',
+			'rate limit',
+		],
 	},
 	{
 		boundary: 'process',
@@ -36,6 +48,7 @@ const BOUNDARIES: ReadonlyArray<BoundaryDefinition> = [
 		pattern:
 			/\b(?:child_process|execSync|execFileSync|spawnSync)\b|\b(?:exec|execFile|spawn)\s*\(/u,
 		cases: ['非ゼロ終了', 'タイムアウト', '標準エラー出力', '実行ファイル不在'],
+		english_cases: ['non-zero exit', 'timeout', 'stderr output', 'missing executable'],
 	},
 	{
 		boundary: 'fs',
@@ -45,6 +58,13 @@ const BOUNDARIES: ReadonlyArray<BoundaryDefinition> = [
 		pattern:
 			/\b(?:node:fs|fs\/promises|readFileSync|writeFileSync)\b|\b(?:readFile|writeFile|mkdir|unlink|readdir|rm)\s*\(/u,
 		cases: ['ファイル不在', '権限エラー', '空ファイル', '不正な内容', '並行書き込み'],
+		english_cases: [
+			'missing file',
+			'permission error',
+			'empty file',
+			'invalid content',
+			'concurrent write',
+		],
 	},
 	{
 		boundary: 'time',
@@ -57,6 +77,12 @@ const BOUNDARIES: ReadonlyArray<BoundaryDefinition> = [
 		pattern:
 			/\b(?:setInterval|setTimeout|setImmediate|schedule|reschedule|retry)\s*\(|\b(?:cron|crontab|heartbeat|watchdog|liveness)\b/u,
 		cases: ['期待した事象が到来しない', '期限超過', '重複発火', '再試行が尽きる'],
+		english_cases: [
+			'awaited event never arrives',
+			'deadline exceeded',
+			'duplicate firing',
+			'retries exhausted',
+		],
 	},
 ]
 
@@ -76,17 +102,24 @@ function boundaries_in(paths: ReadonlyArray<string>): ReadonlyArray<Boundary> {
 	)
 }
 
-// The abnormal cases owed by the given boundaries, in the fixed boundary order.
-function cases_for(boundaries: ReadonlyArray<Boundary>): ReadonlyArray<string> {
+// The abnormal cases owed by the given boundaries, in the fixed boundary order and in `lang`.
+function cases_for(
+	boundaries: ReadonlyArray<Boundary>,
+	lang: string = session_language.DEFAULT_SESSION_LANG,
+): ReadonlyArray<string> {
+	const is_japanese = session_language.is_japanese(lang)
+
 	return BOUNDARIES.filter((definition) => boundaries.includes(definition.boundary)).flatMap(
-		(definition) => definition.cases,
+		(definition) => (is_japanese ? definition.cases : definition.english_cases),
 	)
 }
 
-// The fixed verdict vocabulary the command can print — the three boundary tokens and `none`. The
-// decision-oracle test asserts its registered vocabulary equals this.
+// The fixed verdict vocabulary the command can print — the four boundary tokens, the two interaction
+// tokens (`cases-interaction.ts`) and `none`. The decision-oracle test asserts its registered
+// vocabulary equals this.
 const VOCABULARY: ReadonlyArray<string> = [
 	...BOUNDARIES.map((definition) => definition.boundary),
+	...cases_interaction.INTERACTIONS,
 	NONE,
 ]
 

package/scripts/ci/pr-classification-main.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { pr_classification } from './pr-classification'
+
+// The `josh pr:classification` entry, kept apart from `pr-classification.ts` because other modules
+// import that one: a bundle is one file, so a main guard there would fire for every command that
+// carries it (joshuafolkken/kit#4186).
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	const event_path = process.env['GITHUB_EVENT_PATH']
+	if (!event_path) throw new Error('GITHUB_EVENT_PATH is required')
+
+	const error = pr_classification.check_event(event_path)
+
+	if (error) {
+		console.error(`::error::${error}`)
+		process.exitCode = 1
+	}
+}

package/scripts/ci/pr-classification.ts

@@ -1,8 +1,9 @@
 import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
+import { git_gh_api_path } from '#scripts/gh/git-gh-api-path'
 import { git_gh_exec } from '#scripts/gh/git-gh-exec'
 import {
 	BREAKING_CHANGE_LABEL as BREAKING,
+	BUG_LABEL,
 	BUGFIX_LABEL as BUGFIX,
 	RELEASE_CLASSIFICATION_NAMES as CLASSIFICATION_LABELS,
 	ENHANCEMENT_LABEL,
@@ -12,13 +13,13 @@ import { error_text } from '#scripts/lib/error-message'
 import { z } from 'zod'
 
 const CLASSIFICATION_SET: ReadonlySet<string> = new Set(CLASSIFICATION_LABELS)
-const ISSUE_BUG_LABEL = 'bug'
 // The line an Issue body declares its release classification with. A body written by a script
 // (`josh propagate`'s upgrade issue) builds it with `declaration`, so the writer and this parser share
 // one format.
 const DECLARATION_PREFIX = '- リリース分類: '
 const DECLARATION = new RegExp(`^${DECLARATION_PREFIX}(.+)$`, 'gmu')
 const LEGACY_LABELS: ReadonlySet<string> = new Set(['semver-major', 'semver-minor'])
+const LABEL_NAMES_FILTER = '.[].name'
 
 const LABEL = z.object({ name: z.string() })
 const USER = z.object({ login: z.string() })
@@ -70,7 +71,7 @@ function issue_candidates(issue_json: string): ReadonlyArray<ReleaseClassificati
 
 	if (unknown.length > 0) throw new Error(`Unknown release classification: ${unknown.join(', ')}`)
 
-	if (names.includes(ISSUE_BUG_LABEL) && !candidates.includes(BREAKING)) {
+	if (names.includes(BUG_LABEL) && !candidates.includes(BREAKING)) {
 		candidates.push(BUGFIX)
 	}
 
@@ -96,10 +97,14 @@ function select_issue_classification(issue_json: string): ReleaseClassification
 // payload, that run fails, and when it lands in the newer check suite GitHub keeps its red result —
 // a rerun replays the same payload and fails again.
 function fetch_current_labels(repository: string, pull_number: number): ReadonlyArray<string> {
-	const path = `repos/${repository}/issues/${String(pull_number)}/labels`
+	const path = git_gh_api_path.issue_labels_api_path(String(pull_number), repository)
 
 	try {
-		const names = git_gh_exec.exec_gh_api_sync({ path, jq_filter: '.[].name' })
+		const names = git_gh_exec.exec_gh_api_sync({
+			path,
+			should_paginate: true,
+			jq_filter: LABEL_NAMES_FILTER,
+		})
 
 		return names.split('\n').filter((name) => name !== '')
 	} catch (error) {
@@ -119,18 +124,6 @@ function check_event(
 	return classification_error(labels, event.pull_request.user.login)
 }
 
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-	const event_path = process.env['GITHUB_EVENT_PATH']
-	if (!event_path) throw new Error('GITHUB_EVENT_PATH is required')
-
-	const error = check_event(event_path)
-
-	if (error) {
-		console.error(`::error::${error}`)
-		process.exitCode = 1
-	}
-}
-
 const pr_classification = {
 	classification_error,
 	check_event,

package/scripts/clone/clone-scan.ts

@@ -17,7 +17,7 @@ import { clone_fingerprint } from './clone-fingerprint'
 // which is what makes two identical relative paths in different repositories a cross-repository clone.
 
 // The directories a package keeps its source in; whichever exist are scanned.
-const SOURCE_ROOTS = ['scripts', 'src']
+const SOURCE_ROOTS = ['scripts', 'tools', 'src']
 const SOURCE_EXTENSION = '.ts'
 // Test files and declarations are not product code, so a shared test helper is not a clone to report.
 const IGNORED_SUFFIXES = ['.test.ts', '.svelte.test.ts', '.d.ts']