@joshuafolkken/kit 1.872.0

package/scripts/cases/cases-logic.ts

@@ -0,0 +1,100 @@
+import { readFileSync } from 'node:fs'
+
+// `josh cases <path...>` (joshuafolkken/kit#2246): 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
+// 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").
+
+type Boundary = 'network' | 'process' | 'fs' | 'time'
+const NONE = 'none'
+
+interface BoundaryDefinition {
+	boundary: Boundary
+	// A source pattern that marks the boundary being crossed — an import of, or a call into, it.
+	pattern: RegExp
+	// The abnormal cases this boundary always owes, so they land in the second tier.
+	cases: ReadonlyArray<string>
+}
+
+const BOUNDARIES: ReadonlyArray<BoundaryDefinition> = [
+	{
+		boundary: 'network',
+		// Keyed on a networking API, never a bare URL: a URL in a comment, a doc link or a
+		// string constant crosses no boundary at test time, so matching `https://` text alone
+		// would fire `network` on every markdown edit and defeat the oracle.
+		pattern: /\b(?:fetch|axios|undici|node:https?|XMLHttpRequest)\b/u,
+		cases: ['非200', 'タイムアウト', '接続断', '空レスポンス', '不正JSON', 'レート制限'],
+	},
+	{
+		boundary: 'process',
+		// The module name and the `*Sync` forms are unambiguous; the short verbs (`exec`, `spawn`,
+		// `execFile`) require a call paren, so prose like "exec the plan" or a local named `exec`
+		// no longer fires the boundary.
+		pattern:
+			/\b(?:child_process|execSync|execFileSync|spawnSync)\b|\b(?:exec|execFile|spawn)\s*\(/u,
+		cases: ['非ゼロ終了', 'タイムアウト', '標準エラー出力', '実行ファイル不在'],
+	},
+	{
+		boundary: 'fs',
+		// Same rule as process: the module names and `*Sync` forms are unambiguous, and the short
+		// verbs (`readFile`, `writeFile`, `mkdir`, `unlink`, `readdir`, `rm`) require a call paren,
+		// so prose like "rm the old files" no longer fires the boundary.
+		pattern:
+			/\b(?:node:fs|fs\/promises|readFileSync|writeFileSync)\b|\b(?:readFile|writeFile|mkdir|unlink|readdir|rm)\s*\(/u,
+		cases: ['ファイル不在', '権限エラー', '空ファイル', '不正な内容', '並行書き込み'],
+	},
+	{
+		boundary: 'time',
+		// The absence boundary: a change that coordinates over time — timers, schedules, retries,
+		// heartbeats — owes the cases where the awaited thing never happens, which no diff of an I/O
+		// call can surface (joshuafolkken/kit#2356). Same over-firing discipline as process and fs: the
+		// verbs (`setInterval`, `schedule`, `retry`) require a call paren so prose like "schedule the
+		// release" no longer fires, while the domain nouns (`cron`, `heartbeat`, `watchdog`, `liveness`)
+		// are unambiguous enough in source to match bare.
+		pattern:
+			/\b(?:setInterval|setTimeout|setImmediate|schedule|reschedule|retry)\s*\(|\b(?:cron|crontab|heartbeat|watchdog|liveness)\b/u,
+		cases: ['期待した事象が到来しない', '期限超過', '重複発火', '再試行が尽きる'],
+	},
+]
+
+// A path that cannot be read counts as no boundary rather than an error: a deleted or renamed path in
+// a diff is still passed in, and the answer for it is simply "nothing crossed here".
+function read_file(path: string): string {
+	try {
+		return readFileSync(path, 'utf8')
+	} catch {
+		return ''
+	}
+}
+
+// The distinct boundaries any of the paths cross. The content is joined and each boundary is tested
+// once, so the same boundary is never reported twice however many paths cross it.
+function boundaries_in(paths: ReadonlyArray<string>): ReadonlyArray<Boundary> {
+	const content = paths.map((path) => read_file(path)).join('\n')
+
+	return BOUNDARIES.filter((definition) => definition.pattern.test(content)).map(
+		(definition) => definition.boundary,
+	)
+}
+
+// The abnormal cases owed by the given boundaries, in the fixed boundary order.
+function cases_for(boundaries: ReadonlyArray<Boundary>): ReadonlyArray<string> {
+	return BOUNDARIES.filter((definition) => boundaries.includes(definition.boundary)).flatMap(
+		(definition) => definition.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.
+const VOCABULARY: ReadonlyArray<string> = [
+	...BOUNDARIES.map((definition) => definition.boundary),
+	NONE,
+]
+
+const cases = { BOUNDARIES, NONE, VOCABULARY, boundaries_in, cases_for }
+
+export type { Boundary }
+export { cases }

package/scripts/claude/skill-meta.ts

@@ -0,0 +1,37 @@
+// Where a skill lives and how its frontmatter is read (joshuafolkken/kit#854, single-sourced for
+// joshuafolkken/kit#1151).
+//
+// The suites that assert a skill ships correctly and the `josh cost` resident breakdown that sizes
+// the skills index both need the same two facts: which directory holds the skills, and what the
+// entry file's frontmatter says. This module is where those live, so the pattern is not written
+// twice — `skill-fixture.ts` is a test fixture and is excluded from the published package, so
+// shipped code cannot read it.
+
+const SKILL_ROOT = '.claude/skills'
+const SKILL_ENTRY_FILE = 'SKILL.md'
+const FRONTMATTER_PATTERN = /^---\n([\S\s]*?)\n---\n/u
+const DESCRIPTION_PATTERN = /^description: (.+)$/mu
+
+function has_frontmatter(content: string): boolean {
+	return FRONTMATTER_PATTERN.test(content)
+}
+
+function frontmatter_of(content: string): string {
+	return FRONTMATTER_PATTERN.exec(content)?.[1] ?? ''
+}
+
+// The description is the trigger for every agent that discovers a skill by reading descriptions
+// rather than by being told a path, so it is read out rather than merely asserted present.
+function description_of(content: string): string {
+	return DESCRIPTION_PATTERN.exec(frontmatter_of(content))?.[1] ?? ''
+}
+
+const skill_meta = {
+	SKILL_ROOT,
+	SKILL_ENTRY_FILE,
+	has_frontmatter,
+	frontmatter_of,
+	description_of,
+}
+
+export { skill_meta }

package/scripts/claude/workflow-destination.ts

@@ -0,0 +1,13 @@
+// Whether a path names a workflow file kit writes into a consumer. A leaf module on purpose: both
+// the pin injection and the managed-marker library need this predicate, and the marker library is
+// published (`@joshuafolkken/kit/managed-marker`), so reaching it through the pin logic would inline
+// sync's whole `readdirSync`/`writeFileSync` graph into a bundle that only needs a regex.
+//
+// Matches a consumer workflow destination, absolute or repo-relative, on either separator.
+const WORKFLOW_DESTINATION_PATTERN = /(?:^|[/\\])\.github[/\\]workflows[/\\][^/\\]+\.ya?ml$/u
+
+function is_workflow_destination(destination: string): boolean {
+	return WORKFLOW_DESTINATION_PATTERN.test(destination)
+}
+
+export { is_workflow_destination }

package/scripts/clone/clone-aggregate.ts

@@ -0,0 +1,76 @@
+// Grouping fingerprints into clones, and classifying how far each clone spans (joshuafolkken/kit#2217).
+//
+// This is the pure core the `no-clones` rule was missing a measurement for: `sonarjs/no-identical-
+// functions` sees only inside one file, and the rule's real target is duplication that crosses file
+// and package boundaries. Here a clone is a fingerprint that occurs at two or more sites, and its
+// category is the widest boundary any two of those sites straddle.
+
+// One fingerprint occurrence: the hash of a normalized code window and where it was found.
+interface Fingerprint {
+	hash: string
+	site: CloneSite
+}
+
+// Where a fingerprint occurs. `repo` is the identity duplication is measured against — two sites in
+// different repositories are a cross-repository clone however identical their relative paths look.
+interface CloneSite {
+	repo: string
+	file: string
+	line: number
+}
+
+// How far a clone spans. `same-file` is the narrowest, `cross-repo` the widest.
+type CloneCategory = 'same-file' | 'cross-file' | 'cross-repo'
+
+// A fingerprint that duplicated, its sites, and the boundary it crosses.
+interface CloneGroup {
+	hash: string
+	sites: ReadonlyArray<CloneSite>
+	category: CloneCategory
+}
+
+// A fingerprint is a clone only once it occurs at least twice.
+const MIN_SITES = 2
+
+// The widest boundary any two of the sites straddle: a second repository first, then a second file,
+// else the sites share one file.
+function categorize(sites: ReadonlyArray<CloneSite>): CloneCategory {
+	const repos = new Set(sites.map((site) => site.repo))
+	if (repos.size > 1) return 'cross-repo'
+
+	const files = new Set(sites.map((site) => site.file))
+	if (files.size > 1) return 'cross-file'
+
+	return 'same-file'
+}
+
+// Every site collected under its fingerprint hash, insertion order preserved.
+function group_sites(fingerprints: ReadonlyArray<Fingerprint>): Map<string, Array<CloneSite>> {
+	const groups = new Map<string, Array<CloneSite>>()
+
+	for (const fingerprint of fingerprints) {
+		const sites = groups.get(fingerprint.hash) ?? []
+
+		sites.push(fingerprint.site)
+		groups.set(fingerprint.hash, sites)
+	}
+
+	return groups
+}
+
+// The clones among the fingerprints — those occurring at two or more sites — each classified. The
+// count a caller reports is the length of this array.
+function aggregate(fingerprints: ReadonlyArray<Fingerprint>): Array<CloneGroup> {
+	const clones: Array<CloneGroup> = []
+
+	for (const [hash, sites] of group_sites(fingerprints)) {
+		if (sites.length >= MIN_SITES) clones.push({ hash, sites, category: categorize(sites) })
+	}
+
+	return clones
+}
+
+const clone_aggregate = { categorize, aggregate }
+
+export type { CloneCategory, CloneSite, Fingerprint, CloneGroup }
+export { clone_aggregate }

package/scripts/clone/clone-fingerprint.ts

@@ -0,0 +1,96 @@
+import type { Fingerprint } from './clone-aggregate'
+
+// Turning source text into fingerprints (joshuafolkken/kit#2217).
+//
+// A fingerprint is a block of consecutive significant lines, each normalized so that reindentation
+// and reflowed whitespace do not hide a copy. Blank lines and comment-only lines are dropped before
+// blocking, so a copied block still matches after its comments are edited. The block is the joined
+// normalized text itself — two blocks are the same clone exactly when that text is equal — which needs
+// no parser, so it works across package boundaries and file types the way the rule requires.
+//
+// The blocks are consecutive and non-overlapping (a stride equal to the window), so one copied region
+// counts once rather than once per sliding offset: the number is a count of duplicated blocks, not an
+// inflated tally of every window that happened to overlap the copy. The cost is that a copy whose
+// significant lines do not align to the same block boundary in both files can be missed — an
+// acceptable trade for a count that means what it says.
+
+// How many significant lines make a block. Small enough to catch a copied helper, large enough that a
+// run of ordinary statements does not match by accident.
+const WINDOW_SIZE = 6
+const LINE_SEPARATOR = '\n'
+// Lines that begin a comment once trimmed. `*` covers the continuation lines of a block comment.
+const COMMENT_PREFIXES = ['//', '/*', '*']
+
+// A significant line: its normalized text and its 1-based line number in the original source.
+interface SourceLine {
+	text: string
+	number: number
+}
+
+// Where a file's fingerprints belong, minus the line number the window fills in.
+interface FileSite {
+	repo: string
+	file: string
+}
+
+// Collapse leading, trailing and interior whitespace so formatting differences do not defeat a match.
+function normalize(text: string): string {
+	return text.trim().replaceAll(/\s+/gu, ' ')
+}
+
+// Whether a line carries code — non-blank and not the start of a comment.
+function is_significant(text: string): boolean {
+	const trimmed = text.trim()
+	if (trimmed.length === 0) return false
+
+	return COMMENT_PREFIXES.every((prefix) => !trimmed.startsWith(prefix))
+}
+
+// The significant lines of a source, each normalized and tagged with its original line number.
+function significant_lines(source: string): Array<SourceLine> {
+	const lines: Array<SourceLine> = []
+
+	for (const [index, text] of source.split(LINE_SEPARATOR).entries()) {
+		if (is_significant(text)) lines.push({ text: normalize(text), number: index + 1 })
+	}
+
+	return lines
+}
+
+// One window's fingerprint, or nothing when the slice came up empty.
+function window_fingerprint(
+	window: ReadonlyArray<SourceLine>,
+	site: FileSite,
+): Fingerprint | undefined {
+	const [first] = window
+	if (first === undefined) return undefined
+
+	const hash = window.map((line) => line.text).join(LINE_SEPARATOR)
+
+	return { hash, site: { repo: site.repo, file: site.file, line: first.number } }
+}
+
+// Every non-overlapping block fingerprint of a source, keyed to `site`. A source with fewer than
+// `WINDOW_SIZE` significant lines yields none.
+function fingerprints_for(source: string, site: FileSite): Array<Fingerprint> {
+	const lines = significant_lines(source)
+	const fingerprints: Array<Fingerprint> = []
+
+	for (let start = 0; start + WINDOW_SIZE <= lines.length; start += WINDOW_SIZE) {
+		const fingerprint = window_fingerprint(lines.slice(start, start + WINDOW_SIZE), site)
+		if (fingerprint !== undefined) fingerprints.push(fingerprint)
+	}
+
+	return fingerprints
+}
+
+const clone_fingerprint = {
+	WINDOW_SIZE,
+	normalize,
+	is_significant,
+	significant_lines,
+	fingerprints_for,
+}
+
+export type { FileSite }
+export { clone_fingerprint }

package/scripts/clone/clone-scan-cli.ts

@@ -0,0 +1,39 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { clone_scan } from './clone-scan'
+
+// `josh clone:scan` — count duplication across files and repositories (joshuafolkken/kit#2217).
+//
+// A command rather than a paragraph, for the reason `josh repo:party` is one: the `no-clones` rule
+// fires on the agent's own recognition that it is about to copy something, which is exactly the moment
+// the recognition is easiest to skip. This makes the duplication a number instead. `clean` on stdout
+// so a caller can read the verdict; the count and the `file:line` sites follow it for a person.
+
+const ARGV_OFFSET = 2
+const USAGE = 'Usage: josh clone:scan'
+const FAILURE_EXIT_CODE = 1
+const FLAG_PREFIX = '-'
+
+function run(argv: ReadonlyArray<string>): number {
+	if (argv.some((argument) => !argument.startsWith(FLAG_PREFIX))) {
+		console.error(USAGE)
+
+		return FAILURE_EXIT_CODE
+	}
+
+	const report = clone_scan.format_report(clone_scan.scan(process.cwd()))
+
+	console.info(report)
+
+	return 0
+}
+
+function main(argv: ReadonlyArray<string>): void {
+	process.exitCode = run(argv)
+}
+
+const clone_scan_cli = { USAGE, main, run }
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) main(process.argv.slice(ARGV_OFFSET))
+
+export { clone_scan_cli }

package/scripts/clone/clone-scan.ts

@@ -0,0 +1,158 @@
+import { existsSync, readdirSync, readFileSync, type Dirent } from 'node:fs'
+import path from 'node:path'
+import { repo_discovery } from '#scripts/discovery/repo-discovery'
+import {
+	clone_aggregate,
+	type CloneGroup,
+	type CloneSite,
+	type Fingerprint,
+} from './clone-aggregate'
+import { clone_fingerprint } from './clone-fingerprint'
+
+// Walking the source trees and reporting the clones (joshuafolkken/kit#2217).
+//
+// The current repository is always scanned; every first-party sibling `repo_discovery` finds —
+// including the ones `JOSH_REPO_PATHS` adds — is scanned too, so a copy that crossed a package
+// boundary is counted rather than left invisible. A repository is identified by its absolute root,
+// 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_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']
+const IGNORED_DIRECTORIES = new Set(['node_modules', '.git', '.svelte-kit', 'dist', 'build'])
+const CLEAN_VERDICT = 'clean'
+const CLONES_PREFIX = 'clones:'
+
+// Whether a filename is a source file worth fingerprinting.
+function is_source_file(name: string): boolean {
+	if (!name.endsWith(SOURCE_EXTENSION)) return false
+
+	return IGNORED_SUFFIXES.every((suffix) => !name.endsWith(suffix))
+}
+
+// Whether a directory entry is one to descend into.
+function is_scannable_directory(entry: Dirent): boolean {
+	return entry.isDirectory() && !IGNORED_DIRECTORIES.has(entry.name)
+}
+
+// The directory's entries, or none when it cannot be read: an unreadable directory is reported empty
+// rather than failing the whole scan.
+function read_entries(directory: string): Array<Dirent> {
+	try {
+		return readdirSync(directory, { withFileTypes: true })
+	} catch {
+		return []
+	}
+}
+
+// The source files directly in a directory (not its subdirectories).
+function direct_source_files(directory: string, entries: ReadonlyArray<Dirent>): Array<string> {
+	return entries
+		.filter((entry) => entry.isFile() && is_source_file(entry.name))
+		.map((entry) => path.join(directory, entry.name))
+}
+
+// Every source file under a directory, recursively. Only `walk` recurses, so there is no forward
+// reference to resolve.
+function walk(directory: string): Array<string> {
+	const entries = read_entries(directory)
+	const nested = entries
+		.filter((entry) => is_scannable_directory(entry))
+		.flatMap((entry) => walk(path.join(directory, entry.name)))
+
+	return [...direct_source_files(directory, entries), ...nested]
+}
+
+// Every source file across a repository's source roots.
+function source_files(repo_path: string): Array<string> {
+	return SOURCE_ROOTS.map((root) => path.join(repo_path, root))
+		.filter((root) => existsSync(root))
+		.flatMap((root) => walk(root))
+}
+
+// The fingerprints of one file, keyed to its repository and repo-relative path. An unreadable file
+// contributes none.
+function file_fingerprints(repo_path: string, file: string): Array<Fingerprint> {
+	try {
+		const source = readFileSync(file, 'utf8')
+
+		return clone_fingerprint.fingerprints_for(source, {
+			repo: repo_path,
+			file: path.relative(repo_path, file),
+		})
+	} catch {
+		return []
+	}
+}
+
+// Every fingerprint of every source file in a repository.
+function repo_fingerprints(repo_path: string): Array<Fingerprint> {
+	return source_files(repo_path).flatMap((file) => file_fingerprints(repo_path, file))
+}
+
+// A repository's identity: its `origin` remote, or its resolved path when it declares none. Two
+// worktrees of one repository share an `origin`, so this is what collapses them to a single scan —
+// without it a lane sitting beside its sibling lanes would report every identical line as a clone.
+function repo_identity(repo_path: string): string {
+	return repo_discovery.read_origin_url(repo_path) ?? path.resolve(repo_path)
+}
+
+// The absolute roots to scan: the current repository plus every first-party repository discovered
+// beside it, de-duplicated by identity — the current tree wins, so a worktree of it is dropped — so
+// each repository is scanned exactly once.
+//
+// **Discovery anchors on the main work tree, which `discover_repositories` resolves from `root`.** A
+// `backlogrun` child runs in a lane, whose only neighbors are that repository's other lanes; asked
+// from there, discovery walks up to the main checkout so it still finds the siblings. The current
+// tree is scanned as `root` regardless, so a lane reports its own working state.
+function scan_roots(root: string): Array<string> {
+	const map = repo_discovery.discover_repositories(root)
+	const seen = new Set<string>()
+	const roots: Array<string> = []
+
+	for (const repo_path of [root, ...map.values()]) {
+		const identity = repo_identity(repo_path)
+		if (seen.has(identity)) continue
+
+		seen.add(identity)
+		roots.push(path.resolve(repo_path))
+	}
+
+	return roots
+}
+
+// The clones found across the current repository and its first-party siblings.
+function scan(root: string): Array<CloneGroup> {
+	const fingerprints = scan_roots(root).flatMap((repo_path) => repo_fingerprints(repo_path))
+
+	return clone_aggregate.aggregate(fingerprints)
+}
+
+// One site as `<repo>/<file>:<line>`; the repository basename disambiguates a cross-repository clone.
+// **The main work tree's basename, not the scanned tree's.** A lane's directory is named after its
+// issue, so a site found in one would otherwise print as `2217/…` — a repository nobody has.
+function format_site(site: CloneSite): string {
+	const label = path.basename(repo_discovery.main_worktree(site.repo))
+
+	return `${label}/${site.file}:${String(site.line)}`
+}
+
+// One clone group: its category and every site it occurs at.
+function format_group(group: CloneGroup): string {
+	return `  [${group.category}] ${group.sites.map((site) => format_site(site)).join(', ')}`
+}
+
+// The report: `clean` when nothing duplicated, otherwise the count and each clone's sites.
+function format_report(groups: ReadonlyArray<CloneGroup>): string {
+	if (groups.length === 0) return CLEAN_VERDICT
+
+	const header = `${CLONES_PREFIX} ${String(groups.length)}`
+
+	return [header, ...groups.map((group) => format_group(group))].join('\n')
+}
+
+const clone_scan = { CLEAN_VERDICT, CLONES_PREFIX, scan, format_site, format_group, format_report }
+
+export { clone_scan }

package/scripts/config-merge/index.ts

@@ -0,0 +1,19 @@
+// Public entry point for the parameterized config-merge library (`@joshuafolkken/kit/config-merge`).
+// Both kit's own `josh sync` / `josh init` and downstream consumers (app-kit) drive their cspell
+// `import` and tsconfig `extends` patches through `config_merge`, which exposes ensure + remove
+// semantics for one YAML or JSON list field while preserving every other key, value, and ordering.
+// JSON patches rewrite only the targeted field's own value, so comments, trailing commas and the
+// consumer's hand-formatting elsewhere in the document survive (joshuafolkken/kit#798).
+import { json_list } from './patch-json-list'
+import { yaml_list } from './patch-yaml-list'
+
+const config_merge = {
+	patch_yaml_list_field: yaml_list.patch_yaml_list_field,
+	read_yaml_list_field: yaml_list.read_yaml_list_field,
+	patch_json_list_field: json_list.patch_json_list_field,
+}
+
+export type { ListEntryMatcher } from './list-patch'
+export type { PatchYamlListOptions, YamlFieldPosition } from './patch-yaml-list'
+export type { PatchJsonListOptions } from './patch-json-list'
+export { config_merge }

package/scripts/config-merge/json-format.ts

@@ -0,0 +1,128 @@
+// Serialize JSON config the way prettier would, so a file kit rewrites during `josh sync` stays
+// `prettier --check`-clean. `JSON.stringify(value, undefined, '\t')` matches prettier everywhere
+// EXCEPT one case: prettier keeps a short array of primitives on a single line when it fits within
+// printWidth, whereas JSON.stringify always expands every non-empty array. We post-process the
+// stringify output, collapsing exactly those arrays back inline — reusing JSON.stringify for all
+// string escaping, number formatting, and key ordering so we never diverge on those. See
+// joshuafolkken/kit#660 (a synced tsconfig `exclude` was emitted multi-line and failed prettier).
+//
+// Scope note: an OVER-width array is left one-element-per-line, which matches prettier for string
+// arrays (the only kind these config files hold). prettier uses a packed "fill" layout only for
+// over-width NUMBER arrays — a shape none of the managed JSON configs (tsconfig, package.json,
+// .vscode/*) contain — so that one divergence is unreachable here and deliberately not replicated.
+
+// Mirror the kit prettier preset: printWidth 100, tabs measured as 2 columns for width.
+const PRINT_WIDTH = 100
+const TAB_WIDTH = 2
+const ARRAY_CLOSE = /^\t*\],?$/u
+
+interface ArrayBlock {
+	elements: ReadonlyArray<string>
+	close: string
+	end: number
+}
+
+// True when the line opens an array (`[` or `"key": [`). String / object opens never end in `[`.
+function is_array_open(line: string): boolean {
+	return line.endsWith('[')
+}
+
+// A block is inline-able only when every element line is a leaf scalar. A nested object / array
+// (which prettier and JSON.stringify always break) opens on its own line ending in `{`/`[`, whereas
+// a scalar line ends in a quote, digit, comma, or literal — so a string value that merely CONTAINS
+// a bracket (e.g. the glob `"src/[abc]/*.ts"`) is still correctly treated as a leaf.
+function is_leaf_element(line: string): boolean {
+	return !line.endsWith('{') && !line.endsWith('[')
+}
+
+// Printed column width of a single line: leading tabs count as TAB_WIDTH columns each, the rest as
+// one column per character (config JSON never mixes tabs into the non-indent portion of a line).
+function line_width(line: string): number {
+	const tabs = line.length - line.trimStart().length
+
+	return tabs * TAB_WIDTH + (line.length - tabs)
+}
+
+// Flatten collected element lines into `[a, b, c]`, dropping each element's indentation and the
+// trailing comma JSON.stringify placed between elements.
+function flatten_elements(elements: ReadonlyArray<string>): string {
+	const scalars = elements.map((line) => line.trim().replace(/,$/u, ''))
+
+	return `[${scalars.join(', ')}]`
+}
+
+// Collect the element lines between an array-open at `start` and its matching close line. Returns
+// undefined when any element is a nested structure (not inline-able) — the caller keeps it expanded.
+function collect_block(lines: ReadonlyArray<string>, start: number): ArrayBlock | undefined {
+	const close = lines.findIndex((line, index) => index > start && ARRAY_CLOSE.test(line))
+	if (close === -1) return undefined
+	const elements = lines.slice(start + 1, close)
+	if (elements.some((line) => !is_leaf_element(line))) return undefined
+
+	return { elements, close: lines[close] ?? '', end: close }
+}
+
+// Build the single-line form of an array block, or undefined when it would exceed printWidth (so
+// the caller leaves it expanded, exactly as prettier would).
+function try_inline(open: string, block: ArrayBlock): string | undefined {
+	const trailing_comma = block.close.trimStart() === '],' ? ',' : ''
+	const inlined = `${open.slice(0, -1)}${flatten_elements(block.elements)}${trailing_comma}`
+
+	return line_width(inlined) <= PRINT_WIDTH ? inlined : undefined
+}
+
+interface Rewrite {
+	lines: ReadonlyArray<string>
+	next: number
+}
+
+// Render `line` (at `index`), collapsing it to one line when it opens a short primitive array;
+// otherwise emit it verbatim. `next` is the index to resume from (past a collapsed block).
+function rewrite_at(lines: ReadonlyArray<string>, index: number, line: string): Rewrite {
+	const verbatim: Rewrite = { lines: [line], next: index + 1 }
+	const block = is_array_open(line) ? collect_block(lines, index) : undefined
+	if (block === undefined) return verbatim
+	const inlined = try_inline(line, block)
+	if (inlined === undefined) return verbatim
+
+	return { lines: [inlined], next: block.end + 1 }
+}
+
+function inline_short_arrays(text: string): string {
+	const lines = text.split('\n')
+	const output: Array<string> = []
+	let index = 0
+
+	while (index < lines.length) {
+		const rewrite = rewrite_at(lines, index, lines[index] ?? '')
+
+		output.push(...rewrite.lines)
+		index = rewrite.next
+	}
+
+	return output.join('\n')
+}
+
+// Prettier-clean replacement for `${JSON.stringify(value, undefined, '\t')}\n`. For every managed
+// JSON config EXCEPT package.json — see format_package_json for why that one is different.
+function format_json(value: unknown): string {
+	return `${inline_short_arrays(JSON.stringify(value, undefined, '\t'))}\n`
+}
+
+// Prettier-clean serialization for `package.json`, where prettier does NOT use the `json` parser.
+// It selects `json-stringify` from the FILENAME, and that printer puts every array element on its
+// own line regardless of printWidth — so the inlining above, correct everywhere else, produces a
+// file the consumer's own `prettier --check` rejects. Plain `JSON.stringify` with tab indent is
+// byte-for-byte what that printer emits, so the fix is to skip the inlining rather than model it.
+// See joshuafolkken/kit#797.
+function format_package_json(value: unknown): string {
+	return `${JSON.stringify(value, undefined, '\t')}\n`
+}
+
+const json_format = {
+	inline_short_arrays,
+	format_json,
+	format_package_json,
+}
+
+export { json_format }