@jterrazz/typescript 10.0.0 → 10.1.1

package/README.md

@@ -1,6 +1,6 @@
 # @jterrazz/typescript
 
-The complete TypeScript toolchain — build, run, check, and document with zero configuration. Powered by tsdown, Oxlint, Oxfmt, TypeScript 7, and Knip. Six profiles, one rulebook: every rule of every plugin it loads is decided by name.
+The complete TypeScript toolchain — build, run, check, and document with zero configuration. Powered by tsdown, Oxlint, Oxfmt, TypeScript 7, and Knip. Seven profiles, one rulebook: every rule of every plugin it loads is decided by name.
 
 ## Installation
 
@@ -51,7 +51,7 @@ The full corpus lives in [`docs/`](docs/):
 - [Operating](docs/04-operating.md) — what publishes it, and which number moves.
 - [Building](docs/05-building.md) — `build`, `bundle`, `start`, `dev`.
 - [Quality checks](docs/06-quality-checks.md) — `check` / `fix` and their fifteen passes.
-- [Lint presets](docs/07-lint-presets.md) — the rulebook, the six profiles, `compose`, architecture, knip.
+- [Lint presets](docs/07-lint-presets.md) — the rulebook, the seven profiles, `compose`, architecture, knip.
 - [Docs pipeline](docs/08-docs-pipeline.md) — the `typescript docs` compiler.
 - [Repo structure](docs/09-repo-structure.md) — pointer to the shared doctrine; what's TypeScript-specific here.
 

package/bin/commands/check.sh

@@ -37,30 +37,10 @@ find_binary() {
 # the per-platform @typescript/typescript-* packages instead of a second
 # package named "typescript": typedoc and eslint-plugin-perfectionist load
 # the JS API from the "typescript" name (v6 here), and any typescript@7 in
-# the tree can hijack that lookup under pnpm's hoist fallback.
-find_tsc() {
-    local os arch
-    case "$(uname -s)" in
-        Darwin) os="darwin" ;;
-        Linux) os="linux" ;;
-        MINGW*|MSYS*|CYGWIN*) os="win32" ;;
-        *) os="linux" ;;
-    esac
-    case "$(uname -m)" in
-        arm64|aarch64) arch="arm64" ;;
-        armv7l) arch="arm" ;;
-        *) arch="x64" ;;
-    esac
-
-    local pkg="@typescript/typescript-$os-$arch"
-    if [ -x "$PACKAGE_ROOT/node_modules/$pkg/lib/tsc" ]; then
-        echo "$PACKAGE_ROOT/node_modules/$pkg/lib/tsc"
-    elif [ -x "$PACKAGE_ROOT/../../$pkg/lib/tsc" ]; then
-        echo "$PACKAGE_ROOT/../../$pkg/lib/tsc"
-    else
-        find_binary tsc
-    fi
-}
+# the tree can hijack that lookup under pnpm's hoist fallback. The lookup is
+# shared with the CLI's `tsc` passthrough, so it lives in one file.
+# shellcheck source=../find-tsc.sh
+. "$SCRIPT_DIR/../find-tsc.sh"
 
 # oxlint's type-aware rules run in `tsgolint`, a separate binary it looks up on
 # PATH — and a consumer's PATH has no reason to carry this package's bin dir. It
@@ -369,16 +349,38 @@ run_checks() {
     # ones no syntactic linter can express, and a flag that is only sometimes
     # passed is a rule set that is only sometimes enforced. `oxlint-tsgolint` is
     # a dependency of this package, so it is there for every consumer.
+    #
+    # In FIX mode the two rewriters run one after the other, and they are the
+    # only pair that does: `oxlint --fix` and `oxfmt` write the same files, and
+    # in parallel the second writer lands its copy over the first's — after
+    # which `fix` then `check` fails on formatting the fix had just settled.
+    local lint_pid=""
+    local lint_status=0
+    local format_status=0
     if [ "$FIX_MODE" = true ]; then
-        "$OXLINT" --type-aware --fix "${LINT_ARGS[@]}" > "$tmp_dir/lint.log" 2>&1 &
+        # A fixer that changes MEANING is never applied unattended: the rules
+        # marked `unsafe` in the manifest are allowed for THIS run only, so
+        # `fix` leaves them alone and `check` still reports them for a human.
+        local unsafe_fixers=()
+        while IFS= read -r flag; do
+            [ -n "$flag" ] && unsafe_fixers+=("$flag")
+        done < <(node "$PACKAGE_ROOT/lib/unsafe-fixers.js")
+
+        "$OXLINT" --type-aware --fix "${unsafe_fixers[@]}" "${LINT_ARGS[@]}" \
+            > "$tmp_dir/lint.log" 2>&1 ||
+            lint_status=$?
+        "$OXFMT" > "$tmp_dir/format.log" 2>&1 || format_status=$?
     else
         "$OXLINT" --type-aware "${LINT_ARGS[@]}" > "$tmp_dir/lint.log" 2>&1 &
+        lint_pid=$!
     fi
-    local lint_pid=$!
 
     # The same run, machine-readable, so the ratchet can be judged rule by rule.
     # A second invocation rather than a reformat of the first: the human log is
     # what a failing pass prints, and neither form can be derived from the other.
+    # In check mode it runs BESIDE the human one, on the same bytes. In fix mode
+    # it cannot: the bytes change under the fixer, so the machine-readable run
+    # is made after it, below.
     local lint_json_pid=""
     if [ "$FIX_MODE" = false ] && [ -f "$BASELINE_FILE" ]; then
         "$OXLINT" --type-aware --format json "${LINT_ARGS[@]}" \
@@ -386,12 +388,11 @@ run_checks() {
         lint_json_pid=$!
     fi
 
-    if [ "$FIX_MODE" = true ]; then
-        "$OXFMT" > "$tmp_dir/format.log" 2>&1 &
-    else
+    local format_pid=""
+    if [ "$FIX_MODE" = false ]; then
         "$OXFMT" --check > "$tmp_dir/format.log" 2>&1 &
+        format_pid=$!
     fi
-    local format_pid=$!
 
     # Knip: only run in check mode (fix mode is destructive)
     # Merge base config (from this package) with optional project-local knip.json.
@@ -605,19 +606,31 @@ run_checks() {
 
     # Wait and collect statuses
     wait $type_pid;   local type_status=$?
-    wait $lint_pid;   local lint_status=$?
+    [ -n "$lint_pid" ] && { wait $lint_pid; lint_status=$?; }
 
     # The ratchet, where the project keeps one: the pass is judged by what the
-    # baseline tolerates, not by oxlint's exit code. Bash decides whether the
-    # file is there; the script decides what it says.
-    if [ -n "$lint_json_pid" ]; then
-        wait $lint_json_pid
+    # baseline tolerates, not by oxlint's exit code — in FIX mode as much as in
+    # check mode, or `fix` then `check` reads red then green on the same tree.
+    # Bash decides whether the file is there; the script decides what it says.
+    #
+    # What fix mode judges is what SURVIVED the rewrite, so its machine-readable
+    # run is made here, after the fixer, and in the foreground — with the unsafe
+    # fixers armed again, so a directive that names one of them is used, not
+    # reported unused. The fixer's own exit code is never the verdict: it ran
+    # with those rules allowed. Without a baseline the judge wants zero.
+    if [ -f "$BASELINE_FILE" ] || [ "$FIX_MODE" = true ]; then
+        if [ -n "$lint_json_pid" ]; then
+            wait $lint_json_pid
+        else
+            "$OXLINT" --type-aware --format json "${LINT_ARGS[@]}" \
+                > "$tmp_dir/lint.json" 2>/dev/null
+        fi
         node "$PACKAGE_ROOT/lib/check-baseline.js" "$tmp_dir/lint.json" . \
             >> "$tmp_dir/lint.log" 2>&1
         lint_status=$?
     fi
 
-    wait $format_pid; local format_status=$?
+    [ -n "$format_pid" ] && { wait $format_pid; format_status=$?; }
     [ -n "$knip_pid" ] && { wait $knip_pid; knip_status=$?; }
     [ -n "$gitignore_pid" ] && { wait $gitignore_pid; gitignore_status=$?; }
     [ -n "$docs_layout_pid" ] && { wait $docs_layout_pid; docs_layout_status=$?; }

package/bin/find-tsc.sh

@@ -0,0 +1,30 @@
+# The TS7 Go compiler, by platform — sourced, never run. Both the CLI's `tsc`
+# passthrough and the TypeScript pass of `check` resolve the same binary, and it
+# has to be THIS one: `tsc` on PATH is whatever the tree hoisted, and under
+# pnpm's hoist fallback that is another package's TypeScript 5.
+#
+# `find_binary` is the caller's — typescript.sh and commands/check.sh each
+# define it against their own roots, and this function is resolved at call time.
+find_tsc() {
+    local os arch
+    case "$(uname -s)" in
+        Darwin) os="darwin" ;;
+        Linux) os="linux" ;;
+        MINGW*|MSYS*|CYGWIN*) os="win32" ;;
+        *) os="linux" ;;
+    esac
+    case "$(uname -m)" in
+        arm64|aarch64) arch="arm64" ;;
+        armv7l) arch="arm" ;;
+        *) arch="x64" ;;
+    esac
+
+    local pkg="@typescript/typescript-$os-$arch"
+    if [ -x "$PACKAGE_ROOT/node_modules/$pkg/lib/tsc" ]; then
+        echo "$PACKAGE_ROOT/node_modules/$pkg/lib/tsc"
+    elif [ -x "$PACKAGE_ROOT/../../$pkg/lib/tsc" ]; then
+        echo "$PACKAGE_ROOT/../../$pkg/lib/tsc"
+    else
+        find_binary tsc
+    fi
+}

