@coryrylan/tools 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cory Rylan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,193 @@
+# @coryrylan/tools
+
+Shared tooling configs - ESLint, Prettier, Stylelint, Vale, Vite, and
+Vitest - plus custom ESLint rules for keeping codebases maintainable when
+coding agents are the primary contributors.
+
+## Philosophy
+
+When an agent is the one writing most of a diff, prose instructions living in
+an `AGENTS.md` file are advisory at best. They have to be loaded into
+context, correctly interpreted, and remembered turns later, and none of that
+is guaranteed on any given run. Prose decays: it drifts out of context, gets
+skimmed instead of read, or is outweighed by whatever the agent is focused on
+in the moment. A lint rule has none of these failure modes: it runs on every
+diff, every time, and fails the build instead of hoping to be noticed. Every
+rule and every shared config in this package exists to replace a paragraph an
+agent would otherwise have to read (and might ignore, forget, or misapply)
+with a deterministic check or preset that gates the diff instead.
+
+## Surfaces
+
+| Entry                                            | What it ships                                                                    |
+| ------------------------------------------------ | -------------------------------------------------------------------------------- |
+| `@coryrylan/tools/eslint`                        | Flat configs plus the custom `tools/*` rule plugin.                              |
+| `@coryrylan/tools/prettier`                      | The shared Prettier config.                                                      |
+| `@coryrylan/tools/stylelint`                     | Shared Stylelint config (standard + logical properties + design-token checks).   |
+| `@coryrylan/tools/vite`                          | `createNodeLibraryBuildConfig` / `createBrowserLibraryBuildConfig` factories.    |
+| `@coryrylan/tools/vite/plugins/write-if-changed` | Vite plugin that skips writing chunks whose content didn't change.               |
+| `@coryrylan/tools/vite/plugins/dts`              | Vite plugin that runs the consumer's TypeScript compiler for declaration output. |
+| `@coryrylan/tools/vitest`                        | `nodeTestConfig` preset for node-environment unit tests.                         |
+| `@coryrylan/tools/vitest/browser`                | `browserTestConfig` preset for browser-mode (Playwright Chromium) tests.         |
+| `dist/vale/`                                     | Vale starter kit: ini template plus shared accept/reject vocabulary.             |
+
+## ESLint
+
+```sh
+pnpm add -D eslint @coryrylan/tools typescript typescript-eslint
+```
+
+The remaining peers (`@eslint/js`, `@eslint/json`, `eslint-plugin-jsdoc`)
+install automatically as regular peer dependencies under pnpm 10 or npm.
+Yarn users should add them to `devDependencies` explicitly.
+
+```js
+// eslint.config.js
+import { typescriptConfig, jsonConfig } from '@coryrylan/tools/eslint';
+
+export default [...typescriptConfig, ...jsonConfig];
+```
+
+A default export is also available if you'd rather reach into the plugin and
+config map directly: `import agentLintRules from '@coryrylan/tools/eslint'`
+exposes `{ plugin, configs }`, where `configs` is keyed by `typescript`, `tests`, `browser`, `html`, and `json`.
+
+### Configs
+
+| Config             | What it enables                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | Requirements                                                                                            |
+| ------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- |
+| `typescriptConfig` | On all JS/TS files: size/complexity budgets (`complexity` 8, `max-depth` 3, `max-params` 3, `max-lines` 500, `max-statements` 15, `max-lines-per-function` 50, `max-nested-callbacks` 3) plus `eqeqeq`, `prefer-const`, `no-shadow`, `no-warning-comments`, `no-param-reassign`, and friends, and 5 syntax-only `tools/*` rules. On TS files: type-aware `strictTypeChecked`, plus `@typescript-eslint/no-floating-promises`, `only-throw-error`, `consistent-type-imports`, `switch-exhaustiveness-check`, `explicit-member-accessibility` (`no-public`), a `#private`-over-`private` selector, `no-explicit-any`, `no-unnecessary-boolean-literal-compare`, `jsdoc` checks (`informative-docs`, `no-types`, `valid-types`, `check-tag-names`), and the type-aware `tools/no-deep-class-inheritance` rule. The default starting point for a new agent-maintained project - relax specific rules per-project rather than swapping this config out. | `typescript-eslint`, `eslint-plugin-jsdoc`, `typescript >=5.5.0 <6.1.0`, `parserOptions.projectService` |
+| `testsConfig`      | Relaxes size/complexity budgets (`max-lines`, `max-lines-per-function`, `max-statements`, `max-nested-callbacks`, unused-expression checks) for `*.test.*` / `*.spec.*` files.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | combine with another config                                                                             |
+| `browserConfig`    | `globalThis`-over-`window`/`document`/`location` restrictions, plus 3 cleanup rules (`require-listener-cleanup`, `require-observer-cleanup`, `require-timer-cleanup`).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | none extra                                                                                              |
+| `htmlConfig`       | `@html-eslint` recommended structural rules for `*.html` files (duplicate ids/attrs, obsolete tags, `lang`/`alt` requirements, baseline feature checks), with pure-formatting rules off in favor of Prettier and frontmatter-aware parsing for static-site templates.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | `@html-eslint/eslint-plugin`, `@html-eslint/parser`                                                     |
+| `jsonConfig`       | `@eslint/json` structural rules for `*.json` (JSONC variant for `tsconfig*.json`), plus `no-unpinned-dependency-ranges` scoped to `package.json`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | `@eslint/json`                                                                                          |
+
+### Rules
+
+| Rule                                                                                                | What it catches                                                                                                                                        | Enabled by   |
+| --------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | ------------ |
+| [`tools/no-dead-code`](./src/eslint/docs/rules/no-dead-code.md)                                     | Disallow commented-out source code left behind in comments.                                                                                            | `typescript` |
+| [`tools/no-deep-class-inheritance`](./src/eslint/docs/rules/no-deep-class-inheritance.md)           | Disallow class inheritance chains deeper than a configured maximum.                                                                                    | `typescript` |
+| [`tools/no-single-consumer-abstraction`](./src/eslint/docs/rules/no-single-consumer-abstraction.md) | Disallow exported abstractions (base classes) with fewer than two implementation consumers.                                                            | `typescript` |
+| [`tools/no-unjustified-disable`](./src/eslint/docs/rules/no-unjustified-disable.md)                 | Require every `eslint-disable*` directive to carry a reason (and, by default, an explicit rule list).                                                  | `typescript` |
+| [`tools/no-reexport-barrels`](./src/eslint/docs/rules/no-reexport-barrels.md)                       | Flag files that re-export from more than a configured number of modules.                                                                               | `typescript` |
+| [`tools/consistent-error-messages`](./src/eslint/docs/rules/consistent-error-messages.md)           | Require thrown/constructed `Error`s to carry a non-empty, informative message.                                                                         | `typescript` |
+| [`tools/require-listener-cleanup`](./src/eslint/docs/rules/require-listener-cleanup.md)             | Require a matching `removeEventListener` for every `addEventListener` added in a setup lifecycle method; forbid `addEventListener` in the constructor. | `browser`    |
+| [`tools/require-observer-cleanup`](./src/eslint/docs/rules/require-observer-cleanup.md)             | Flag `ResizeObserver`/`MutationObserver`/`IntersectionObserver`/`PerformanceObserver` instances created without storing a reference.                   | `browser`    |
+| [`tools/require-timer-cleanup`](./src/eslint/docs/rules/require-timer-cleanup.md)                   | Flag `setInterval` handles that are never stored or never cleared.                                                                                     | `browser`    |
+| [`tools/no-unpinned-dependency-ranges`](./src/eslint/docs/rules/no-unpinned-dependency-ranges.md)   | Require `package.json` dependency version specifiers appropriate to the package's publish status and dependency kind.                                  | `json`       |
+
+## Prettier
+
+```sh
+pnpm add -D @coryrylan/tools prettier
+```
+
+Reference the config straight from `package.json`:
+
+```json
+{ "prettier": "@coryrylan/tools/prettier" }
+```
+
+Or import and spread it in a `prettier.config.js` to override options.
+Embedded template literals stay hand-formatted
+(`embeddedLanguageFormatting: 'off'`). See
+[src/prettier/docs](./src/prettier/docs/index.md).
+
+## Stylelint
+
+```sh
+pnpm add -D @coryrylan/tools stylelint stylelint-config-standard
+```
+
+```js
+// stylelint.config.js
+export { default } from '@coryrylan/tools/stylelint';
+```
+
+Layers `stylelint-config-standard` with logical-property enforcement (no
+physical `margin-*`/`padding-*`) and design-token checks (no hardcoded pixel
+values in spacing properties). See
+[src/stylelint/docs](./src/stylelint/docs/index.md).
+
+## Vale
+
+Install the Vale binary (`mise use vale`, or brew), then point a `.vale.ini`
+at the styles this package ships:
+
+```ini
+StylesPath = node_modules/@coryrylan/tools/dist/vale/styles
+Vocab = Tools
+Packages = Google, write-good
+```
+
+Run `vale sync` once to download the style packages. The full template with
+per-filetype sections lives at [src/vale/vale.ini](./src/vale/vale.ini). See
+[src/vale/docs](./src/vale/docs/index.md).
+
+## Vite
+
+```sh
+pnpm add -D @coryrylan/tools vite
+```
+
+```ts
+// vite.config.ts
+import { defineConfig, mergeConfig } from 'vite';
+import { createNodeLibraryBuildConfig } from '@coryrylan/tools/vite';
+
+export default defineConfig(mergeConfig(createNodeLibraryBuildConfig({ entry: { index: 'src/index.ts' } }), {}));
+```
+
+ESM-only, every bare specifier externalized, `preserveModules` for deep
+imports, no minification. The `write-if-changed` and `dts` plugins ship as
+deep imports under `@coryrylan/tools/vite/plugins/`. See
+[src/vite/docs](./src/vite/docs/index.md).
+
+## Vitest
+
+```sh
+pnpm add -D @coryrylan/tools vitest
+```
+
+```ts
+// vitest.config.ts
+import { defineConfig } from 'vitest/config';
+import { nodeTestConfig } from '@coryrylan/tools/vitest';
+
+export default defineConfig(nodeTestConfig);
+```
+
+`@coryrylan/tools/vitest/browser` exports `browserTestConfig` for real-Chromium
+browser-mode tests (requires the optional `@vitest/browser-playwright`,
+`@vitest/coverage-istanbul`, and `playwright` peers) with istanbul coverage
+gated at 90% across lines, branches, functions, and statements. See
+[src/vitest/docs](./src/vitest/docs/index.md).
+
+## Peer dependencies
+
+Every peer beyond `eslint` is scoped to the surface that needs it; the
+non-ESLint peers are marked optional, so install them with the surface you
+use.
+
+- `typescript` must satisfy `>=5.5.0 <6.1.0` for type-aware linting
+  (`typescriptConfig`) - this is the range `typescript-eslint`
+  supports; newer `typescript` majors are not yet compatible with type-aware
+  rules here. Note that a bare `pnpm add -D typescript` resolves to 7.x
+  (the native compiler, which no longer ships the JS compiler API
+  `typescript-eslint` needs), so install an explicit `typescript@6` until
+  `typescript-eslint` supports 7.
+- `typescript-eslint >=8.40.0` and `eslint-plugin-jsdoc >=60.0.0` are only
+  needed if you use `typescriptConfig`.
+- `@eslint/json >=0.13.0` is only needed if you use `jsonConfig`.
+- `@html-eslint/eslint-plugin >=0.61.0` and `@html-eslint/parser >=0.61.0` are
+  only needed if you use `htmlConfig`.
+- `prettier >=3` for the Prettier config; `stylelint >=17` and
+  `stylelint-config-standard >=40` for the Stylelint config.
+- `vite >=8` for the Vite factories and plugins; `vitest >=4` for the test
+  presets, plus `@vitest/browser-playwright >=4`, `@vitest/coverage-istanbul >=4`,
+  and `playwright >=1.50` for `browserTestConfig`.
+
+## License
+
+MIT - see [LICENSE](./LICENSE). Copyright (c) 2026 Cory Rylan.

