@shivaedev/quality 0.24.0 → 0.26.0

package/src/cli/args.ts

@@ -1,10 +1,9 @@
 import { parseArgs } from "node:util";
 import { Result } from "effect";
-import type { WarningDetail } from "#report/render.ts";
-import { ADOPT_REMOVED, USAGE as COMMAND_USAGE } from "./messages.ts";
+import { USAGE as COMMAND_USAGE, SUBCOMMANDS } from "./messages.ts";
 
 export type Command =
-	| { readonly _tag: "Lint"; readonly config: string | undefined; readonly warnings: WarningDetail }
+	| { readonly _tag: "Lint"; readonly config: string | undefined }
 	| { readonly _tag: "ExceptionsMigrate"; readonly config: string | undefined; readonly from: string | undefined }
 	| { readonly _tag: "Fix"; readonly config: string | undefined }
 	| { readonly _tag: "BaselineWrite"; readonly config: string | undefined; readonly rules: readonly string[] }
@@ -28,19 +27,12 @@ const OPTIONS = {
 	help: { short: "h", type: "boolean" },
 	rule: { multiple: true, type: "string" },
 	staged: { type: "boolean" },
-	warnings: { type: "string" },
 } as const;
 
 function usage(problem: string): Parsed {
 	return { _tag: "Usage", problem };
 }
 
-const SUBCOMMANDS: Readonly<Record<string, string>> = {
-	baseline: "baseline takes write, prune, tighten or migrate.",
-	exceptions: "exceptions takes migrate.",
-	hooks: "hooks takes install, uninstall or pre-commit.",
-};
-
 function parsed(command: Command): Parsed {
 	return { _tag: "Parsed", command };
 }