package/bin/typescript.sh

@@ -39,6 +39,9 @@ find_binary() {
     fi
 }
 
+# shellcheck source=find-tsc.sh
+. "$SCRIPT_DIR/find-tsc.sh"
+
 TSDOWN=$(find_binary tsdown)
 
 # oxlint's type-aware rules run in `tsgolint`, a separate binary it looks up on
@@ -68,7 +71,15 @@ run_tsdown() {
 
     cd "$PROJECT_ROOT"
 
-    if ! "$TSDOWN" --config "$CONFIG_PATH" --cwd "$PROJECT_ROOT"; then
+    # What the package publishes is its `exports` map, so the build reads its
+    # entries there rather than assuming one. A package with no map, or whose
+    # map names nothing under `dist/`, keeps the preset's `src/index.ts`.
+    local entries=()
+    while IFS= read -r entry; do
+        [ -n "$entry" ] && entries+=("$entry")
+    done < <(node "$PACKAGE_ROOT/lib/entry-points.js" "$PROJECT_ROOT")
+
+    if ! "$TSDOWN" --config "$CONFIG_PATH" --cwd "$PROJECT_ROOT" "${entries[@]}"; then
         printf "${RED}Error: Build failed${NC}\n"
         exit 1
     fi
@@ -219,6 +230,16 @@ case "$COMMAND" in
         "$OXFMT" oxlint.baseline.json > /dev/null 2>&1 || true
         ;;
 
+    tsc)
+        # The compiler itself, for the one thing `check` cannot do: EMIT. A
+        # repository built with project references runs `tsc --build`, and
+        # without this it reaches for `tsc` on PATH — whatever version the tree
+        # hoisted, which is how a package that dropped its own `typescript`
+        # dependency silently compiled against TypeScript 5.
+        cd "$PROJECT_ROOT"
+        exec "$(find_tsc)" "$@"
+        ;;
+
     check|fix)
         exec bash "$SCRIPT_DIR/commands/check.sh" "$COMMAND" "$@"
         ;;
@@ -235,6 +256,7 @@ case "$COMMAND" in
         printf "  docs-layout  Check a repository's docs/ against the manual spine\n"
         printf "  doctor       Report the installed tool versions against the declared ranges\n"
         printf "  baseline     Record the oxlint baseline this project may not exceed\n"
+        printf "  tsc          Run the TypeScript 7 compiler this package ships (emit, --build)\n"
         printf "  check        Check types, lint, formatting, and unused code\n"
         printf "  fix          Auto-fix lint and formatting issues\n"
         printf "  clean        Remove .artifacts/ — dist/ stays, it is the build's product\n\n"
@@ -248,6 +270,7 @@ case "$COMMAND" in
         printf "  typescript docs-layout .\n"
         printf "  typescript doctor\n"
         printf "  typescript baseline\n"
+        printf "  typescript tsc --build\n"
         printf "  typescript check\n"
         printf "  typescript fix\n"
         printf "  typescript clean\n"

package/lib/check-baseline.js

