@joshuafolkken/kit 1.883.0 → 1.921.0

package/scripts/init/init-static.ts

@@ -0,0 +1,52 @@
+import { json_format } from '#scripts/config-merge/json-format'
+import { z } from 'zod'
+import { init_logic } from './init-logic'
+import type { ProjectShape } from './project-profile'
+
+const KIT_PACKAGE_NAME = '@joshuafolkken/kit'
+const record_schema = z.record(z.string(), z.unknown())
+
+function is_record(value: unknown): value is Record<string, unknown> {
+	return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+interface StaticVersions {
+	kit: string
+	prettier: string
+}
+
+function initial_manifest(): string {
+	return json_format.format_json({ private: true })
+}
+
+function with_recorded_profile(content: string, profile: ProjectShape['profile']): string {
+	const parsed: unknown = JSON.parse(content)
+	const manifest = record_schema.parse(parsed)
+	const existing = manifest['josh']
+	const josh = is_record(existing) ? existing : {}
+
+	manifest['josh'] = { ...josh, profile }
+
+	return json_format.format_json(manifest)
+}
+
+function merge_static_manifest(
+	content: string,
+	shape: ProjectShape,
+	versions: StaticVersions,
+): string {
+	const with_profile = with_recorded_profile(content, shape.profile)
+	const with_script = init_logic.merge_package_scripts(with_profile, { josh: 'josh' })
+	const with_kit = init_logic.merge_development_dependencies(with_script, {
+		[KIT_PACKAGE_NAME]: versions.kit,
+	})
+	const with_prettier = shape.has_web
+		? init_logic.merge_development_dependencies(with_kit, { prettier: versions.prettier })
+		: with_kit
+
+	return init_logic.sort_package_json_keys(with_prettier)
+}
+
+const init_static = { initial_manifest, with_recorded_profile, merge_static_manifest }
+export { init_static }
+export type { StaticVersions }

package/scripts/init/init.ts

@@ -12,16 +12,20 @@ import { did_refuse_self_run } from '#scripts/self-sync-guard/self-sync-refusal'
 import { sync } from '#scripts/sync/sync'
 import { package_manager_version } from '#scripts/version/package-manager-version'
 import { execaSync } from 'execa'
+import { z } from 'zod'
 import { init_actions, PRETTIER_CONFIG_JS, type FileAction } from './init-actions'
 import { init_ai_copy } from './init-ai-copy'
 import { init_logic } from './init-logic'
 import { PACKAGE_DIR, PROJECT_ROOT } from './init-paths'
+import { init_static } from './init-static'
 import { plugin_install_hint_module } from './plugin-install-hint'
+import { project_profile, type ProjectShape } from './project-profile'
 
 const PACKAGE_JSON = 'package.json'
 const KIT_PACKAGE_NAME = '@joshuafolkken/kit'
 const LEFTHOOK_BIN = 'lefthook'
 const SAMPLE_INDENT_WIDTH = 4
+const ARGUMENT_START_INDEX = 2
 const SAMPLE_INDENT = ' '.repeat(SAMPLE_INDENT_WIDTH)
 
 function write_new_file(action: FileAction, destination_path: string): void {
@@ -93,22 +97,48 @@ function get_kit_self_dependency(): Record<string, string> {
 	return { [KIT_PACKAGE_NAME]: version }
 }
 
-function apply_dependency_merges(content: string): string {
+function get_eslint_development_dependencies(): Record<string, string> {
+	const manifest = z
+		.object({
+			peerDependencies: z.record(z.string(), z.string()),
+			devDependencies: z.record(z.string(), z.string()),
+		})
+		.parse(init_actions.read_package_json(PACKAGE_JSON))
+	const entries = Object.keys(manifest.peerDependencies)
+		.filter((name) => name !== '@playwright/test')
+		.map((name): [string, string] => {
+			const version = manifest.devDependencies[name]
+			if (version === undefined) throw new Error(`Missing development version for ${name}`)
+
+			return [name, version]
+		})
+
+	return Object.fromEntries(entries)
+}
+
+function apply_dependency_merges(content: string, has_git = true): string {
 	const migrated = init_logic.strip_managed_postinstall(content)
+	const suggested = init_logic.get_suggested_scripts_for_content(migrated)
 	const merged = init_logic.merge_package_scripts(
 		migrated,
-		init_logic.get_suggested_scripts_for_content(migrated),
+		has_git
+			? suggested
+			: Object.fromEntries(Object.entries(suggested).filter(([key]) => key !== 'prepare')),
 	)
 	const with_prettier = init_logic.merge_prettier_plugin_development_deps(merged)
-	const with_secretlint = init_logic.merge_secretlint_development_deps(with_prettier)
+	const with_eslint = init_logic.merge_development_dependencies(
+		with_prettier,
+		get_eslint_development_dependencies(),
+	)
+	const with_secretlint = init_logic.merge_secretlint_development_deps(with_eslint)
 
 	return init_logic.merge_development_dependencies(with_secretlint, get_kit_self_dependency())
 }
 
-function apply_package_json_merges(content: string): string {
-	const with_kit = apply_dependency_merges(content)
-	const upgraded = init_logic.upgrade_prepare_lefthook_warning(with_kit)
-	const with_lifecycle = init_logic.merge_prepare_lifecycle_cmd(upgraded)
+function apply_package_json_merges(content: string, has_git = true): string {
+	const with_kit = apply_dependency_merges(content, has_git)
+	const upgraded = has_git ? init_logic.upgrade_prepare_lefthook_warning(with_kit) : with_kit
+	const with_lifecycle = has_git ? init_logic.merge_prepare_lifecycle_cmd(upgraded) : upgraded
 	const kit_pm = get_kit_package_manager()
 	const with_pm =
 		kit_pm === undefined ? with_lifecycle : init_logic.merge_package_manager(with_lifecycle, kit_pm)
@@ -121,21 +151,46 @@ function apply_package_json_merges(content: string): string {
 	return package_manager_version.align_development_engines_version(sorted)
 }
 
-function merge_project_package_json(): void {
-	const package_json_path = path.join(PROJECT_ROOT, PACKAGE_JSON)
-	if (!existsSync(package_json_path)) return
+function get_static_versions(): { kit: string; prettier: string } {
+	const manifest = z
+		.object({
+			version: z.string(),
+			devDependencies: z.record(z.string(), z.string()),
+		})
+		.parse(init_actions.read_package_json(PACKAGE_JSON))
+	const { prettier } = manifest.devDependencies
+	if (prettier === undefined) throw new Error('Missing prettier development version')
+
+	return { kit: manifest.version, prettier }
+}
 
-	const existing = readFileSync(package_json_path, 'utf8')
-	const merged = apply_package_json_merges(existing)
+function merged_manifest(existing: string, shape: ProjectShape): string {
+	if (shape.profile === 'static') {
+		return init_static.merge_static_manifest(existing, shape, get_static_versions())
+	}
 
-	if (merged === existing) {
+	return init_static.with_recorded_profile(
+		apply_package_json_merges(existing, shape.has_git),
+		shape.profile,
+	)
+}
+
+function merge_project_package_json(shape: ProjectShape): void {
+	const package_json_path = path.join(PROJECT_ROOT, PACKAGE_JSON)
+	const is_existing = existsSync(package_json_path)
+	const existing = is_existing
+		? readFileSync(package_json_path, 'utf8')
+		: init_static.initial_manifest()
+	const merged = merged_manifest(existing, shape)
+
+	if (is_existing && merged === existing) {
 		console.info('  ✔ unchanged package.json')
 
 		return
 	}
 
 	writeFileSync(package_json_path, merged)
-	console.info('  ✔ updated   package.json')
+	console.info(`  ✔ ${is_existing ? 'updated' : 'created'}   package.json`)
 }
 
 function install_lefthook(): void {
@@ -148,14 +203,17 @@ function install_lefthook(): void {
 	}
 }
 
-function run_config_file_actions(): void {
+function run_config_file_actions(shape: ProjectShape): void {
 	console.info('Config files:')
 
-	if (sync.migrate_prettierrc(path.join(PROJECT_ROOT, PRETTIER_CONFIG_JS))) {
+	if (
+		shape.profile === 'node' &&
+		sync.migrate_prettierrc(path.join(PROJECT_ROOT, PRETTIER_CONFIG_JS))
+	) {
 		console.info('  ✔ migrated  .prettierrc → prettier.config.js')
 	}
 
-	for (const action of init_actions.build_file_actions()) {
+	for (const action of init_actions.build_file_actions(shape)) {
 		execute_file_action(action)
 	}
 }
@@ -179,36 +237,45 @@ function report_repository_settings(name_with_owner: string | undefined): void {
 // rather than through `sync`'s own `main()`, so the guard there never ran for it — and on top of the
 // 14 files #868 reproduced, `init` also rewrites `package.json` scripts and devDependencies
 // (joshuafolkken/kit#879). Checked before the first write, for the reason the sync guard is.
-function run_ai_file_actions(): void {
+function run_ai_file_actions(shape: ProjectShape): void {
 	console.info('\nAI files:')
 	// `init` writes the same npm-disabling `.github/dependabot.yml` that `sync` distributes, so a
 	// freshly scaffolded repository is exposed from its first commit — and a new private repository
 	// is exactly where the setting is off by default. The name is the one the Sonar config already
 	// resolved, so `gh repo view` runs once; the position is the pre-existing one.
-	const name_with_owner = init_ai_copy.run_ai_copies()
+	const name_with_owner = init_ai_copy.run_ai_copies(shape)
 
-	install_lefthook()
+	if (shape.has_git && shape.profile === 'node') install_lefthook()
 
-	report_repository_settings(name_with_owner)
+	if (shape.has_github) report_repository_settings(name_with_owner)
 
-	plugin_install_hint_module.report_plugin_install_hint()
+	if (shape.profile === 'node') plugin_install_hint_module.report_plugin_install_hint()
 }
 
-function main(): void {
-	if (did_refuse_self_run(PACKAGE_DIR, PROJECT_ROOT)) return
-
+function initialize_project(shape: ProjectShape): void {
 	console.info('\n🚀 Initializing @joshuafolkken/kit\n')
-	run_config_file_actions()
+	console.info(`profile: ${shape.profile} (${shape.reason})`)
+	run_config_file_actions(shape)
 
 	console.info('\nPackage scripts:')
-	merge_project_package_json()
+	merge_project_package_json(shape)
 
-	run_ai_file_actions()
-	project_config.sync_project_config(PROJECT_ROOT)
+	run_ai_file_actions(shape)
+	if (shape.profile === 'node') project_config.sync_project_config(PROJECT_ROOT)
 	console.info('\n✅ Done.\n')
 }
 
-if (process.argv[1] === fileURLToPath(import.meta.url)) main()
+function main(args: ReadonlyArray<string> = []): void {
+	if (did_refuse_self_run(PACKAGE_DIR, PROJECT_ROOT)) return
+	const requested = project_profile.requested_profile(args)
+	const shape = project_profile.inspect_project(PROJECT_ROOT, requested)
+
+	initialize_project(shape)
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	main(process.argv.slice(ARGUMENT_START_INDEX))
+}
 
 const init = {
 	copy_ai_file: init_ai_copy.copy_ai_file,

package/scripts/init/project-profile-cli.ts

@@ -0,0 +1,14 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { project_profile } from './project-profile'
+
+const ARGUMENT_START_INDEX = 2
+
+function main(): void {
+	const requested = project_profile.requested_profile(process.argv.slice(ARGUMENT_START_INDEX))
+	const result = project_profile.resolve_profile(process.cwd(), requested)
+
+	console.info(`profile: ${result.profile} (${result.reason})`)
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) main()

package/scripts/init/project-profile.ts

@@ -0,0 +1,149 @@
+import { existsSync, readdirSync, readFileSync, type Dirent } from 'node:fs'
+import path from 'node:path'
+import { repo_origin } from '#scripts/discovery/repo-origin'
+import { execaSync } from 'execa'
+
+type ProjectProfile = 'static' | 'node'
+
+interface ProfileResult {
+	profile: ProjectProfile
+	reason: string
+}
+
+interface ProjectShape extends ProfileResult {
+	has_web: boolean
+	has_typescript: boolean
+	has_git: boolean
+	has_github: boolean
+}
+
+const IGNORED_DIRECTORIES = new Set(['.git', 'node_modules', 'dist', 'build', '.svelte-kit'])
+const WEB_EXTENSIONS = new Set(['.html', '.css', '.js', '.jsx', '.mjs', '.cjs'])
+const TYPESCRIPT_EXTENSIONS = new Set(['.ts', '.tsx'])
+const PROFILE_ARG_LENGTH = 2
+
+function parse_profile(value: unknown): ProjectProfile | undefined {
+	if (value === 'static' || value === 'node') return value
+
+	return undefined
+}
+
+function requested_profile(args: ReadonlyArray<string>): ProjectProfile | undefined {
+	if (args.length === 0) return undefined
+
+	if (args.length !== PROFILE_ARG_LENGTH || args[0] !== '--profile') {
+		throw new Error('Usage: josh init [--profile static|node]')
+	}
+
+	const profile = parse_profile(args[1])
+	if (profile !== undefined) return profile
+	throw new Error('Profile must be static or node')
+}
+
+function read_manifest(root: string): Record<string, unknown> | undefined {
+	const filename = path.join(root, 'package.json')
+	if (!existsSync(filename)) return undefined
+	const parsed: unknown = JSON.parse(readFileSync(filename, 'utf8'))
+
+	if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+		throw new Error('package.json must contain an object')
+	}
+
+	return parsed as Record<string, unknown>
+}
+
+function has_entries(value: unknown): boolean {
+	return typeof value === 'object' && value !== null && Object.keys(value).length > 0
+}
+
+function is_record(value: unknown): value is Record<string, unknown> {
+	return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function recorded_profile(manifest: Record<string, unknown>): ProjectProfile | undefined {
+	const { josh } = manifest
+
+	return is_record(josh) ? parse_profile(josh['profile']) : undefined
+}
+
+function has_build_script(value: unknown): boolean {
+	return is_record(value) && ('build' in value || 'dev' in value)
+}
+
+function inferred_profile(manifest: Record<string, unknown>): ProfileResult {
+	if (has_entries(manifest['dependencies']) || has_entries(manifest['devDependencies'])) {
+		return { profile: 'node', reason: 'package dependencies' }
+	}
+
+	if (has_build_script(manifest['scripts'])) {
+		return { profile: 'node', reason: 'build or dev script' }
+	}
+
+	return { profile: 'static', reason: 'metadata-only package.json' }
+}
+
+function resolve_profile(root: string, requested?: ProjectProfile): ProfileResult {
+	if (requested !== undefined) return { profile: requested, reason: 'explicit --profile' }
+	const manifest = read_manifest(root)
+	if (manifest === undefined) return { profile: 'static', reason: 'no package.json' }
+	const profile = recorded_profile(manifest)
+	if (profile !== undefined) return { profile, reason: 'package.json josh.profile' }
+
+	return inferred_profile(manifest)
+}
+
+function should_visit(entry: Dirent): boolean {
+	return entry.isDirectory() && !IGNORED_DIRECTORIES.has(entry.name)
+}
+
+function scan_directory(directory: string, pending: Array<string>): Array<string> {
+	const entries = readdirSync(directory, { withFileTypes: true })
+
+	pending.push(
+		...entries
+			.filter((entry) => should_visit(entry))
+			.map((entry) => path.join(directory, entry.name)),
+	)
+
+	return entries.filter((entry) => entry.isFile()).map((entry) => path.extname(entry.name))
+}
+
+function file_extensions(root: string): Array<string> {
+	const pending = [root]
+	const extensions: Array<string> = []
+
+	for (const directory of pending) {
+		extensions.push(...scan_directory(directory, pending))
+	}
+
+	return extensions
+}
+
+function scan_files(root: string): { has_web: boolean; has_typescript: boolean } {
+	const extensions = file_extensions(root)
+	const has_web = extensions.some((extension) => WEB_EXTENSIONS.has(extension))
+	const has_typescript = extensions.some((extension) => TYPESCRIPT_EXTENSIONS.has(extension))
+
+	return { has_web, has_typescript }
+}
+
+function has_github_remote(root: string): boolean {
+	const result = execaSync('git', ['config', '--get', 'remote.origin.url'], {
+		cwd: root,
+		reject: false,
+	})
+
+	return result.exitCode === 0 && repo_origin.parse_origin_url(result.stdout) !== undefined
+}
+
+function inspect_project(root: string, requested?: ProjectProfile): ProjectShape {
+	const profile = resolve_profile(root, requested)
+	const files = scan_files(root)
+	const has_git = existsSync(path.join(root, '.git'))
+
+	return { ...profile, ...files, has_git, has_github: has_git && has_github_remote(root) }
+}
+
+const project_profile = { resolve_profile, inspect_project, requested_profile }
+export { project_profile }
+export type { ProjectProfile, ProjectShape }

package/scripts/init/start.ts

@@ -0,0 +1,30 @@
+#!/usr/bin/env tsx
+import { fileURLToPath } from 'node:url'
+import { main as init_main } from './init'
+import { project_profile, type ProjectShape } from './project-profile'
+
+const ARGUMENT_START_INDEX = 2
+
+function prerequisite(shape: ProjectShape): string | undefined {
+	if (!shape.has_git) return 'josh start requires Git. Run git init, or use josh init without Git.'
+	if (!shape.has_github) return 'josh start requires a GitHub origin. Add one, or use josh init.'
+
+	return undefined
+}
+
+function main(args: ReadonlyArray<string> = []): void {
+	// --profile uses the same override as josh init.
+	const requested = project_profile.requested_profile(args)
+	const shape = project_profile.inspect_project(process.cwd(), requested)
+	const message = prerequisite(shape)
+	if (message !== undefined) throw new Error(message)
+	init_main(args)
+	console.info('GitHub workflow ready. Use kickoff in your assistant to plan an Issue.')
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+	main(process.argv.slice(ARGUMENT_START_INDEX))
+}
+
+const start = { prerequisite }
+export { start }

package/scripts/issue/issue-bug-label.ts

@@ -0,0 +1,13 @@
+import { markdown_section } from './markdown-section'
+
+const BUG_DECLARATION_LINE = '- 種別: 不具合'
+
+function is_bug_fix(body: string): boolean {
+	const background = markdown_section.section_lines(body, '## 背景').join('\n')
+
+	return markdown_section.has_unfenced_line(background, BUG_DECLARATION_LINE)
+}
+
+const issue_bug_label = { BUG_DECLARATION_LINE, is_bug_fix }
+
+export { issue_bug_label }

package/scripts/issue/issue-classification.ts

@@ -0,0 +1,74 @@
+import {
+	BREAKING_CHANGE_LABEL,
+	BUG_LABEL,
+	ENHANCEMENT_LABEL,
+	has_label_name,
+} from '#scripts/git/issue-labels'
+import { issue_bug_label } from './issue-bug-label'
+import { markdown_section } from './markdown-section'
+
+const FEATURE_DECLARATIONS = ['- 目的: 機能追加', '- 目的: 機能改善']
+const BREAKING_DECLARATION = '- 互換性: 破壊的変更'
+const NON_BUG_DECLARATION = '- 種別: 非不具合'
+const CLASSIFICATION_LABELS = [BUG_LABEL, ENHANCEMENT_LABEL, BREAKING_CHANGE_LABEL]
+const CONFLICT = 'bug and enhancement declarations cannot be combined'
+const MISSING_BUG_CLASSIFICATION = 'missing bug classification'
+const CONFLICTING_BUG_CLASSIFICATIONS = 'conflicting bug classifications'
+
+function required_labels(body: string): ReadonlyArray<string> {
+	const labels: Array<string> = []
+	const background = markdown_section.section_lines(body, '## 背景').join('\n')
+
+	if (issue_bug_label.is_bug_fix(body)) labels.push(BUG_LABEL)
+
+	if (FEATURE_DECLARATIONS.some((line) => markdown_section.has_unfenced_line(background, line))) {
+		labels.push(ENHANCEMENT_LABEL)
+	}
+
+	if (markdown_section.has_unfenced_line(background, BREAKING_DECLARATION)) {
+		labels.push(BREAKING_CHANGE_LABEL)
+	}
+
+	return labels
+}
+
+function labels_for(body: string, existing: ReadonlyArray<string>): ReadonlyArray<string> {
+	const missing = required_labels(body).filter((label) => !has_label_name(existing, label))
+
+	return [...existing, ...missing]
+}
+
+function bug_classification_problem(body: string): string | undefined {
+	const background = markdown_section.section_lines(body, '## 背景').join('\n')
+	const has_bug = issue_bug_label.is_bug_fix(body)
+	const has_non_bug = markdown_section.has_unfenced_line(background, NON_BUG_DECLARATION)
+
+	if (!has_bug && !has_non_bug) return MISSING_BUG_CLASSIFICATION
+	if (has_bug && has_non_bug) return CONFLICTING_BUG_CLASSIFICATIONS
+
+	return undefined
+}
+
+function problems(body: string): ReadonlyArray<string> {
+	const classification_problem = bug_classification_problem(body)
+	const found: Array<string> = []
+
+	if (classification_problem !== undefined) found.push(classification_problem)
+	const labels = required_labels(body)
+
+	if (labels.includes(BUG_LABEL) && labels.includes(ENHANCEMENT_LABEL)) found.push(CONFLICT)
+
+	return found
+}
+
+const issue_classification = {
+	BREAKING_DECLARATION,
+	CLASSIFICATION_LABELS,
+	FEATURE_DECLARATIONS,
+	NON_BUG_DECLARATION,
+	labels_for,
+	problems,
+	required_labels,
+}
+
+export { issue_classification }

package/scripts/issue/issue-lint-cli.ts

@@ -2,6 +2,7 @@
 import { readFile } from 'node:fs/promises'
 import { fileURLToPath } from 'node:url'
 import { behavior_change_lint } from './behavior-change-lint'
+import { issue_classification } from './issue-classification'
 import { issue_lint } from './issue-lint'
 
 // `josh issue:lint <path>` — read an Issue body from a file and print `ok`, or every template problem
@@ -13,6 +14,7 @@ import { issue_lint } from './issue-lint'
 const SUCCESS_EXIT_CODE = 0
 const FAILURE_EXIT_CODE = 1
 const OK_MESSAGE = 'ok'
+const NO_LABELS = 'none'
 const USAGE = 'Usage: josh issue:lint <path-to-issue-body>'
 
 // Every problem a body has: the four base template headings it lacks, then the behavior-change
@@ -20,12 +22,17 @@ const USAGE = 'Usage: josh issue:lint <path-to-issue-body>'
 function problems(body: string): ReadonlyArray<string> {
 	const missing = issue_lint.missing_headings(body).map((heading) => `missing heading: ${heading}`)
 
-	return [...missing, ...behavior_change_lint.problems(body)]
+	return [
+		...missing,
+		...behavior_change_lint.problems(body),
+		...issue_classification.problems(body),
+	]
 }
 
-function report(found: ReadonlyArray<string>): number {
+function report(found: ReadonlyArray<string>, body: string): number {
 	if (found.length === 0) {
 		console.info(OK_MESSAGE)
+		console.info(`labels: ${issue_classification.required_labels(body).join(', ') || NO_LABELS}`)
 
 		return SUCCESS_EXIT_CODE
 	}
@@ -44,7 +51,7 @@ async function run(body_path: string | undefined): Promise<number> {
 
 	const body = await readFile(body_path, 'utf8')
 
-	return report(problems(body))
+	return report(problems(body), body)
 }
 
 async function main(argv: ReadonlyArray<string>): Promise<void> {

package/scripts/issue/markdown-section.ts

@@ -15,8 +15,41 @@ function is_the_heading(line: string, heading: string): boolean {
 // Whether some body line, trimmed, is exactly `text`. Both linters ask this — of a `## heading` and of
 // the behavior-change declaration line — so the trim-and-match lives here rather than being written in
 // each. A required token mentioned inside a sentence is not the token, so only an exact line matches.
+function next_fence(line: string, fence: string): string | undefined {
+	const marker = /^ {0,3}(`{3,}|~{3,})/u.exec(line)?.[1]
+
+	if (fence === '') return marker
+	const closing = new RegExp(
+		String.raw`^ {0,3}${fence.charAt(0)}{${String(fence.length)},}\s*$`,
+		'u',
+	)
+
+	if (closing.test(line)) return ''
+
+	return undefined
+}
+
+function unfenced_lines(body: string): ReadonlyArray<string> {
+	let fence = ''
+	const visible: Array<string> = []
+
+	for (const line of body.split('\n')) {
+		const next = next_fence(line, fence)
+		const visible_line = line.replace(/^(?: {4}|\t).*/u, '')
+
+		visible.push(next === undefined && fence === '' ? visible_line : '')
+		fence = next ?? fence
+	}
+
+	return visible
+}
+
+function has_unfenced_line(body: string, text: string): boolean {
+	return unfenced_lines(body).some((line) => line.trim() === text)
+}
+
 function has_line(body: string, text: string): boolean {
-	return body.split('\n').some((line) => line.trim() === text)
+	return has_unfenced_line(body, text)
 }
 
 // The lines between `heading` and the next `## ` heading, trimmed of the heading line itself; an empty
@@ -24,16 +57,17 @@ function has_line(body: string, text: string): boolean {
 // only a line that is exactly the heading opens the section.
 function section_lines(body: string, heading: string): ReadonlyArray<string> {
 	const lines = body.split('\n')
-	const start = lines.findIndex((line) => is_the_heading(line, heading))
+	const visible = unfenced_lines(body)
+	const start = visible.findIndex((line) => is_the_heading(line, heading))
 
 	if (start === -1) return []
 
 	const rest = lines.slice(start + 1)
-	const end = rest.findIndex((line) => is_heading(line))
+	const end = visible.slice(start + 1).findIndex((line) => is_heading(line))
 
 	return end === -1 ? rest : rest.slice(0, end)
 }
 
-const markdown_section = { section_lines, is_heading, has_line }
+const markdown_section = { section_lines, is_heading, has_line, has_unfenced_line }
 
 export { markdown_section }