dlinter-ts-react 0.2.0

package/dist/index.mjs

@@ -0,0 +1,775 @@
+import tsParser from "@typescript-eslint/parser";
+import js from "@eslint/js";
+import tsPlugin from "@typescript-eslint/eslint-plugin";
+import { createTypeScriptImportResolver } from "eslint-import-resolver-typescript";
+import checkFilePlugin from "eslint-plugin-check-file";
+import { createNodeResolver, importX } from "eslint-plugin-import-x";
+import jsdocPlugin from "eslint-plugin-jsdoc";
+import reactPlugin from "eslint-plugin-react";
+import reactDoctor from "eslint-plugin-react-doctor";
+import reactHooksPlugin from "eslint-plugin-react-hooks";
+import sonarjsPlugin from "eslint-plugin-sonarjs";
+import { existsSync } from "node:fs";
+import path from "node:path";
+//#region src/configs/dumb-ui.ts
+/**
+* Dumb UI preset: every `.tsx` file is presentational. Side effects live in
+* the colocated `use-*.ts` hook, never in the view.
+* @param plugin - the dlinter plugin instance the config registers itself with.
+* @returns flat config entries scoped to view files.
+*/
+function createDumbUiConfig(plugin) {
+	return [{
+		name: "dlinter/dumb-ui",
+		files: ["**/*.tsx"],
+		languageOptions: {
+			parser: tsParser,
+			ecmaVersion: "latest",
+			sourceType: "module",
+			parserOptions: { ecmaFeatures: { jsx: true } }
+		},
+		plugins: { dlinter: plugin },
+		rules: { "dlinter/no-view-effects": "error" }
+	}];
+}
+//#endregion
+//#region src/rules/composition-only-delivery.ts
+const reactHookNamePattern = "^use(State|Reducer|Effect|LayoutEffect|InsertionEffect|SyncExternalStore|Memo|Callback|Ref|Context|Transition|DeferredValue|ImperativeHandle|DebugValue|Id|Optimistic|ActionState)?$";
+const customHookModulePattern = /(^|\/)use-[^/]+$/u;
+/**
+* Delivery Layer Rule: delivery files (App.tsx, app/**) compose feature
+* entrypoints — they never orchestrate. No React hooks, no custom hook
+* imports; screen logic belongs in feature hooks and components.
+*/
+const compositionOnlyDelivery = {
+	meta: {
+		type: "problem",
+		docs: { description: "restrict delivery-layer files to pure composition" },
+		messages: {
+			reactHookImport: "Delivery Rule: composition files cannot import React hooks. Move screen logic into feature hooks or components.",
+			reactHookNamespace: "Delivery Rule: composition files cannot call React hooks through the React namespace. Move screen logic into feature hooks or components.",
+			customHookImport: "Delivery Rule: composition files cannot import custom hooks directly. Render a feature entrypoint component instead."
+		},
+		schema: []
+	},
+	create(context) {
+		return {
+			[`ImportDeclaration[source.value='react'] ImportSpecifier[imported.name=/${reactHookNamePattern}/]`](node) {
+				context.report({
+					node,
+					messageId: "reactHookImport"
+				});
+			},
+			[`MemberExpression[object.name='React'][property.name=/${reactHookNamePattern}/]`](node) {
+				context.report({
+					node,
+					messageId: "reactHookNamespace"
+				});
+			},
+			ImportDeclaration(node) {
+				if (customHookModulePattern.test(String(node.source.value))) context.report({
+					node,
+					messageId: "customHookImport"
+				});
+			}
+		};
+	}
+};
+//#endregion
+//#region src/rules/folder-ownership.ts
+const roleSuffixes = [
+	".constants.ts",
+	".helpers.ts",
+	".schema.ts",
+	".types.ts"
+];
+/**
+* Split Module Ownership Rule: when a main module splits into role files
+* (`*.helpers.ts`, `*.types.ts`, `*.constants.ts`, `*.schema.ts`), the whole
+* unit moves into a folder named after the module with a pure `index.ts`
+* entrypoint. Sibling detection reads the real filesystem, so the rule guards
+* its own scope: role files, `index.ts`, and declaration files are skipped
+* regardless of config globs.
+*/
+const folderOwnership = {
+	meta: {
+		type: "problem",
+		docs: { description: "require folder-owned entrypoints for main modules split into role files" },
+		messages: {
+			flatSplitModule: "Split module ownership: flat main modules with sibling role files must move into a dedicated folder with a pure index.ts entrypoint.",
+			missingFolderIndex: "Split module ownership: folder-owned modules with role files must publish a pure index.ts entrypoint in the same folder."
+		},
+		schema: []
+	},
+	create(context) {
+		return { Program(node) {
+			const filename = context.filename;
+			const baseName = path.basename(filename);
+			if (!baseName.endsWith(".ts") || baseName.endsWith(".d.ts") || baseName === "index.ts" || roleSuffixes.some((suffix) => baseName.endsWith(suffix))) return;
+			const moduleStem = baseName.slice(0, -3);
+			const moduleDirectory = path.dirname(filename);
+			if (roleSuffixes.filter((suffix) => existsSync(path.join(moduleDirectory, `${moduleStem}${suffix}`))).length === 0) return;
+			if (path.basename(moduleDirectory) !== moduleStem) {
+				context.report({
+					node,
+					messageId: "flatSplitModule"
+				});
+				return;
+			}
+			if (!existsSync(path.join(moduleDirectory, "index.ts"))) context.report({
+				node,
+				messageId: "missingFolderIndex"
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/hook-anatomy.ts
+const hookBlock = "ExportNamedDeclaration > FunctionDeclaration[id.name=/^use[A-Z0-9]/] > BlockStatement";
+/**
+* Hook Anatomy Rule: exported hooks follow one ordering — derived state
+* (useMemo) before callbacks (useCallback) before effects (useEffect) — and
+* always end with a return statement.
+*/
+const hookAnatomy = {
+	meta: {
+		type: "problem",
+		docs: { description: "enforce useMemo → useCallback → useEffect ordering and a final return in exported hooks" },
+		messages: {
+			effectBeforeDerived: "Hook Anatomy Rule: useEffect must come after derived state and callbacks in hooks.",
+			memoAfterCallback: "Hook Anatomy Rule: useMemo derived state must come before useCallback callbacks in hooks.",
+			missingReturn: "Hook Anatomy Rule: hooks must end with a return statement."
+		},
+		schema: []
+	},
+	create(context) {
+		return {
+			[`${hookBlock} > ExpressionStatement:has(CallExpression[callee.name="useEffect"]) ~ VariableDeclaration:has(CallExpression[callee.name=/^use(Memo|Callback)$/])`](node) {
+				context.report({
+					node,
+					messageId: "effectBeforeDerived"
+				});
+			},
+			[`${hookBlock} > ExpressionStatement:has(CallExpression[callee.object.name="React"][callee.property.name="useEffect"]) ~ VariableDeclaration:has(CallExpression[callee.name=/^use(Memo|Callback)$/])`](node) {
+				context.report({
+					node,
+					messageId: "effectBeforeDerived"
+				});
+			},
+			[`${hookBlock} > VariableDeclaration:has(CallExpression[callee.name="useCallback"]) ~ VariableDeclaration:has(CallExpression[callee.name="useMemo"])`](node) {
+				context.report({
+					node,
+					messageId: "memoAfterCallback"
+				});
+			},
+			[`${hookBlock} > :not(ReturnStatement):last-child`](node) {
+				context.report({
+					node,
+					messageId: "missingReturn"
+				});
+			}
+		};
+	}
+};
+//#endregion
+//#region src/rules/no-infrastructure-in-view.ts
+/**
+* Feature Boundary Rule: presentational and composition files never touch the
+* infrastructure edge directly — neither by importing generated bindings nor
+* through runtime globals. The edge itself is consumer configuration:
+* `importPatterns` are regex sources matched against import specifiers, and
+* `runtimeGlobals` are `object.property` member paths (e.g. `window.go`).
+* Without options the rule is inert by design.
+*/
+const noInfrastructureInView = {
+	meta: {
+		type: "problem",
+		docs: { description: "forbid direct access to the configured infrastructure edge from views" },
+		messages: {
+			infrastructureImport: "Feature Boundary: this file cannot import infrastructure bindings ({{source}}) directly. Route the call through the colocated use-*.ts hook or adapter.",
+			infrastructureRuntime: "Feature Boundary: this file cannot access the {{memberPath}} runtime directly. Route the call through the colocated use-*.ts hook or adapter."
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				importPatterns: {
+					type: "array",
+					items: { type: "string" }
+				},
+				runtimeGlobals: {
+					type: "array",
+					items: {
+						type: "string",
+						pattern: "^[A-Za-z_$][\\w$]*\\.[A-Za-z_$][\\w$]*$"
+					}
+				}
+			},
+			additionalProperties: false
+		}]
+	},
+	create(context) {
+		const importPatterns = context.options[0]?.importPatterns ?? [];
+		const runtimeGlobals = context.options[0]?.runtimeGlobals ?? [];
+		const importMatchers = importPatterns.map((pattern) => new RegExp(pattern, "u"));
+		const runtimePaths = runtimeGlobals.map((memberPath) => {
+			const [objectName, propertyName] = memberPath.split(".");
+			return {
+				memberPath,
+				objectName,
+				propertyName
+			};
+		});
+		return {
+			ImportDeclaration(node) {
+				const source = String(node.source.value);
+				if (importMatchers.some((matcher) => matcher.test(source))) context.report({
+					node,
+					messageId: "infrastructureImport",
+					data: { source }
+				});
+			},
+			MemberExpression(node) {
+				if (node.object.type !== "Identifier" || node.property.type !== "Identifier") return;
+				const objectName = node.object.name;
+				const propertyName = node.property.name;
+				const match = runtimePaths.find((candidate) => candidate.objectName === objectName && candidate.propertyName === propertyName);
+				if (match) context.report({
+					node,
+					messageId: "infrastructureRuntime",
+					data: { memberPath: match.memberPath }
+				});
+			}
+		};
+	}
+};
+//#endregion
+//#region src/rules/no-view-effects.ts
+const effectHookPattern = /^use(?:Effect|LayoutEffect)$/u;
+/**
+* Dumb UI Rule: view components (.tsx) must stay presentational. Side effects
+* belong in the colocated `use-*.ts` hook, never in the view itself.
+*/
+const noViewEffects = {
+	meta: {
+		type: "problem",
+		docs: { description: "forbid useEffect/useLayoutEffect inside view components" },
+		messages: { viewEffectForbidden: "Dumb UI Rule: view components cannot call {{hookName}}. Move side effects into the colocated use-*.ts hook." },
+		schema: []
+	},
+	create(context) {
+		return { CallExpression(node) {
+			const { callee } = node;
+			if (callee.type === "Identifier" && effectHookPattern.test(callee.name)) {
+				context.report({
+					node,
+					messageId: "viewEffectForbidden",
+					data: { hookName: callee.name }
+				});
+				return;
+			}
+			if (callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "React" && callee.property.type === "Identifier" && effectHookPattern.test(callee.property.name)) context.report({
+				node,
+				messageId: "viewEffectForbidden",
+				data: { hookName: callee.property.name }
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/pure-index-barrel.ts
+/**
+* Pure Barrel Contract: an `index.ts` entrypoint only re-exports from sibling
+* modules — no local declarations, no imports, no side effects. Scope this
+* rule to `**​/index.ts` globs; the rule judges content, the config owns scope.
+*/
+const pureIndexBarrel = {
+	meta: {
+		type: "problem",
+		docs: { description: "restrict barrel entrypoints to re-export statements only" },
+		messages: { impureBarrel: "Pure barrel contract: index.ts must only contain re-export statements with explicit module targets." },
+		schema: []
+	},
+	create(context) {
+		return { Program(node) {
+			for (const statement of node.body) if (!(statement.type === "ExportAllDeclaration" || statement.type === "ExportNamedDeclaration" && statement.source != null && statement.declaration == null)) context.report({
+				node: statement,
+				messageId: "impureBarrel"
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/readonly-props.ts
+const propsBoundary = "[typeAnnotation.typeAnnotation.type=\"TSTypeReference\"][typeAnnotation.typeAnnotation.typeName.name=/Props$/]";
+/**
+* Type Contract Rule: component props are immutable. Parameters use
+* `Readonly<Props>` at the function boundary, and every field of a `*Props`
+* interface is declared readonly.
+*/
+const readonlyProps = {
+	meta: {
+		type: "problem",
+		docs: { description: "require Readonly<Props> boundaries and readonly Props fields" },
+		messages: {
+			boundaryNotReadonly: "Type Contract Rule: component props parameters must use Readonly<Props> at the function boundary.",
+			propsFieldNotReadonly: "Type Contract Rule: every Props field must be declared as readonly."
+		},
+		schema: []
+	},
+	create(context) {
+		return {
+			[`ExportNamedDeclaration > FunctionDeclaration > Identifier${propsBoundary}`](node) {
+				context.report({
+					node,
+					messageId: "boundaryNotReadonly"
+				});
+			},
+			[`ExportNamedDeclaration > FunctionDeclaration > ObjectPattern${propsBoundary}`](node) {
+				context.report({
+					node,
+					messageId: "boundaryNotReadonly"
+				});
+			},
+			["TSInterfaceDeclaration[id.name=/Props$/] TSPropertySignature[readonly!=true]"](node) {
+				context.report({
+					node,
+					messageId: "propsFieldNotReadonly"
+				});
+			}
+		};
+	}
+};
+//#endregion
+//#region src/rules/require-exported-variable-jsdoc.ts
+/**
+* Documentation Contract Rule: every exported variable declaration carries an
+* immediately preceding JSDoc block. Complements `jsdoc/require-jsdoc`, whose
+* contexts cover functions, interfaces, and type aliases but not variables.
+*/
+const requireExportedVariableJsdoc = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "require JSDoc immediately before exported variable declarations" },
+		messages: { missingJsdoc: "Exported variables must have an immediately preceding JSDoc block." },
+		schema: []
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		return { ExportNamedDeclaration(node) {
+			if (node.declaration?.type !== "VariableDeclaration") return;
+			const precedingComment = sourceCode.getCommentsBefore(node).at(-1);
+			if (!(precedingComment?.type === "Block" && precedingComment.value.startsWith("*"))) context.report({
+				node,
+				messageId: "missingJsdoc"
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/strict-colocation.ts
+const allChecks = [
+	"root-variable",
+	"root-helper-function",
+	"exported-const",
+	"default-arrow-export",
+	"inline-interface",
+	"inline-type-alias",
+	"zod-import"
+];
+const zodImportPattern = /^zod(?:\/.*)?$/u;
+//#endregion
+//#region src/plugin.ts
+/**
+* Plugin core shared by every preset: metadata plus the dlinter rule registry.
+* Presets receive this object so config factories never import the package
+* entrypoint back (which would create a module cycle).
+*/
+const pluginBase = {
+	meta: {
+		name: "dlinter-ts-react",
+		version: "0.1.0"
+	},
+	rules: {
+		"composition-only-delivery": compositionOnlyDelivery,
+		"folder-ownership": folderOwnership,
+		"hook-anatomy": hookAnatomy,
+		"no-infrastructure-in-view": noInfrastructureInView,
+		"no-view-effects": noViewEffects,
+		"pure-index-barrel": pureIndexBarrel,
+		"readonly-props": readonlyProps,
+		"require-exported-variable-jsdoc": requireExportedVariableJsdoc,
+		"strict-colocation": {
+			meta: {
+				type: "problem",
+				docs: { description: "enforce role-file colocation for declarations in governed main modules" },
+				messages: {
+					rootVariable: "Strict Colocation: root-level variables are forbidden in governed modules. Move constants to *.constants.ts and helper state into the function body.",
+					rootHelperFunction: "Strict Colocation: root-level helper functions are forbidden in governed modules. Move them to *.helpers.ts.",
+					exportedConst: "Strict Colocation: export governed main modules as named function declarations, not root-level consts.",
+					defaultArrowExport: "Strict Colocation: export governed main modules as named function declarations.",
+					inlineInterface: "Strict Colocation: interfaces must be declared in a separate *.types.ts file.",
+					inlineTypeAlias: "Strict Colocation: type aliases must be declared in a separate *.types.ts file.",
+					zodImport: "Strict Colocation: Zod schemas must live in a dedicated *.schema.ts file."
+				},
+				schema: [{
+					type: "object",
+					properties: { checks: {
+						type: "array",
+						items: { enum: [...allChecks] }
+					} },
+					additionalProperties: false
+				}]
+			},
+			create(context) {
+				const configuredChecks = context.options[0]?.checks ?? allChecks;
+				const enabled = new Set(configuredChecks);
+				const visitor = {};
+				if (enabled.has("root-variable")) visitor["Program > VariableDeclaration"] = (node) => {
+					context.report({
+						node,
+						messageId: "rootVariable"
+					});
+				};
+				if (enabled.has("root-helper-function")) visitor["Program > FunctionDeclaration"] = (node) => {
+					context.report({
+						node,
+						messageId: "rootHelperFunction"
+					});
+				};
+				if (enabled.has("exported-const")) visitor["Program > ExportNamedDeclaration > VariableDeclaration"] = (node) => {
+					context.report({
+						node,
+						messageId: "exportedConst"
+					});
+				};
+				if (enabled.has("default-arrow-export")) visitor["Program > ExportDefaultDeclaration > ArrowFunctionExpression"] = (node) => {
+					context.report({
+						node,
+						messageId: "defaultArrowExport"
+					});
+				};
+				if (enabled.has("inline-interface")) visitor["TSInterfaceDeclaration"] = (node) => {
+					context.report({
+						node,
+						messageId: "inlineInterface"
+					});
+				};
+				if (enabled.has("inline-type-alias")) visitor["TSTypeAliasDeclaration"] = (node) => {
+					context.report({
+						node,
+						messageId: "inlineTypeAlias"
+					});
+				};
+				if (enabled.has("zod-import")) visitor["ImportDeclaration"] = (node) => {
+					if (node.type === "ImportDeclaration" && zodImportPattern.test(String(node.source.value))) context.report({
+						node,
+						messageId: "zodImport"
+					});
+				};
+				return visitor;
+			}
+		}
+	}
+};
+//#endregion
+//#region src/configs/severities.ts
+/**
+* Re-emits a rules map with every active severity downgraded to "warn".
+* Used to surface advisory plugins (react-doctor) as warnings instead of hard
+* errors that would break the gate on pre-existing patterns.
+* @param rules - source rules map keyed by rule name.
+* @returns the same rules with non-off severities set to "warn".
+*/
+function downgradeRuleSeverities(rules) {
+	return Object.fromEntries(Object.entries(rules).map(([ruleName, ruleValue]) => {
+		if (ruleValue === "off" || ruleValue === 0) return [ruleName, "off"];
+		if (Array.isArray(ruleValue)) return [ruleName, ["warn", ...ruleValue.slice(1)]];
+		return [ruleName, "warn"];
+	}));
+}
+//#endregion
+//#region src/configs/recommended.ts
+const typescriptPlugin = tsPlugin;
+const importXExtensions = [
+	".js",
+	".jsx",
+	".ts",
+	".tsx",
+	".d.ts"
+];
+const productionTestGlobs = [
+	"**/__tests__/**/*.{ts,tsx}",
+	"**/*.test.{ts,tsx}",
+	"src/test/**/*.{ts,tsx}",
+	"test/**/*.{ts,tsx}"
+];
+const nodeScriptGlobs = ["scripts/**/*.{js,mjs,cjs}"];
+const sourceBrowserGlobs = ["src/**/*.{ts,tsx,js,jsx}"];
+const documentationExemptGlobs = [...productionTestGlobs, "**/*.invalid.{ts,tsx,js,jsx}"];
+const governedMainModuleExemptGlobs = [
+	...documentationExemptGlobs,
+	"**/index.ts",
+	"**/*.constants.ts",
+	"**/*.helpers.ts",
+	"**/*.schema.ts",
+	"**/*.types.ts"
+];
+const documentationContexts = [
+	"ExportNamedDeclaration > FunctionDeclaration",
+	"ExportNamedDeclaration > TSInterfaceDeclaration",
+	"ExportNamedDeclaration > TSTypeAliasDeclaration",
+	"ExportDefaultDeclaration > FunctionDeclaration",
+	"ExportDefaultDeclaration > ArrowFunctionExpression",
+	"ExportDefaultDeclaration > CallExpression > ArrowFunctionExpression"
+];
+const allDlinterRulesOff = {
+	"dlinter/composition-only-delivery": "off",
+	"dlinter/folder-ownership": "off",
+	"dlinter/hook-anatomy": "off",
+	"dlinter/no-infrastructure-in-view": "off",
+	"dlinter/no-view-effects": "off",
+	"dlinter/pure-index-barrel": "off",
+	"dlinter/readonly-props": "off",
+	"dlinter/require-exported-variable-jsdoc": "off",
+	"dlinter/strict-colocation": "off"
+};
+/**
+* Builds the full governance preset: bundled third-party plugin stack plus
+* every dlinter architecture rule, composed with the glob topology proven in
+* autoreas-bridge (views / hooks / delivery / role files / tests).
+* @param options - project-specific knobs: infrastructure edge, delivery globs, tsconfig path.
+* @returns flat config array ready to spread into `eslint.config.js`.
+*/
+function createRecommendedConfig(options = {}) {
+	const deliveryGlobs = [...options.deliveryGlobs ?? ["src/App.tsx", "src/app/**/*.{ts,tsx}"]];
+	const tsconfigPath = options.tsconfigPath ?? "./tsconfig.json";
+	const infrastructureRule = options.infrastructure ? ["error", {
+		importPatterns: [...options.infrastructure.importPatterns],
+		runtimeGlobals: [...options.infrastructure.runtimeGlobals]
+	}] : "off";
+	const reactDoctorWarnRules = downgradeRuleSeverities(reactDoctor.configs.recommended.rules);
+	return [
+		js.configs.recommended,
+		importX.flatConfigs.recommended,
+		importX.flatConfigs.typescript,
+		reactPlugin.configs.flat["jsx-runtime"],
+		{ ignores: ["dist/**/*", "coverage/**/*"] },
+		{
+			files: nodeScriptGlobs,
+			languageOptions: { globals: {
+				console: "readonly",
+				process: "readonly"
+			} }
+		},
+		{
+			files: ["**/*.{ts,tsx,js,jsx,mjs,cjs}"],
+			languageOptions: {
+				parser: tsParser,
+				ecmaVersion: "latest",
+				sourceType: "module"
+			},
+			plugins: { sonarjs: sonarjsPlugin },
+			settings: {
+				react: { version: "detect" },
+				"import-x/resolver-next": [createTypeScriptImportResolver({
+					alwaysTryTypes: true,
+					project: tsconfigPath
+				}), createNodeResolver({ extensions: importXExtensions })]
+			},
+			rules: {
+				"import/default": "off",
+				"import/export": "off",
+				"import/named": "off",
+				"import/namespace": "off",
+				"import/no-duplicates": "off",
+				"import/no-named-as-default": "off",
+				"import/no-named-as-default-member": "off",
+				"import/no-unresolved": "off",
+				"no-redeclare": "off",
+				"import-x/no-cycle": ["error", { maxDepth: 1 }],
+				"import-x/no-duplicates": "error",
+				"import-x/no-unresolved": "error",
+				"sonarjs/cognitive-complexity": ["warn", 15],
+				"sonarjs/no-all-duplicated-branches": "warn",
+				"sonarjs/no-identical-functions": "warn",
+				"sonarjs/no-redundant-boolean": "warn",
+				"sonarjs/no-small-switch": "warn"
+			}
+		},
+		{
+			files: sourceBrowserGlobs,
+			languageOptions: { globals: {
+				document: "readonly",
+				navigator: "readonly",
+				window: "readonly"
+			} }
+		},
+		{
+			files: ["**/*.ts", "**/*.tsx"],
+			plugins: { "@typescript-eslint": typescriptPlugin },
+			rules: {
+				"max-lines": ["error", {
+					max: 500,
+					skipBlankLines: true,
+					skipComments: true
+				}],
+				"no-undef": "off",
+				"no-unused-vars": "off",
+				"@typescript-eslint/no-unused-vars": ["error", {
+					argsIgnorePattern: "^_",
+					varsIgnorePattern: "^_",
+					caughtErrors: "none"
+				}]
+			}
+		},
+		{
+			files: productionTestGlobs,
+			plugins: { "@typescript-eslint": typescriptPlugin },
+			rules: {
+				"no-unused-vars": "off",
+				"@typescript-eslint/no-unused-vars": "off"
+			}
+		},
+		{
+			files: ["src/**/*.{ts,tsx}"],
+			plugins: { "react-hooks": reactHooksPlugin },
+			rules: {
+				"react-hooks/rules-of-hooks": "error",
+				"react-hooks/exhaustive-deps": "warn"
+			}
+		},
+		{
+			files: ["**/*.{ts,tsx}"],
+			ignores: governedMainModuleExemptGlobs,
+			plugins: { dlinter: pluginBase },
+			rules: { "dlinter/strict-colocation": "error" }
+		},
+		{
+			files: ["src/**/*.{ts,tsx}"],
+			ignores: productionTestGlobs,
+			plugins: { "react-doctor": reactDoctor },
+			rules: {
+				...reactDoctorWarnRules,
+				"react-doctor/react-compiler-no-manual-memoization": "off"
+			}
+		},
+		{
+			files: ["src/**/*.{ts,tsx}"],
+			plugins: { "check-file": checkFilePlugin },
+			rules: {
+				"check-file/filename-blocklist": ["error", {
+					"src/**/utils.ts": "*.helpers.ts",
+					"src/**/Utils.ts": "*.helpers.ts"
+				}],
+				"check-file/folder-match-with-fex": ["error", {
+					"src/**/*.test.ts": "**/__tests__/",
+					"src/**/*.test.tsx": "**/__tests__/"
+				}],
+				"check-file/folder-naming-convention": ["error", { "src/features/*/": "KEBAB_CASE" }]
+			}
+		},
+		{
+			files: ["src/**/*.tsx"],
+			ignores: [...deliveryGlobs, ...productionTestGlobs],
+			plugins: { dlinter: pluginBase },
+			rules: {
+				"dlinter/no-view-effects": "error",
+				"dlinter/readonly-props": "error",
+				"dlinter/strict-colocation": "error",
+				"dlinter/no-infrastructure-in-view": infrastructureRule
+			}
+		},
+		{
+			files: deliveryGlobs,
+			plugins: { dlinter: pluginBase },
+			rules: {
+				"dlinter/composition-only-delivery": "error",
+				"dlinter/strict-colocation": "error",
+				"dlinter/no-infrastructure-in-view": infrastructureRule
+			}
+		},
+		{
+			files: ["**/index.ts"],
+			ignores: productionTestGlobs,
+			plugins: { dlinter: pluginBase },
+			rules: { "dlinter/pure-index-barrel": "error" }
+		},
+		{
+			files: ["src/**/*.ts"],
+			ignores: documentationExemptGlobs,
+			plugins: { dlinter: pluginBase },
+			rules: { "dlinter/folder-ownership": "error" }
+		},
+		{
+			files: ["**/*.{ts,tsx}"],
+			ignores: documentationExemptGlobs,
+			plugins: {
+				jsdoc: jsdocPlugin,
+				dlinter: pluginBase
+			},
+			rules: {
+				"jsdoc/require-jsdoc": ["error", {
+					contexts: documentationContexts,
+					exemptEmptyConstructors: false,
+					publicOnly: false,
+					require: {
+						ClassDeclaration: false,
+						ClassExpression: false,
+						FunctionDeclaration: false,
+						MethodDefinition: false
+					}
+				}],
+				"dlinter/require-exported-variable-jsdoc": "error"
+			}
+		},
+		{
+			files: ["src/**/use-*.ts"],
+			ignores: productionTestGlobs,
+			plugins: { dlinter: pluginBase },
+			rules: {
+				"dlinter/hook-anatomy": "error",
+				"dlinter/strict-colocation": "error"
+			}
+		},
+		{
+			files: ["src/**/*.types.ts"],
+			ignores: productionTestGlobs,
+			plugins: { dlinter: pluginBase },
+			rules: { "dlinter/readonly-props": "error" }
+		},
+		{
+			files: ["src/**/*.helpers.ts"],
+			ignores: productionTestGlobs,
+			plugins: { dlinter: pluginBase },
+			rules: { "dlinter/strict-colocation": ["error", { checks: ["inline-interface", "inline-type-alias"] }] }
+		},
+		{
+			files: productionTestGlobs,
+			plugins: {
+				dlinter: pluginBase,
+				jsdoc: jsdocPlugin
+			},
+			rules: {
+				...allDlinterRulesOff,
+				"jsdoc/require-jsdoc": "off"
+			}
+		}
+	];
+}
+//#endregion
+//#region src/index.ts
+/**
+* Architecture-concept presets exposed to consumers as flat config arrays.
+* `recommended` composes the full governance stack with default options;
+* projects with an infrastructure edge use `createRecommendedConfig` instead.
+*/
+const configs = {
+	"dumb-ui": createDumbUiConfig(pluginBase),
+	recommended: createRecommendedConfig()
+};
+const dlinter = {
+	...pluginBase,
+	configs
+};
+//#endregion
+export { createRecommendedConfig, dlinter as default };