@joshuafolkken/kit 1.1010.0 → 1.1035.0

package/scripts/sync/dependabot-pin-logic.ts

@@ -1,135 +0,0 @@
-import type { PinDrift } from './workflow-pin-logic'
-
-// Orchestration for `josh sync-dependabot-pins`: propagate a Dependabot action
-// bump from .github/workflows into templates/workflows for one or more PRs.
-// All git/gh side effects are injected via DependabotPinOps so the control flow
-// (checkout order, drift-skip, dry-run no-op) is unit-testable without spawning.
-const NO_PR_MESSAGE = 'No PR numbers supplied (e.g. `josh sdp 578 641`)'
-const INVALID_PR_PREFIX = 'Invalid PR number: '
-const DEPENDABOT_BRANCH_PREFIX = 'dependabot/'
-const PR_NUMBER_PATTERN = /^[1-9]\d*$/u
-
-interface DependabotPinOps {
-	get_current_branch: () => Promise<string>
-	get_pr_branch: (pr: number) => Promise<string>
-	checkout_pr: (pr: number) => Promise<void>
-	checkout_branch: (branch: string) => Promise<void>
-	sync_pins: () => Array<PinDrift>
-	stage_templates: () => Promise<void>
-	commit: (message: string) => Promise<void>
-	push: () => Promise<void>
-	log: (message: string) => void
-}
-
-interface SyncOptions {
-	is_dry_run: boolean
-}
-
-interface PrResult {
-	pr: number
-	synced_count: number
-	is_committed: boolean
-}
-
-function build_commit_message(pr: number): string {
-	return `Sync template workflow pins (Dependabot #${String(pr)})`
-}
-
-function parse_pr_number(token: string): number {
-	if (!PR_NUMBER_PATTERN.test(token)) throw new Error(`${INVALID_PR_PREFIX}${token}`)
-
-	const pr = Number(token)
-	if (!Number.isSafeInteger(pr)) throw new Error(`${INVALID_PR_PREFIX}${token}`)
-
-	return pr
-}
-
-function parse_pr_numbers(tokens: ReadonlyArray<string>): Array<number> {
-	if (tokens.length === 0) throw new Error(NO_PR_MESSAGE)
-
-	return tokens.map((token) => parse_pr_number(token))
-}
-
-async function commit_synced_pins(pr: number, ops: DependabotPinOps): Promise<void> {
-	await ops.stage_templates()
-	await ops.commit(build_commit_message(pr))
-	await ops.push()
-}
-
-function skipped_result(pr: number): PrResult {
-	return { pr, synced_count: 0, is_committed: false }
-}
-
-async function checkout_dependabot_pr(pr: number, ops: DependabotPinOps): Promise<boolean> {
-	await ops.checkout_pr(pr)
-	const branch = await ops.get_current_branch()
-
-	if (branch.startsWith(DEPENDABOT_BRANCH_PREFIX)) return true
-
-	ops.log(`#${String(pr)}: ${branch} is not a Dependabot branch — skipped`)
-
-	return false
-}
-
-async function apply_pr(pr: number, ops: DependabotPinOps): Promise<PrResult> {
-	if (!(await checkout_dependabot_pr(pr, ops))) return skipped_result(pr)
-
-	const drifts = ops.sync_pins()
-
-	if (drifts.length === 0) {
-		ops.log(`#${String(pr)}: template pins already in sync — skipped`)
-
-		return skipped_result(pr)
-	}
-
-	await commit_synced_pins(pr, ops)
-	ops.log(`#${String(pr)}: synced ${String(drifts.length)} pin(s) and pushed`)
-
-	return { pr, synced_count: drifts.length, is_committed: true }
-}
-
-async function plan_pr(pr: number, ops: DependabotPinOps): Promise<PrResult> {
-	const branch = await ops.get_pr_branch(pr)
-
-	ops.log(`#${String(pr)} (${branch}): would sync template pins and push if drifted [dry-run]`)
-
-	return skipped_result(pr)
-}
-
-async function process_pr(
-	pr: number,
-	options: SyncOptions,
-	ops: DependabotPinOps,
-): Promise<PrResult> {
-	if (options.is_dry_run) return await plan_pr(pr, ops)
-
-	return await apply_pr(pr, ops)
-}
-
-async function run_sync(
-	prs: ReadonlyArray<number>,
-	options: SyncOptions,
-	ops: DependabotPinOps,
-): Promise<Array<PrResult>> {
-	const start_branch = await ops.get_current_branch()
-	const results: Array<PrResult> = []
-
-	try {
-		for (const pr of prs) {
-			results.push(await process_pr(pr, options, ops))
-		}
-	} finally {
-		if (!options.is_dry_run) await ops.checkout_branch(start_branch)
-	}
-
-	return results
-}
-
-const dependabot_pin_logic = {
-	build_commit_message,
-	parse_pr_numbers,
-	run_sync,
-}
-
-export { dependabot_pin_logic }
-export type { DependabotPinOps }

