@joshuafolkken/kit 1.2114.0 → 1.3000.0

package/eslint/base.js

@@ -13,12 +13,11 @@ import globals from 'globals'
 import ts from 'typescript-eslint'
 import { checkout_rooted_parser } from './checkout-rooted-parser.js'
 import { config_fingerprint } from './config-fingerprint.js'
-import { code_quality_rules } from './rules/code-quality.js'
+import { code_quality_rules, code_quality_test_rules } from './rules/code-quality.js'
 import { early_return_one_liner_rule } from './rules/early-return-one-liner.js'
 import { formatting_rules } from './rules/formatting.js'
 import { import_rules } from './rules/import.js'
 import { namespace_object_export_rule } from './rules/namespace-object-export.js'
-import { naming_convention_rules } from './rules/naming-convention.js'
 import { promise_rules } from './rules/promise.js'
 import { sonarjs_rules } from './rules/sonarjs.js'
 import {
@@ -30,6 +29,7 @@ import {
 } from './rules/test-filename.js'
 import { typescript_rules } from './rules/typescript.js'
 import { unicorn_rules, unicorn_test_rules } from './rules/unicorn.js'
+import { untyped_lint } from './untyped.js'
 
 const FILE_PATTERNS = {
 	d_ts: ['**/*.d.ts'],
@@ -42,6 +42,9 @@ const FILE_PATTERNS = {
 	// file that was failing anyway.
 	tests: ['**/*.test.ts', '**/*.e2e.ts'],
 	eslint_rules: ['eslint/**/*.ts', 'eslint/rules/**/*.js'],
+	// joshuafolkken/kit#6028: the josh command tables — one object per command, no control flow.
+	command_tables: ['scripts/josh/josh-commands-*.ts'],
+	fixtures: ['scripts/**/*-fixture.ts'],
 	// joshuafolkken/kit#3294: the SvelteKit convention files, whose named exports — route handlers,
 	// `load`, `handle`, `match` — are typed through a const annotation (`export const GET:
 	// RequestHandler = …`). That idiom is the one place `func-style` allows an arrow const.
@@ -118,14 +121,14 @@ export function create_base_config({ gitignore_path, tsconfig_root_dir }) {
 			// them. It is the spelling git's own exclude uses, for the same reason.
 			ignores: ['node_modules/**', '**/.claude/worktrees/**', '*.config.{ts,js,cjs,mjs}'],
 		},
-		// joshuafolkken/kit#1347: a content fingerprint of this directory's rule modules, carried in
+		// joshuafolkken/kit#1347: a content fingerprint of the rule modules the config imports, carried in
 		// `settings` so that ESLint's own cache key changes when one of them is edited. Serializing the
 		// config drops every `create` function, so without this an edit to a rule left every cached
 		// entry valid and the gate reported the pre-edit verdict for every unchanged file. It sits in
 		// the shared config rather than beside either cache file because both the gate's cache and the
 		// edit hook's are invalidated by the same value — `config-fingerprint.js` carries the reasoning
 		// and what the fingerprint deliberately does not cover.
-		config_fingerprint.create_config_fingerprint_block(),
+		config_fingerprint.create_config_fingerprint_block(tsconfig_root_dir),
 		js.configs.recommended,
 		...ts.configs.strictTypeChecked,
 		...ts.configs.stylisticTypeChecked,
@@ -138,10 +141,8 @@ export function create_base_config({ gitignore_path, tsconfig_root_dir }) {
 			plugins: { import: importPlugin },
 			settings: {
 				// joshuafolkken/kit#3599: `import-x/resolver-next` is the key eslint-plugin-import-x
-				// reads. The resolvers used to sit under `import/resolver`, which the plugin ignores —
-				// the rules are only *named* `import/` here, the settings namespace stays the plugin's
-				// own — so every import fell back to the default node resolver, which does not follow
-				// an extensionless `.ts` specifier, and `no-cycle` was green over cycles it never saw.
+				// reads. The settings namespace must match the plugin even though the rules are named
+				// `import/`, so extensionless TypeScript imports resolve and cycle checks can follow them.
 				'import-x/resolver-next': [
 					// `project` roots the resolver's tsconfig where the parser's is. Left out, the
 					// resolver reads the one in `process.cwd()`, so a run started anywhere else resolves
@@ -177,7 +178,7 @@ export function create_base_config({ gitignore_path, tsconfig_root_dir }) {
 				'no-undef': 'off',
 				'local/namespace-object-export': 'error',
 				'local/early-return-one-liner': 'error',
-				...naming_convention_rules,
+				...untyped_lint.naming_convention(process.env),
 				...typescript_rules,
 				...code_quality_rules,
 				...import_rules,
@@ -197,7 +198,7 @@ export function create_base_config({ gitignore_path, tsconfig_root_dir }) {
 			ignores: ['**/*.svelte.ts'],
 			languageOptions: {
 				parser: checkout_rooted_parser.create(tsconfig_root_dir),
-				parserOptions: { project: './tsconfig.json' },
+				parserOptions: { project: false, projectService: true },
 			},
 		},
 		{
@@ -220,8 +221,15 @@ export function create_base_config({ gitignore_path, tsconfig_root_dir }) {
 		{
 			files: FILE_PATTERNS.tests,
 			rules: {
+				...ts.configs.disableTypeChecked.rules,
+				// Missing awaits can make tests finish before their assertions; void callbacks can
+				// silently discard rejected promises. Keep both checks with real project types.
+				'@typescript-eslint/no-floating-promises':
+					typescript_rules['@typescript-eslint/no-floating-promises'],
+				'@typescript-eslint/no-misused-promises':
+					typescript_rules['@typescript-eslint/no-misused-promises'],
 				'@typescript-eslint/no-magic-numbers': 'off',
-				'max-lines-per-function': ['error', { max: 35, skipBlankLines: true, skipComments: true }],
+				...code_quality_test_rules,
 				'no-console': ['error', { allow: ['warn', 'error', 'info'] }],
 				// vi mock/stub patterns require explicit undefined (mockResolvedValue/stubGlobal)
 				'unicorn/no-useless-undefined': 'off',
@@ -244,6 +252,21 @@ export function create_base_config({ gitignore_path, tsconfig_root_dir }) {
 				'@typescript-eslint/no-magic-numbers': 'off',
 			},
 		},
+		{
+			// `max-lines` bounds the reading load of functions and branches, which a data table has
+			// none of; splitting one only to stay under it scattered a table across files. The
+			// function, complexity and nesting limits still apply.
+			files: FILE_PATTERNS.command_tables,
+			ignores: FILE_PATTERNS.tests,
+			rules: { 'max-lines': 'off' },
+		},
+		{
+			// A command table keys by command name (`'exports:unused'`) and a fixture may mirror an
+			// external shape (`'timeout-minutes'`), so either kind breaks the naming convention by design.
+			files: [...FILE_PATTERNS.command_tables, ...FILE_PATTERNS.fixtures],
+			ignores: FILE_PATTERNS.tests,
+			rules: { '@typescript-eslint/naming-convention': 'off' },
+		},
 		{
 			// `.mjs` / `.cjs` too (joshuafolkken/kit#2693): the typed parser options above reach only
 			// TypeScript files, so a hand-authored module in either extension crashed the whole run on
@@ -284,5 +307,7 @@ export function create_base_config({ gitignore_path, tsconfig_root_dir }) {
 			CENTRALIZED_TESTS_DIRECTORY_PATTERNS,
 			CENTRALIZED_TESTS_DIRECTORY_ENTRY,
 		),
+		// joshuafolkken/kit#6768: nothing unless the process was started for edit-time lint.
+		untyped_lint.blocks(process.env),
 	)
 }

package/eslint/config-fingerprint.js

@@ -1,7 +1,10 @@
 import { createHash } from 'node:crypto'
-import { readdirSync, readFileSync } from 'node:fs'
+import { readFileSync, realpathSync, statSync } from 'node:fs'
+import { createRequire } from 'node:module'
 import path from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { resolve } from 'import-meta-resolve'
+import ts from 'typescript'
 
 // joshuafolkken/kit#1347: ESLint decides a cache entry is still valid from the file's own content
 // hash plus a hash of the **serialized** config, and serializing drops every function — so the
@@ -29,24 +32,154 @@ import { fileURLToPath } from 'node:url'
 // invalidate — the safe direction, and the same direction `--cache-strategy content` already picked
 // for the files themselves.
 //
-// **Its scope is this directory, not the consumer's config entry file.** A consumer that writes an
-// inline rule implementation directly in its own `eslint.config.js` is outside the fingerprint: that
-// file's serializable content is already part of ESLint's hash, its `create` functions are not, and
-// this preset cannot locate a file it is not given. Rule implementations belong in a module the
-// preset composes, which is what every kit project does.
+// **Its scope is the modules of this directory the config loads, not the consumer's config entry
+// file.** A consumer that writes an inline rule implementation directly in its own `eslint.config.js`
+// is outside the fingerprint: that file's serializable content is already part of ESLint's hash, its
+// `create` functions are not, and this preset cannot locate a file it is not given. Rule
+// implementations belong in a module the preset composes, which is what every kit project does.
+//
+// joshuafolkken/kit#5380: **a module counts only when an import chain from a config entry reaches
+// it** — this preset's `base.js`, which every kit config loads, and the project's own
+// `eslint.config.*`. A rule module not yet wired in changes no file's lint result, so adding or
+// editing one must not throw every cache entry away; the commit that wires it changes the importing
+// module, and the module joins the fingerprint there. The `.test.ts` files beside the modules are
+// never imported, so a test edit keeps the cache warm too.
 
 const HASH_ALGORITHM = 'sha256'
 // Half of a sha256 is far more than a cache key needs, and it keeps the value readable when the
 // calculated config is dumped for debugging.
 const FINGERPRINT_LENGTH = 32
-// What serialization drops: the modules in this directory are loaded as code. The `.test.ts` files
-// beside them are not config inputs at all, so the extension list is what leaves them out — a test
-// edit must not throw away a warm cache.
-const CONFIG_SOURCE_EXTENSIONS = new Set(['.js', '.mjs', '.cjs'])
 // Namespaced by the package rather than by a plugin, because no plugin owns it. A plugin key would
 // read as configuration something is meant to consume.
 const SETTINGS_KEY = 'kit_config_fingerprint'
 const PRESET_DIRECTORY = path.dirname(fileURLToPath(import.meta.url))
+const PRESET_ENTRY = 'base.js'
+const MODULE_EXTENSIONS = ['.js', '.mjs', '.cjs', '.ts', '.mts', '.cts']
+const CONFIG_ENTRY_NAMES = MODULE_EXTENSIONS.map((extension) => `eslint.config${extension}`)
+
+function is_file(file) {
+	return statSync(file, { throwIfNoEntry: false })?.isFile() === true
+}
+
+// The files a specifier may name: itself, then what a TypeScript config's resolution adds — a missing
+// extension, a directory's `index`, and a `.js` written for the `.ts` beside it.
+function module_candidates(target) {
+	const typed = target.replace(/\.([cm]?)js$/u, '.$1ts')
+	const bare = MODULE_EXTENSIONS.map((extension) => `${target}${extension}`)
+	const indexes = MODULE_EXTENSIONS.map((extension) => path.join(target, `index${extension}`))
+
+	return [target, typed, ...bare, ...indexes]
+}
+
+function resolve_module(target) {
+	return module_candidates(target).find((candidate) => is_file(candidate))
+}
+
+function is_inside(relative_path) {
+	return relative_path !== '' && !relative_path.startsWith('..') && !path.isAbsolute(relative_path)
+}
+
+function is_local_module(target) {
+	return (
+		path.isAbsolute(target) &&
+		(!target.split(path.sep).includes('node_modules') ||
+			is_inside(path.relative(PRESET_DIRECTORY, target)))
+	)
+}
+
+function keep_path_spelling(file, target) {
+	const directory = path.dirname(file)
+	const relative = path.relative(realpathSync(directory), target)
+
+	return path.resolve(directory, relative)
+}
+
+function resolve_es_module(specifier, file) {
+	const url = resolve(specifier, pathToFileURL(file).href)
+
+	return url.startsWith('file:') ? fileURLToPath(url) : ''
+}
+
+function resolve_commonjs_module(specifier, file) {
+	return createRequire(file).resolve(specifier)
+}
+
+// Third-party packages are versioned by the lockfile; only project files and this preset need their
+// implementation hashed. Resolving a specifier never executes the module it names.
+function resolve_package_import(file, specifier, resolver) {
+	try {
+		const target = resolver(specifier, file)
+
+		// Node resolves symlinks, while entries may use a checkout alias such as macOS's /tmp. Keep
+		// that spelling so relative names still belong to the directory being fingerprinted.
+		return is_local_module(target) ? [keep_path_spelling(file, target)] : []
+	} catch {
+		return []
+	}
+}
+
+function resolve_import(file, specifier) {
+	const relative = specifier.startsWith('.')
+		? [resolve_module(path.resolve(path.dirname(file), specifier))]
+		: []
+
+	// A source may mix import() and require(); including both conditional branches avoids dropping
+	// a loaded module while the lockfile still accounts for third-party dependencies.
+	return [
+		...relative,
+		...resolve_package_import(file, specifier, resolve_es_module),
+		...resolve_package_import(file, specifier, resolve_commonjs_module),
+	]
+}
+
+function list_imports(file) {
+	const source = readFileSync(file, 'utf8')
+
+	return ts
+		.preProcessFile(source, true, true)
+		.importedFiles.flatMap((entry) => resolve_import(file, entry.fileName))
+		.filter((resolved) => resolved !== undefined)
+}
+
+function visit_module(file, reached, pending) {
+	if (reached.has(file) || !is_file(file)) return
+
+	reached.add(file)
+	pending.push(...list_imports(file))
+}
+
+// The absolute paths of every module an import chain from `entries` reaches, the entries included. A
+// specifier that names no file is dropped: Node refuses to load it, so it configures nothing.
+/**
+ * @param {ReadonlyArray<string>} entries
+ * @returns {ReadonlySet<string>}
+ */
+function list_reachable_modules(entries) {
+	/** @type {Set<string>} */
+	const reached = new Set()
+	const pending = [...entries]
+
+	while (pending.length > 0) visit_module(pending.pop(), reached, pending)
+
+	return reached
+}
+
+// The project's own config entry files that exist under `project_root`, as absolute paths.
+/**
+ * @param {string} project_root
+ * @returns {Array<string>}
+ */
+function list_config_entries(project_root) {
+	return CONFIG_ENTRY_NAMES.map((name) => path.join(project_root, name)).filter((file) =>
+		is_file(file),
+	)
+}
+
+function default_entries(directory, project_root) {
+	const project_entries = project_root === undefined ? [] : list_config_entries(project_root)
+
+	return [path.join(directory, PRESET_ENTRY), ...project_entries]
+}
 
 // Code-unit order rather than `localeCompare`: the fingerprint has to be identical on every machine
 // that reads the same sources, and a locale-aware comparison is by definition not.
@@ -57,13 +190,14 @@ function compare_source_names(left, right) {
 }
 
 // Sorted, relative to the directory being read, and always with forward slashes. Each of the three is
-// what keeps the value the same on two machines: `readdirSync` guarantees no order, an absolute path
+// what keeps the value the same on two machines: a traversal guarantees no order, an absolute path
 // carries the checkout location into the hash, and `path.sep` would make a Windows checkout disagree
-// with the CI cache it restores.
-function list_config_sources(directory) {
-	return readdirSync(directory, { recursive: true, withFileTypes: true })
-		.filter((entry) => entry.isFile() && CONFIG_SOURCE_EXTENSIONS.has(path.extname(entry.name)))
-		.map((entry) => path.relative(directory, path.join(entry.parentPath, entry.name)))
+// with the CI cache it restores. A reached module outside `directory` is left out — the project's own
+// entry file is already in ESLint's hash.
+function list_config_sources(directory, entries) {
+	return [...list_reachable_modules(entries)]
+		.map((file) => path.relative(directory, file))
+		.filter((relative_path) => is_inside(relative_path))
 		.map((relative_path) => relative_path.split(path.sep).join('/'))
 		.toSorted(compare_source_names)
 }
@@ -75,10 +209,13 @@ function list_config_sources(directory) {
 // The `NUL` between them is what keeps the concatenation unambiguous: fed straight into one digest,
 // a byte moved from the end of a name into the start of the next file's content would hash the same,
 // and a fingerprint that silently fails to change is the one failure this file exists to prevent.
-function compute_config_fingerprint(directory = PRESET_DIRECTORY) {
+function compute_config_fingerprint(
+	directory = PRESET_DIRECTORY,
+	entries = default_entries(directory),
+) {
 	const digest = createHash(HASH_ALGORITHM)
 
-	for (const relative_path of list_config_sources(directory)) {
+	for (const relative_path of list_config_sources(directory, entries)) {
 		digest.update(`${relative_path}\0`)
 		digest.update(readFileSync(path.join(directory, relative_path)))
 		digest.update('\0')
@@ -90,14 +227,20 @@ function compute_config_fingerprint(directory = PRESET_DIRECTORY) {
 // A config block of its own, carrying no `files`, so it applies to every file the run lints. Given
 // `files`, the entries for everything outside that glob would keep the old config hash and the whole
 // point would be lost on exactly the files a rule edit is least likely to be tested against.
-function create_config_fingerprint_block(directory = PRESET_DIRECTORY) {
-	return { settings: { [SETTINGS_KEY]: compute_config_fingerprint(directory) } }
+// `project_root` is where the project's `eslint.config.*` lives — kit's own wires a module of this
+// directory the preset does not (`rules/english-only-prose.js`).
+function create_config_fingerprint_block(project_root) {
+	const entries = default_entries(PRESET_DIRECTORY, project_root)
+
+	return { settings: { [SETTINGS_KEY]: compute_config_fingerprint(PRESET_DIRECTORY, entries) } }
 }
 
 const config_fingerprint = {
 	SETTINGS_KEY,
 	compute_config_fingerprint,
 	create_config_fingerprint_block,
+	list_config_entries,
+	list_reachable_modules,
 }
 
 export { config_fingerprint }

package/eslint/rules/code-quality.js

@@ -1,3 +1,9 @@
+// テストファイルだけ関数の最大行数を引き上げる。eslint/base.js の tests ブロックが使い、
+// CLAUDE.md の Quality limits は tools/document/generate-lint-prose.ts がここから生成する
+export const code_quality_test_rules = {
+	'max-lines-per-function': ['error', { max: 35, skipBlankLines: true, skipComments: true }],
+}
+
 export const code_quality_rules = {
 	// ===== 一般的なコード品質 =====
 	// console の使用を警告（開発時は許可、本番ではエラーにするべき）

package/eslint/rules/comment-why-only.js

@@ -1,12 +1,11 @@
 // Enforce the comment rule of prompts/coding-standards.md → 基本方針: a comment states why, so the
-// history of how the code got here ("Previously, …", "used to …") and measured values with a unit
-// ("about 16,000 tokens", "1.9 seconds") are reported — git history and the Issue hold both. An Issue
-// citation such as `joshuafolkken/kit#5282` is allowed: it is where the why is recorded. The two
-// checks are separate rules so a repository can switch each on once its own comments are clean.
+// history of how the code got here and measured values with a time, size or token unit are
+// reported — git history and the Issue hold both. An Issue citation such as `joshuafolkken/kit#5282`
+// is allowed: it is where the why is recorded. The two checks are separate rules so a repository can
+// switch each on once its own comments are clean.
 
-// A bare "previously" often means "earlier in this run" ("a previously parked lane"); only the
-// sentence-opening "Previously," narrates the past. "is used to" describes a purpose, not a
-// history, so the look-behind skips it.
+// A bare adverb can refer to an earlier event in the current run; a comma marks historical narration.
+// Passive constructions and present-perfect verbs describe a purpose, so the look-behind skips them.
 const HISTORY_PATTERNS = [
 	/\bpreviously,/iu,
 	/\bformerly\b/iu,
@@ -14,16 +13,19 @@ const HISTORY_PATTERNS = [
 	/以前は/u,
 ]
 
-// A sentence opening with "Used to" describes a purpose too, so that opening is cut off before the
-// history check. A sentence opens at a line start (after a block comment's `*`) or after `.`, `!`,
-// `?` or `:`; the capital `U` keeps a lowercase "used to" that wraps onto the next line of a
-// sentence a history.
+// A capitalized sentence-opening purpose and a participial phrase after punctuation describe a use.
+// Keep lowercase continuations so wrapping a historical statement does not hide it.
 const SENTENCE_BOUNDARY = /(?<=[.!?:\n])/u
 const OPENING_PURPOSE_PATTERN = /^[\s*]*Used to\b/u
+const PURPOSE_PATTERNS = [
+	/(?<=[,—–])\s*used to\b/giu,
+	/\b(?:has|have|had) used to\b/giu,
+	/\bused to (?=(?:the|this|that|these|those|an?|it)\b)/giu,
+]
 
-// A number with a time, size or token unit, `12k tokens` and `10-second` included. The look-behind
-// keeps `#1234` and the tail of a longer number or identifier from matching. A bare `s` is left out:
-// it would read `1990s` and `502s` as durations.
+// A number with a time, size or token unit, a `k` multiplier and a hyphenated unit included. The
+// look-behind keeps `#1234` and the tail of a longer number or identifier from matching. A bare `s`
+// is left out: it would read `1990s` and `502s` as durations.
 const MEASUREMENT_PATTERNS = [
 	/(?<![#\w.,])\d[\d.,]*[\s-]?(?:ms|secs?|mins?)(?!\w)/u,
 	/(?<![#\w.,])\d[\d.,]*[\s-]?(?:seconds?|minutes?|hours?)(?!\w)/u,
@@ -31,6 +33,22 @@ const MEASUREMENT_PATTERNS = [
 	/(?<![#\w.,])\d[\d.,]*[kKM]?[\s-]?tokens?(?!\w)/u,
 ]
 
+// Strip only the value whose adjacent words state a design or input, so a measured value elsewhere
+// in the same comment still reports. Test files get no blanket exemption (joshuafolkken/kit#5366).
+const UNIT_VALUE = `(?:${MEASUREMENT_PATTERNS.map((pattern) => pattern.source).join('|')})`
+const DECLARED_VALUE_PATTERNS = [
+	new RegExp(
+		String.raw`${UNIT_VALUE}\s+(?:cache\s+)?(?:writes?|TTL|timeouts?|budgets?|limits?)\b`,
+		'giu',
+	),
+	new RegExp(
+		String.raw`\b(?:timeout|budget|limit|TTL|test input|fixture)(?: is| of|:)?\s+${UNIT_VALUE}`,
+		'giu',
+	),
+	new RegExp(String.raw`\bfor prompts (?:over|under|up to)\s+${UNIT_VALUE}`, 'giu'),
+	new RegExp(String.raw`\b(?:machine|input|fixture) (?:of|with)\s+${UNIT_VALUE}`, 'giu'),
+]
+
 /**
  * @param {string} sentence
  * @returns {boolean}
@@ -47,7 +65,10 @@ function sentence_has_history(sentence) {
  * @returns {boolean}
  */
 function has_history(text) {
-	return text.split(SENTENCE_BOUNDARY).some((sentence) => sentence_has_history(sentence))
+	let narration = text.replaceAll(/\n[\t ]*\*/gu, '\n')
+	for (const pattern of PURPOSE_PATTERNS) narration = narration.replaceAll(pattern, '')
+
+	return narration.split(SENTENCE_BOUNDARY).some((sentence) => sentence_has_history(sentence))
 }
 
 /**
@@ -55,7 +76,10 @@ function has_history(text) {
  * @returns {boolean}
  */
 function has_measurement(text) {
-	return MEASUREMENT_PATTERNS.some((pattern) => pattern.test(text))
+	let measured_text = text
+	for (const pattern of DECLARED_VALUE_PATTERNS) measured_text = measured_text.replace(pattern, '')
+
+	return MEASUREMENT_PATTERNS.some((pattern) => pattern.test(measured_text))
 }
 
 /**

package/eslint/rules/english-only-prose.js

@@ -5,7 +5,9 @@
 // is an AST-and-codepoint one: look at comment tokens and the title/message string literals of
 // `describe` / `it` / `test` / `expect`, and report when they carry a CJK codepoint. The single
 // exception is `eslint/rules/` itself, where the rule modules are allowed to explain their rationale in
-// Japanese — that exemption is wired in `eslint.config.js`, not here, so the rule stays a pure detector.
+// Japanese — that exemption is wired in `eslint.config.js`, not here, so the rule stays a pure detector;
+// only its directory lives here, read by both the config and the generated Content-rules prose.
+const JAPANESE_RATIONALE_DIRECTORY = 'eslint/rules/'
 
 // CJK codepoints: Han (Kanji), Hiragana, Katakana and Hangul. This is intentionally the "comment or
 // title" alphabet, not "any non-ASCII" — a comment may legitimately carry `≤`, `→` or an accented
@@ -129,7 +131,12 @@ const english_only_prose_rule = {
 }
 
 // The plugin wrapper `eslint.config.js` wires under the `kit` namespace, plus the bare rule and the CJK
-// pattern for the tests and the document-sync guard to read.
+// pattern for the tests to read.
 const english_only_prose_plugin = { rules: { 'english-only-prose': english_only_prose_rule } }
 
-export { CJK_PATTERN, english_only_prose_rule, english_only_prose_plugin }
+export {
+	CJK_PATTERN,
+	JAPANESE_RATIONALE_DIRECTORY,
+	english_only_prose_rule,
+	english_only_prose_plugin,
+}

package/eslint/rules/import.js

@@ -5,8 +5,7 @@ export const import_rules = {
 	// joshuafolkken/kit#3599: off for the same reason, and for one more. These six read the exports of
 	// the imported file, so a per-file content cache keeps a stale "no problem" for an unchanged
 	// importer after the file it imports changes. The compiler runs the first four checks on every
-	// file it type-checks; the last two never ran on a `.ts` import before the resolver was wired, so
-	// nothing that used to be reported is lost. `base.js` switches all six back on for hand-authored
+	// file it type-checks. `base.js` switches all six back on for hand-authored
 	// JavaScript, which the compiler does not check.
 	'import-x/named': 'off',
 	'import-x/namespace': 'off',
@@ -27,14 +26,8 @@ export const import_rules = {
 	// 名前付きエクスポートを優先
 	'import/prefer-default-export': 'off',
 	'import/no-default-export': 'error',
-	// 循環依存を禁止
-	'import/no-cycle': 'error',
-	// 未使用のインポートを禁止
-	// ESLint 10 で FileEnumerator API が削除されたため no-op だが、将来の代替実装に備えて残す
-	'import/no-unused-modules': [
-		'error',
-		{ unusedExports: true, suppressMissingFileEnumeratorAPIWarning: true },
-	],
+	// Skip dependencies outside the project without limiting internal cycle depth (#6405).
+	'import/no-cycle': ['error', { ignoreExternal: true }],
 	// CommonJSを禁止
 	'import/no-commonjs': 'error',
 	// AMD形式を禁止
@@ -85,11 +78,4 @@ export const import_rules = {
 	'import/newline-after-import': 'error',
 	// グループ化されていないインポートを禁止
 	'import/no-unassigned-import': ['error', { allow: ['**/*.css', '**/*.scss'] }],
-
-	// // 循環参照チェックは重いため、ローカル開発時は off、CIでのみ実行などを検討
-	// // どうしても有効にしたい場合は maxDepth を指定して制限する
-	// 'import/no-cycle': 'off',
-
-	// // 未使用モジュールチェックも非常に重い
-	// 'import/no-unused-modules': 'off',
 }

package/eslint/rules/test-helper-bans.js

@@ -0,0 +1,34 @@
+// テストが共有ヘルパーを素通りする 2 つの書き方を lint で止めるルール群（Issue #6489）。
+// 詳細は prompts/testing-guide.md の「Use the shared test helpers」。
+//
+// kit 自身の `eslint.config.js` だけが wire する。代替の `temporary_directory` は `tools/test/` にあり
+// パッケージに含まれないので、base config に入れると consumer は直しようのない違反を抱える。
+
+const TEST_HELPER_BAN_PATTERNS = ['**/*.test.ts']
+
+// `mkdtempSync(...)` と `fs.mkdtempSync(...)` の呼び出しだけに一致する。`vi.mock('node:fs')` の
+// ファクトリにある `mkdtempSync: vi.fn()` はプロパティなので一致しない。
+const MKDTEMP_SYNC_ENTRY = {
+	selector:
+		"CallExpression:matches([callee.name='mkdtempSync'], [callee.property.name='mkdtempSync'])",
+	message:
+		'Use temporary_directory() from #tools/test/temporary-directory instead of calling mkdtempSync in a test: it registers the cleanup. See prompts/testing-guide.md.',
+}
+
+// vitest の設定が `clearMocks: true` なので、`beforeEach` での呼び出しは毎テスト前の自動クリアの重複。
+// テストの途中で呼ぶ形は自動クリアでは代替できないため対象外にする。
+const CLEAR_ALL_MOCKS_IN_BEFORE_EACH_ENTRY = {
+	selector:
+		"CallExpression[callee.name='beforeEach'] CallExpression[callee.object.name='vi'][callee.property.name='clearAllMocks']",
+	message:
+		'Remove vi.clearAllMocks() from beforeEach: the vitest config sets clearMocks: true, so every test already starts with cleared mocks. See prompts/testing-guide.md.',
+}
+
+const TEST_HELPER_BAN_ENTRIES = [MKDTEMP_SYNC_ENTRY, CLEAR_ALL_MOCKS_IN_BEFORE_EACH_ENTRY]
+
+export {
+	TEST_HELPER_BAN_PATTERNS,
+	MKDTEMP_SYNC_ENTRY,
+	CLEAR_ALL_MOCKS_IN_BEFORE_EACH_ENTRY,
+	TEST_HELPER_BAN_ENTRIES,
+}

package/eslint/untyped-environment.js

@@ -0,0 +1,21 @@
+// joshuafolkken/kit#6768: the switch that has the shared config lint without a TypeScript program
+// (`./untyped.js`). Kept apart from that config so the processes that only set it — the edit hook
+// and the `eslint_d` launcher — never load `typescript-eslint`, an optional peer of this package.
+//
+// The switch is an environment variable rather than a second config file because every consumer's
+// `eslint.config.js` reaches the shared config through `create_base_config`, and none of them has a
+// second file to point a `--config` at. `eslint_d` reads it once: the daemon keeps the environment
+// of the process that started it, so whoever starts one sets it.
+const ENVIRONMENT_VARIABLE = 'JOSH_ESLINT_UNTYPED'
+const ENABLED = '1'
+
+function is_requested(variables) {
+	return variables[ENVIRONMENT_VARIABLE] === ENABLED
+}
+
+// What a process that starts an edit-time eslint adds to its child's environment.
+function environment() {
+	return { [ENVIRONMENT_VARIABLE]: ENABLED }
+}
+
+export const untyped_environment = { environment, is_requested, ENVIRONMENT_VARIABLE }

package/eslint/untyped.js

@@ -0,0 +1,60 @@
+import ts from 'typescript-eslint'
+import { naming_convention_rules } from './rules/naming-convention.js'
+import { untyped_environment } from './untyped-environment.js'
+
+// joshuafolkken/kit#6768: the config the edit-time eslint runs — the `PostToolUse` hook, `josh
+// lint:related` and the pre-commit hook, all through the checkout's warm `eslint_d` — without a
+// TypeScript program. A typed program per checkout stayed resident in each daemon, and with one
+// daemon per lane those programs were what the lanes' memory went to. Typed findings are left to
+// the gate's own lint, which runs cold and never sets the switch (`./untyped-environment.js`).
+const { is_requested } = untyped_environment
+
+const NAMING_CONVENTION = '@typescript-eslint/naming-convention'
+
+// Rules that read the type program when one is there and guess without it — each reported code the
+// typed config passes when this repository's tree was linted both ways. Off here, they stay the gate's.
+const TYPE_GUESSING_RULES = [
+	'sonarjs/no-redundant-optional',
+	'unicorn/no-array-callback-reference',
+	'unicorn/no-for-each',
+	'unicorn/no-return-array-push',
+	'unicorn/prefer-await',
+	'unicorn/prefer-default-parameters',
+	'unicorn/prefer-includes-over-repeated-comparisons',
+	'unicorn/prefer-minimal-ternary',
+	'unicorn/prefer-string-raw',
+	'unicorn/prefer-top-level-await',
+]
+
+// A `types` selector asks the type checker what a name holds, and typescript-eslint throws on the
+// first file when no program answers. The selector's names are still checked by the ones beside it.
+// Filtered where the rule is set rather than overridden after it, so the blocks that switch the rule
+// off for some files still do.
+function naming_convention(variables) {
+	if (!is_requested(variables)) return naming_convention_rules
+	const [severity, ...selectors] = naming_convention_rules[NAMING_CONVENTION]
+
+	return {
+		[NAMING_CONVENTION]: [severity, ...selectors.filter((selector) => !('types' in selector))],
+	}
+}
+
+// Appended after every other block of the shared config, so no earlier block — the test files' own
+// re-enabled promise rules included — brings a typed rule back. Every rule here is only switched off.
+// A disable comment for a typed rule has nothing left to suppress, so it is not reported as unused.
+function blocks(variables) {
+	if (!is_requested(variables)) return []
+
+	return [
+		{
+			...ts.configs.disableTypeChecked,
+			linterOptions: { reportUnusedDisableDirectives: 'off' },
+			rules: {
+				...ts.configs.disableTypeChecked.rules,
+				...Object.fromEntries(TYPE_GUESSING_RULES.map((rule) => [rule, 'off'])),
+			},
+		},
+	]
+}
+
+export const untyped_lint = { blocks, naming_convention, TYPE_GUESSING_RULES }