package/dist/eslint/configs/browser.d.ts

@@ -0,0 +1,12 @@
+import type { Linter } from 'eslint';
+/**
+ * Flags direct references to browser globals that silently assume a
+ * `window`-backed environment. Agents reach for `window`/`document` out of
+ * habit; the `globalThis`-qualified form works in browser, SSR, and worker
+ * contexts alike, so there is nothing to rewrite later.
+ *
+ * Also wires in the `tools/*` cleanup rules - listener, observer, and timer
+ * teardown are all browser/DOM-lifecycle concerns, so they live alongside
+ * the SSR-safety check rather than in `typescriptConfig`.
+ */
+export declare const browserConfig: Linter.Config[];

package/dist/eslint/configs/browser.js

@@ -0,0 +1,40 @@
+import { plugin } from "../plugin.js";
+import { globalIgnores, jsTsFiles } from "./shared.js";
+//#region src/eslint/configs/browser.ts
+var ssrSafeMessage = (globalName) => `Use ${globalName} instead of the bare global so this code stays safe to run outside a full browser window (SSR, workers, tests).`;
+/**
+* Flags direct references to browser globals that silently assume a
+* `window`-backed environment. Agents reach for `window`/`document` out of
+* habit; the `globalThis`-qualified form works in browser, SSR, and worker
+* contexts alike, so there is nothing to rewrite later.
+*
+* Also wires in the `tools/*` cleanup rules - listener, observer, and timer
+* teardown are all browser/DOM-lifecycle concerns, so they live alongside
+* the SSR-safety check rather than in `typescriptConfig`.
+*/
+var browserConfig = [globalIgnores, {
+	files: jsTsFiles,
+	plugins: { tools: plugin },
+	rules: {
+		"no-restricted-globals": [
+			"error",
+			{
+				name: "window",
+				message: ssrSafeMessage("globalThis")
+			},
+			{
+				name: "location",
+				message: ssrSafeMessage("globalThis.location")
+			},
+			{
+				name: "document",
+				message: ssrSafeMessage("globalThis.document")
+			}
+		],
+		"tools/require-listener-cleanup": "error",
+		"tools/require-observer-cleanup": "error",
+		"tools/require-timer-cleanup": "error"
+	}
+}];
+//#endregion
+export { browserConfig };

