@fast-china/eslint-config 2.0.9 → 2.1.0

package/CHANGELOG.md

@@ -6,6 +6,44 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and
 
 ## Unreleased
 
+### Changed
+
+- Expanded the inline documentation for local ESLint rules and scoped overrides, including their purpose, important exceptions, and ownership of duplicate React checks.
+
+## 2.1.0 - 2026-08-26
+
+### Added
+
+- Added built-in UniApp support for `.nvue`, cross-platform and conditional-platform runtime globals, comment-compatible `pages.json` and `manifest.json`, and generated `unpackage` output ignores.
+- Added a trailing Node.js tooling override that permits logging and CommonJS interoperability in config, script, test, and CLI files.
+- Added root-exported `createBaseConfigs()` as a fixed, framework-neutral composition for React, Angular, Node.js, and SDK projects.
+
+### Changed
+
+- Replaced project-type strictness with one shared rule set for SDKs, OA systems, administration apps, Vue web apps, and clients.
+- Changed the root entry to a fixed Vue 3, type-aware TypeScript, and UniApp preset; `fastConfig()` now retains only the runtime `environment` option and trailing Flat Config overrides.
+- Changed TypeScript, Vue, and React TypeScript to always use `recommendedTypeChecked` and Project Service.
+- Required explicit parameter and return types at exported TypeScript module boundaries without forcing return annotations on internal functions and callbacks.
+- Changed Vue to inherit `flat/recommended`, enforce kebab-case template attributes, warn on `v-html`, and reject `v-text`/`v-html` on components.
+- Replaced the full RegExp recommended preset with an explicit correctness and safety rule set.
+- Restored JavaScript conventions including camelCase, declaration order, arrow callbacks, logical assignment, object spread, object shorthand, rest/spread, and template literals.
+- Restored `sort-imports`; import ordering is an error again and includes side-effect imports.
+- Enabled the official React Hooks Recommended preset and aligned Angular TypeScript, template, and accessibility rules with the Angular ESLint recommended presets.
+- Enabled `package.json` and `tsconfig*.json` sorting in the fixed root and base compositions; Markdown remains explicitly composed.
+- Corrected the built-in dependency ignore glob so both `.pnpm-store` and `node_modules` are matched without relying on `.gitignore`.
+- Allowed JSONC comments in both VS Code `.vscode/settings.json` and `.vscode/extensions.json`.
+
+### Removed
+
+- Removed `defaultConfigOptions`, root language/framework/plugin switches, factory-level rules/globals/ignores, `typeChecked`, and `tsconfigRootDir`. Native trailing Flat Config and focused factories replace these wrapper options.
+
+## 2.0.10 - 2026-08-19
+
+### Changed
+
+- Changed the default export to a ready-to-use Flat Config array that can be exported directly or spread into another configuration; configurable usage remains available through the named `fastConfig()` export.
+- Enabled Markdown, `package.json` sorting, and `tsconfig*.json` sorting by default while keeping React and Angular disabled by default.
+
 ## 2.0.9 - 2026-08-10
 
 ### Changed

package/CONTRIBUTING.md

@@ -27,13 +27,14 @@ Use `pnpm lint:fix` and `pnpm format` for safe mechanical fixes. `pnpm test` fir
 2. Scope every rule group with `files` unless it is intentionally global.
 3. Register each plugin in a configuration that matches the same files as its rules.
 4. Prefer upstream recommended configs before adding local overrides.