package/scripts/test/classify-isolation.ts

@@ -1,149 +0,0 @@
-#!/usr/bin/env tsx
-import { globSync, readFileSync, writeFileSync } from 'node:fs'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { VITEST_INCLUDE_GLOBS } from './vitest-include-globs'
-
-// Isolation requirements — a test matching ANY condition below mutates state a sibling test running
-// in the same worker could observe, so it must run with the default isolate:true and must NOT appear
-// in the generated pilot list. The classifier is deliberately conservative: a file it cannot decide
-// is left isolated, because a false "pure" costs a flaky pilot while a false "isolate" costs only a
-// little speed.
-//   1. Module mocks: vi.mock / vi.spyOn / vi.stubEnv / vi.stubGlobal / vi.resetModules /
-//      vi.unstubAllEnvs / vi.unstubAllGlobals
-//   2. Environment variable writes: process.env.X = ... or delete process.env.X
-//   3. Subprocess calls: execSync / spawnSync / spawn / exec / execa / child_process.*
-//   4. Filesystem writes: writeFileSync / mkdirSync / mkdtemp / rmSync / unlinkSync / rimraf
-//   5. Git operations: enforced by condition 3 — every git operation spawns a process, so a file
-//      that runs git already matches the subprocess pattern.
-
-const MOCK_TOKENS: ReadonlyArray<string> = [
-	'mock',
-	'spyOn',
-	'stubEnv',
-	'stubGlobal',
-	'resetModules',
-	'unstubAllEnvs',
-	'unstubAllGlobals',
-]
-// Bare `exec` is deliberately absent: it matches the pure word (`pnpm exec …`, `regex.exec(…)`) more
-// often than the child_process call, which an `execSync` / `child_process` token catches anyway.
-const SUBPROCESS_TOKENS: ReadonlyArray<string> = [
-	'execSync',
-	'execFileSync',
-	'spawnSync',
-	'execaSync',
-	'execa',
-	'spawn',
-	'child_process',
-]
-const FS_WRITE_TOKENS: ReadonlyArray<string> = [
-	'writeFileSync',
-	'writeFile',
-	'appendFileSync',
-	'mkdirSync',
-	'mkdtempSync',
-	'mkdtemp',
-	'rmSync',
-	'rmdirSync',
-	'unlinkSync',
-	'cpSync',
-	'copyFileSync',
-	'renameSync',
-	'rimraf',
-]
-
-function word_pattern(tokens: ReadonlyArray<string>): RegExp {
-	return new RegExp(String.raw`\b(?:${tokens.join('|')})\b`, 'u')
-}
-
-const MODULE_MOCKS = new RegExp(String.raw`\bvi\.(?:${MOCK_TOKENS.join('|')})\b`, 'u')
-const ENV_WRITES =
-	/(?:process\.env\.\w+\s*=(?!=)|process\.env\[[^\]]+\]\s*=(?!=)|delete\s+process\.env)/u
-const SUBPROCESS = word_pattern(SUBPROCESS_TOKENS)
-const FS_WRITES = word_pattern(FS_WRITE_TOKENS)
-
-const ISOLATION_PATTERNS: ReadonlyArray<RegExp> = [MODULE_MOCKS, ENV_WRITES, SUBPROCESS, FS_WRITES]
-
-// Excluded from the main suite in vitest.config.ts (packs and installs the real tarball), so it must
-// never reach the pilot either.
-const MAIN_EXCLUDE = new Set(['scripts/build/packed-consumer.test.ts'])
-const NODE_MODULES = 'node_modules'
-const PILOT_FILES_PATH = 'scripts/test/pilot-files.ts'
-const WRITE_FLAG = '--write'
-const INDENT = '\t'
-const UTF8 = 'utf8'
-
-const GENERATED_HEADER = `/* eslint-disable max-lines */
-// GENERATED FILE — do not edit by hand.
-// Regenerate with: pnpm exec tsx scripts/test/classify-isolation.ts --write
-// Every entry is a test file the classifier judges free of the isolation requirements documented in
-// classify-isolation.ts; these files run with isolate:false in vitest.pilot.config.ts.`
-
-function normalize_path(file: string): string {
-	return file.split(path.sep).join('/')
-}
-
-function is_in_node_modules(entry: string): boolean {
-	return entry.split(/[/\\]/u).includes(NODE_MODULES)
-}
-
-function collect_glob(glob: string): Array<string> {
-	return globSync(glob, { exclude: is_in_node_modules }).map((file) => normalize_path(file))
-}
-
-// Code-point order, never localeCompare: the list is generated on one machine and re-derived in CI,
-// and ICU collation differs across platforms — so localeCompare reorders the list under CI's Linux
-// ICU and fails the drift test on order alone (joshuafolkken/kit#2170).
-function by_code_point(left: string, right: string): number {
-	if (left < right) return -1
-
-	return left > right ? 1 : 0
-}
-
-function all_test_files(): Array<string> {
-	const files = VITEST_INCLUDE_GLOBS.flatMap((glob) => collect_glob(glob))
-
-	return [...new Set(files)].filter((file) => !MAIN_EXCLUDE.has(file)).toSorted(by_code_point)
-}
-
-function requires_isolation(source: string): boolean {
-	return ISOLATION_PATTERNS.some((pattern) => pattern.test(source))
-}
-
-function is_pilot_candidate(file: string): boolean {
-	return !requires_isolation(readFileSync(file, UTF8))
-}
-
-function classify_pilot_files(): Array<string> {
-	return all_test_files().filter((file) => is_pilot_candidate(file))
-}
-
-function render_pilot_files(files: ReadonlyArray<string>): string {
-	const entries = files.map((file) => `${INDENT}'${file}',`).join('\n')
-	const body = `const PILOT_FILES: ReadonlyArray<string> = [\n${entries}\n]`
-
-	return `${GENERATED_HEADER}\n\n${body}\n\nexport { PILOT_FILES }\n`
-}
-
-function write_pilot_files(): void {
-	writeFileSync(PILOT_FILES_PATH, render_pilot_files(classify_pilot_files()))
-}
-
-if (process.argv[1] === fileURLToPath(import.meta.url)) {
-	if (process.argv.includes(WRITE_FLAG)) write_pilot_files()
-	else process.stdout.write(`${classify_pilot_files().join('\n')}\n`)
-}
-
-const classify_isolation = {
-	ISOLATION_PATTERNS,
-	all_test_files,
-	by_code_point,
-	classify_pilot_files,
-	is_pilot_candidate,
-	render_pilot_files,
-	requires_isolation,
-	write_pilot_files,
-}
-
-export { classify_isolation }