package/dist/eslint/configs/html.d.ts

@@ -0,0 +1,10 @@
+import type { Linter } from 'eslint';
+/**
+ * Structural and correctness rules for HTML files: `@html-eslint`
+ * recommended (duplicate ids/attrs, obsolete tags, `lang`/`alt`
+ * requirements, baseline feature checks, ...) with the pure-formatting
+ * rules turned off - Prettier owns formatting. `frontmatter: true` lets
+ * static-site templates (11ty and similar) carry YAML frontmatter without
+ * tripping the parser.
+ */
+export declare const htmlConfig: Linter.Config[];

package/dist/eslint/configs/html.js

@@ -0,0 +1,38 @@
+import { globalIgnores } from "./shared.js";
+import html from "@html-eslint/eslint-plugin";
+import htmlParser from "@html-eslint/parser";
+//#region src/eslint/configs/html.ts
+/**
+* Structural and correctness rules for HTML files: `@html-eslint`
+* recommended (duplicate ids/attrs, obsolete tags, `lang`/`alt`
+* requirements, baseline feature checks, ...) with the pure-formatting
+* rules turned off - Prettier owns formatting. `frontmatter: true` lets
+* static-site templates (11ty and similar) carry YAML frontmatter without
+* tripping the parser.
+*/
+var htmlConfig = [globalIgnores, {
+	files: ["**/*.html"],
+	languageOptions: {
+		parser: htmlParser,
+		parserOptions: { frontmatter: true }
+	},
+	plugins: { html },
+	rules: {
+		...html.configs.recommended.rules,
+		"html/require-doctype": "off",
+		"html/require-title": "off",
+		"html/no-extra-spacing-text": "error",
+		"html/quotes": "off",
+		"html/no-extra-spacing-attrs": "off",
+		"html/indent": "off",
+		"html/require-closing-tags": "off",
+		"html/element-newline": "off",
+		"html/no-extra-spacing-tags": "off",
+		"html/attrs-newline": ["error", {
+			closeStyle: "sameline",
+			ifAttrsMoreThan: 10
+		}]
+	}
+}];
+//#endregion
+export { htmlConfig };