-5. Keep organization-specific dependency restrictions out of this general-purpose package; projects should own those policies.
-6. Explain the purpose, rationale, and important exception or risk immediately above every local rule override.
-7. Mark disruptive defaults with `[高影响]`; verify `meta.fixable` before using `[可自动修复]`, and keep `docs/rules-risk.md` plus `docs/rules-risk.zh.md` synchronized.
-8. Never sort a map whose key order has semantics, including conditional objects under `package.json#exports`.
-9. Regenerate `src/typegen.d.ts` whenever ESLint or a bundled plugin changes; confirm new rules and changed option schemas intentionally.
-10. Add or update an integration test for every parser, plugin, option, auto-fix, generated type, or public export change. The root API is intentionally limited to `fastConfig`, `defaultConfigOptions`, `defineRules`, and related types.
-11. Document behavior changes in `CHANGELOG.md` and both README files.
+5. Preserve the documented JavaScript, TypeScript, and Vue behavior unless a release explicitly changes it; keep historical comparisons in the changelog rather than source comments.
+6. Keep organization-specific dependency restrictions out of this general-purpose package; projects should own those policies.
+7. Explain the purpose, rationale, and important exception or risk immediately above every local rule override.
+8. Document every default rule's severity and valid exceptions; verify `meta.fixable` before using `[可自动修复]`, and keep `docs/rules-risk.md` plus `docs/rules-risk.zh.md` synchronized.
+9. Never sort a map whose key order has semantics, including conditional objects under `package.json#exports`.
+10. Regenerate `src/typegen.d.ts` whenever ESLint or a bundled plugin changes; confirm new rules and changed option schemas intentionally.
+11. Add or update an integration test for every parser, plugin, option, auto-fix, generated type, or public export change. The root API is intentionally limited to the default config, `fastConfig`, `defineRules`, and related types.
+12. Document behavior changes in `CHANGELOG.md` and both README files.
 
 ## Pull requests
 

package/README.md

@@ -8,21 +8,20 @@
 
 # @fast-china/eslint-config
 
-A practical, typed ESLint Flat Config for Vue 3, React, Angular, Vite, TypeScript, and JavaScript projects.
+A practical ESLint Flat Config for Vue 3, UniApp, React, Angular, Vite, TypeScript, and JavaScript projects.
 