package/scripts/test/http-fault-injection.ts

@@ -1,79 +0,0 @@
-import { cases } from '#scripts/cases/cases-logic'
-
-// joshuafolkken/kit#2355: the network boundary's abnormal cases were declared and never run. The unit
-// suite blocks the network by construction (`test-network-guard.ts` shims the `gh` and `git`
-// binaries), so `josh cases`' network vocabulary had no way to be *executed* — only named in a test
-// declaration, where the failure mode nobody anticipated is exactly the one that never gets declared
-// (the transport failure of joshuafolkken/kit#2317 was hit before it was foreseen).
-//
-// This makes each of those failure modes injectable as a `fetch` stand-in that produces the failure
-// without opening a connection. It does not weaken the guard: the shims are untouched, no real request
-// leaves the machine, and the stand-in only shapes the `Response` (or rejection) the caller's error
-// path already has to survive. The mode set is single-sourced from `cases`, so the vocabulary the
-// command prints and the failures that can be injected cannot drift apart — `INJECTORS` is asserted
-// exhaustive against it in the colocated test.
-
-// A `fetch` stand-in: the real signature takes an input and an optional init, both ignored here since
-// the failure is fixed by the mode rather than the request.
-type FetchStub = (input?: unknown, init?: unknown) => Promise<Response>
-
-const NON_200_STATUS = 500
-const RATE_LIMIT_STATUS = 429
-const OK_STATUS = 200
-
-// The two rejection failures wear the shapes the platform itself throws, so a caller's `catch` sees
-// what a real timeout or dropped connection would produce: `AbortSignal.timeout` rejects with a
-// `TimeoutError` DOMException, and a transport failure rejects with a `TypeError`.
-const TIMEOUT_MESSAGE = 'The operation timed out.'
-const TIMEOUT_NAME = 'TimeoutError'
-const CONNECTION_DROP_MESSAGE = 'fetch failed'
-// A body that is present but not JSON, told apart from the empty body by having content at all.
-const INVALID_JSON_BODY = '{'
-const EMPTY_BODY = ''
-
-function ok_body(body: string): FetchStub {
-	return async () => new Response(body, { status: OK_STATUS })
-}
-
-function non_ok(code: number): FetchStub {
-	return async () => new Response(EMPTY_BODY, { status: code })
-}
-
-function rejecting(error: Error): FetchStub {
-	return async () => {
-		throw error
-	}
-}
-
-// Keyed by the exact vocabulary term `josh cases` prints for the network boundary. The colocated test
-// proves this key set equals that vocabulary, so a term added there without an injector here fails.
-const INJECTORS: Readonly<Record<string, FetchStub>> = {
-	非200: non_ok(NON_200_STATUS),
-	タイムアウト: rejecting(new DOMException(TIMEOUT_MESSAGE, TIMEOUT_NAME)),
-	接続断: rejecting(new TypeError(CONNECTION_DROP_MESSAGE)),
-	空レスポンス: ok_body(EMPTY_BODY),
-	不正JSON: ok_body(INVALID_JSON_BODY),
-	レート制限: non_ok(RATE_LIMIT_STATUS),
-}
-
-// The failure modes that can be injected — the injector key set, for the correspondence assertion.
-function supported_modes(): ReadonlyArray<string> {
-	return Object.keys(INJECTORS)
-}
-
-// A `fetch` stand-in producing the named failure. An unknown mode throws rather than silently passing:
-// a typo in a test must not degrade into a request that quietly does nothing.
-function faulty_fetch(mode: string): FetchStub {
-	const injector = INJECTORS[mode]
-	if (injector === undefined) throw new Error(`unknown network failure mode: ${mode}`)
-
-	return injector
-}
-
-// The network vocabulary this injector must cover, single-sourced from the command's own definition.
-const NETWORK_MODES: ReadonlyArray<string> = cases.cases_for(['network'])
-
-const http_fault_injection = { NETWORK_MODES, faulty_fetch, supported_modes }
-
-export type { FetchStub }
-export { http_fault_injection }

