markuplint 5.1.0 → 5.1.1

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [5.1.1](https://github.com/markuplint/markuplint/compare/v5.1.0...v5.1.1) (2026-10-09)
+
+### Bug Fixes
+
+- **markuplint:** fail a file whose config cannot be loaded instead of passing it ([4579d89](https://github.com/markuplint/markuplint/commit/4579d890e4b3e18f34fbe91f8b8d7f59ca886e92))
+
 # [5.1.0](https://github.com/markuplint/markuplint/compare/v5.0.1...v5.1.0) (2026-10-08)
 
 ### Bug Fixes

package/lib/api/ml-engine.js

@@ -1,9 +1,9 @@
 import { ConfigProvider, createPretenderResolver, disambiguatePretendersForFile, invalidatePretenderResolutionCaches, resolveFiles, resolveParser, resolveRules, resolveSpecs, } from '@markuplint/file-resolver';
 import path from 'node:path';
 import { applyRuleAliasesToConfig, mergeConfig } from '@markuplint/ml-config';
-import { MLCore, convertRuleset } from '@markuplint/ml-core';
+import { CONFIG_ERROR_RULE_ID, MLCore, convertRuleset } from '@markuplint/ml-core';
 import { ruleAliasTable } from '@markuplint/rules';
-import { isFatalError } from '@markuplint/shared';
+import { ConfigLoadError, isFatalError } from '@markuplint/shared';
 import { Emitter } from 'strict-event-emitter';
 import { log as coreLog, verbosely } from '../debug.js';
 import { i18n } from '../i18n.js';
@@ -71,6 +71,15 @@ export class MLEngine extends Emitter {
         return files[0];
     }
     #configProvider;
+    /**
+     * Why the latest config resolution left nothing to lint with: a config that
+     * cannot be loaded (Tier 2). `null` while the latest resolution succeeded.
+     *
+     * Set by `#provide` and reported by `#reportConfigFailure` as one
+     * error-severity `config-error` for the file. It is not folded into an empty
+     * config plus a warning: a file that no rule has looked at must not pass.
+     */
+    #configFailure = null;
     #core = null;
     #file;
     #options;
@@ -168,6 +177,10 @@ export class MLEngine extends Emitter {
         log('exec: start');
         const core = await this.#setup();
         if (!core) {
+            if (this.#configFailure) {
+                log('exec: config cannot be loaded');
+                return this.#reportConfigFailure(this.#configFailure);
+            }
             log('exec: cancel (unsetuped yet)');
             return null;
         }
@@ -394,14 +407,32 @@ export class MLEngine extends Emitter {
             return;
         }
         const fabric = await this.#provide(false);
-        if (!fabric || !this.#options?.watch) {
+        if (!fabric) {
+            if (this.#configFailure) {
+                // The core holds the config that no longer loads. Dropping it makes the
+                // next `exec()` / `setCode()` resolve again instead of linting on it.
+                this.#core = null;
+                if (this.#options?.watch) {
+                    await this.#reportConfigFailure(this.#configFailure);
+                }
+            }
+            return;
+        }
+        if (!this.#options?.watch) {
             return;
         }
         if (fabric.configErrors) {
             this.emit('config-errors', this.#file.path, fabric.configErrors);
         }
         this.emit('log', 'update:core', this.#file.path);
-        this.#core?.update(fabric);
+        if (this.#core) {
+            this.#core.update(fabric);
+        }
+        else {
+            // No core yet — the config did not load until now. `#exec()` would
+            // resolve once more through `#setup()`, for the fabric just resolved.
+            await this.#createCore(fabric);
+        }
         await this.#exec();
     }
     #enqueue(task) {
@@ -464,32 +495,42 @@ export class MLEngine extends Emitter {
         this.#pretenderDependencies = dependencies;
         await this.#syncWatch();
     }
+    /**
+     * Resolves everything a lint of the file needs and returns it, or `null`
+     * when there is nothing to lint with: the file is missing, excluded, or
+     * unmatched by the extension — or its config cannot be loaded, which
+     * `#configFailure` records.
+     *
+     * A config that cannot be loaded is a Tier 2 failure (see the module JSDoc
+     * of `@markuplint/shared`'s `errors/index.ts`): any non-fatal error thrown by
+     * the resolution, or a `ConfigLoadError` collected into the config set's
+     * `errs`, fails the file. Tier 1 errors — markuplint's own bugs
+     * (`isFatalError()`) — are not caught here. The other `errs` (a rule or a
+     * plugin that is not found, an invalid selector, a circular `extends`)
+     * leave the rest of the config usable, so they stay `config-error` warnings
+     * that `MLCore.verify()` reports.
+     */
     async #provide(cache = true) {
+        this.#configFailure = null;
         let configSet;
         try {
             configSet = await this.resolveConfig(cache);
         }
         catch (error) {
-            if (error instanceof Error) {
-                configSet = {
-                    config: {},
-                    plugins: [],
-                    files: new Set(),
-                    errs: [error],
-                    ruleDeprecations: [],
-                };
-            }
-            else {
+            if (isFatalError(error) || !(error instanceof Error)) {
                 throw error;
             }
+            return this.#failConfig(error);
         }
         fileLog('Fetched Config files: %O', configSet.files);
         fileLog('Resolved Config: %O', configSet.config);
         fileLog('Resolved Plugins: %O', configSet.plugins);
         fileLog('Resolve Errors: %O', configSet.errs);
-        if (!(await this.#file.isFile())) {
-            this.emit('log', 'file-no-exists', `The file doesn't exist or it is not a file: ${this.#file.path}`);
-            fileLog("The file doesn't exist or it is not a file: %s", this.#file.path);
+        const loadError = configSet.errs.find(error => error instanceof ConfigLoadError);
+        if (loadError) {
+            return this.#failConfig(loadError);
+        }
+        if (!(await this.#isTargetFile())) {
             return null;
         }
         // Exclude
@@ -698,6 +739,58 @@ export class MLEngine extends Emitter {
         this.emit('schemas', this.#file.path, schemas);
         return schemas;
     }
+    async #isTargetFile() {
+        if (await this.#file.isFile()) {
+            return true;
+        }
+        this.emit('log', 'file-no-exists', `The file doesn't exist or it is not a file: ${this.#file.path}`);
+        fileLog("The file doesn't exist or it is not a file: %s", this.#file.path);
+        return false;
+    }
+    /**
+     * Records that the config cannot be loaded, unless the file is missing too,
+     * which is the more basic reason to skip it. Always resolves to `null`: the
+     * "nothing to lint with" answer of `#provide`.
+     */
+    async #failConfig(error) {
+        fileLog('Config cannot be loaded: %O', error);
+        if (await this.#isTargetFile()) {
+            this.#configFailure = error;
+        }
+        return null;
+    }
+    /**
+     * Reports a config that cannot be loaded as the file's only violation, at
+     * error severity, so the run fails instead of passing a file no rule has
+     * checked.
+     *
+     * Emits `lint` as well as `lint-error`: an editor shows its diagnostics from
+     * `lint`, and a config that stops loading while it is being edited must show
+     * up there. See `#exec` for the `lint-error` conversion of a failed
+     * `verify()`, which has no violations to publish.
+     */
+    async #reportConfigFailure(error) {
+        const sourceCode = await this.#file.getCode();
+        const violations = [
+            {
+                ruleId: CONFIG_ERROR_RULE_ID,
+                severity: 'error',
+                message: error.message,
+                line: 1,
+                col: 1,
+                raw: '',
+            },
+        ];
+        this.emit('lint-error', this.#file.path, sourceCode, error);
+        this.emit('lint', this.#file.path, sourceCode, violations, sourceCode, null, null);
+        return {
+            violations,
+            filePath: this.#file.path,
+            sourceCode,
+            fixedCode: sourceCode,
+            status: 'processed',
+        };
+    }
     async #setup() {
         if (this.#core) {
             return this.#core;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "markuplint",
-	"version": "5.1.0",
+	"version": "5.1.1",
 	"description": "An HTML linter for all markup developers",
 	"author": "Yusuke Hirao",
 	"license": "MIT",
@@ -35,17 +35,17 @@
 		"clean": "tsc --build --clean tsconfig.build.json"
 	},
 	"dependencies": {
-		"@markuplint/cli-utils": "5.1.0",
-		"@markuplint/file-resolver": "5.1.0",
-		"@markuplint/html-parser": "5.1.0",
-		"@markuplint/html-spec": "5.1.0",
-		"@markuplint/i18n": "5.1.0",
-		"@markuplint/ml-ast": "5.1.0",
-		"@markuplint/ml-config": "5.1.0",
-		"@markuplint/ml-core": "5.1.0",
-		"@markuplint/ml-spec": "5.1.0",
-		"@markuplint/rules": "5.1.0",
-		"@markuplint/shared": "5.1.0",
+		"@markuplint/cli-utils": "5.1.1",
+		"@markuplint/file-resolver": "5.1.1",
+		"@markuplint/html-parser": "5.1.1",
+		"@markuplint/html-spec": "5.1.1",
+		"@markuplint/i18n": "5.1.1",
+		"@markuplint/ml-ast": "5.1.1",
+		"@markuplint/ml-config": "5.1.1",
+		"@markuplint/ml-core": "5.1.1",
+		"@markuplint/ml-spec": "5.1.1",
+		"@markuplint/rules": "5.1.1",
+		"@markuplint/shared": "5.1.1",
 		"@types/debug": "4.1.13",
 		"chokidar": "5.0.0",
 		"debug": "4.4.3",
@@ -55,5 +55,5 @@
 		"strip-ansi": "7.2.0",
 		"type-fest": "5.6.0"
 	},
-	"gitHead": "3a061784a8211034ad0c1cbd64798c0213414f65"
+	"gitHead": "a940c8526e971d590d97395ce924910221208820"
 }