@@ -128,7 +128,18 @@ if (import.meta.main) {
     const baseline = readBaseline(root);
 
     if (baseline === null) {
-        exit(Object.keys(counts).length > 0 ? 1 : 0);
+        const rules = Object.keys(counts).toSorted();
+        for (const rule of rules) {
+            stdout.write(
+                `${rule}  ${counts[rule]} diagnostic(s), and the project keeps no baseline\n`,
+            );
+        }
+        if (rules.length > 0) {
+            stdout.write(
+                "Fix them, or run 'typescript baseline' to record where the project stands.\n",
+            );
+        }
+        exit(rules.length > 0 ? 1 : 0);
     }
 
     const broken = judge(counts, baseline);

package/lib/entry-points.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+
+/**
+ * The entries a build compiles, read off the consumer's own `exports` map.
+ *
+ * A package with several public subpaths — `./register`, `./testing`, `./oxlint`
+ * — used to need a `tsdown.config.ts` of its own to name them, which means
+ * declaring tsdown as a dependency, which is the one-devDependency contract
+ * broken ([Developing](../docs/02-developing.md)). The map already says what
+ * the package publishes, so the build reads it there.
+ *
+ * The rule: every subpath whose target is a file under `dist/` is compiled from
+ * the same path under `src/`, with a `.ts` extension. A subpath carrying a `*`
+ * is skipped — a pattern names a set the map does not enumerate — and so is a
+ * target the source tree has no file for, because a build cannot compile what
+ * nobody wrote.
+ *
+ * Prints one entry per line, sorted; prints NOTHING when the package has no
+ * exports map or no subpath resolves, and the caller then keeps the preset's
+ * single `src/index.ts`.
+ *
+ * Usage: node entry-points.js [project-root]
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { argv, stdout } from 'node:process';
+
+/**
+ * The file a subpath's condition tree points at, in the order Node resolves
+ * them. The empty string is "no target": a condition tree is data, and every
+ * answer here is a path.
+ */
+function targetOf(entry) {
+    if (typeof entry === 'string') {
+        return entry;
+    }
+    if (typeof entry !== 'object' || entry === null) {
+        return '';
+    }
+    for (const condition of ['import', 'default', 'require']) {
+        const nested = targetOf(entry[condition]);
+        if (nested !== '') {
+            return nested;
+        }
+    }
+    return '';
+}
+
+/** `./dist/register.js` -> `src/register.ts`, and the empty string otherwise. */
+function sourceOf(target) {
+    const match = /^\.\/dist\/(?<path>.+)\.(?:js|mjs|cjs)$/u.exec(target);
+    return match === null ? '' : `src/${match.groups.path}.ts`;
+}
+
+/** Every entry the map earns, in one order, each one a file that exists. */
+export function entryPoints(root) {
+    const manifest = join(root, 'package.json');
+    if (!existsSync(manifest)) {
+        return [];
+    }
+
+    let exported;
+    try {
+        exported = JSON.parse(readFileSync(manifest, 'utf8')).exports;
+    } catch {
+        return [];
+    }
+    if (typeof exported !== 'object' || exported === null) {
+        return [];
+    }
+
+    const entries = new Set();
+    for (const [subpath, entry] of Object.entries(exported)) {
+        if (subpath.includes('*')) {
+            continue;
+        }
+        const source = sourceOf(targetOf(entry));
+        if (source !== '' && existsSync(join(root, source))) {
+            entries.add(source);
+        }
+    }
+
+    return [...entries].toSorted((left, right) => left.localeCompare(right));
+}
+
+if (import.meta.main) {
+    for (const entry of entryPoints(resolve(argv[2] ?? '.'))) {
+        stdout.write(`${entry}\n`);
+    }
+}

package/lib/unsafe-fixers.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+/**
+ * The rules `fix` must not let oxlint rewrite, as the flags that switch them
+ * off for one run: `--allow <rule>` per rule, one per line.
+ *
+ * A fixer that changes MEANING cannot be applied unattended — it turns working
+ * code into code that does not compile, or into code that claims something
+ * else. The rules are marked in the manifest (`unsafeFix()`), this prints them
+ * for the shell, and the oxlint pass of `fix` passes them through. Check mode
+ * keeps every one of them armed: the diagnostic is still owed an answer, from
+ * a human ([Quality checks](../docs/06-quality-checks.md)).
+ *
+ * Usage: node unsafe-fixers.js
+ */
+
+import { stdout } from 'node:process';
+
+import { unsafeFixers } from '../rules/catalog.js';
+
+if (import.meta.main) {
+    for (const { rule } of unsafeFixers()) {
+        stdout.write(`--allow\n${rule}\n`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@jterrazz/typescript",
-    "version": "10.0.0",
+    "version": "10.1.1",
     "license": "MIT",
     "author": "Jean-Baptiste Terrazzoni <contact@jterrazz.com>",
     "repository": {
@@ -39,12 +39,24 @@
         },
         "./tsconfig/*": "./presets/tsconfig/*.json",
         "./tsconfig/*.json": "./presets/tsconfig/*.json",
-        "./tsdown/*": "./presets/tsdown/*.js",
-        "./tsdown/*.js": "./presets/tsdown/*.js",
+        "./tsdown/*": {
+            "types": "./presets/tsdown/*.d.ts",
+            "default": "./presets/tsdown/*.js"
+        },
+        "./tsdown/*.js": {
+            "types": "./presets/tsdown/*.d.ts",
+            "default": "./presets/tsdown/*.js"
+        },
         "./presets/tsconfig/*": "./presets/tsconfig/*.json",
         "./presets/tsconfig/*.json": "./presets/tsconfig/*.json",
-        "./presets/tsdown/*": "./presets/tsdown/*.js",
-        "./presets/tsdown/*.js": "./presets/tsdown/*.js"
+        "./presets/tsdown/*": {
+            "types": "./presets/tsdown/*.d.ts",
+            "default": "./presets/tsdown/*.js"
+        },
+        "./presets/tsdown/*.js": {
+            "types": "./presets/tsdown/*.d.ts",
+            "default": "./presets/tsdown/*.js"
+        }
     },
     "publishConfig": {
         "registry": "https://registry.npmjs.org/"
@@ -72,7 +84,7 @@
         "typescript": "^6.0.0"
     },
     "devDependencies": {
-        "@jterrazz/test": "^14.0.0",
+        "@jterrazz/test": "^15.0.0",
         "@types/node": "^26.1.1",
         "vitest": "^4.1.10"
     },

package/presets/oxlint/profiles/library.js

@@ -10,7 +10,7 @@ import { PROFILES } from '../../../rules/profiles.js';
  * The `.js` extension on every relative import is core's (`import/extensions`
  * at `always`), because Node ESM resolves a specifier literally and a package
  * published as ESM is read by Node before any bundler reads it. It pairs with
- * `presets/tsconfig/library.json`, whose `isolatedDeclarations` is what makes
- * the declarations emit without a type-checker.
+ * `presets/tsdown/bundle.js`, whose `isolatedDeclarations` is what makes the
+ * published declarations emit without a type-checker.
  */
 export default defineConfig(profile(PROFILES.library));

package/presets/oxlint/profiles/react.js

@@ -0,0 +1,7 @@
+import { defineConfig } from 'oxlint';
+
+import { profile } from '../../../rules/compile.js';
+import { PROFILES } from '../../../rules/profiles.js';
+
+/** React with no framework under it: the rulebook, plus React and accessibility. */
+export default defineConfig(profile(PROFILES.react));

package/presets/tsconfig/astro.json

@@ -0,0 +1,25 @@
+{
+    "display": "Astro",
+    "compilerOptions": {
+        "allowJs": true,
+        "esModuleInterop": true,
+        "exactOptionalPropertyTypes": true,
+        "incremental": true,
+        "jsx": "react-jsx",
+        "jsxImportSource": "react",
+        "lib": ["DOM", "DOM.Iterable", "ESNext"],
+        "module": "ESNext",
+        "moduleResolution": "bundler",
+        "noEmit": true,
+        "noFallthroughCasesInSwitch": true,
+        "noImplicitOverride": true,
+        "noUncheckedIndexedAccess": true,
+        "noUncheckedSideEffectImports": true,
+        "resolveJsonModule": true,
+        "skipLibCheck": true,
+        "strict": true,
+        "target": "ESNext",
+        "tsBuildInfoFile": "${configDir}/.artifacts/tsc/tsconfig.tsbuildinfo",
+        "verbatimModuleSyntax": true
+    }
+}

package/presets/tsconfig/library.json

@@ -4,8 +4,7 @@
     "compilerOptions": {
         "allowJs": false,
         "declaration": true,
-        "erasableSyntaxOnly": true,
-        "isolatedDeclarations": true
+        "erasableSyntaxOnly": true
     },
     "include": ["${configDir}/**/*.ts"],
     "exclude": [

package/presets/tsconfig/react.json

@@ -0,0 +1,33 @@
+{
+    "display": "React (bundled, no framework)",
+    "include": ["${configDir}/**/*.ts", "${configDir}/**/*.tsx"],
+    "exclude": [
+        "${configDir}/node_modules",
+        "${configDir}/dist",
+        "${configDir}/.artifacts",
+        "${configDir}/**/_fixtures",
+        "${configDir}/**/_expected"
+    ],
+    "compilerOptions": {
+        "allowJs": true,
+        "esModuleInterop": true,
+        "exactOptionalPropertyTypes": true,
+        "incremental": true,
+        "isolatedModules": true,
+        "jsx": "react-jsx",
+        "lib": ["DOM", "DOM.Iterable", "ESNext"],
+        "module": "ESNext",
+        "moduleResolution": "bundler",
+        "noEmit": true,
+        "noFallthroughCasesInSwitch": true,
+        "noImplicitOverride": true,
+        "noUncheckedIndexedAccess": true,
+        "noUncheckedSideEffectImports": true,
+        "resolveJsonModule": true,
+        "skipLibCheck": true,
+        "strict": true,
+        "target": "ESNext",
+        "tsBuildInfoFile": "${configDir}/.artifacts/tsc/tsconfig.tsbuildinfo",
+        "verbatimModuleSyntax": true
+    }
+}

package/presets/tsdown/build.d.ts

@@ -0,0 +1,13 @@
+/*
+ * The shape of a bundler config is tsdown's own fact, so this declaration does
+ * not restate it: `UserConfig` is re-exported from the tool, for a consumer
+ * that annotates its own config ([Developing](../../docs/02-developing.md)).
+ */
+
+import type { UserConfig } from 'tsdown';
+
+/** An application build: one ESM output with declarations and source maps. */
+declare const build: UserConfig;
+
+export { type UserConfig } from 'tsdown';
+export default build;

package/presets/tsdown/bundle.d.ts

@@ -0,0 +1,13 @@
+/*
+ * The shape of a bundler config is tsdown's own fact, so this declaration does
+ * not restate it: `UserConfig` is re-exported from the tool, for a consumer
+ * that annotates its own config ([Developing](../../docs/02-developing.md)).
+ */
+
+import type { UserConfig } from 'tsdown';
+
+/** A library bundle: ESM and CJS outputs with declarations and source maps. */
+declare const bundle: UserConfig;
+
+export { type UserConfig } from 'tsdown';
+export default bundle;

package/presets/tsdown/bundle.js

@@ -3,7 +3,16 @@ import { defineConfig } from 'tsdown';
 export default defineConfig({
     entry: ['src/index.ts'],
     format: ['esm', 'cjs'],
-    dts: true,
+    /*
+     * `isolatedDeclarations` lives here, not in the `library` tsconfig preset:
+     * what it buys is a declaration emitted without a type-checker, which is a
+     * property of the PUBLISHED artefact and of nothing else. In the tsconfig
+     * it also reached every spec file, where it refused the destructured
+     * export a specification hands back ([Developing](../../docs/02-developing.md)).
+     * `bundle` is the library command, so the guarantee sits exactly where the
+     * tsconfig preset used to put it — and nowhere wider.
+     */
+    dts: { compilerOptions: { isolatedDeclarations: true } },
     sourcemap: true,
     clean: true,
     hash: false,

package/rules/README.md

@@ -2,17 +2,17 @@
 
 One nature lives here: a DECISION about a lint rule. Never a config object, never a path, never a tool invocation — those are `presets/`'s and `bin/`'s. What the decisions mean, and the four laws they answer to, is [Lint presets](../docs/07-lint-presets.md); this page only says where each thing is.
 
-| File                                                                | Holds                                                                                                                                                    |
-| ------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `_contract.js`                                                      | `fragment()`, `on()`, `typeAware()`, `off()`, `scoped()` — and the load-time refusal of a level that is not `error`/`off` and of an `off` with no reason |
-| `compile.js`                                                        | fragment → plain oxlint config, and the deterministic merge behind `compose()`. It never emits `categories`                                              |
-| `profiles.js`                                                       | which fragments each of the six profiles carries, and what none of them lints                                                                            |
-| `catalog.js`                                                        | every decision as one list, and the markdown the chapter carries between its `GENERATED` markers                                                         |
-| `core/`                                                             | one file per plugin of the rulebook every profile holds: `eslint`, `typescript`, `unicorn`, `oxc`, `import`, `promise`, `node`, `jsdoc`                  |
-| `react.js` · `a11y.js` · `next.js` · `react-native.js` · `astro.js` | what a framework profile adds to that rulebook                                                                                                           |
-| `vitest.js`                                                         | the test-file rules, as an `overrides` block — they read a test and say nothing about anything else                                                      |
-| `sorted.js`                                                         | perfectionist: only what oxfmt does not sort                                                                                                             |
-| `architecture/`                                                     | `layers.js` turns a declared layer map into `no-restricted-imports` overrides; `hexagonal.js` is the map this package ships                              |
+| File                                                                               | Holds                                                                                                                                                                                                      |
+| ---------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `_contract.js`                                                                     | `fragment()`, `on()`, `typeAware()`, `off()`, `unsafeFix()`, `scoped()` — and the load-time refusal of a level that is not `error`/`off`, of an `off` with no reason and of an unsafe fixer with no reason |
+| `compile.js`                                                                       | fragment → plain oxlint config, and the deterministic merge behind `compose()`. It never emits `categories`                                                                                                |
+| `profiles.js`                                                                      | which fragments each of the seven profiles carries, and what none of them lints                                                                                                                            |
+| `catalog.js`                                                                       | every decision as one list, and the markdown the chapter carries between its `GENERATED` markers                                                                                                           |
+| `core/`                                                                            | one file per plugin of the rulebook every profile holds: `eslint`, `typescript`, `unicorn`, `oxc`, `import`, `promise`, `node`, `jsdoc`                                                                    |
+| `react.js` · `a11y.js` · `next.js` · `react-native.js` · `astro.js` · `bundler.js` | what a framework profile adds to that rulebook, and what a bundled tree with no framework still owes                                                                                                       |
+| `vitest.js`                                                                        | the test-file rules, as an `overrides` block — they read a test and say nothing about anything else                                                                                                        |
+| `sorted.js`                                                                        | perfectionist: only what oxfmt does not sort                                                                                                                                                               |
+| `architecture/`                                                                    | `layers.js` turns a declared layer map into `no-restricted-imports` overrides; `hexagonal.js` is the map this package ships                                                                                |
 
 A fragment is loaded, not read: importing one runs its contract, so a decision that breaks an invariant fails at import time rather than at review time.
 

package/rules/_contract.js

@@ -30,6 +30,8 @@
  * @property {unknown} [options] The rule's options, at their decided value.
  * @property {Reason} [reason] Present on every `off`, absent on every `on`.
  * @property {boolean} [typeAware] Whether the rule needs type information.
+ * @property {'unsafe'} [fixer] Present when the rule's own fixer changes meaning.
+ * @property {string} [fixerReason] What that rewrite changes — measured, one clause.
  * @property {string} since The version the decision was taken in.
  *
  * @typedef {object} Scoped An `overrides` block, stated in decisions.
@@ -80,6 +82,20 @@ export function off(reason, since) {
     return Object.freeze({ level: 'off', reason: Object.freeze({ ...reason }), since });
 }
 
+/**
+ * A decision whose FIXER changes meaning. The rule stays on — `check` reports
+ * it and a human answers it — but `fix` never applies the rewrite: the eight
+ * marked here have each been measured turning working code into code that
+ * does not compile, or into code that claims something else
+ * ([Lint presets](../docs/07-lint-presets.md)).
+ */
+export function unsafeFix(decision, why) {
+    if (typeof why !== 'string' || why.length === 0) {
+        throw new TypeError('An unsafe fixer must say what its rewrite changes.');
+    }
+    return Object.freeze({ ...decision, fixer: 'unsafe', fixerReason: why });
+}
+
 /**
  * A rule that is on and needs type information — `oxlint --type-aware`, which
  * every profile of this package turns on. The mark is what the catalogue reads.

package/rules/astro.js

@@ -1,5 +1,5 @@
 import { fragment, off, on, scoped } from './_contract.js';
-import { EXTENSIONS_NEVER } from './core/import.js';
+import { ASSETS } from './core/import.js';
 
 /*
  * Astro. oxlint parses an `.astro` file's script body but not its frontmatter
@@ -28,7 +28,14 @@ export default fragment({
         }),
     ],
     rules: {
-        'import/extensions': EXTENSIONS_NEVER,
+        /*
+         * `never`, with two extensions that stay: an asset, which Vite resolves
+         * BY its extension, and `.astro` itself — Astro's `resolve.extensions`
+         * does not carry it, so a layout imported without it fails the build.
+         * An override's options REPLACE the base entry, so the whole list is
+         * restated here.
+         */
+        'import/extensions': on(['never', { ...ASSETS, astro: 'always' }]),
         'no-restricted-imports': on([
             {
                 patterns: [

package/rules/bundler.js

@@ -0,0 +1,19 @@
+import { fragment } from './_contract.js';
+import { EXTENSIONS_NEVER } from './core/import.js';
+
+/*
+ * A bundled tree with no framework behind it — Vite, Remotion, a browser
+ * extension. oxlint has no plugin to load for one, so this fragment carries a
+ * single decision: the bundler resolves the specifier, so an import carries no
+ * extension.
+ *
+ * `rules/next.js`, `rules/astro.js` and `rules/react-native.js` each state the
+ * same decision inside their own framework fragment, where it sits beside that
+ * framework's plugin. A profile with no framework fragment states it here.
+ */
+export default fragment({
+    id: 'bundler',
+    rules: {
+        'import/extensions': EXTENSIONS_NEVER,
+    },
+});

package/rules/catalog.js

@@ -31,6 +31,12 @@ export const MARKERS = Object.freeze({
     start: '<!-- GENERATED -->',
 });
 
+/** The fence that bounds the list of fixers `fix` refuses to run. */
+export const FIXER_MARKERS = Object.freeze({
+    end: '<!-- /GENERATED:fixers -->',
+    start: '<!-- GENERATED:fixers -->',
+});
+
 /** Every profile there is, so a decision carried by all of them says `all`. */
 const EVERY_PROFILE = Object.keys(PROFILES).length;
 
@@ -132,3 +138,29 @@ function scopeOf(entry) {
     }
     return `scoped to ${entry.scoped.map((glob) => `\`${glob}\``).join(', ')}`;
 }
+
+/**
+ * Every rule whose own fixer changes meaning, with what the rewrite does.
+ * `check` reports them and a human answers them; `fix` runs with each one
+ * allowed, so the rewrite is never applied
+ * ([Quality checks](../docs/06-quality-checks.md)).
+ */
+export function unsafeFixers() {
+    const seen = new Map();
+    for (const entry of catalog()) {
+        if (entry.fixer === 'unsafe' && !seen.has(entry.rule)) {
+            seen.set(entry.rule, entry.fixerReason);
+        }
+    }
+
+    return [...seen.entries()]
+        .map(([rule, why]) => ({ rule, why }))
+        .toSorted((left, right) => left.rule.localeCompare(right.rule));
+}
+
+/** The same list as the markdown the chapter carries between its fixer markers. */
+export function renderFixers() {
+    return unsafeFixers()
+        .map(({ rule, why }) => `- \`${rule}\` — ${why}`)
+        .join('\n');
+}

package/rules/catalog.test.ts

@@ -2,7 +2,14 @@ import { readFileSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { expect, test } from 'vitest';
 
-import { catalog, MARKERS, render, renderReference } from './catalog.js';
+import {
+    catalog,
+    FIXER_MARKERS,
+    MARKERS,
+    render,
+    renderFixers,
+    renderReference,
+} from './catalog.js';
 
 /*
  * The catalogue has two readers and one source. `docs/07-lint-presets.md` is
@@ -19,10 +26,17 @@ import { catalog, MARKERS, render, renderReference } from './catalog.js';
 
 const PROJECTIONS = {
     chapter: {
+        markers: MARKERS,
         page: resolve(import.meta.dirname, '../docs/07-lint-presets.md'),
         render,
     },
+    'fixer list': {
+        markers: FIXER_MARKERS,
+        page: resolve(import.meta.dirname, '../docs/07-lint-presets.md'),
+        render: renderFixers,
+    },
     'skill reference': {
+        markers: MARKERS,
         page: resolve(import.meta.dirname, '../skills/jterrazz-typescript/references/rules.md'),
         render: renderReference,
     },
@@ -54,18 +68,18 @@ test('every decision carries the version it was taken in', () => {
 
 test.each(Object.entries(PROJECTIONS))(
     'the %s carries the catalogue the manifest renders',
-    (_name, { page, render: project }) => {
+    (_name, { markers, page, render: project }) => {
         // Given - the generated section of the projection
         const before = readFileSync(page, 'utf8');
-        const start = before.indexOf(MARKERS.start);
-        const end = before.indexOf(MARKERS.end);
+        const start = before.indexOf(markers.start);
+        const end = before.indexOf(markers.end);
         expect(start, 'the page has lost its GENERATED marker').toBeGreaterThan(-1);
         expect(end, 'the page has lost its /GENERATED marker').toBeGreaterThan(start);
 
         // Then - it is exactly what the manifest renders today
         const table = project();
         if (process.env.TEST_UPDATE === '1') {
-            const head = before.slice(0, start + MARKERS.start.length);
+            const head = before.slice(0, start + markers.start.length);
             writeFileSync(page, `${head}\n\n${table}\n\n${before.slice(end)}`);
         }
 
@@ -76,8 +90,8 @@ test.each(Object.entries(PROJECTIONS))(
          */
         const fresh = readFileSync(page, 'utf8');
         const carried = fresh.slice(
-            fresh.indexOf(MARKERS.start) + MARKERS.start.length,
-            fresh.indexOf(MARKERS.end),
+            fresh.indexOf(markers.start) + markers.start.length,
+            fresh.indexOf(markers.end),
         );
         expect(cells(carried)).toStrictEqual(cells(table));
     },

package/rules/core/import.js

@@ -6,8 +6,9 @@ import { allOn, fragment, off, on } from '../_contract.js';
  * `import/extensions` is the one rule two platforms answer differently: Node
  * ESM resolves a specifier literally and needs the `.js`, a bundler resolves it
  * and refuses one. Core states the Node answer; `rules/next.js`,
- * `rules/astro.js` and `rules/react-native.js` re-decide it for their platform,
- * at `error` either way — a profile changes the convention, never the level.
+ * `rules/astro.js`, `rules/react-native.js` and `rules/bundler.js` re-decide it
+ * for their platform, at `error` either way — a profile changes the convention,
+ * never the level.
  *
  * `import/no-cycle` rides here for +0.05s. Mind what it does NOT see: oxlint's
  * implementation ignores type-only imports, so a value import one way and an
@@ -15,7 +16,7 @@ import { allOn, fragment, off, on } from '../_contract.js';
  */
 
 /** Asset specifiers keep their extension on every platform — a bundler resolves them by it. */
-const ASSETS = {
+export const ASSETS = {
     avif: 'always',
     css: 'always',
     gif: 'always',
@@ -58,12 +59,17 @@ export default fragment({
                 'no-self-import',
                 'no-unassigned-import',
                 'no-webpack-loader-syntax',
-                'unambiguous',
             ].map((rule) => `import/${rule}`),
         ),
 
         // -- On, at the strictest value the option carries ---------------------
-        'import/consistent-type-specifier-style': on(['prefer-inline']),
+        /*
+         * Top level, not inline, and `verbatimModuleSyntax` is why: under it
+         * `import { type X } from 'leaflet'` is emitted as
+         * `import {} from 'leaflet'` — a runtime side-effect import of a module
+         * that may only exist in a browser. signews-web served a 500 from it.
+         */
+        'import/consistent-type-specifier-style': on(['prefer-top-level']),
         'import/extensions': EXTENSIONS_ALWAYS,
 
         // -- Off, each with its one reason -------------------------------------
@@ -103,5 +109,9 @@ export default fragment({
             by: 'docs/07-lint-presets.md — a module exports what it owns by name',
             kind: 'convention',
         }),
+        'import/unambiguous': off({
+            by: 'TypeScript — `verbatimModuleSyntax` and a package\'s `"type": "module"` already make every file a module, and what the rule reports beyond that is a file with nothing to export: an entry script, an Astro `is:inline` block',
+            kind: 'covered',
+        }),
     },
 });

package/rules/core/typescript.js

@@ -1,4 +1,4 @@
-import { allOn, fragment, off, on, scoped, typeAware } from '../_contract.js';
+import { allOn, fragment, off, on, scoped, typeAware, unsafeFix } from '../_contract.js';
 
 /*
  * The `typescript` plugin, all 108 non-nursery rules decided by name. Fifty-one
@@ -92,7 +92,6 @@ export default fragment({
                 'dot-notation',
                 'no-array-delete',
                 'no-base-to-string',
-                'no-confusing-void-expression',
                 'no-deprecated',
                 'no-duplicate-type-constituents',
                 'no-floating-promises',
@@ -107,7 +106,6 @@ export default fragment({
                 'no-unnecessary-qualifier',
                 'no-unnecessary-template-expression',
                 'no-unnecessary-type-arguments',
-                'no-unnecessary-type-assertion',
                 'no-unnecessary-type-conversion',
                 'no-unnecessary-type-parameters',
                 'no-unsafe-argument',
@@ -119,7 +117,6 @@ export default fragment({
                 'no-unsafe-type-assertion',
                 'no-unsafe-unary-minus',
                 'no-useless-default-assignment',
-                'non-nullable-type-assertion-style',
                 'only-throw-error',
                 'prefer-find',
                 'prefer-includes',
@@ -153,14 +150,36 @@ export default fragment({
                 'ts-nocheck': true,
             },
         ]),
-        'typescript/consistent-type-definitions': on(['type']),
+        /* Three fixers that change meaning, so `fix` never applies them and
+         * `check` still reports them: one rewrites a `declare module`
+         * augmentation into an alias that no longer merges, one wraps a
+         * returned promise so nothing awaits it, one drops a cast a widened
+         * platform type needs. */
+        'typescript/consistent-type-definitions': unsafeFix(
+            on(['type']),
+            'rewrites a `declare module` augmentation into an alias, which no longer merges',
+        ),
+        'typescript/no-confusing-void-expression': unsafeFix(
+            typeAware(),
+            'wraps a returned promise, after which nothing awaits it',
+        ),
+        'typescript/no-unnecessary-type-assertion': unsafeFix(
+            typeAware(),
+            'drops a cast a widened platform type needs',
+        ),
+        /* `separate-type-imports`, for `import/consistent-type-specifier-style`'s
+         * reason: an inline type specifier survives `verbatimModuleSyntax` as an
+         * empty runtime import. */
         'typescript/consistent-type-imports': on([
             {
                 disallowTypeAnnotations: true,
-                fixStyle: 'inline-type-imports',
+                fixStyle: 'separate-type-imports',
                 prefer: 'type-imports',
             },
         ]),
+        /* The guard for the emit above: an all-inline type import is the shape
+         * `verbatimModuleSyntax` turns into a side effect, and this names it. */
+        'typescript/no-import-type-side-effects': on(),
         'typescript/explicit-member-accessibility': on([{ accessibility: 'no-public' }]),
         /* Booleans excepted: `false ?? x` is `false` and `false || x` is `x`,
          * so on a boolean the two operators mean different things and the
@@ -177,21 +196,21 @@ export default fragment({
             kind: 'covered',
         }),
         'typescript/explicit-function-return-type': off({
-            by: 'presets/tsconfig/library.json — isolatedDeclarations requires the annotation exactly where it is load-bearing',
+            by: 'presets/tsdown/bundle.js — isolatedDeclarations requires the annotation exactly where it is load-bearing, on a published export',
             kind: 'covered',
         }),
         'typescript/explicit-module-boundary-types': off({
-            by: 'presets/tsconfig/library.json — isolatedDeclarations requires the annotation exactly where it is load-bearing',
+            by: 'presets/tsdown/bundle.js — isolatedDeclarations requires the annotation exactly where it is load-bearing, on a published export',
             kind: 'covered',
         }),
-        'typescript/no-import-type-side-effects': off({
-            by: 'import/consistent-type-specifier-style (prefer-inline) — an import whose specifiers are all inline types is exactly the form that rule asks for',
-            kind: 'exclusive',
-        }),
         'typescript/no-empty-interface': off({
             by: 'typescript/no-empty-object-type — its upstream successor',
             kind: 'covered',
         }),
+        'typescript/non-nullable-type-assertion-style': off({
+            by: 'typescript/no-non-null-assertion — its fix is the `!` assertion that rule forbids, so no edit closes both',
+            kind: 'exclusive',
+        }),
         'typescript/no-var-requires': off({
             by: 'typescript/no-require-imports — its upstream successor',
             kind: 'covered',

package/rules/core/unicorn.js

@@ -1,4 +1,4 @@
-import { allOn, fragment, off, on } from '../_contract.js';
+import { allOn, fragment, off, on, unsafeFix } from '../_contract.js';
 
 /*
  * The `unicorn` plugin, all 137 non-nursery rules decided by name. Two of the
@@ -72,7 +72,6 @@ export default fragment({
                 'no-useless-promise-resolve-reject',
                 'no-useless-spread',
                 'no-useless-switch-case',
-                'no-useless-undefined',
                 'no-zero-fractions',
                 'numeric-separators-style',
                 'prefer-add-event-listener',
@@ -96,7 +95,6 @@ export default fragment({
                 'prefer-event-target',
                 'prefer-export-from',
                 'prefer-global-this',
-                'prefer-import-meta-properties',
                 'prefer-keyboard-event-key',
                 'prefer-logical-operator-over-ternary',
                 'prefer-math-min-max',
@@ -159,6 +157,18 @@ export default fragment({
          * default preference, and `'utf-8'` is the same encoding spelled longer. */
         'unicorn/text-encoding-identifier-case': on(),
 
+        /* Both fixers change meaning, so `fix` never applies them and `check`
+         * still reports them: one strips a REQUIRED argument, the other drops
+         * the trailing slash `new URL('.', import.meta.url)` carries. */
+        'unicorn/no-useless-undefined': unsafeFix(
+            on(),
+            'strips a REQUIRED argument, `mockReturnValue(undefined)` included (TS2554)',
+        ),
+        'unicorn/prefer-import-meta-properties': unsafeFix(
+            on(),
+            "rewrites `fileURLToPath(new URL('.', import.meta.url))` into `import.meta.dirname`, which carries no trailing slash",
+        ),
+
         // -- Off, each with its one reason -------------------------------------
         'unicorn/explicit-length-check': off({
             by: 'typescript/strict-boolean-expressions — it already refuses a length used as a condition',

package/rules/profiles.js

@@ -1,5 +1,6 @@
 import a11y from './a11y.js';
 import astro from './astro.js';
+import bundler from './bundler.js';
 import eslint from './core/eslint.js';
 import importPlugin from './core/import.js';
 import jsdoc from './core/jsdoc.js';
@@ -86,4 +87,9 @@ export const PROFILES = Object.freeze({
         fragments: [...CORE],
         ignorePatterns: [...IGNORED],
     },
+    react: {
+        env: { browser: true, builtin: true, node: true },
+        fragments: [...CORE, react, a11y, bundler],
+        ignorePatterns: [...IGNORED],
+    },
 });

package/rules/react.js

@@ -144,5 +144,12 @@ export default fragment({
             by: 'presets/tsconfig/next.json — the automatic JSX runtime (jsx: react-jsx) imports it',
             kind: 'covered',
         }),
+
+        /*
+         * A stylesheet import IS its own assignment — `import './index.css'`
+         * is how a React tree carries its styles, whatever bundles it, and
+         * there is nothing to bind it to. One owner for every React profile.
+         */
+        'import/no-unassigned-import': on([{ allow: ['**/*.css', '**/*.scss'] }]),
     },
 });

package/rules/vitest.js

@@ -1,4 +1,4 @@
-import { allOn, fragment, off, on, scoped } from './_contract.js';
+import { allOn, fragment, off, on, scoped, unsafeFix } from './_contract.js';
 
 /*
  * The `vitest` plugin, all 73 rules decided by name — inside an `overrides`
@@ -63,18 +63,16 @@ const ON_IN_TESTS = [
     'prefer-mock-return-shorthand',
     'prefer-snapshot-hint',
     'prefer-spy-on',
+    'prefer-strict-boolean-matchers',
     'prefer-strict-equal',
     'prefer-to-be',
-    'prefer-to-be-falsy',
     'prefer-to-be-object',
-    'prefer-to-be-truthy',
     'prefer-to-contain',
     'prefer-to-have-been-called-times',
     'prefer-to-have-length',
     'prefer-todo',
     'require-awaited-expect-poll',
     'require-local-test-context-for-concurrent-snapshots',
-    'require-mock-type-parameters',
     'require-to-throw-message',
     'valid-describe-callback',
     'valid-expect',
@@ -83,6 +81,30 @@ const ON_IN_TESTS = [
     'warn-todo',
 ].map((rule) => `vitest/${rule}`);
 
+/*
+ * The three vitest fixers that change meaning, so `fix` never applies them and
+ * `check` still reports them. They are named here rather than inline because a
+ * decision three calls deep inside an override reads as nesting, not as a
+ * decision.
+ *
+ * `prefer-lowercase-title` carries no `allowedPrefixes`: the rule is stricter
+ * than the `j5` rule @jterrazz/test retires for it — it also refuses a title
+ * opening on an all-caps identifier (`HTTP 404 …`, `DI …`) — and an existing
+ * title is a rename, not a case for an estate-specific escape hatch.
+ */
+const CONSISTENT_TEST_IT = unsafeFix(
+    on([{ fn: 'test' }]),
+    'rewrites `it(` into `test(` and leaves `import { it }` behind',
+);
+const PREFER_LOWERCASE_TITLE = unsafeFix(
+    on(),
+    'lower-cases the first character blindly: `CLI …` becomes `cLI …`',
+);
+const REQUIRE_MOCK_TYPE_PARAMETERS = unsafeFix(
+    on(),
+    "rewrites `vi.mock('x', f)` into `vi.mock(import('x'), f)`, after which the factory owes the module's full type",
+);
+
 export default fragment({
     id: 'vitest',
     plugins: ['vitest'],
@@ -92,13 +114,9 @@ export default fragment({
             rules: {
                 ...allOn(ON_IN_TESTS),
 
-                'vitest/consistent-test-it': on([{ fn: 'test' }]),
-                /* No `allowedPrefixes`. The rule is stricter than the `j5` rule
-                 * @jterrazz/test retires for it: it also refuses a title opening
-                 * on an all-caps identifier (`HTTP 404 …`, `DI …`). Strictest
-                 * sensible wins, and an existing title is a rename, not a case
-                 * for an estate-specific escape hatch. */
-                'vitest/prefer-lowercase-title': on(),
+                'vitest/consistent-test-it': CONSISTENT_TEST_IT,
+                'vitest/prefer-lowercase-title': PREFER_LOWERCASE_TITLE,
+                'vitest/require-mock-type-parameters': REQUIRE_MOCK_TYPE_PARAMETERS,
 
                 'vitest/no-conditional-in-test': off({
                     by: "vitest/no-conditional-expect — the defect is an assertion that may not run, and that rule names it; this one also refuses a golden suite's TEST_UPDATE branch and every comparator",
@@ -124,8 +142,15 @@ export default fragment({
                     by: 'docs/07-lint-presets.md — a spec states its assertions; counting them is bookkeeping the reader does not need',
                     kind: 'convention',
                 }),
-                'vitest/prefer-strict-boolean-matchers': off({
-                    by: 'vitest/prefer-to-be-truthy, vitest/prefer-to-be-falsy',
+                /* The pair the other way round. `toBe(true)` is a strict
+                 * boolean assertion and `toBeTruthy()` is not — the fixer that
+                 * rewrote one into the other WEAKENED every spec it touched. */
+                'vitest/prefer-to-be-falsy': off({
+                    by: 'vitest/prefer-strict-boolean-matchers — one asks for the strict matcher, the other for the falsy one',
+                    kind: 'exclusive',
+                }),
+                'vitest/prefer-to-be-truthy': off({
+                    by: 'vitest/prefer-strict-boolean-matchers — one asks for the strict matcher, the other for the truthy one',
                     kind: 'exclusive',
                 }),
                 'vitest/require-top-level-describe': off({

package/src/docs.test.ts

@@ -1,6 +1,7 @@
 import { expect, test } from 'vitest';
 
-import { auditDocs, type DocsTree } from './docs.js';
+import { auditDocs } from './docs.js';
+import type { DocsTree } from './docs.js';
 
 /**
  * The manual every repository carries, in its smallest compliant form: a map,

package/src/index.d.ts

@@ -1,5 +1,5 @@
-import { type OxfmtConfig } from './oxfmt.js';
-import { type OxlintConfig } from './oxlint.js';
+import type { OxfmtConfig } from './oxfmt.js';
+import type { OxlintConfig } from './oxlint.js';
 
 declare const oxfmtConfig: OxfmtConfig;
 
@@ -11,6 +11,7 @@ declare const oxlintProfiles: {
     library: OxlintConfig;
     next: OxlintConfig;
     node: OxlintConfig;
+    react: OxlintConfig;
 };
 
 declare const defaultExport: {

package/src/index.js

@@ -5,6 +5,7 @@ import expoProfile from '../presets/oxlint/profiles/expo.js';
 import libraryProfile from '../presets/oxlint/profiles/library.js';
 import nextProfile from '../presets/oxlint/profiles/next.js';
 import nodeProfile from '../presets/oxlint/profiles/node.js';
+import reactProfile from '../presets/oxlint/profiles/react.js';
 import hexagonalFragment from '../rules/architecture/hexagonal.js';
 import { compile } from '../rules/compile.js';
 
@@ -18,6 +19,7 @@ export const oxlint = {
     library: libraryProfile,
     next: nextProfile,
     node: nodeProfile,
+    react: reactProfile,
 };
 
 export default { oxfmt, oxlint };

package/src/oxfmt.d.ts

@@ -6,7 +6,7 @@
  * consumer's `defineConfig(base)` stopped type-checking because of it.
  */
 
-import { type OxfmtConfig } from 'oxfmt';
+import type { OxfmtConfig } from 'oxfmt';
 
 declare const base: OxfmtConfig;
 

package/src/oxfmt.test.ts

@@ -12,7 +12,7 @@ test('gives the formatter the three sorters, so no lint rule owns an order', ()
     // Given - the shared preset
     // Then - import order, package.json key order and Tailwind class order are oxfmt's
     expect(base.sortImports).toMatchObject({ ignoreCase: true, order: 'asc' });
-    expect(base.sortPackageJson).toBeTruthy();
+    expect(base.sortPackageJson).toBe(true);
     expect(base.sortTailwindcss).toStrictEqual({
         functions: ['clsx', 'cn', 'cva', 'tv', 'twMerge', 'twJoin', 'tw'],
     });

package/src/oxlint.d.ts

@@ -3,10 +3,10 @@
  * restate it: `OxlintConfig` and `OxlintOverride` are re-exported from the
  * tool, under the names a consumer already reads here. A hand copy drifts —
  * this one had `plugins?: string[]` where oxlint takes a closed union, and a
- * consumer's `defineConfig({ extends: [node] })` stopped type-checking.
+ * consumer's `defineConfig(node)` stopped type-checking.
  */
 
-import { type OxlintConfig } from 'oxlint';
+import type { OxlintConfig } from 'oxlint';
 
 /** A rule entry as oxlint reads it: a level, or a level and its options. */
 type RuleEntry = NonNullable<OxlintConfig['rules']>[string];
@@ -27,6 +27,7 @@ declare const hexagonal: OxlintConfig;
 declare const library: OxlintConfig;
 declare const next: OxlintConfig;
 declare const node: OxlintConfig;
+declare const react: OxlintConfig;
 
 /** The six boundaries the `hexagonal` fragment enforces, as a declared map. */
 declare const HEXAGONAL_MAP: readonly Layer[];
@@ -59,5 +60,6 @@ export {
     library,
     next,
     node,
+    react,
     type RuleEntry,
 };

package/src/oxlint.js

@@ -1,11 +1,11 @@
 /*
- * The tool-facing oxlint entry (`@jterrazz/typescript/oxlint`): the six
+ * The tool-facing oxlint entry (`@jterrazz/typescript/oxlint`): the seven
  * profiles, the `compose()` merger, the layer-map builder, and oxlint's own
  * `defineConfig`. A consumer names a PROFILE, not a set of fragments:
  *
  *     import { defineConfig, node } from '@jterrazz/typescript/oxlint';
  *
- *     export default defineConfig({ extends: [node] });
+ *     export default defineConfig(node);
  *
  * What each profile carries, and why every rule of every loaded plugin is
  * decided by name, is [Lint presets](../docs/07-lint-presets.md).
@@ -33,6 +33,7 @@ export { default as expo } from '../presets/oxlint/profiles/expo.js';
 export { default as library } from '../presets/oxlint/profiles/library.js';
 export { default as next } from '../presets/oxlint/profiles/next.js';
 export { default as node } from '../presets/oxlint/profiles/node.js';
+export { default as react } from '../presets/oxlint/profiles/react.js';
 
 export { HEXAGONAL_MAP } from '../rules/architecture/hexagonal.js';