package/dist/eslint/configs/json.d.ts

@@ -0,0 +1,13 @@
+import type { Linter } from 'eslint';
+/**
+ * Structural correctness for JSON files (duplicate keys, unsafe numeric
+ * values, ...) - the same class of "syntactically valid but semantically
+ * broken" failure the JS/TS configs guard against, just for manifests and
+ * config files. `tsconfig*.json` gets the JSONC variant since it commonly
+ * carries comments.
+ *
+ * `package.json` additionally gets the `tools/no-unpinned-dependency-ranges`
+ * check, scoped separately since it only applies to that one filename, not
+ * JSON generally.
+ */
+export declare const jsonConfig: Linter.Config[];

package/dist/eslint/configs/json.js

@@ -0,0 +1,39 @@
+import { plugin } from "../plugin.js";
+import { globalIgnores } from "./shared.js";
+import json from "@eslint/json";
+//#region src/eslint/configs/json.ts
+/**
+* Structural correctness for JSON files (duplicate keys, unsafe numeric
+* values, ...) - the same class of "syntactically valid but semantically
+* broken" failure the JS/TS configs guard against, just for manifests and
+* config files. `tsconfig*.json` gets the JSONC variant since it commonly
+* carries comments.
+*
+* `package.json` additionally gets the `tools/no-unpinned-dependency-ranges`
+* check, scoped separately since it only applies to that one filename, not
+* JSON generally.
+*/
+var jsonConfig = [
+	globalIgnores,
+	{
+		files: ["**/*.json"],
+		ignores: ["**/tsconfig*.json", "**/tsconfig.*.json"],
+		language: "json/json",
+		plugins: { json },
+		rules: { ...json.configs.recommended.rules }
+	},
+	{
+		files: ["**/tsconfig*.json", "**/tsconfig.*.json"],
+		language: "json/jsonc",
+		plugins: { json },
+		rules: { ...json.configs.recommended.rules }
+	},
+	{
+		files: ["**/package.json"],
+		language: "json/json",
+		plugins: { tools: plugin },
+		rules: { "tools/no-unpinned-dependency-ranges": "error" }
+	}
+];
+//#endregion
+export { jsonConfig };

