@joshuafolkken/kit 1.1094.0 → 1.1128.0

package/scripts/document/entry-read-set.ts

@@ -420,16 +420,40 @@ function point_of_use_cost(
 	return { file, heading: '', cost: cost_of(read_document(root, file)), is_resolved: true }
 }
 
-function point_of_use_costs(root: string, entry: string): Array<SectionCost> {
-	const found = document_section.section(read_document(root, SKILL_FILE), TABLE_SECTION)
-	const references = all_matches(found?.text ?? '', SECTION_REFERENCE).map((match) =>
-		to_reference(match),
-	)
+// **What an entry's path names: its own manifests, and the §1 trigger rows that name the entry**
+// (joshuafolkken/kit#3078). `SKILL.md`'s other text is left out for the reason `sections_for` gives —
+// §2 names every document, so counting it would charge a `kickoff` for `followup.md`. One hop only:
+// the point-of-use documents cite one another, and following them would reach the whole set again.
+// `also` is what a role reaches beside its base entry's path (`read-set-trim.ts`).
+function cited_by(
+	root: string,
+	entry: string,
+	table_text: string,
+	also: ReadonlySet<string>,
+): Set<string> {
+	const manifests = files_for(root, entry).filter((file) => file !== SKILL_FILE)
+	const rows = table_text
+		.split('\n')
+		.filter((line) => line.startsWith('|') && line.includes(`\`${entry}\``))
+	const texts = [...manifests.map((file) => read_document(root, file)), ...rows]
+
+	return new Set([...also, ...texts.flatMap((text) => names_in(text))])
+}
+
+function point_of_use_costs(
+	root: string,
+	entry: string,
+	also: ReadonlySet<string>,
+): Array<SectionCost> {
+	const table_text =
+		document_section.section(read_document(root, SKILL_FILE), TABLE_SECTION)?.text ?? ''
+	const references = all_matches(table_text, SECTION_REFERENCE).map((match) => to_reference(match))
+	const cited = cited_by(root, entry, table_text, also)
 
-	return point_of_use_files(entry).map((file) => point_of_use_cost(root, file, references))
+	return point_of_use_files(entry, cited).map((file) => point_of_use_cost(root, file, references))
 }
 
-function costed(root: string, entry: string): ReadSetCost {
+function costed(root: string, entry: string, also: ReadonlySet<string> = new Set()): ReadSetCost {
 	const { files, sections } = read_set(root, entry)
 	const own_costs = file_costs(root, files)
 	const section_costs = sections.map((reference) => section_cost(root, reference))
@@ -439,7 +463,7 @@ function costed(root: string, entry: string): ReadSetCost {
 		entry,
 		files: own_costs,
 		sections: section_costs,
-		point_of_use: point_of_use_costs(root, entry),
+		point_of_use: point_of_use_costs(root, entry, also),
 		bash_output_cap: bash_output_cap_reader.bash_output_cap(root),
 		whole: total([own, referenced_cost(root, sections)]),
 		scoped: total([own, scoped_cost(root, sections)]),

package/scripts/document/lane-child-read-set.ts

@@ -64,17 +64,24 @@ const SKIPPED_POINT_OF_USE: ReadonlySet<string> = new Set([
 	'retrospective.md',
 ])
 
+// **A child that parks reads `backlogrun-park.md`** (`SKILL.md` §1, "A lane child that parks"), a
+// document a standalone `fullrun`'s path never names — so the child's reach adds it to its base
+// entry's (joshuafolkken/kit#3078).
+const REACHED_POINT_OF_USE: ReadonlySet<string> = new Set(['backlogrun-park.md'])
+
 function costed(root: string): ReadSetCost {
 	return read_set_trim.costed(root, {
 		base_entry: FULLRUN,
 		label: LANE_CHILD,
 		unused_skill_sections: UNUSED_SKILL_SECTIONS,
 		skipped_point_of_use: SKIPPED_POINT_OF_USE,
+		reached_point_of_use: REACHED_POINT_OF_USE,
 	})
 }
 
 const lane_child_read_set = {
 	LANE_CHILD,
+	REACHED_POINT_OF_USE,
 	SKIPPED_POINT_OF_USE,
 	UNUSED_SKILL_SECTIONS,
 	costed,

package/scripts/document/read-set-point-of-use.ts

@@ -75,9 +75,14 @@ function is_point_of_use(entry: string, file: string): boolean {
 	return (POINT_OF_USE_BY_ENTRY.get(entry) ?? NO_PER_ENTRY_FILES).has(file)
 }
 
-// The global point-of-use files plus the ones this entry names in its own row.
-function point_of_use_files(entry: string): Array<string> {
-	return [...POINT_OF_USE_FILES, ...(POINT_OF_USE_BY_ENTRY.get(entry) ?? NO_PER_ENTRY_FILES)]
+// **Only the global files the entry reaches, plus the ones this entry names in its own row**
+// (joshuafolkken/kit#3078). `cited` is every document the entry's path names; a global file outside it
+// is one this entry never opens — a `kickoff` never issues `followup` — so charging it made every
+// entry's total the same figure and the per-entry ratchet measured nothing.
+function point_of_use_files(entry: string, cited: ReadonlySet<string>): Array<string> {
+	const reached = [...POINT_OF_USE_FILES].filter((file) => cited.has(file))
+
+	return [...reached, ...(POINT_OF_USE_BY_ENTRY.get(entry) ?? NO_PER_ENTRY_FILES)]
 }
 
 const read_set_point_of_use = {

package/scripts/document/read-set-trim.ts

@@ -24,6 +24,8 @@ interface TrimSpec {
 	unused_skill_sections: ReadonlyArray<string>
 	// The point-of-use documents this role's parent owns; empty when the role owns them all.
 	skipped_point_of_use: ReadonlySet<string>
+	// The point-of-use documents this role reaches that its base entry's path does not name.
+	reached_point_of_use: ReadonlySet<string>
 }
 
 function subtract(left: Cost, right: Cost): Cost {
@@ -59,7 +61,7 @@ function reduce_skill(file: FileCost, saving: Cost): FileCost {
 // **`whole` and `scoped` both carry the own-files cost identically**, so the `SKILL.md` saving lands
 // on each by the same amount — there is no need to re-derive the referenced-section split.
 function costed(root: string, spec: TrimSpec): ReadSetCost {
-	const base = entry_read_set.costed(root, spec.base_entry)
+	const base = entry_read_set.costed(root, spec.base_entry, spec.reached_point_of_use)
 	const saving = unused_skill_cost(root, spec.unused_skill_sections)
 
 	return {

package/scripts/epic/epic-audit.ts

@@ -1,3 +1,4 @@
+import { markdown_section } from '#scripts/issue/markdown-section'
 import { epic_graph, type EpicChild, type IssueReference } from './epic-graph'
 
 // Reading an epic's children against each other.
@@ -43,7 +44,6 @@ const ACCEPTANCE_HEADINGS: ReadonlySet<string> = new Set([
 	'## 受け入れ条件',
 	'## Acceptance criteria',
 ])
-const HEADING_PREFIX = '## '
 
 type FindingLevel = 'error' | 'warning'
 
@@ -169,26 +169,11 @@ function is_acceptance_heading(line: string): boolean {
 	return ACCEPTANCE_HEADINGS.has(line.trim())
 }
 
-function is_heading(line: string): boolean {
-	return line.trimStart().startsWith(HEADING_PREFIX)
-}
-
-// The lines under the acceptance-criteria heading, up to the next `##`. Shaped like the other
-// section readers in this repository, for the same reason: a regex spanning the block backtracks.
-function section_lines(lines: ReadonlyArray<string>): Array<string> {
-	const start = lines.findIndex((line) => is_acceptance_heading(line))
-	if (start === -1) return []
-	const rest = lines.slice(start + 1)
-	const end = rest.findIndex((line) => is_heading(line))
-
-	return end === -1 ? rest : rest.slice(0, end)
-}
-
-// The acceptance-criteria section of a child's body, or an empty string.
+// The acceptance-criteria section of a child's body, up to the next unfenced `##`, or an empty string.
 function acceptance_section(body: string | undefined): string {
 	if (body === undefined) return ''
 
-	return section_lines(body.split('\n')).join('\n')
+	return markdown_section.section_lines_matching(body, is_acceptance_heading).join('\n')
 }
 
 // Everything `node` depends on, directly or through a chain. Walked iteratively so a graph that

package/scripts/gh/git-gh-issue-list.ts

@@ -1,3 +1,4 @@
+import { bounded_pool } from '#scripts/lib/bounded-pool'
 import { git_gh_api_path } from './git-gh-api-path'
 import { git_gh_exec } from './git-gh-exec'
 import { read_blocked_by } from './git-gh-issue-read'
@@ -198,21 +199,21 @@ async function fetch_selected(request: IssueListRequest): Promise<SelectedRows>
 // issue GitHub itself reports as unblocked costs no request. A backlog with no declared blockers
 // therefore costs exactly what `gh` cost — one listing — rather than one request per row.
 //
-// Sequential rather than a burst: the only caller that asks for the field is the `auto-ok` pickup,
-// whose listing is already narrowed by a label, and a rate limit reached in parallel would fail rows
-// that a paced pass reads.
+// Bounded rather than sequential (joshuafolkken/kit#3103): the pass was paced one request at a time,
+// which made every `backlog:plan` wait about 0.7 s per opted-in issue declaring a blocker. The width
+// is the one `epic:bundle` already reads the same endpoint at, so the burst stays bounded while a
+// rate-limited read still fails the whole listing rather than a row (`bounded-pool.ts`).
+const RELATION_CONCURRENCY = 8
+
 async function read_relations(
 	rows: ReadonlyArray<RestIssue>,
 	repo?: string,
 ): Promise<Array<BlockedBy>> {
-	const relations: Array<BlockedBy> = []
-
-	for (const row of rows) {
-		// eslint-disable-next-line no-await-in-loop -- paced reads, so a rate limit does not fail rows
-		relations.push(await read_blocked_by(String(row.number), row, repo))
-	}
-
-	return relations
+	return await bounded_pool.bounded_map(
+		rows,
+		RELATION_CONCURRENCY,
+		async (row) => await read_blocked_by(String(row.number), row, repo),
+	)
 }
 
 // The listing, plus what it could not cover. `json` is `undefined` — never `'[]'` — when the listing

package/scripts/gh/git-gh-issue-write.ts

@@ -1,3 +1,4 @@
+import { error_text } from '#scripts/lib/error-message'
 import { git_gh_api_path } from './git-gh-api-path'
 import { git_gh_exec, type GhApiRequest } from './git-gh-exec'
 
@@ -43,7 +44,9 @@ async function did_write_succeed(write: () => Promise<unknown>): Promise<boolean
 		await write()
 
 		return true
-	} catch {
+	} catch (error) {
+		error_text.trace_swallowed('git_gh_issue_write.did_write_succeed', error)
+
 		return false
 	}
 }

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

@@ -1,3 +1,4 @@
+import { error_text } from '#scripts/lib/error-message'
 import { git_gh_api_path } from './git-gh-api-path'
 import { git_gh_exec } from './git-gh-exec'
 import { read_pull, require_pr_number } from './git-gh-pr-read'
@@ -40,7 +41,9 @@ async function pr_enable_auto_merge(branch_name: string): Promise<void> {
 async function pr_is_merged(branch_name: string): Promise<boolean> {
 	try {
 		return git_gh_pr_rest.is_merged(await read_pull(await require_pr_number(branch_name)))
-	} catch {
+	} catch (error) {
+		error_text.trace_swallowed('git_gh_pr_auto_merge.pr_is_merged', error)
+
 		return false
 	}
 }

package/scripts/git/git-command.ts

@@ -1,6 +1,8 @@
 import { PORCELAIN_FLAG, UNTRACKED_FILES_FLAG } from './constants'
+import { create_spawn_error } from './git-execa-error'
 import { git_push_transport } from './git-push-transport'
 import { git_spawn } from './git-spawn'
+import { git_spawn_sync } from './git-spawn-sync'
 
 async function branch(): Promise<string> {
 	return await git_spawn.read(['rev-parse', '--abbrev-ref', 'HEAD'])
@@ -31,7 +33,10 @@ async function status(directory?: string): Promise<string> {
 // onto the working directory resolves to nothing, and a digest map built that way collapses to
 // "every file absent" — which compares *equal* to another such map (joshuafolkken/kit#1241).
 async function repository_root(): Promise<string> {
-	return await git_spawn.read(['rev-parse', '--show-toplevel'])
+	const result = git_spawn_sync.toplevel()
+	if (result.exit_code !== 0) throw create_spawn_error('rev-parse', result.exit_code)
+
+	return result.stdout.trim()
 }
 
 // The commit this checkout is sitting on, as opposed to `change_base_commit`'s commit a change is

package/scripts/git/git-spawn-sync.ts

@@ -0,0 +1,65 @@
+import { read_spawn_stderr, read_spawn_stdout } from '#scripts/lib/spawn-exit'
+import { execaSync } from 'execa'
+import { git_utilities } from './constants'
+
+// The one place a synchronous git command is spawned from (joshuafolkken/kit#3065) — the sync
+// counterpart of `git-spawn.ts`. Every caller here wants an answer rather than an exception, so a
+// non-zero exit is returned as a result, and every call is bounded: a git that never answers is an
+// unknown the caller already handles, never a hang.
+
+const GIT_TIMEOUT_MS = 10_000
+const SUCCESS_EXIT_CODE = 0
+// git translates its messages, so a caller matching stderr would fail under any non-English locale.
+const C_LOCALE: Record<string, string> = { LC_ALL: 'C', LANGUAGE: 'C' }
+
+interface GitSyncOptions {
+	cwd?: string
+	timeout?: number
+	env?: Record<string, string | undefined>
+}
+
+interface GitSyncResult {
+	exit_code: number | undefined
+	stdout: string
+	stderr: string
+}
+
+function run(args: ReadonlyArray<string>, options: GitSyncOptions = {}): GitSyncResult {
+	// execa runs the binary directly with an argument array and no `shell` option; the git command and
+	// args are internally controlled, never untrusted input. tssecurity:S8705 is a false positive here.
+	const result = execaSync(git_utilities.get_git_command_for_spawn(), args, {
+		...options,
+		extendEnv: true,
+		reject: false,
+		timeout: options.timeout ?? GIT_TIMEOUT_MS,
+	}) // NOSONAR
+
+	return {
+		exit_code: result.exitCode,
+		stdout: read_spawn_stdout(result),
+		stderr: read_spawn_stderr(result),
+	}
+}
+
+// The trimmed output of a command that succeeded, or undefined for any failure.
+function read(args: ReadonlyArray<string>, options: GitSyncOptions = {}): string | undefined {
+	const result = run(args, options)
+
+	return result.exit_code === SUCCESS_EXIT_CODE ? result.stdout.trim() : undefined
+}
+
+// The configured `origin` URL, or undefined when the repository has none.
+function origin_url(cwd: string): string | undefined {
+	return read(['config', '--get', 'remote.origin.url'], { cwd })
+}
+
+// The absolute repository (or worktree) root, asked under the C locale so a caller can tell "not a
+// repository" apart from every other failure by its stderr.
+function toplevel(timeout: number = GIT_TIMEOUT_MS): GitSyncResult {
+	return run(['rev-parse', '--show-toplevel'], { env: C_LOCALE, timeout })
+}
+
+const git_spawn_sync = { GIT_TIMEOUT_MS, C_LOCALE, run, read, origin_url, toplevel }
+
+export { git_spawn_sync }
+export type { GitSyncResult }

package/scripts/git/git-spawn.ts

@@ -18,10 +18,11 @@ import { git_ssh_keepalive } from './git-ssh-keepalive'
 // **`git-push-transport.ts` is the one deliberate exception among the command modules** and is not a
 // second helper of this kind: a push needs a transport-fault retry that no other command has, so it
 // spawns git itself. The timeout it carries is shared here by `read_remote` / `with_output_remote`. Those two files are the spawn sites of the ordinary command
-// modules — the claim stops there. Other parts of this package spawn git for their own purposes
-// (`scripts/run/run-progress-clock.ts`, `scripts/propagate/propagate-git.ts`,
-// `scripts/doctor/doctor-io.ts`, `scripts/git/git-fixture-workspace.ts`), and an audit of how the git
-// binary is resolved has to read those too.
+// modules — the claim stops there. A synchronous caller goes through `git-spawn-sync.ts`, the same
+// binary resolution with a result instead of an exception (joshuafolkken/kit#3065). Other parts of
+// this package spawn git for their own purposes (`scripts/run/run-progress-clock.ts`,
+// `scripts/git/git-fixture-workspace.ts`), and an audit of how the git binary is resolved has to read
+// those too.
 
 async function read(arguments_: Array<string>): Promise<string> {
 	const git_cmd = git_utilities.get_git_command_for_spawn()

package/scripts/git/stash/stash-pop-args.ts

@@ -21,12 +21,7 @@ interface Request {
 }
 
 function read_arguments(argv: ReadonlyArray<string>): ParsedValues | undefined {
-	return cli_flags.parse_or_undefined({
-		args: [...argv],
-		options: OPTIONS,
-		strict: true,
-		allowPositionals: true,
-	})
+	return cli_flags.arguments_of(argv, OPTIONS)
 }
 
 // The message is the sole positional and must be a non-empty string: an empty message matches every

package/scripts/init/init-file-action.ts

@@ -0,0 +1,54 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import path from 'node:path'
+import type { FileAction } from './init-actions'
+
+const SAMPLE_INDENT_WIDTH = 4
+const SAMPLE_INDENT = ' '.repeat(SAMPLE_INDENT_WIDTH)
+
+function write_new_file(action: FileAction, destination_path: string): void {
+	mkdirSync(path.dirname(destination_path), { recursive: true })
+	writeFileSync(destination_path, action.create())
+	console.info(`  ✔ created   ${action.dest}`)
+}
+
+function show_sample(action: FileAction): void {
+	console.info(`  ⚠ exists    ${action.dest} — add manually:`)
+	console.info('')
+	console.info(action.create().replaceAll(/^/gmu, () => SAMPLE_INDENT))
+}
+
+// A file that already holds the sample needs nothing added, so only one that differs gets it shown —
+// for a create-only file (no merge) as for a merge that only migrates a kit-written line (#3069).
+function report_unchanged(action: FileAction, existing: string): void {
+	const is_sample_missing = existing !== action.create()
+	const should_show_sample =
+		action.merge === undefined || action.should_show_sample_when_unchanged === true
+
+	if (is_sample_missing && should_show_sample) show_sample(action)
+	else console.info(`  ✔ unchanged ${action.dest}`)
+}
+
+function merge_existing_file(action: FileAction, destination_path: string): void {
+	const existing = readFileSync(destination_path, 'utf8')
+	const merged = action.merge === undefined ? existing : action.merge(existing)
+
+	if (merged === existing) {
+		report_unchanged(action, existing)
+
+		return
+	}
+
+	writeFileSync(destination_path, merged)
+	console.info(`  ✔ updated   ${action.dest}`)
+}
+
+function execute_file_action(action: FileAction, project_root: string): void {
+	const destination_path = path.join(project_root, action.dest)
+
+	if (existsSync(destination_path)) merge_existing_file(action, destination_path)
+	else write_new_file(action, destination_path)
+}
+
+const init_file_action = { execute_file_action }
+
+export { init_file_action }

package/scripts/init/init-logic-migrate.ts

@@ -4,6 +4,27 @@ const PREINSTALL_KEY = 'preinstall'
 const JF_PREFIX = 'jf-'
 const JOSH_PREFIX = 'josh '
 
+// The plain values kit wrote before its scripts became josh subcommands (#80). `check` is left out:
+// its value is the one `sv create` writes itself, so it cannot be told apart from the project's own.
+const PRE_JOSH_SCRIPT_VALUES: ReadonlyMap<string, string> = new Map([
+	['lint', 'pnpm lint:prettier && pnpm lint:eslint'],
+	['lint:prettier', 'prettier --check .'],
+	['lint:eslint', 'eslint . --cache --cache-strategy content'],
+	['format', 'pnpm format:prettier && pnpm format:eslint'],
+	['format:prettier', 'prettier --write .'],
+	['format:eslint', 'eslint . --fix --cache --cache-strategy content'],
+	['cspell', 'cspell lint --no-must-find-files --no-progress "**/*.{ts,js,md,yaml,yml,json}"'],
+	['cspell:dot', 'pnpm cspell . --dot'],
+	['test:unit', 'vitest run'],
+	['lefthook:install', 'lefthook install'],
+	['lefthook:uninstall', 'lefthook uninstall'],
+	['lefthook:commit', 'lefthook run pre-commit'],
+	['lefthook:push', 'lefthook run pre-push'],
+	['main:sync', 'git checkout main && git pull'],
+	['main:merge', 'git pull origin main'],
+	['check:ci', 'svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --threshold error'],
+])
+
 const RETIRED_MANAGED_SCRIPTS = new Set<string>([
 	'git',
 	'git:followup',
@@ -18,30 +39,15 @@ const RETIRED_MANAGED_SCRIPTS = new Set<string>([
 	'version:patch',
 	'version:current',
 	'overrides:check',
-	'lint',
-	'lint:prettier',
-	'lint:eslint',
-	'format',
-	'format:prettier',
-	'format:eslint',
-	'cspell',
-	'cspell:dot',
-	'test:unit',
 	'test:e2e',
 	'test',
-	'lefthook:install',
-	'lefthook:uninstall',
-	'lefthook:commit',
-	'lefthook:push',
-	'main:sync',
-	'main:merge',
 	'latest',
 	'latest:corepack',
 	'latest:update',
 	'check',
-	'check:ci',
 	'check:svelte',
 	'check:svelte:ci',
+	...PRE_JOSH_SCRIPT_VALUES.keys(),
 ])
 
 function migrate_jf_value(value: string): string {
@@ -62,9 +68,21 @@ function apply_jf_migrations(scripts: Record<string, string>): Record<string, st
 	)
 }
 
+function is_kit_written(key: string, value: string): boolean {
+	if (value.startsWith(JOSH_PREFIX) || value.startsWith(JF_PREFIX)) return true
+
+	return PRE_JOSH_SCRIPT_VALUES.get(key) === value
+}
+
+// A retired name alone does not make a script kit's: `sv create` writes its own `check`, which must
+// survive `josh init` (joshuafolkken/kit#3069). Only a value kit itself wrote is retired.
+function is_retired_script(key: string, value: string): boolean {
+	return RETIRED_MANAGED_SCRIPTS.has(key) && is_kit_written(key, value)
+}
+
 function remove_retired_scripts(scripts: Record<string, string>): Record<string, string> {
 	return Object.fromEntries(
-		Object.entries(scripts).filter(([key]) => !RETIRED_MANAGED_SCRIPTS.has(key)),
+		Object.entries(scripts).filter(([key, value]) => !is_retired_script(key, value)),
 	)
 }
 

package/scripts/init/init-logic-secretlint.ts

@@ -5,7 +5,7 @@ const SECRETLINT_RULE_PRESET = '@secretlint/secretlint-rule-preset-recommend'
 
 // secretlint resolves both its CLI and every rule package from the project it runs in, not
 // transitively through the kit — the same constraint that forces the prettier plugins into
-// consumer devDependencies (see PRETTIER_PLUGIN_DEV_DEPS in init-logic.ts). Omitting either
+// consumer devDependencies (as kit peers, see init.ts). Omitting either
 // entry makes the pre-commit hook fail with "Cannot find module". Versions mirror the kit's
 // own devDependencies.
 const SECRETLINT_DEV_DEPS: Record<string, string> = {

package/scripts/init/init-logic.ts

@@ -92,10 +92,13 @@ const AI_COPY_FILES: ReadonlyArray<string> = [
 	'.github/workflows/production.yml',
 	'.github/workflows/sonar-qube.yml',
 	'.github/workflows/pr-classification.yml',
-	// Called by `pr-classification.yml` as `uses: ./.github/actions/setup-pnpm`; without it the
-	// consumer's job cannot resolve the action and the Release classification check fails
-	// (joshuafolkken/kit#3013).
+	// Called by `ci.yml` and `pr-classification.yml` as `uses: ./.github/actions/setup-pnpm`; without
+	// it the consumer's jobs cannot resolve the action and their checks fail (joshuafolkken/kit#3013,
+	// joshuafolkken/kit#3095).
 	'.github/actions/setup-pnpm/action.yml',
+	// The one place the workflows' Node.js version is written, called by every distributed workflow
+	// that sets Node.js up (joshuafolkken/kit#3084).
+	'.github/actions/setup-node/action.yml',
 	'.github/pull_request_template.md',
 	'.github/release.yml',
 	'.github/dependabot.yml',
@@ -220,20 +223,6 @@ const SUGGESTED_SCRIPTS_COMMON: Record<string, string> = {
 	josh: 'josh',
 }
 
-// prettier resolves its `plugins[]` from the consumer project, not transitively through the kit,
-// so every package that uses the kit prettier preset must declare these as devDependencies. The
-// preset references all three unconditionally (prettier/index.js → plugins), hence all three are
-// added regardless of project — omitting any breaks `prettier`/`josh lint` with a
-// "Cannot find package" error. Versions mirror the kit's own devDependencies.
-const SORT_IMPORTS_PLUGIN_KEY = '@ianvs/prettier-plugin-sort-imports'
-const PRETTIER_SVELTE_PLUGIN_KEY = 'prettier-plugin-svelte'
-const PRETTIER_TAILWIND_PLUGIN_KEY = 'prettier-plugin-tailwindcss'
-const PRETTIER_PLUGIN_DEV_DEPS: Record<string, string> = {
-	[SORT_IMPORTS_PLUGIN_KEY]: '^4.7.1',
-	[PRETTIER_SVELTE_PLUGIN_KEY]: '^4.1.1',
-	[PRETTIER_TAILWIND_PLUGIN_KEY]: '^0.8.0',
-}
-
 // format_json rather than JSON.stringify: it lays arrays out the way prettier does — inline while
 // they fit within printWidth, one element per line once they do not — so the file kit writes is
 // `prettier --check`-clean in the consumer whatever the entry count happens to be (#660).
@@ -433,10 +422,6 @@ function strip_managed_postinstall(content: string): string {
 	)
 }
 
-function merge_prettier_plugin_development_deps(content: string): string {
-	return init_logic_json_merge.merge_development_dependencies(content, PRETTIER_PLUGIN_DEV_DEPS)
-}
-
 const init_logic = {
 	...init_logic_templates,
 	...init_logic_workspace,
@@ -454,7 +439,6 @@ const init_logic = {
 	generate_npmrc,
 	merge_npmrc,
 	merge_gitignore,
-	merge_prettier_plugin_development_deps,
 	get_tsconfig_extends_entry,
 	get_tsconfig_preset_filename,
 	get_lefthook_extends_value,