package/scripts/test/josh-harness-environment.ts

@@ -1,260 +0,0 @@
-import { execFileSync } from 'node:child_process'
-import {
-	existsSync,
-	mkdirSync,
-	mkdtempSync,
-	readFileSync,
-	realpathSync,
-	rmSync,
-	symlinkSync,
-	writeFileSync,
-} from 'node:fs'
-import { tmpdir } from 'node:os'
-import path from 'node:path'
-import { build_bin } from '#scripts/build/build-bin'
-import { resolve_local_bin } from '#scripts/build/local-bin'
-import { git_fixture_workspace } from '#scripts/git/git-fixture-workspace'
-import { josh_cli_fixture, type JoshLauncher } from '#scripts/josh/josh-cli-fixture'
-
-// Most defects reach a run at an environment boundary rather than inside a function
-// (joshuafolkken/kit#2447): a consumer without `docs/` (#2402), a lane worktree whose ledger lives in
-// the primary checkout (#2419), two processes racing on one marker (#2434). Unit tests call functions
-// inside this checkout, so none of those boundaries exists for them. Each environment here is a real
-// directory in the system temp dir, assembled the way a run meets it, and josh is spawned into it as a
-// subprocess — so a test asserts on the exit code, the output and the files the command left behind.
-//
-// **Every environment is gate-green on its own.** The toolchain files below are the least a project
-// needs for `josh gate` to pass in a few seconds, and `node_modules` is this checkout's, linked rather
-// than installed — so a scenario can run the real gate, not a stand-in for it.
-
-type EnvironmentKind = 'consumer' | 'kit' | 'lane' | 'packed'
-
-interface JoshEnvironment {
-	kind: EnvironmentKind
-	// Where the commands run — the lane checkout for a lane, the project root otherwise.
-	root: string
-	// The primary checkout: the same directory as `root` everywhere but a lane.
-	primary: string
-	launcher: JoshLauncher
-	// The temp directory that holds everything above, removed whole on close.
-	workspace: string
-}
-
-const PACKAGE_NAME = '@joshuafolkken/kit'
-const PRIMARY_DIRECTORY = 'primary'
-const LANE_DIRECTORY = 'lane'
-const LANE_BRANCH = 'lane'
-const NODE_MODULES = 'node_modules'
-const JOSH_BIN = 'josh'
-const PACKAGE_JSON = 'package.json'
-const WORKSPACE_PREFIX = 'josh-harness-'
-const JSON_INDENT = '\t'
-// pnpm 11 fails an install whose dependencies carry build scripts nobody approved; the throwaway
-// consumer approves none, and the smoke needs none of them run.
-const NON_STRICT_BUILDS = '--config.strict-dep-builds=false'
-
-function json_file(value: unknown): string {
-	return `${JSON.stringify(value, undefined, JSON_INDENT)}\n`
-}
-
-// A command josh runs inside the environment — the gate's `pnpm josh lint` and the rest — must reach
-// this checkout's source, as the kit's own `josh` script and a consumer's installed bin do. Without the
-// script it fell through to whatever `josh` was on PATH: a global install locally, nothing at all in CI.
-// The kit's `packageManager` goes with it, so Corepack runs the pinned pnpm rather than fetching the latest.
-function launch_command(launcher: JoshLauncher): string {
-	return [launcher.executable, ...launcher.leading_arguments]
-		.map((part) => JSON.stringify(part))
-		.join(' ')
-}
-
-function kit_package_manager(): string {
-	const manifest = readFileSync(path.join(josh_cli_fixture.REPO_ROOT, PACKAGE_JSON), 'utf8')
-
-	return (JSON.parse(manifest) as { packageManager: string }).packageManager
-}
-
-const PROJECT_FIELDS = {
-	private: true,
-	type: 'module',
-	packageManager: kit_package_manager(),
-	scripts: { josh: launch_command(josh_cli_fixture.SOURCE_JOSH) },
-}
-
-// A file the fixture writes: its path relative to the project root, and its content.
-type FixtureFile = readonly [string, string]
-
-const TOOLCHAIN_FILES: ReadonlyArray<FixtureFile> = [
-	['.gitignore', 'node_modules\n.*cache\n.tsbuildinfo\npnpm-lock.yaml\n'],
-	['.prettierignore', '*.json\npnpm-lock.yaml\n_tmp_*\n'],
-	['.prettierrc', json_file({ semi: false, singleQuote: true, useTabs: true })],
-	[
-		'cspell.config.yaml',
-		// `package.json` is skipped because its `josh` script carries this checkout's absolute paths.
-		'words:\n  - joshuafolkken\nignorePaths:\n  - .git\n  - node_modules\n  - .tsbuildinfo\n  - .*cache\n  - package.json\n  - pnpm-lock.yaml\n',
-	],
-	['eslint.config.js', 'export default [{}]\n'],
-	[
-		'sample.test.ts',
-		"import { expect, it } from 'vitest'\n\nit('passes', () => {\n\texpect(1).toBe(1)\n})\n",
-	],
-	[
-		'tsconfig.json',
-		json_file({
-			compilerOptions: { strict: true, noEmit: true, module: 'nodenext', types: [] },
-			include: ['*.ts'],
-		}),
-	],
-]
-
-// The kit's own shape: its package name, so josh treats the directory as the kit rather than a
-// consumer, and the `docs/` and `prompts/` directories only the kit carries.
-const KIT_FILES: ReadonlyArray<FixtureFile> = [
-	...TOOLCHAIN_FILES,
-	[PACKAGE_JSON, json_file({ name: PACKAGE_NAME, version: '0.0.0', ...PROJECT_FIELDS })],
-	['docs/README.md', '# Docs\n'],
-	['prompts/README.md', '# Prompts\n'],
-]
-
-// The least a consumer is: a project that depends on the kit and carries neither `docs/` nor
-// `prompts/` — the shape #2402's ENOENT needed.
-const CONSUMER_FILES: ReadonlyArray<FixtureFile> = [
-	...TOOLCHAIN_FILES,
-	[
-		PACKAGE_JSON,
-		json_file({
-			name: 'kit-consumer',
-			version: '0.0.0',
-			...PROJECT_FIELDS,
-			devDependencies: { [PACKAGE_NAME]: '*' },
-		}),
-	],
-]
-
-// Resolved through `realpath` because a child's `process.cwd()` is: on macOS the temp dir is a
-// symlink, and a path the test built would not match the one the command printed or keyed a record on.
-function open_workspace(): string {
-	const workspace = mkdtempSync(path.join(tmpdir(), WORKSPACE_PREFIX))
-
-	return realpathSync(workspace)
-}
-
-function write_files(directory: string, files: ReadonlyArray<FixtureFile>): void {
-	for (const [relative_path, content] of files) {
-		const file = path.join(directory, relative_path)
-
-		mkdirSync(path.dirname(file), { recursive: true })
-		writeFileSync(file, content, 'utf8')
-	}
-}
-
-function link_toolchain(directory: string): void {
-	symlinkSync(
-		path.join(josh_cli_fixture.REPO_ROOT, NODE_MODULES),
-		path.join(directory, NODE_MODULES),
-		'dir',
-	)
-}
-
-async function assemble(directory: string, files: ReadonlyArray<FixtureFile>): Promise<void> {
-	const { git, MAIN_BRANCH } = git_fixture_workspace
-
-	write_files(directory, files)
-	link_toolchain(directory)
-	await git(directory, ['init', MAIN_BRANCH])
-	await git(directory, ['add', '-A'])
-	await git(directory, ['commit', '-m', 'fixture'])
-}
-
-// A lane is a `git worktree` of the primary checkout, as `josh lane` makes one. `node_modules` is
-// ignored, so the worktree gets its own link rather than inheriting one.
-async function add_lane(primary: string, lane: string): Promise<string> {
-	await git_fixture_workspace.git(primary, ['worktree', 'add', lane, '-b', LANE_BRANCH])
-	link_toolchain(lane)
-
-	return lane
-}
-
-// A setup that throws returns no environment, so nothing would ever close its workspace — it is
-// removed here before the error travels on.
-async function in_workspace<T>(build: (workspace: string) => T | Promise<T>): Promise<T> {
-	const workspace = open_workspace()
-
-	try {
-		return await build(workspace)
-	} catch (error) {
-		rmSync(workspace, { recursive: true, force: true })
-		throw error
-	}
-}
-
-async function assemble_environment(
-	kind: Exclude<EnvironmentKind, 'packed'>,
-	workspace: string,
-): Promise<JoshEnvironment> {
-	const primary = path.join(workspace, PRIMARY_DIRECTORY)
-
-	await assemble(primary, kind === 'consumer' ? CONSUMER_FILES : KIT_FILES)
-	const root =
-		kind === 'lane' ? await add_lane(primary, path.join(workspace, LANE_DIRECTORY)) : primary
-
-	return { kind, root, primary, launcher: josh_cli_fixture.SOURCE_JOSH, workspace }
-}
-
-async function open_environment(
-	kind: Exclude<EnvironmentKind, 'packed'>,
-): Promise<JoshEnvironment> {
-	return await in_workspace(async (workspace) => await assemble_environment(kind, workspace))
-}
-
-function pack_into(directory: string): string {
-	const pack_output = execFileSync(
-		'pnpm',
-		['pack', '--json', '--pack-destination', directory, '--config.ignore-scripts=true'],
-		{ cwd: josh_cli_fixture.REPO_ROOT, encoding: 'utf8' },
-	)
-	const { filename } = JSON.parse(pack_output) as { filename: string }
-
-	// pnpm 11 reports the tarball's absolute path, earlier versions its bare name; `resolve` takes both.
-	return path.resolve(directory, filename)
-}
-
-// The published package rather than the source: the real tarball packed and installed into a bare
-// consumer, and josh run through the `node_modules/.bin` shim that install writes — the command a
-// consumer types. Not `resolve_package_bin`: the kit's `exports` map does not export its
-// `package.json`, so that route answers nothing for the kit itself. Slow (~60 s), so its suite stays
-// out of the unit gate.
-function install_packed(workspace: string): JoshEnvironment {
-	writeFileSync(
-		path.join(workspace, PACKAGE_JSON),
-		json_file({ name: 'test-consumer', version: '1.0.0' }),
-	)
-	const tarball = pack_into(workspace)
-
-	execFileSync('pnpm', ['add', NON_STRICT_BUILDS, tarball], { cwd: workspace, encoding: 'utf8' })
-	const shim = resolve_local_bin(workspace, JOSH_BIN)
-	if (!existsSync(shim)) throw new Error(`josh bin not found after installing ${tarball}`)
-
-	const launcher: JoshLauncher = { executable: shim, leading_arguments: [] }
-
-	return { kind: 'packed', root: workspace, primary: workspace, launcher, workspace }
-}
-
-async function open_packed_consumer(): Promise<JoshEnvironment> {
-	await build_bin()
-
-	return await in_workspace(install_packed)
-}
-
-function close_environment(environment: JoshEnvironment): void {
-	rmSync(environment.workspace, { recursive: true, force: true })
-}
-
-const josh_harness_environment = {
-	close_environment,
-	in_workspace,
-	open_environment,
-	open_packed_consumer,
-}
-
-export type { EnvironmentKind, JoshEnvironment }
-export { josh_harness_environment }