package/dist/eslint/configs/shared.d.ts

@@ -0,0 +1,11 @@
+import type { Linter } from 'eslint';
+export declare const jsTsFiles: string[];
+export declare const tsFiles: string[];
+/**
+ * A standalone `ignores`-only config entry, meant to be the first element of
+ * every exported config array. ESLint only treats an `ignores` entry as a
+ * *global* ignore when no other keys (`files`, `rules`, ...) share the same
+ * object - merging them in turns it into a file-scoped ignore instead of a
+ * global one. https://github.com/eslint/eslint/discussions/18304
+ */
+export declare const globalIgnores: Linter.Config;

package/dist/eslint/configs/shared.js

@@ -0,0 +1,19 @@
+//#region src/eslint/configs/shared.ts
+var jsTsFiles = ["**/*.{js,ts}"];
+var tsFiles = ["**/*.ts"];
+/**
+* A standalone `ignores`-only config entry, meant to be the first element of
+* every exported config array. ESLint only treats an `ignores` entry as a
+* *global* ignore when no other keys (`files`, `rules`, ...) share the same
+* object - merging them in turns it into a file-scoped ignore instead of a
+* global one. https://github.com/eslint/eslint/discussions/18304
+*/
+var globalIgnores = { ignores: [
+	"**/node_modules/**",
+	"**/dist/**",
+	"**/build/**",
+	"**/coverage/**",
+	"**/.wireit/**"
+] };
+//#endregion
+export { globalIgnores, jsTsFiles, tsFiles };

package/dist/eslint/configs/tests.d.ts

@@ -0,0 +1,8 @@
+import type { Linter } from 'eslint';
+/**
+ * Relaxes size/complexity limits that make sense for source files but are
+ * routinely and legitimately exceeded by thorough tests (long `describe`
+ * blocks, many assertions, `expect(x).to.be.true` style unused-expression
+ * patterns).
+ */
+export declare const testsConfig: Linter.Config[];

package/dist/eslint/configs/tests.js

@@ -0,0 +1,20 @@
+import { globalIgnores } from "./shared.js";
+/**
+* Relaxes size/complexity limits that make sense for source files but are
+* routinely and legitimately exceeded by thorough tests (long `describe`
+* blocks, many assertions, `expect(x).to.be.true` style unused-expression
+* patterns).
+*/
+var testsConfig = [globalIgnores, {
+	files: ["**/*.test.*", "**/*.spec.*"],
+	rules: {
+		"max-lines": "off",
+		"max-lines-per-function": "off",
+		"max-statements": "off",
+		"max-nested-callbacks": "off",
+		"no-unused-expressions": "off",
+		"@typescript-eslint/no-unused-expressions": "off"
+	}
+}];
+//#endregion
+export { testsConfig };