-[![npm version](https://img.shields.io/npm/v/@fast-china/eslint-config?color=orange)](https://www.npmjs.com/package/@fast-china/eslint-config) [![node](https://img.shields.io/badge/node-%5E22.18%20%7C%7C%20%5E24.18-brightgreen)](https://nodejs.org/) [![eslint](https://img.shields.io/badge/eslint-%5E10.0-4b32c3)](https://eslint.org/) [![license](https://img.shields.io/npm/l/@fast-china/eslint-config)](./LICENSE)
+[![npm version](https://img.shields.io/npm/v/@fast-china/eslint-config?color=orange)](https://www.npmjs.com/package/@fast-china/eslint-config) [![Node.js](https://img.shields.io/badge/node-%5E22.18%20%7C%7C%20%5E24.18-brightgreen)](https://nodejs.org/) [![ESLint](https://img.shields.io/badge/eslint-%5E10.0-4b32c3)](https://eslint.org/) [![license](https://img.shields.io/npm/l/@fast-china/eslint-config)](./LICENSE)
 
-## Highlights
+## Features
 
-- Built for ESLint 10 and the native Flat Config format.
-- Vue 3 + TypeScript + Vite defaults; React and Angular are first-class opt-in integrations, so existing Vue projects do not activate unrelated rules.
-- First-class JavaScript, TypeScript, Vue SFC, JSX/TSX, Angular TypeScript and templates, JSON dialects, Markdown, RegExp, and import rules.
-- One focused `fastConfig()` factory with a compact public API and no project-file reads at module import time.
-- Schema-generated rule types provide exact rule-name and rule-option completion.
-- Plugins and parsers are regular package dependencies, so consumers do not need to assemble the plugin graph.
-- Prettier stays a formatter: the default only disables conflicting ESLint rules and does not run Prettier inside ESLint.
-- Manifest sorting is explicit opt-in, preventing an unexpected large first-fix diff.
-- An opt-in Lodash policy keeps projects on either `lodash` or `lodash-unified` without mixing package entry points.
+- Built for ESLint 10 and native Flat Config only.
+- The root entry is a fixed Vue 3 + TypeScript + UniApp preset with no language or plugin switches.
+- TypeScript, Vue, and React TypeScript always use type-aware recommended rules and Project Service.
+- SDKs, OA systems, administration apps, and clients use one JavaScript, TypeScript, Import, and RegExp rule set with no strictness tiers.
+- JavaScript, TypeScript, Vue/`.nvue`, UniApp globals, JSON dialects, Import, RegExp, manifest sorting, `.gitignore`, and Prettier compatibility are enabled by default.
+- React, Angular, Markdown, and Lodash policies compose explicitly from `@fast-china/eslint-config/configs`.
+- Schema-generated `RuleOptions` provides exact rule-name and option completion.
+- Plugins and parsers are direct package dependencies, so consumers do not assemble a plugin dependency tree.
 
 ## Requirements
 
@@ -30,319 +29,194 @@ A practical, typed ESLint Flat Config for Vue 3, React, Angular, Vite, TypeScrip
 - ESLint `^10.0.0`
 - TypeScript `^6.0.0`
 
-These versions follow the runtime requirements of ESLint 10 and the included language plugins.
-
 ## Installation
 
 ```sh
 pnpm add -D eslint typescript @fast-china/eslint-config
 ```
 
-Equivalent npm, Yarn, and Bun commands work as well.
-
-## Quick start: Vue 3 + Vite
+## Vue 3 / UniApp quick start
 
 Create `eslint.config.mjs`:
 
 ```js
 import fastChina from "@fast-china/eslint-config";
 
-export default fastChina();
+export default fastChina;
 ```
 
-The default targets a conventional Vue 3 browser-based administration project. It enables Vue 3, TypeScript, JavaScript, JSON dialects, import ordering, RegExp checks, `.gitignore`, browser globals, and Node globals for common config, script, test, and CLI files. Markdown, React, Angular, and manifest sorting remain opt-in. Lodash policies are composed separately from the `configs` subpath.
+The default entry includes:
 
-## Other project types
+- Browser globals plus dedicated Node.js globals for tooling files.
+- JavaScript, type-aware TypeScript, Vue 3, and `.nvue`.
+- `uni`, `uniCloud`, page APIs, and conditional-platform globals such as `wx`, `plus`, `my`, and `tt`.
+- JSON, JSONC, JSON5, comment-compatible `pages.json`, `manifest.json`, and VS Code `settings.json` and `extensions.json`.
+- Import, RegExp, `package.json`/`tsconfig*.json` sorting, `.gitignore`, and Prettier conflict handling.
 
-Other projects can either configure the root factory or compose focused fragments directly.
+ESLint does not execute UniApp `#ifdef`/`#endif` directives. It recognizes platform objects but cannot verify that they are used in the correct platform branch. `.uvue` and `.uts`, which require dedicated parsers, are not handled.
 
-### Use `fastConfig()`
+## `fastConfig()`
 
-#### React + Vite
+The root factory retains only `environment`, whose default is `"browser"`:
 
 ```js
-import fastChina from "@fast-china/eslint-config";
+import { fastConfig } from "@fast-china/eslint-config";
 
-export default fastChina({
-	react: true,
-	vue: false,
+export default fastConfig({
+	environment: "universal",
 });
 ```
 
-React support applies the modern `@eslint-react` JavaScript/TypeScript preset, the official React Hooks Flat Config, and additional DOM safety checks. JSX and TSX are parsed by the existing JavaScript and TypeScript integrations. For a React-compatible JSX runtime such as Preact, set `react: { importSource: "preact" }`.
+| Value         | Application globals |
+| ------------- | ------------------- |
+| `"browser"`   | Browser             |
+| `"node"`      | Node.js             |
+| `"universal"` | Browser and Node.js |
 
-#### Angular
-
-```js
-import fastChina from "@fast-china/eslint-config";
+Config, script, test, and CLI files always receive Node.js globals and allow necessary logging and CommonJS interoperability.
 
-export default fastChina({
-	angular: true,
-	vue: false,
-});
-```
-
-Angular support checks framework TypeScript, external `.html` templates, and inline component templates. Template accessibility and inline-template extraction are enabled by default:
-
-```js
-export default fastChina({
-	angular: {
-		inlineTemplates: true,
-		templateAccessibility: true,
-	},
-	vue: false,
-});
-```
-
-Angular requires the TypeScript integration; `angular: true` together with `typescript: false` fails early with a clear configuration error.
+## Project overrides
 
-#### Node.js + TypeScript
+Rules, globals, ignores, and special parser settings use trailing Flat Config objects instead of root factory options:
 
 ```js
-import fastChina from "@fast-china/eslint-config";
+import { defineRules, fastConfig } from "@fast-china/eslint-config";
 
-export default fastChina({
-	environment: "node",
-	vue: false,
-});
+export default fastConfig(
+	{ environment: "browser" },
+	{
+		ignores: ["public/vendor/**"],
+		languageOptions: {
+			globals: {
+				__APP_VERSION__: "readonly",
+			},
+		},
+		rules: defineRules({
+			"no-console": "warn",
+		}),
+	},
+	{
+		files: ["**/*.generated.ts"],
+		rules: defineRules({
+			"@typescript-eslint/no-unused-vars": "off",
+		}),
+	}
+);
 ```
 
-#### JavaScript only
+Trailing configs have the highest precedence. `defineRules()` leaves the object unchanged and only adds exact type checking.
 
-```js
-import fastChina from "@fast-china/eslint-config";
+## TypeScript
 
-export default fastChina({
-	environment: "node",
-	json: false,
-	markdown: false,
-	typescript: false,
-	vue: false,
-});
-```
-
-#### Type-aware TypeScript rules
+`createTypeScriptConfigs()`, Vue SFCs, and React TSX always use `recommendedTypeChecked` with:
 
 ```js
-import fastChina from "@fast-china/eslint-config";
-
-export default fastChina({
-	typescript: {
-		tsconfigRootDir: import.meta.dirname,
-		typeChecked: true,
-	},
-});
+parserOptions: {
+	projectService: true,
+}
 ```
 
-Type-aware linting uses the typescript-eslint Project Service. Project files must belong to a `tsconfig.json`. Most projects can omit `tsconfigRootDir`; complex monorepos should pass the directory containing the ESLint config explicitly.
+Linted files must belong to a discoverable `tsconfig.json`. The `typeChecked` and `tsconfigRootDir` wrapper options have been removed. Complex monorepos can override `languageOptions.parserOptions` in a trailing Flat Config when necessary.
 
-### Compose config fragments directly
+## React
 
-Projects that do not want the root factory can assemble only the required fragments. This React browser example is fully independent of `fastConfig()`:
+React projects compose from the framework-neutral base:
 
 ```js
+import { createBaseConfigs } from "@fast-china/eslint-config";
+import { createReactConfigs } from "@fast-china/eslint-config/configs";
 import { defineConfig } from "eslint/config";
 
-import {
-	createCommonConfigs,
-	createEnvironmentConfigs,
-	createGitignoreConfigs,
-	createGlobalIgnores,
-	createImportConfigs,
-	createJavaScriptConfigs,
-	createPrettierConfigs,
-	createReactConfigs,
-	createRegexpConfigs,
-	createTypeScriptConfigs,
-} from "@fast-china/eslint-config/configs";
-import { GLOBS_JAVASCRIPT, GLOBS_TYPESCRIPT } from "@fast-china/eslint-config/constants";
-
-const codeFiles = [...GLOBS_JAVASCRIPT, ...GLOBS_TYPESCRIPT];
-
-export default defineConfig([
-	...createGlobalIgnores(),
-	...createGitignoreConfigs(),
-	...createEnvironmentConfigs({ environment: "browser", files: codeFiles, nodeFiles: codeFiles }),
-	...createCommonConfigs(codeFiles),
-	...createJavaScriptConfigs(),
-	...createImportConfigs(codeFiles),
-	...createRegexpConfigs(codeFiles),
-	...createTypeScriptConfigs(),
-	...createReactConfigs({}, { javascript: true, typescript: true }),
-	...createPrettierConfigs(),
-]);
+export default defineConfig([...createBaseConfigs(), ...createReactConfigs()]);
 ```
 
-Use `createVueConfigs()` for Vue SFCs, `createAngularConfigs()` for Angular, or set `environment: "node"` for Node.js. Fragment order is significant: project overrides should remain last.
-
-## Options
-
-| Option            | Default     | Purpose                                                                    |
-| ----------------- | ----------- | -------------------------------------------------------------------------- |
-| `angular`         | `false`     | Enable Angular TypeScript and templates, or pass Angular-specific options. |
-| `environment`     | `"browser"` | Use `"browser"`, `"node"`, or `"universal"` globals.                       |
-| `globals`         | none        | Add globals supplied by a host platform or test runner.                    |
-| `gitignore`       | `true`      | Read ignore patterns from the project `.gitignore`.                        |
-| `ignores`         | `[]`        | Append project-specific global ignore patterns.                            |
-| `imports`         | `true`      | Enable import-x correctness and ordering rules.                            |
-| `javascript`      | `true`      | Process JavaScript and JSX files.                                          |
-| `json`            | `true`      | Enable recommended JSON, JSONC, and JSON5 rules.                           |
-| `markdown`        | `false`     | Enable the official Markdown language rules.                               |
-| `prettier`        | `true`      | Disable ESLint rules that conflict with Prettier.                          |
-| `react`           | `false`     | Enable React/JSX/Hooks, or pass runtime and React-version settings.        |
-| `regexp`          | `true`      | Enable recommended RegExp rules.                                           |
-| `rules`           | none        | Add exactly typed project rules to every enabled code file.                |
-| `sortPackageJson` | `false`     | Sort safe package.json keys without entering conditional `exports`.        |
-| `sortTsconfig`    | `false`     | Sort `tsconfig*.json` by TypeScript documentation topics.                  |
-| `typescript`      | `true`      | Disable it or pass `{ typeChecked: true, tsconfigRootDir }`.               |
-| `vue`             | `true`      | Enable Vue 3 single-file components.                                       |
-
-## Framework coverage
-
-Vue 3, React, and Angular have dedicated parsers or processors, presets, options, generated rule types, and integration tests. Nuxt can use the Vue base; Next.js and Remix can use the React base, then append their framework-specific Flat Config after `fastConfig()` when needed. React-compatible JSX runtimes can use `react.importSource`.
-
-Svelte, Astro, and Solid use different template or compiler semantics and are not presented as first-class integrations yet. Their official Flat Config can already be appended as a trailing override, but first-class switches should only be added together with the correct parser, processor, rule schemas, documentation, and runtime fixtures.
-
-## Lodash import policy
-
-Lodash policy is not a `fastConfig()` option. Import `createLodashConfigs()` from `@fast-china/eslint-config/configs` only when every static import should use one package:
+The base provides the shared JavaScript, type-aware TypeScript, JSON, Import, RegExp, manifest sorting, and Prettier compatibility. The React fragment adds `@eslint-react`, the official Hooks Recommended preset, and DOM safety rules without loading Vue or UniApp globals.
 
-- `createLodashConfigs("lodash-unified")` rejects static imports and re-exports from `lodash`, `lodash-es`, and their subpaths.
-- `createLodashConfigs("lodash")` rejects static imports and re-exports from `lodash-es`, `lodash-unified`, and their subpaths. The `lodash` root and `lodash/*` method imports remain valid.
-
-Choose `lodash-unified`:
-
-```sh
-pnpm add lodash-unified
-```
+React-compatible runtimes can pass recognition settings:
 
 ```js
-import { defineConfig } from "eslint/config";
-
-import fastChina from "@fast-china/eslint-config";
-import { createLodashConfigs } from "@fast-china/eslint-config/configs";
-import { cloneDeep, debounce } from "lodash-unified";
-
-export default defineConfig([...fastChina(), ...createLodashConfigs("lodash-unified")]);
+export default defineConfig([...createBaseConfigs(), ...createReactConfigs({ importSource: "preact", version: "detect" })]);
 ```
 
-Choose standard `lodash`:
-
-```sh
-pnpm add lodash
-pnpm add -D @types/lodash
-```
+## Angular
 
 ```js
+import { createBaseConfigs } from "@fast-china/eslint-config";
+import { createAngularConfigs } from "@fast-china/eslint-config/configs";
 import { defineConfig } from "eslint/config";
 
-import fastChina from "@fast-china/eslint-config";
-import { createLodashConfigs } from "@fast-china/eslint-config/configs";
-import debounce from "lodash/debounce";
-
-export default defineConfig([...fastChina(), ...createLodashConfigs("lodash")]);
+export default defineConfig([...createBaseConfigs(), ...createAngularConfigs()]);
 ```
 
-This fragment uses ESLint core `no-restricted-imports`, adds no plugin, and does not install Lodash for the project. It checks static `import`/`export` only, not dynamic `import()` or CommonJS `require()`. It is independent of the root factory's `imports` option.
-
-If a later `rules` record or file-scoped override sets `no-restricted-imports`, ESLint replaces this complete policy instead of merging its options. Projects that need additional package restrictions can import raw `preferLodashRules` or `preferLodashUnifiedRules` from `@fast-china/eslint-config/rules` and maintain one combined rule.
-
-## Exact rule types and completion
-
-The package generates `RuleOptions` from the JSON Schemas published by ESLint core and every bundled plugin. The identity helper `defineRules()` adds editor completion for rule names, severities, and options while rejecting misspelled rules and invalid options at type-checking time.
+The Angular fragment checks TypeScript source, external HTML templates, and component inline templates. Official template accessibility rules are enabled by default. Exceptional projects can still configure:
 
 ```js
-// @ts-check
-import fastChina, { defineRules } from "@fast-china/eslint-config";
-
-const projectRules = defineRules({
-	"@angular-eslint/template/alt-text": "error",
-	"@eslint-react/dom-no-missing-button-type": "error",
-	"@typescript-eslint/no-unused-vars": ["error", { args: "after-used" }],
-	"import-x/order": ["error", { "newlines-between": "never" }],
-	"react-hooks/exhaustive-deps": "warn",
-	"vue/attributes-order": ["error", { order: ["DEFINITION", "EVENTS", "CONTENT"] }],
+createAngularConfigs({
+	inlineTemplates: false,
+	templateAccessibility: false,
 });
-
-export default fastChina(
-	{ rules: projectRules },
-	{
-		files: ["**/*.generated.ts"],
-		name: "project/generated",
-		rules: defineRules({ "@typescript-eslint/no-unused-vars": "off" }),
-	}
-);
 ```
 
-TypeScript configuration and tooling code can use the generated interface directly:
+## Node.js / SDK
+
+Projects that do not need Vue, UniApp, React, or Angular use the base directly:
 
-```ts
-import type { RuleOptions } from "@fast-china/eslint-config";
+```js
+import { createBaseConfigs } from "@fast-china/eslint-config";
 
-const rules = {
-	"no-console": ["warn", { allow: ["warn", "error"] }],
-} satisfies RuleOptions;
+export default createBaseConfigs({ environment: "node" });
 ```
 
-The generated set covers ESLint core and plugins bundled by this package. Rules from additional project-installed plugins are outside this type set, and precision ultimately depends on the schema published by each rule.
+`createBaseConfigs()` always enables JavaScript, type-aware TypeScript, JSON, Import, RegExp, manifest sorting, `.gitignore`, and Prettier compatibility, but does not claim framework files.
 
-## Rule risk and maintenance
+## Markdown and Lodash
 
-The default includes a small set of high-impact rules. They can block particular patterns or require a review of import side effects, type-only imports, and public component events. React and Angular are disabled globally by default, but enabling them also enables their documented modern-framework and accessibility policies. Manifest sorting is high-impact and disabled by default. Source comments mark these decisions as `[高影响]`, `[可自动修复]`, `[安全关注]`, or `[按需启用]`.
+Markdown composes explicitly:
 
-See the [default-rule and risk guide](./docs/rules-risk.md) for inherited presets, the high-impact inventory, scoped override examples, and the maintenance contract. Run a read-only lint before `eslint --fix`, apply fixes in an isolated commit, and review imports, `package.json`, component events, and build output.
+```js
+import { createBaseConfigs } from "@fast-china/eslint-config";
+import { createMarkdownConfigs } from "@fast-china/eslint-config/configs";
+import { defineConfig } from "eslint/config";
 
-## Project overrides
+export default defineConfig([...createBaseConfigs(), ...createMarkdownConfigs()]);
+```
 
-Put common overrides in `rules`, and pass file-scoped overrides as later arguments. Later configurations take precedence:
+Lodash static-import policies are also standalone:
 
 ```js
-import fastChina, { defineRules } from "@fast-china/eslint-config";
+import { createLodashConfigs } from "@fast-china/eslint-config/configs";
 
-export default fastChina(
-	{
-		rules: {
-			"no-console": "warn",
-		},
-	},
-	{
-		files: ["**/{scripts,tests}/**/*.{js,ts}"],
-		name: "project/node-files",
-		rules: defineRules({ "no-console": "off" }),
-	}
-);
+createLodashConfigs("lodash");
+createLodashConfigs("lodash-unified");
 ```
 
-The root entry exports only `fastConfig`, `defaultConfigOptions`, `defineRules`, `FastConfigOptions`, and `RuleOptions`. Advanced composition uses focused subpaths instead of widening the root API:
+## Public entries
 
-- `@fast-china/eslint-config/configs` exports every configuration creator and its option types.
-- `@fast-china/eslint-config/constants` exports all maintained file globs.
-- `@fast-china/eslint-config/rules` exports the fully commented raw rule records and `RuleOptions`.
+The root entry exports only:
 
-```js
-import { defineConfig } from "eslint/config";
+- The default Vue 3 + TypeScript + UniApp Flat Config.
+- `fastConfig`, `createBaseConfigs`, and `FastConfigOptions`.
+- `defineRules` and `RuleOptions`.
 
-import { createCommonConfigs, createTypeScriptConfigs } from "@fast-china/eslint-config/configs";
-import { GLOBS_TYPESCRIPT } from "@fast-china/eslint-config/constants";
+Focused subpaths provide advanced composition:
 
-export default defineConfig([...createCommonConfigs(GLOBS_TYPESCRIPT), ...createTypeScriptConfigs({ typeChecked: true })]);
-```
+- `@fast-china/eslint-config/configs`: framework and capability fragments.
+- `@fast-china/eslint-config/constants`: file globs and UniApp globals.
+- `@fast-china/eslint-config/rules`: typed raw rule records.
 
 ## Prettier
 
-Prettier is intentionally not a peer dependency and is not executed as an ESLint rule. Install and run it separately if the project uses it:
+Prettier does not run as an ESLint rule. The default only loads `eslint-config-prettier` to disable conflicting rules. Install and run formatting separately:
 
 ```sh
 pnpm add -D prettier
 pnpm exec prettier --check .
 ```
 
-Set `prettier: false` if another formatter or stylistic rule set should remain fully in control.
-
 ## Documentation
 
 - [Default rules and risk guide](./docs/rules-risk.md)
-- [Engineering audit (Chinese)](./docs/engineering-audit.zh.md)
+- [Engineering quality audit](./docs/engineering-audit.zh.md)
 - [Contributing guide](./CONTRIBUTING.md)
 - [Security policy](./SECURITY.md)
 - [Changelog](./CHANGELOG.md)
@@ -356,9 +230,7 @@ pnpm check
 pnpm pack --dry-run
 ```
 
-Use `pnpm dev` to inspect the active Flat Config interactively while changing factories or rules.
-
-Run `pnpm typegen` after upgrading ESLint or a plugin and commit `src/typegen.d.ts`; never edit the generated file manually. `pnpm test` rebuilds the package before running consumer type-contract, runtime integration, and package-contract tests. `pnpm check` adds source type-checking, full-repository linting, and formatting verification.
+Run `pnpm typegen` after upgrading ESLint or plugins and commit `src/typegen.d.ts`. `pnpm check` verifies types, builds, runtime behavior, package contracts, ESLint, and formatting.
 
 ## License