@@ -49,7 +41,7 @@ type Values = ReturnType<typeof parseArgs<{ options: typeof OPTIONS; allowPositi
 
 type Option = Exclude<keyof Values, "config" | "help">;
 
-const COMMAND_OPTIONS: readonly Option[] = ["against", "force", "from", "rule", "staged", "warnings"];
+const COMMAND_OPTIONS: readonly Option[] = ["against", "force", "from", "rule", "staged"];
 
 const ACCEPTS: Readonly<Record<string, readonly Option[]>> = {
 	"baseline migrate": ["from"],
@@ -61,7 +53,7 @@ const ACCEPTS: Readonly<Record<string, readonly Option[]>> = {
 	"hooks install": ["force"],
 	"hooks pre-commit": [],
 	"hooks uninstall": [],
-	lint: ["warnings"],
+	lint: [],
 };
 
 function misplaced(name: string, values: Values): string | undefined {
@@ -77,12 +69,8 @@ function ref(against: string | undefined, command: Command): Parsed {
 function commandFor(name: string, values: Values): Parsed {
 	const config = values.config;
 	switch (name) {
-		case "lint": {
-			const warnings = values.warnings ?? "summary";
-			return warnings === "summary" || warnings === "all"
-				? parsed({ _tag: "Lint", config, warnings })
-				: usage(`--warnings takes summary or all, not "${warnings}".`);
-		}
+		case "lint":
+			return parsed({ _tag: "Lint", config });
 		case "exceptions migrate":
 			return parsed({ _tag: "ExceptionsMigrate", config, from: values.from });
 		case "fix":
@@ -118,9 +106,6 @@ export function parseCommand(args: readonly string[]): Parsed {
 		return parsed({ _tag: "Help" });
 	}
 	const name = [command, ...rest].join(" ");
-	if (command === "adopt") {
-		return usage(ADOPT_REMOVED);
-	}
 	if (ACCEPTS[name] === undefined) {
 		const subcommands = SUBCOMMANDS[command];
 		return usage(subcommands !== undefined && rest.length < 2 ? subcommands : `unknown command: ${name}`);

package/src/cli/fix.ts

@@ -4,7 +4,7 @@ import { biomeReport, type Report } from "#biome/report.ts";
 import { loadConfig } from "#config/load.ts";
 import type { ExceptionDeclaration } from "#exceptions/declaration.ts";
 import { SetupFailure } from "#failure.ts";
-import { posix } from "#inventory/ignore-scope.ts";
+import { posix } from "#inventory/ignoreScope.ts";
 import { walk } from "#inventory/walk.ts";
 import { sortManifests } from "#manifests/sorted.ts";
 import { plural } from "#report/plural.ts";

package/src/cli/lint.ts

@@ -3,12 +3,11 @@ import { Console, Effect, type FileSystem } from "effect";
 import { evaluate, passes } from "#engine/evaluate.ts";
 import { openSession } from "#engine/session.ts";
 import { GateFailed, type SetupFailure } from "#failure.ts";
-import { render, type WarningDetail } from "#report/render.ts";
+import { render } from "#report/render.ts";
 
 export const lint = Effect.fn("Cli.lint")(function* (
 	cwd: string,
 	config: string | undefined,
-	warnings: WarningDetail,
 ): Effect.fn.Return<void, SetupFailure | GateFailed, FileSystem.FileSystem> {
 	const session = yield* openSession(cwd, config);
 	const outcome = evaluate(session.violations, session.registry, session.baseline.entries, session.config);
@@ -18,7 +17,6 @@ export const lint = Effect.fn("Cli.lint")(function* (
 			checked: session.inventory.sources.length,
 			descriptions: new Map(session.config.active.map((rule) => [rule.id, rule.description])),
 			registry: session.config.exceptions.length === 0 ? session.config.registry : `${relative(session.config.root, session.config.file)} exceptions`,
-			warnings,
 		}),
 	);
 	if (!passes(outcome)) {

package/src/cli/messages.ts

@@ -1,5 +1,5 @@
 export const USAGE = `Usage:
-  quality lint [--config <file>] [--warnings summary|all]
+  quality lint [--config <file>]
   quality fix [--config <file>]
   quality exceptions migrate [--config <file>] [--from <registry>]
   quality baseline write [--config <file>] [--rule <id>]...
@@ -11,7 +11,7 @@ export const USAGE = `Usage:
   quality hooks pre-commit [--config <file>]
 
 lint              Run every rule. Exits 1 on an error-level violation, a file over its baseline, a stale registry entry
-                  or a baseline entry for a rule that is off or unknown.
+                  or a baseline entry for an unknown rule.
 fix               Sort every package.json, apply Biome's lint fixes, unsafe ones included, its assist actions and formatting, then format again.
 exceptions migrate Move legacy registry entries and Biome declarations into quality.config.ts exceptions and remove matching root overrides.
 baseline write    Record current error-level violations. Creates the baseline, or records the named rules again, replacing their entries.
@@ -27,5 +27,8 @@ hooks pre-commit  What the hook runs: lint, then package.json scripts typecheck
 --against <ref>  The branch the work merges into, whose merge base prune follows moves from. Defaults to origin/HEAD, then origin/main, then origin/master.
 Exit codes: 0 passed, 1 failed the gate, 2 could not run.`;
 
-export const ADOPT_REMOVED =
-	"`quality adopt` was removed in 0.7.0. To record a rule's existing findings in the baseline, run `quality baseline write --rule <id>`; to apply the fixes Biome can make first, run `quality fix`.";
+export const SUBCOMMANDS: Readonly<Record<string, string>> = {
+	baseline: "baseline takes write, prune, tighten or migrate.",
+	exceptions: "exceptions takes migrate.",
+	hooks: "hooks takes install, uninstall or pre-commit.",
+};

package/src/cli/migrate.ts

@@ -4,7 +4,7 @@ import { encodeBaseline } from "#baseline/format.ts";
 import { convertLegacy, decodeLegacyBaseline, LEGACY_BASELINE } from "#baseline/legacy.ts";
 import { loadConfig } from "#config/load.ts";
 import { validOrFail } from "#decoded.ts";
-import { readInput } from "#engine/baseline-file.ts";
+import { readInput } from "#engine/baselineFile.ts";
 import { scan } from "#engine/session.ts";
 import { SetupFailure } from "#failure.ts";
 import { writeText } from "#inventory/filesystem.ts";

package/src/cli/migrateExceptions.ts

@@ -2,7 +2,7 @@ import { join } from "node:path";
 import { Console, Effect, FileSystem } from "effect";
 import { loadConfig } from "#config/load.ts";
 import { validOrFail } from "#decoded.ts";
-import { readInput } from "#engine/baseline-file.ts";
+import { readInput } from "#engine/baselineFile.ts";
 import { decodeExceptions, type ExceptionDeclaration } from "#exceptions/declaration.ts";
 import { migrateBiome } from "#exceptions/migrateBiome.ts";
 import { migrateConfig } from "#exceptions/migrateConfig.ts";

package/src/cli/program.ts

@@ -27,7 +27,7 @@ export const program = Effect.fn("Cli.program")(function* (args: readonly string
 		case "Help":
 			return yield* Console.log(USAGE);
 		case "Lint":
-			return yield* lint(cwd, command.config, command.warnings);
+			return yield* lint(cwd, command.config);
 		case "Fix":
 			return yield* fix(cwd, command.config);
 		case "BaselineWrite":

package/src/cli.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import process from "node:process";
 import { program } from "#cli/program.ts";
-import { runMain } from "#cli/run-main.ts";
+import { runMain } from "#cli/runMain.ts";
 
 runMain(program(process.argv.slice(2), { cwd: process.cwd(), launch: { options: process.execArgv, script: process.argv[1] ?? "" } }));

package/src/config/decode.ts

@@ -22,22 +22,11 @@ const Setting = Schema.Union([Level, Schema.Struct({ level: Schema.optionalKey(L
 
 const LocalRule = Schema.declare(isRule, { expected: "a rule made with defineRule" });
 
-const AdoptRemoved = Schema.Never.annotate({
-	message: "removed in quality 0.7.0. Delete the key, and record a rule's existing findings with `quality baseline write --rule <id>`.",
-});
-
-const PreCommitRemoved = Schema.Never.annotate({
-	message:
-		"removed. Put repository checks in the package.json quality:commit script; the hook also runs typecheck when present. Use `quality baseline tighten --staged` explicitly to lower staged debt.",
-});
-
 const ConfigInput = Schema.Struct({
-	adopt: Schema.optionalKey(AdoptRemoved),
 	baseline: Schema.optionalKey(Schema.String),
 	exceptions: Schema.optionalKey(Schema.Array(ExceptionDeclaration)),
 	extensions: Schema.optionalKey(Schema.Array(Schema.String)),
 	local: Schema.optionalKey(Schema.Array(LocalRule)),
-	preCommit: Schema.optionalKey(PreCommitRemoved),
 	registry: Schema.optionalKey(Schema.String),
 	rules: Schema.optionalKey(Schema.Record(Schema.String, Setting)),
 	sources: Schema.optionalKey(Schema.Array(Schema.String)),

package/src/config/resolve.ts

@@ -1,9 +1,9 @@
 import { Effect } from "effect";
 import type { Decoded } from "#decoded.ts";
-import type { ActiveRule } from "#engine/run-rules.ts";
+import type { ActiveRule } from "#engine/runRules.ts";
 import type { RuleIndex } from "#engine/violation.ts";
 import type { Rule } from "#rule.ts";
-import { builtInRules } from "#rules/built-in.ts";
+import { builtInRules } from "#rules/builtIn.ts";
 import type { ConfigInput } from "./decode.ts";
 
 export interface ResolvedRules extends RuleIndex {

package/src/config.ts

@@ -1,8 +1,8 @@
 import type { ExceptionDeclaration } from "#exceptions/declaration.ts";
-import type { builtInRules } from "#rules/built-in.ts";
+import type { builtInRules } from "#rules/builtIn.ts";
 import type { Rule } from "./rule.ts";
 
-export type Level = "error" | "warn" | "off";
+export type Level = "error";
 
 export type RuleSetting<TInput> = "error" | { readonly level?: "error"; readonly options?: TInput };
 

package/src/decoded.ts

@@ -1,6 +1,6 @@
 import { Effect } from "effect";
 import { SetupFailure } from "./failure.ts";
-import { describeIssue, type StandardSchemaV1 } from "./standard-schema.ts";
+import { describeIssue, type StandardSchemaV1 } from "./standardSchema.ts";
 
 export type Decoded<TValue> = { readonly _tag: "Valid"; readonly value: TValue } | { readonly _tag: "Invalid"; readonly issues: readonly string[] };
 

package/src/engine/evaluate.ts

@@ -11,7 +11,6 @@ export interface Outcome {
 	readonly regressions: readonly Regression[];
 	readonly staleBaseline: readonly StaleBaselineEntry[];
 	readonly staleRegistry: readonly StaleRegistryEntry[];
-	readonly warnings: readonly Violation[];
 }
 
 export function evaluate(
@@ -25,13 +24,12 @@ export function evaluate(
 	const kept = [...baselined.kept].sort(byLocation);
 	return {
 		baselined: baselined.baselined,
-		errors: kept.filter((violation) => violation.level === "error"),
+		errors: kept,
 		looseBaseline: baselined.loose,
 		registered: registered.registered,
 		regressions: baselined.regressions,
 		staleBaseline: baselined.stale,
 		staleRegistry: registered.stale,
-		warnings: kept.filter((violation) => violation.level === "warn"),
 	};
 }
 

package/src/engine/{run-rules.ts → runRules.ts}

@@ -1,7 +1,7 @@
 import { isAbsolute, relative } from "node:path";
 import { Effect } from "effect";
 import { SetupFailure } from "#failure.ts";
-import { posix } from "#inventory/ignore-scope.ts";
+import { posix } from "#inventory/ignoreScope.ts";
 import type { Finding, Findings, RuleInputs } from "#rule.ts";
 import type { ActiveLevel, Violation } from "./violation.ts";
 

package/src/engine/session.ts

@@ -7,8 +7,8 @@ import { registryEntries } from "#exceptions/registryEntries.ts";
 import { SetupFailure } from "#failure.ts";
 import { collectInventory, type Inventory } from "#inventory/collect.ts";
 import { type FilesystemFailure, readOptionalText } from "#inventory/filesystem.ts";
-import { type BaselineFile, readBaseline, readInput } from "./baseline-file.ts";
-import { runRules } from "./run-rules.ts";
+import { type BaselineFile, readBaseline, readInput } from "./baselineFile.ts";
+import { runRules } from "./runRules.ts";
 import type { Violation } from "./violation.ts";
 
 export interface Session {

package/src/engine/violation.ts

@@ -1,7 +1,7 @@
 import type { Level } from "#config.ts";
 import type { Finding } from "#rule.ts";
 
-export type ActiveLevel = "error" | "warn";
+export type ActiveLevel = "error";
 
 export interface Violation extends Finding {
 	readonly level: ActiveLevel;
@@ -56,5 +56,5 @@ export function unusedEntryProblem(index: RuleIndex, rule: string, unused: strin
 	if (level === undefined) {
 		return "names no known rule";
 	}
-	return level === "off" ? "names a rule that is off" : unused;
+	return unused;
 }

package/src/hooks/preCommit.ts

@@ -48,7 +48,7 @@ const runScript = Effect.fnUntraced(
 export const preCommitHook = Effect.fn("Hooks.preCommitHook")(function* (cwd: string, path: string | undefined) {
 	const config = yield* loadConfig(cwd, path);
 	const { manager, scripts } = yield* commitScripts(config.root);
-	const linted = yield* lint(cwd, path, "summary").pipe(
+	const linted = yield* lint(cwd, path).pipe(
 		Effect.as(true),
 		Effect.catchTag("GateFailed", () => Effect.succeed(false)),
 	);

package/src/imports/generated.ts

@@ -1,7 +1,7 @@
 import { execFile } from "node:child_process";
 import { posix } from "node:path";
 import { promisify } from "node:util";
-import { emptyScope, type IgnoreScope, verdictFor, withIgnoreFile } from "#inventory/ignore-scope.ts";
+import { emptyScope, type IgnoreScope, verdictFor, withIgnoreFile } from "#inventory/ignoreScope.ts";
 import type { RuleInputs } from "#rule.ts";
 import type { ImportGraph, UnresolvedImport } from "./graph.ts";
 

package/src/imports/resolve.ts

@@ -2,7 +2,7 @@ import { realpathSync } from "node:fs";
 import { isBuiltin } from "node:module";
 import { dirname, join, relative } from "node:path";
 import ts from "typescript";
-import { posix } from "#inventory/ignore-scope.ts";
+import { posix } from "#inventory/ignoreScope.ts";
 import type { Ambient } from "./ambient.ts";
 import type { ImportRequest } from "./extract.ts";
 import type { Project } from "./projects.ts";

package/src/imports/workspace.ts

@@ -4,7 +4,7 @@ import { Effect } from "effect";
 import { manifestsIn } from "#manifests/sorted.ts";
 import type { RuleInputs } from "#rule.ts";
 import { globMatcher } from "./glob.ts";
-import { pnpmWorkspacePatterns } from "./pnpm-workspace.ts";
+import { pnpmWorkspacePatterns } from "./pnpmWorkspacePatterns.ts";
 
 export interface WorkspacePackage {
 	readonly directory: string;

package/src/inventory/collect.ts

@@ -3,7 +3,7 @@ import { Effect, FileSystem } from "effect";
 import ignore from "ignore";
 import type { SourceFile } from "#rule.ts";
 import { FilesystemFailure, orWhenAbsent, readRequiredText } from "./filesystem.ts";
-import { posix } from "./ignore-scope.ts";
+import { posix } from "./ignoreScope.ts";
 import { scopeAbove, walk } from "./walk.ts";
 
 export interface InventoryScope {

package/src/inventory/walk.ts

@@ -1,7 +1,7 @@
 import { dirname, join, relative, sep } from "node:path";
 import { Effect, FileSystem } from "effect";
 import { FilesystemFailure, orWhenAbsent, readOptionalText } from "./filesystem.ts";
-import { emptyScope, type IgnoreScope, insideKept, verdictFor, withIgnoreFile } from "./ignore-scope.ts";
+import { emptyScope, type IgnoreScope, insideKept, verdictFor, withIgnoreFile } from "./ignoreScope.ts";
 import { trackedPaths } from "./trackedPaths.ts";
 
 const SKIPPED = new Set([".git", "node_modules"]);

package/src/manifests/sorted.ts

@@ -2,7 +2,7 @@ import { basename, join, relative } from "node:path";
 import { Effect, FileSystem } from "effect";
 import { sortPackageJson } from "sort-package-json";
 import { FilesystemFailure } from "#inventory/filesystem.ts";
-import { posix } from "#inventory/ignore-scope.ts";
+import { posix } from "#inventory/ignoreScope.ts";
 import { walk } from "#inventory/walk.ts";
 
 export type Sorting = { readonly _tag: "Invalid" } | { readonly _tag: "Sorted" } | { readonly _tag: "Unsorted"; readonly sorted: string };

package/src/report/render.ts

@@ -4,18 +4,13 @@ import { groupBy, keyOf, type Violation } from "#engine/violation.ts";
 import { plural } from "./plural.ts";
 import { staleSections } from "./stale.ts";
 
-export type WarningDetail = "summary" | "all";
-
 export interface ReportContext {
 	readonly baseline: string;
 	readonly checked: number;
 	readonly descriptions: ReadonlyMap<string, string>;
 	readonly registry: string;
-	readonly warnings: WarningDetail;
 }
 
-const LISTED_FILES = 5;
-
 function locate(violation: Violation): string {
 	return violation.line === undefined ? violation.file : `${violation.file}:${violation.line}`;
 }
@@ -24,9 +19,9 @@ function regressionNote(regression: Regression): string {
 	return `  ${regression.entry.file} is over its baseline: ${regression.count} against ${regression.entry.count} baselined.`;
 }
 
-function heading(label: string, rule: string, violations: readonly Violation[], context: ReportContext): readonly string[] {
+function heading(rule: string, violations: readonly Violation[], context: ReportContext): readonly string[] {
 	const description = context.descriptions.get(rule);
-	return [`${label} ${rule} (${violations.length})`, ...(description === undefined ? [] : [`  ${description}`])];
+	return [`error ${rule} (${violations.length})`, ...(description === undefined ? [] : [`  ${description}`])];
 }
 
 function detailed(violations: readonly Violation[], regressions: ReadonlyMap<string, Regression>): readonly string[] {
@@ -40,21 +35,9 @@ function detailed(violations: readonly Violation[], regressions: ReadonlyMap<str
 	});
 }
 
-function summarized(violations: readonly Violation[]): readonly string[] {
-	const files = [...groupBy(violations, (violation) => violation.file).entries()].sort(([, left], [, right]) => right.length - left.length);
-	const listed = files.slice(0, LISTED_FILES).map(([file, inFile]) => `${file} (${inFile.length})`);
-	const rest = files.length - listed.length;
-	return [`  ${listed.join(", ")}${rest > 0 ? `, and ${plural(rest, "more file", "more files")}` : ""}. --warnings all lists each one.`];
-}
-
-function ruleSections(
-	label: string,
-	violations: readonly Violation[],
-	context: ReportContext,
-	body: (inRule: readonly Violation[]) => readonly string[],
-): readonly string[] {
+function ruleSections(violations: readonly Violation[], context: ReportContext, regressions: ReadonlyMap<string, Regression>): readonly string[] {
 	return [...groupBy(violations, (violation) => violation.rule).entries()].map(([rule, inRule]) =>
-		[...heading(label, rule, inRule, context), ...body(inRule)].join("\n"),
+		[...heading(rule, inRule, context), ...detailed(inRule, regressions)].join("\n"),
 	);
 }
 
@@ -68,14 +51,13 @@ function failures(outcome: Outcome): string {
 
 function summary(outcome: Outcome, context: ReportContext): string {
 	const verdict = passes(outcome) ? "quality: passed" : `quality: failed with ${failures(outcome)}`;
-	const warnings = outcome.warnings.length > 0 ? `; ${plural(outcome.warnings.length, "warning")} from rules still at warn` : "";
 	const hidden = [
 		...(outcome.baselined > 0 ? [`${outcome.baselined} baselined`] : []),
 		...(outcome.registered > 0 ? [`${outcome.registered} registered`] : []),
 	];
 	const suppressed =
 		hidden.length === 0 ? "" : `; ${hidden.join(" and ")} ${outcome.baselined + outcome.registered === 1 ? "violation" : "violations"} not shown`;
-	return `${verdict}${warnings}. ${plural(context.checked, "source file")} checked${suppressed}.`;
+	return `${verdict}. ${plural(context.checked, "source file")} checked${suppressed}.`;
 }
 
 function rerecord(outcome: Outcome): readonly string[] {
@@ -91,10 +73,8 @@ function rerecord(outcome: Outcome): readonly string[] {
 
 export function render(outcome: Outcome, context: ReportContext): string {
 	const regressions = new Map(outcome.regressions.map((regression) => [keyOf(regression.entry.rule, regression.entry.file), regression]));
-	const warningBody = context.warnings === "all" ? (inRule: readonly Violation[]) => detailed(inRule, regressions) : summarized;
 	return [
-		...ruleSections("error", outcome.errors, context, (inRule) => detailed(inRule, regressions)),
-		...ruleSections("warn", outcome.warnings, context, warningBody),
+		...ruleSections(outcome.errors, context, regressions),
 		...staleSections(outcome, context),
 		summary(outcome, context),
 		...rerecord(outcome),

package/src/report/stale.ts

@@ -27,7 +27,7 @@ export function staleSections(outcome: Outcome, files: StaleFiles): readonly str
 		...section(
 			"error",
 			files.baseline,
-			"An entry for a rule that is off or unknown covers nothing. Run `quality baseline prune` to drop it.",
+			"An entry for an unknown rule covers nothing. Run `quality baseline prune` to drop it.",
 			outcome.staleBaseline.map(baselineLine),
 		),
 		...section(

package/src/rule.ts

@@ -1,6 +1,6 @@
 import type { Bivariant } from "@shivaedev/types/bivariant.ts";
 import type { ExceptionDeclaration } from "#exceptions/declaration.ts";
-import { describeIssue, type StandardSchemaV1 } from "./standard-schema.ts";
+import { describeIssue, type StandardSchemaV1 } from "./standardSchema.ts";
 
 export interface Finding {
 	readonly count?: number | undefined;

package/src/rules/{built-in.ts → builtIn.ts}

@@ -1,10 +1,10 @@
-import { maxPerFile } from "#rules/comments/max-per-file.ts";
-import { noBanner } from "#rules/comments/no-banner.ts";
-import { noEnvironmentPragma } from "#rules/comments/no-environment-pragma.ts";
-import { noJsdoc } from "#rules/comments/no-jsdoc.ts";
-import { noLineReference } from "#rules/comments/no-line-reference.ts";
-import { noPrReference } from "#rules/comments/no-pr-reference.ts";
-import { noTodo } from "#rules/comments/no-todo.ts";
+import { maxPerFile } from "#rules/comments/maxPerFile.ts";
+import { noBanner } from "#rules/comments/noBanner.ts";
+import { noEnvironmentPragma } from "#rules/comments/noEnvironmentPragma.ts";
+import { noJsdoc } from "#rules/comments/noJsdoc.ts";
+import { noLineReference } from "#rules/comments/noLineReference.ts";
+import { noPrReference } from "#rules/comments/noPrReference.ts";
+import { noTodo } from "#rules/comments/noTodo.ts";
 import { distinctCase } from "#rules/files/distinctCase.ts";
 import { folderNames } from "#rules/files/folderNames.ts";
 import { namedAfterExport } from "#rules/files/namedAfterExport.ts";
@@ -18,17 +18,18 @@ import { importsResolvable } from "#rules/imports/resolvable.ts";
 import { importsRuntime } from "#rules/imports/runtime.ts";
 import { storySetup } from "#rules/stories/setup.ts";
 import { storySpecs } from "#rules/stories/specs.ts";
-import { biomeOverrides } from "#rules/suppressions/biome-overrides.ts";
+import { biomeOverrides } from "#rules/suppressions/biomeOverrides.ts";
 import { biomeRecommended } from "#rules/suppressions/biomeRecommended.ts";
-import { noDoubleCast } from "#rules/suppressions/no-double-cast.ts";
-import { noInline } from "#rules/suppressions/no-inline.ts";
+import { noDoubleCast } from "#rules/suppressions/noDoubleCast.ts";
 import { noIgnoreDeprecations } from "#rules/suppressions/noIgnoreDeprecations.ts";
+import { noInline } from "#rules/suppressions/noInline.ts";
 import { testsColocated } from "#rules/test-names/colocated.ts";
 import { testsFollow } from "#rules/test-names/follow.ts";
 import { biome } from "./biome.ts";
-import { manifestsSorted } from "./manifests-sorted.ts";
-import { maxLines } from "./max-lines.ts";
+import { manifestsSorted } from "./manifestsSorted.ts";
+import { manifestsSourceFirst } from "./manifestsSourceFirst.ts";
 import { maxDepth } from "./maxDepth.ts";
+import { maxLines } from "./maxLines.ts";
 import { noBarrel } from "./noBarrel.ts";
 
 export const builtInRules = [
@@ -56,6 +57,7 @@ export const builtInRules = [
 	importsAliased,
 	noTestCode,
 	manifestsSorted,
+	manifestsSourceFirst,
 	namedAfterExport,
 	folderNames,
 	distinctCase,

package/src/rules/comments/{no-banner.ts → noBanner.ts}

@@ -1,4 +1,4 @@
-import { definePatternRule } from "./pattern-rule.ts";
+import { definePatternRule } from "./definePattern.ts";
 
 const DIVIDER = "[-=*#~_+/\\\\─━═┄┈]{3,}";
 

package/src/rules/comments/{no-environment-pragma.ts → noEnvironmentPragma.ts}

@@ -1,4 +1,4 @@
-import { definePatternRule } from "./pattern-rule.ts";
+import { definePatternRule } from "./definePattern.ts";
 
 export const noEnvironmentPragma = definePatternRule({
 	description:

package/src/rules/comments/{no-line-reference.ts → noLineReference.ts}

@@ -1,4 +1,4 @@
-import { definePatternRule } from "./pattern-rule.ts";
+import { definePatternRule } from "./definePattern.ts";
 
 const SOURCE_EXTENSION =
 	"(?:[cm]?[jt]sx?|json5?|mdx?|css|scss|less|html?|vue|svelte|astro|ya?ml|toml|sql|prisma|graphql|gql|go|rs|py|rb|java|kt|swift|sh)";

package/src/rules/comments/{no-pr-reference.ts → noPrReference.ts}

@@ -1,4 +1,4 @@
-import { definePatternRule } from "./pattern-rule.ts";
+import { definePatternRule } from "./definePattern.ts";
 
 export const noPrReference = definePatternRule({
 	description: "History belongs in version control, not in the code. State the reason itself, so the comment holds without the link.",

package/src/rules/comments/{no-todo.ts → noTodo.ts}

@@ -1,4 +1,4 @@
-import { definePatternRule } from "./pattern-rule.ts";
+import { definePatternRule } from "./definePattern.ts";
 
 export const noTodo = definePatternRule({
 	description: "A TODO in the code is never done. Do the work now, or track it where the repository tracks work.",

package/src/rules/manifestsSourceFirst.ts

@@ -0,0 +1,48 @@
+import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
+import { Effect } from "effect";
+import { manifestsIn } from "#manifests/sorted.ts";
+import { defineRule, type Finding } from "#rule.ts";
+import { entriesOf, itemsOf, type Json, member, parseJsonc } from "#rules/suppressions/biome/json.ts";
+
+const CONDITION = "source";
+
+function misplaced(path: string, field: string, node: Json): readonly Finding[] {
+	const conditions = entriesOf(node);
+	const first = conditions[0]?.[0];
+	const own: readonly Finding[] =
+		first === CONDITION || !conditions.some(([key]) => key === CONDITION)
+			? []
+			: [
+					{
+						file: path,
+						line: node.line,
+						message: `Lists the "${CONDITION}" condition after "${first}" in ${field}. TypeScript takes the first condition that matches, so once built output exists it reads that instead of the sources the "${CONDITION}" condition names. Move "${CONDITION}" to the top of this condition block.`,
+						subject: field,
+					},
+				];
+	const nested = [...conditions.map(([, value]) => value), ...itemsOf(node)];
+	return [...own, ...nested.flatMap((value) => misplaced(path, field, value))];
+}
+
+function findingsIn(path: string, text: string): readonly Finding[] {
+	const parsed = parseJsonc(path, text);
+	if (parsed._tag !== "Parsed") {
+		return [];
+	}
+	return ["exports", "imports"].flatMap((field) => {
+		const map = member(parsed.json, field);
+		return map === undefined ? [] : misplaced(path, field, map);
+	});
+}
+
+export const manifestsSourceFirst = defineRule({
+	check: async ({ readText, root }) => {
+		const manifests = await Effect.runPromise(manifestsIn(root).pipe(Effect.provide(NodeFileSystem.layer)));
+		const texts = await Promise.all(manifests.map(async (path) => ({ path, text: (await readText(path)) ?? "" })));
+		return texts.filter(({ text }) => text.includes(`"${CONDITION}"`)).flatMap(({ path, text }) => findingsIn(path, text));
+	},
+	description:
+		'Every package.json condition block that names the "source" condition lists it first in exports and imports, so TypeScript reads the sources whether or not built output exists.',
+	id: "manifests/source-first",
+	registrable: false,
+});

package/src/rules/suppressions/noIgnoreDeprecations.ts

@@ -1,7 +1,7 @@
 import { relative } from "node:path";
 import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem";
 import { Effect } from "effect";
-import { posix } from "#inventory/ignore-scope.ts";
+import { posix } from "#inventory/ignoreScope.ts";
 import { walk } from "#inventory/walk.ts";
 import { defineRule, type Finding } from "#rule.ts";
 import { member, parseJsonc } from "#rules/suppressions/biome/json.ts";

package/src/rules/suppressions/{no-inline.ts → noInline.ts}

@@ -1,7 +1,7 @@
 import { defineRule, type Finding, type RuleInputs } from "#rule.ts";
 import { type SourceComment, scanComments } from "#rules/comments/scan.ts";
 import { suppressionIn } from "./directives.ts";
-import { STYLESHEET, stylesheetComments } from "./stylesheet-comments.ts";
+import { STYLESHEET, stylesheetComments } from "./stylesheetComments.ts";
 
 const TYPE_TEST = /(?:(?:^|\/)typecheck\.test|\.typecheck\.(?:test|spec))\.[cm]?[jt]sx?$/u;