package/dist/eslint/configs/typescript.d.ts

@@ -0,0 +1,18 @@
+import type { Linter } from 'eslint';
+/**
+ * The full, no-exceptions config, in two entries. The first is non-type-aware
+ * and applies to all JS/TS files: `@eslint/js` recommended plus size and
+ * complexity limits that keep any single generated file or function within a
+ * range a reviewer (human or agent) can actually hold in their head, and the
+ * syntax-only `tools/*` rules. The second is type-aware and scoped to TS
+ * files: `typescript-eslint` `strictTypeChecked`, JSDoc checks, and the
+ * `tools/*` rules that need type information - currently just
+ * `no-deep-class-inheritance`, which resolves each superclass's own
+ * declaration via the type checker. It requires
+ * `parserOptions.projectService` to resolve type information, which makes it
+ * comparatively slow (e.g. pre-commit, CI).
+ *
+ * Meant as the default for new agent-maintained projects - relax specific
+ * rules per-project rather than swapping this config out wholesale.
+ */
+export declare const typescriptConfig: Linter.Config[];

package/dist/eslint/configs/typescript.js

@@ -0,0 +1,104 @@
+import { plugin } from "../plugin.js";
+import { globalIgnores, jsTsFiles, tsFiles } from "./shared.js";
+import js from "@eslint/js";
+import tseslint from "typescript-eslint";
+import jsdoc from "eslint-plugin-jsdoc";
+//#region src/eslint/configs/typescript.ts
+/**
+* Flattens `strictTypeChecked`'s config array (base + eslint-recommended +
+* strict-type-checked) into a single rules record, the same way a project
+* would when folding it into one flat-config entry alongside custom rules.
+*/
+var strictTypeCheckedRules = tseslint.configs.strictTypeChecked.reduce((rules, config) => ({
+	...rules,
+	...config.rules
+}), {});
+/**
+* The full, no-exceptions config, in two entries. The first is non-type-aware
+* and applies to all JS/TS files: `@eslint/js` recommended plus size and
+* complexity limits that keep any single generated file or function within a
+* range a reviewer (human or agent) can actually hold in their head, and the
+* syntax-only `tools/*` rules. The second is type-aware and scoped to TS
+* files: `typescript-eslint` `strictTypeChecked`, JSDoc checks, and the
+* `tools/*` rules that need type information - currently just
+* `no-deep-class-inheritance`, which resolves each superclass's own
+* declaration via the type checker. It requires
+* `parserOptions.projectService` to resolve type information, which makes it
+* comparatively slow (e.g. pre-commit, CI).
+*
+* Meant as the default for new agent-maintained projects - relax specific
+* rules per-project rather than swapping this config out wholesale.
+*/
+var typescriptConfig = [
+	globalIgnores,
+	{
+		files: jsTsFiles,
+		plugins: { tools: plugin },
+		rules: {
+			...js.configs.recommended.rules,
+			complexity: ["error", { max: 8 }],
+			"max-depth": ["error", 3],
+			"max-params": ["error", 3],
+			"max-lines": ["error", 500],
+			"max-statements": ["error", 15],
+			"max-lines-per-function": ["error", 50],
+			"max-nested-callbacks": ["error", 3],
+			"max-statements-per-line": ["error", { max: 1 }],
+			eqeqeq: "error",
+			"prefer-const": "error",
+			"no-param-reassign": "error",
+			"no-useless-return": "error",
+			"no-useless-catch": "error",
+			"no-warning-comments": "error",
+			"no-shadow": "error",
+			"no-implicit-globals": "error",
+			"no-restricted-imports": ["error", { patterns: ["**/dist/**", "**/node_modules/**"] }],
+			"id-length": ["error", {
+				min: 2,
+				exceptions: ["_"]
+			}],
+			"tools/no-dead-code": "error",
+			"tools/no-single-consumer-abstraction": "error",
+			"tools/no-unjustified-disable": "error",
+			"tools/no-reexport-barrels": "error",
+			"tools/consistent-error-messages": "error"
+		}
+	},
+	{
+		files: tsFiles,
+		plugins: {
+			"@typescript-eslint": tseslint.plugin,
+			jsdoc,
+			tools: plugin
+		},
+		languageOptions: {
+			parser: tseslint.parser,
+			parserOptions: { projectService: true }
+		},
+		rules: {
+			...strictTypeCheckedRules,
+			"tools/no-deep-class-inheritance": "error",
+			"no-shadow": "off",
+			"@typescript-eslint/no-shadow": "error",
+			"@typescript-eslint/no-explicit-any": "error",
+			"@typescript-eslint/no-floating-promises": "error",
+			"@typescript-eslint/only-throw-error": "error",
+			"@typescript-eslint/consistent-type-imports": "error",
+			"@typescript-eslint/switch-exhaustiveness-check": "error",
+			"@typescript-eslint/explicit-member-accessibility": ["error", { accessibility: "no-public" }],
+			"@typescript-eslint/no-unnecessary-boolean-literal-compare": "error",
+			"@typescript-eslint/prefer-readonly": "error",
+			"@typescript-eslint/explicit-module-boundary-types": "error",
+			"no-restricted-syntax": ["error", {
+				selector: ":matches(PropertyDefinition, MethodDefinition)[accessibility=\"private\"]:not(:has(Decorator)):not([kind=\"constructor\"])",
+				message: "Use #private instead of the `private` keyword - it is enforced at runtime, not just by the type checker."
+			}],
+			"jsdoc/no-types": "error",
+			"jsdoc/valid-types": "error",
+			"jsdoc/check-tag-names": "error",
+			"jsdoc/informative-docs": "error"
+		}
+	}
+];
+//#endregion
+export { typescriptConfig };

package/dist/eslint/index.d.ts

@@ -0,0 +1,27 @@
+import type { ESLint, Linter } from 'eslint';
+import { plugin } from './plugin.js';
+export { typescriptConfig } from './configs/typescript.js';
+export { testsConfig } from './configs/tests.js';
+export { htmlConfig } from './configs/html.js';
+export { jsonConfig } from './configs/json.js';
+export { browserConfig } from './configs/browser.js';
+/**
+ * The `tools/*` rule registry every config below wires in under the
+ * `tools` namespace (alongside `@typescript-eslint`/`jsdoc`/etc.). Defined
+ * in `./plugin.js` - a separate module - so the configs can import the same
+ * plugin instance directly without a circular import through this file.
+ */
+export { plugin };
+interface ConfigsMap {
+    readonly typescript: Linter.Config[];
+    readonly tests: Linter.Config[];
+    readonly html: Linter.Config[];
+    readonly json: Linter.Config[];
+    readonly browser: Linter.Config[];
+}
+interface AgentLintRules {
+    readonly plugin: ESLint.Plugin;
+    readonly configs: ConfigsMap;
+}
+declare const agentLintRules: AgentLintRules;
+export default agentLintRules;

package/dist/eslint/index.js

@@ -0,0 +1,19 @@
+import { plugin } from "./plugin.js";
+import { typescriptConfig } from "./configs/typescript.js";
+import { testsConfig } from "./configs/tests.js";
+import { htmlConfig } from "./configs/html.js";
+import { jsonConfig } from "./configs/json.js";
+import { browserConfig } from "./configs/browser.js";
+//#region src/eslint/index.ts
+var agentLintRules = {
+	plugin,
+	configs: {
+		typescript: typescriptConfig,
+		tests: testsConfig,
+		html: htmlConfig,
+		json: jsonConfig,
+		browser: browserConfig
+	}
+};
+//#endregion
+export { browserConfig, agentLintRules as default, htmlConfig, jsonConfig, plugin, testsConfig, typescriptConfig };

package/dist/eslint/plugin.d.ts

@@ -0,0 +1,8 @@
+import type { ESLint } from 'eslint';
+/**
+ * The `tools/*` rule registry, shared by every config in `./configs/*.ts`
+ * under the `tools` namespace. Lives in its own module (rather than
+ * `index.ts`, where it was previously declared empty) so the configs can
+ * import it directly without a circular import back through `index.ts`.
+ */
+export declare const plugin: ESLint.Plugin;