@markuplint/ml-core 5.0.0-rc.5 → 5.0.0-rc.7

package/CHANGELOG.md

@@ -3,6 +3,39 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [5.0.0-rc.7](https://github.com/markuplint/markuplint/compare/v5.0.0-rc.6...v5.0.0-rc.7) (2026-08-31)
+
+### Bug Fixes
+
+- **ml-core:** fix named rule group disable propagation and validation ([139f466](https://github.com/markuplint/markuplint/commit/139f4661a12ac10b15ade305c30bbd8234b07b0f))
+
+# [5.0.0-rc.6](https://github.com/markuplint/markuplint/compare/v5.0.0-rc.5...v5.0.0-rc.6) (2026-08-30)
+
+### Features
+
+- split rule-deprecation notices out of config-error ([#4013](https://github.com/markuplint/markuplint/issues/4013)) ([812e6f3](https://github.com/markuplint/markuplint/commit/812e6f356839af8f257cfd91e6b16cfdfdd7cf33))
+
+### BREAKING CHANGES
+
+- violations for deprecated rule names now have
+  `ruleId: 'rule-deprecation'` instead of `ruleId: 'config-error'`. Any
+  consumer filtering `MLCore.verify()` output (or the markuplint CLI/API) by
+  `ruleId === 'config-error'` to catch deprecation messages must also check
+  for `rule-deprecation`.
+
+- feat(markuplint): add --severity-deprecation CLI flag
+
+Wires the new severity.deprecation config option (@markuplint/ml-config)
+and the rule-deprecation ruleId (@markuplint/ml-core) through the CLI:
+
+- --severity-deprecation flag, mirroring --severity-parse-error
+- --show-config details now also surfaces ruleDeprecations
+- per-run dedupe and failed-file counting generalized to cover both
+  config-level ruleIds (config-error and rule-deprecation), not just
+  config-error
+
+* docs(website): document severity.deprecation (EN + JA)
+
 # [5.0.0-rc.5](https://github.com/markuplint/markuplint/compare/v5.0.0-rc.4...v5.0.0-rc.5) (2026-08-28)
 
 ### Bug Fixes

package/lib/ml-core.d.ts

@@ -2,6 +2,20 @@ import type { MLFabric } from './types.js';
 import type { PlainData, RuleConfigValue, TextEdit, Violation } from '@markuplint/ml-config';
 import { ParserError } from '@markuplint/parser-utils';
 import { Document } from './ml-dom/index.js';
+/**
+ * `ruleId` of a genuinely broken config (unresolved rule reference, plugin
+ * resolution failure, ...). Exported so consumers that need to recognize
+ * config-level violations (e.g. the CLI's per-run dedupe and failed-file
+ * counting in `packages/markuplint/src/cli/command.ts`) reference the same
+ * literal `MLCore.verify()` emits, instead of duplicating the string.
+ */
+export declare const CONFIG_ERROR_RULE_ID = "config-error";
+/**
+ * `ruleId` of a deprecated-but-working rule name notice — see
+ * {@link CONFIG_ERROR_RULE_ID} for why this is exported rather than a
+ * private literal.
+ */
+export declare const RULE_DEPRECATION_RULE_ID = "rule-deprecation";
 /**
  * Summary of the multi-pass fix process.
  */
@@ -74,7 +88,7 @@ export type MLCoreParams = {
  */
 export declare class MLCore {
     #private;
-    constructor({ parser, sourceCode, ruleset, rules, locale, schemas, ruleCommonSettings, parserOptions, severity, pretenders, filename, debug, configErrors, }: MLCoreParams);
+    constructor({ parser, sourceCode, ruleset, rules, locale, schemas, ruleCommonSettings, parserOptions, severity, pretenders, filename, debug, configErrors, ruleDeprecations, }: MLCoreParams);
     /**
      * The parsed document, or a {@link ParserError} if parsing failed.
      */
@@ -91,7 +105,7 @@ export declare class MLCore {
      *
      * @param fabric - Partial fabric with the properties to update
      */
-    update({ parser, ruleset, rules, locale, schemas, parserOptions, pretenders, configErrors }: Partial<MLFabric>): void;
+    update({ parser, ruleset, rules, locale, schemas, parserOptions, pretenders, configErrors, ruleDeprecations, }: Partial<MLFabric>): void;
     /**
      * Runs all configured rules against the parsed document and returns violations.
      *

package/lib/ml-core.js

@@ -4,6 +4,20 @@ import { applyFixes } from './fix-applier.js';
 import { Document } from './ml-dom/index.js';
 import { expandNamedNodeRules, expandNamedRules } from './virtual-rule.js';
 const resultLog = log.extend('result');
+/**
+ * `ruleId` of a genuinely broken config (unresolved rule reference, plugin
+ * resolution failure, ...). Exported so consumers that need to recognize
+ * config-level violations (e.g. the CLI's per-run dedupe and failed-file
+ * counting in `packages/markuplint/src/cli/command.ts`) reference the same
+ * literal `MLCore.verify()` emits, instead of duplicating the string.
+ */
+export const CONFIG_ERROR_RULE_ID = 'config-error';
+/**
+ * `ruleId` of a deprecated-but-working rule name notice — see
+ * {@link CONFIG_ERROR_RULE_ID} for why this is exported rather than a
+ * private literal.
+ */
+export const RULE_DEPRECATION_RULE_ID = 'rule-deprecation';
 /**
  * The core linting engine for markuplint.
  *
@@ -29,6 +43,13 @@ export class MLCore {
      * Set once per construction/`update()` and never mutated by re-parsing.
      */
     #configErrors;
+    /**
+     * Deprecated-rule-name notices, kept structured and separate from
+     * `#configErrors` so `verify()` can report them under their own
+     * `rule-deprecation` ruleId. Set once per construction/`update()`, same
+     * lifecycle as `#configErrors`.
+     */
+    #ruleDeprecations;
     /**
      * Rule-mapping errors for the CURRENT document. Reset (not accumulated) on
      * every `#createDocument()` so repeated `setCode()` calls don't duplicate
@@ -44,7 +65,7 @@ export class MLCore {
     #originalNodeRules;
     #originalChildNodeRules;
     #disabledNamespaces;
-    constructor({ parser, sourceCode, ruleset, rules, locale, schemas, ruleCommonSettings, parserOptions, severity, pretenders, filename, debug, configErrors, }) {
+    constructor({ parser, sourceCode, ruleset, rules, locale, schemas, ruleCommonSettings, parserOptions, severity, pretenders, filename, debug, configErrors, ruleDeprecations, }) {
         if (debug) {
             enableDebug();
         }
@@ -58,6 +79,7 @@ export class MLCore {
         this.#severity = severity;
         this.#pretenders = [...pretenders];
         this.#configErrors = [...(configErrors ?? [])];
+        this.#ruleDeprecations = [...(ruleDeprecations ?? [])];
         // Preserve pre-expansion nodeRules for hot-reload
         this.#originalNodeRules = ruleset.nodeRules ?? [];
         this.#originalChildNodeRules = ruleset.childNodeRules ?? [];
@@ -72,6 +94,11 @@ export class MLCore {
             nodeRules: nodeRuleResult.transformedNodeRules,
             childNodeRules: childNodeRuleResult.transformedNodeRules,
             baseRuleToVirtualNames: buildBaseRuleToVirtualNames(namedRulesResult.virtualRules),
+            baseRuleToScopedVirtualNames: buildBaseRuleToVirtualNames([
+                ...nodeRuleResult.virtualRules,
+                ...childNodeRuleResult.virtualRules,
+            ]),
+            knownNamedRuleGroupKeys: ruleset.knownNamedRuleGroupKeys ?? new Set(),
             mappingErrors: [],
         };
         this.#disabledNamespaces = extractDisabledNamespaces(resolvedRules);
@@ -101,12 +128,13 @@ export class MLCore {
      *
      * @param fabric - Partial fabric with the properties to update
      */
-    update({ parser, ruleset, rules, locale, schemas, parserOptions, pretenders, configErrors }) {
+    update({ parser, ruleset, rules, locale, schemas, parserOptions, pretenders, configErrors, ruleDeprecations, }) {
         this.#parser = parser ?? this.#parser;
         this.#locale = locale ?? this.#locale;
         this.#schemas = schemas ?? this.#schemas;
         this.#pretenders = pretenders ? [...pretenders] : this.#pretenders;
         this.#configErrors = [...(configErrors ?? [])];
+        this.#ruleDeprecations = [...(ruleDeprecations ?? [])];
         const baseRules = rules ? [...rules] : this.#rules.filter(r => !r.baseRuleId);
         const incomingNodeRules = ruleset?.nodeRules ?? this.#originalNodeRules;
         const incomingChildNodeRules = ruleset?.childNodeRules ?? this.#originalChildNodeRules;
@@ -128,6 +156,11 @@ export class MLCore {
             nodeRules: nodeRuleResult.transformedNodeRules,
             childNodeRules: childNodeRuleResult.transformedNodeRules,
             baseRuleToVirtualNames: buildBaseRuleToVirtualNames(namedRulesResult.virtualRules),
+            baseRuleToScopedVirtualNames: buildBaseRuleToVirtualNames([
+                ...nodeRuleResult.virtualRules,
+                ...childNodeRuleResult.virtualRules,
+            ]),
+            knownNamedRuleGroupKeys: ruleset?.knownNamedRuleGroupKeys ?? this.#ruleset.knownNamedRuleGroupKeys,
             mappingErrors: [],
         };
         this.#disabledNamespaces = extractDisabledNamespaces(resolvedRules);
@@ -168,9 +201,18 @@ export class MLCore {
             if (setRuleName.endsWith('/*')) {
                 continue;
             }
+            // Skip a named rule group disabled via top-level `rules` (e.g. "html-standard/foo": false).
+            // `expandNamedRules` intentionally doesn't instantiate a virtual rule when the merged value
+            // already resolved to `false` (there's nothing to run), so it never appears in `definedRuleName`.
+            // `knownNamedRuleGroupKeys` (threaded from config merge — see its JSDoc) tells a genuine
+            // named-group disable apart from a typo'd/nonexistent rule name that also happens to be
+            // set to `false` with a `/` in its key; only the former is exempt from this check.
+            if (this.#ruleset.rules[setRuleName] === false && this.#ruleset.knownNamedRuleGroupKeys.has(setRuleName)) {
+                continue;
+            }
             if (!definedRuleName.has(setRuleName)) {
                 configViolations.push({
-                    ruleId: 'config-error',
+                    ruleId: CONFIG_ERROR_RULE_ID,
                     severity: 'warning',
                     message: `Rule not found: ${setRuleName}`,
                     col: 1,
@@ -181,7 +223,7 @@ export class MLCore {
         }
         for (const error of [...this.#configErrors, ...this.#mappingErrors]) {
             configViolations.push({
-                ruleId: 'config-error',
+                ruleId: CONFIG_ERROR_RULE_ID,
                 severity: 'warning',
                 message: error.message,
                 col: 1,
@@ -189,6 +231,19 @@ export class MLCore {
                 raw: '',
             });
         }
+        const deprecationSeverity = this.#resolveDeprecationSeverity();
+        if (deprecationSeverity != null) {
+            for (const { deprecatedName, replacedBy } of this.#ruleDeprecations) {
+                configViolations.push({
+                    ruleId: RULE_DEPRECATION_RULE_ID,
+                    severity: deprecationSeverity,
+                    message: `Rule "${deprecatedName}" is deprecated and will be removed in v6. Use ${replacedBy.join(', ')} instead.`,
+                    col: 1,
+                    line: 1,
+                    raw: '',
+                });
+            }
+        }
         violations.push(...configViolations);
         const ruleViolations = await this.#runAllRules(fix);
         violations.push(...ruleViolations);
@@ -363,6 +418,22 @@ export class MLCore {
             }
         }
     }
+    /**
+     * Resolves `severity.deprecation`, honouring its single-value form only
+     * (unlike `severity.parseError`, there's no fixed enum of deprecated rule
+     * names to key a per-code `Record` on).
+     *
+     * Unlike `#createParseError`'s parse-error channel, this defaults to
+     * `'warning'` (not off/suppressed) when unset — the deprecation channel
+     * is being carved out of the always-on `config-error` channel, not
+     * introduced cold, so leaving the option unset must not silence a notice
+     * users already see today.
+     *
+     * @returns the resolved severity, or `null` if suppressed.
+     */
+    #resolveDeprecationSeverity() {
+        return resolveUniformSeverity(this.#severity.deprecation, 'warning');
+    }
     /**
      * Builds a `ruleId: 'parse-error'` violation, honouring
      * `severity.parseError`.
@@ -377,36 +448,18 @@ export class MLCore {
      */
     #createParseError(message, line, col, raw, code) {
         const cfg = this.#severity.parseError;
-        if (cfg === false || cfg === 'off') {
+        // Fatal ParserErrors (no `code`) can't be targeted by the per-code
+        // Record form, so they fall back to `'error'` there; under the
+        // uniform form they default to `'error'` too, while non-fatal entries
+        // default to suppressed when unset — see `resolveUniformSeverity`.
+        const severity = typeof cfg === 'object'
+            ? code == null
+                ? 'error'
+                : resolveUniformSeverity(cfg[code], null)
+            : resolveUniformSeverity(cfg, code == null ? 'error' : null);
+        if (severity == null) {
             return null;
         }
-        let severity;
-        if (typeof cfg === 'object') {
-            if (code == null) {
-                // Fatal ParserError without a code; the Record form cannot target
-                // it, so fall back to `'error'` (the channel is otherwise enabled).
-                severity = 'error';
-            }
-            else {
-                const perCode = cfg[code];
-                if (perCode == null || perCode === false || perCode === 'off') {
-                    return null;
-                }
-                severity = perCode === true ? 'error' : perCode;
-            }
-        }
-        else if (cfg == null) {
-            // New default: non-fatal `parseErrors` entries are off; fatal
-            // `ParserError`s (no code) still emit at `'error'`.
-            if (code != null) {
-                return null;
-            }
-            severity = 'error';
-        }
-        else {
-            // Uniform string/boolean form (legacy).
-            severity = cfg === true ? 'error' : cfg;
-        }
         return {
             ruleId: 'parse-error',
             severity,
@@ -597,6 +650,24 @@ export class MLCore {
         }
     }
 }
+/**
+ * Normalizes a single-value `Severity | 'off' | boolean | undefined` option
+ * (the shape `severity.deprecation` and `severity.parseError`'s uniform/
+ * per-code leaf values share) to a resolved severity or `null` (suppressed).
+ *
+ * Shared so the same three-way rule — `false`/`'off'` → suppressed, `true` →
+ * `'error'`, unset → `defaultWhenUnset` — isn't reimplemented at each call
+ * site as channels using this shape are added.
+ */
+function resolveUniformSeverity(cfg, defaultWhenUnset) {
+    if (cfg === false || cfg === 'off') {
+        return null;
+    }
+    if (cfg == null) {
+        return defaultWhenUnset;
+    }
+    return cfg === true ? 'error' : cfg;
+}
 function extractDisabledNamespaces(rules) {
     return Object.entries(rules)
         .filter(([key, value]) => key.endsWith('/*') && value === false)

package/lib/ml-dom/node/document.js

@@ -2440,7 +2440,9 @@ export class MLDocument extends MLParentNode {
                         specificity: matches.specificity,
                         rule: mergedRule,
                     });
-                    // Propagate to virtual rules that wrap this base rule
+                    // Propagate to top-level-group virtual rules that wrap this base rule. These
+                    // wrappers have no selector scope of their own (they mirror the base rule
+                    // globally), so any matched value is safe to forward.
                     const virtualNames = ruleset.baseRuleToVirtualNames.get(ruleName);
                     if (virtualNames) {
                         for (const vName of virtualNames) {
@@ -2453,6 +2455,26 @@ export class MLDocument extends MLParentNode {
                             });
                         }
                     }
+                    // Propagate a disable to selector-scoped (nodeRules/childNodeRules-named) virtual
+                    // rules that wrap this base rule. Limited to `false`: unlike the top-level-group
+                    // case above, these wrappers DO have their own selector scope, so forwarding a
+                    // non-false value would apply their semantics (e.g. a required attribute name) to
+                    // every node this (unrelated) nodeRule matches, even where the virtual rule's own
+                    // selector never matched — see issue #4023's fix history for the regression this caused.
+                    if (convertedRule === false) {
+                        const scopedVirtualNames = ruleset.baseRuleToScopedVirtualNames.get(ruleName);
+                        if (scopedVirtualNames) {
+                            for (const vName of scopedVirtualNames) {
+                                // No merge needed: mergeRule(_, false) always returns false, so the
+                                // disable is unconditional regardless of any global config for vName.
+                                ruleMapper.set(node, vName, {
+                                    from: 'nodeRules',
+                                    specificity: matches.specificity,
+                                    rule: false,
+                                });
+                            }
+                        }
+                    }
                 }
             }
             // overwrite rule to child node
@@ -2518,7 +2540,8 @@ export class MLDocument extends MLParentNode {
                                 rule: mergedRule,
                             });
                         }
-                        // Propagate to virtual rules that wrap this base rule
+                        // Propagate to top-level-group virtual rules — see the matching nodeRules
+                        // propagation above for why any value is safe to forward here.
                         const virtualNames = ruleset.baseRuleToVirtualNames.get(ruleName);
                         if (virtualNames) {
                             for (const vName of virtualNames) {
@@ -2533,6 +2556,25 @@ export class MLDocument extends MLParentNode {
                                 }
                             }
                         }
+                        // Propagate a disable to selector-scoped virtual rules. Limited to `false` —
+                        // see the matching nodeRules propagation above for why a non-false value must
+                        // not be forwarded to a virtual rule whose own selector didn't match.
+                        if (convertedRule === false) {
+                            const scopedVirtualNames = ruleset.baseRuleToScopedVirtualNames.get(ruleName);
+                            if (scopedVirtualNames) {
+                                for (const vName of scopedVirtualNames) {
+                                    // No merge needed: mergeRule(_, false) always returns false, so the
+                                    // disable is unconditional regardless of any global config for vName.
+                                    for (const descendant of targetDescendants) {
+                                        ruleMapper.set(descendant, vName, {
+                                            from: 'childNodeRules',
+                                            specificity: matches.specificity,
+                                            rule: false,
+                                        });
+                                    }
+                                }
+                            }
+                        }
                     }
                 }
             }

package/lib/ruleset/index.d.ts

@@ -5,14 +5,31 @@ import type { ChildNodeRule, Config, NodeRule, Rules } from '@markuplint/ml-conf
  */
 export declare class Ruleset {
     /**
-     * Maps base rule names to their virtual rule names created by NamedRuleGroups.
-     * For example, if `a11y/landmark-roles` wraps `no-nested-top-level-landmark`, this maps
-     * `"no-nested-top-level-landmark"` → `["a11y/landmark-roles"]`.
-     * Used by nodeRules/childNodeRules to propagate settings to virtual rules.
+     * Maps base rule names to the virtual rule names created by top-level `rules`
+     * NamedRuleGroups (e.g. `"a11y/landmark-roles": { rules: { "no-nested-top-level-landmark": true } }`).
+     * These wrappers have no selector scope of their own — they mirror the base rule
+     * globally — so nodeRules/childNodeRules may propagate *any* matched value to them,
+     * not just a disable.
      */
     readonly baseRuleToVirtualNames: ReadonlyMap<string, readonly string[]>;
+    /**
+     * Maps base rule names to the virtual rule names created by `nodeRules[].name` /
+     * `childNodeRules[].name` (selector-scoped named groups), as opposed to
+     * {@link baseRuleToVirtualNames}'s top-level `rules` groups. Because these wrappers
+     * DO have their own selector scope, only a disable (`false`) may be propagated to
+     * them from an unrelated nodeRules/childNodeRules entry — forwarding a non-false
+     * value would apply the wrapper's semantics to nodes its own selector never matched
+     * (see issue #4023's fix history).
+     */
+    readonly baseRuleToScopedVirtualNames: ReadonlyMap<string, readonly string[]>;
     /** Rule overrides that apply to child nodes matching specific selectors */
     readonly childNodeRules: readonly ChildNodeRule[];
+    /**
+     * `rules` keys that are a genuine NamedRuleGroup in some layer of the
+     * `extends`/override chain, carried over from {@link Config.knownNamedRuleGroupKeys}
+     * even where the final merged value collapsed to `false`. See that field's JSDoc.
+     */
+    readonly knownNamedRuleGroupKeys: ReadonlySet<string>;
     /**
      * Errors collected during rule mapping (e.g., invalid wildcard usage).
      * Consumed by MLCore and reported as config-error violations.
@@ -24,7 +41,8 @@ export declare class Ruleset {
     readonly rules: Rules;
     /**
      * @param config - The markuplint configuration to extract rules from
-     * @param baseRuleToVirtualNames - Mapping from base rule names to virtual rule names
+     * @param baseRuleToVirtualNames - Mapping from base rule names to top-level-group virtual rule names
+     * @param baseRuleToScopedVirtualNames - Mapping from base rule names to selector-scoped (nodeRules/childNodeRules) virtual rule names
      */
-    constructor(config: Config, baseRuleToVirtualNames?: ReadonlyMap<string, readonly string[]>);
+    constructor(config: Config, baseRuleToVirtualNames?: ReadonlyMap<string, readonly string[]>, baseRuleToScopedVirtualNames?: ReadonlyMap<string, readonly string[]>);
 }

package/lib/ruleset/index.js

@@ -4,14 +4,31 @@
  */
 export class Ruleset {
     /**
-     * Maps base rule names to their virtual rule names created by NamedRuleGroups.
-     * For example, if `a11y/landmark-roles` wraps `no-nested-top-level-landmark`, this maps
-     * `"no-nested-top-level-landmark"` → `["a11y/landmark-roles"]`.
-     * Used by nodeRules/childNodeRules to propagate settings to virtual rules.
+     * Maps base rule names to the virtual rule names created by top-level `rules`
+     * NamedRuleGroups (e.g. `"a11y/landmark-roles": { rules: { "no-nested-top-level-landmark": true } }`).
+     * These wrappers have no selector scope of their own — they mirror the base rule
+     * globally — so nodeRules/childNodeRules may propagate *any* matched value to them,
+     * not just a disable.
      */
     baseRuleToVirtualNames;
+    /**
+     * Maps base rule names to the virtual rule names created by `nodeRules[].name` /
+     * `childNodeRules[].name` (selector-scoped named groups), as opposed to
+     * {@link baseRuleToVirtualNames}'s top-level `rules` groups. Because these wrappers
+     * DO have their own selector scope, only a disable (`false`) may be propagated to
+     * them from an unrelated nodeRules/childNodeRules entry — forwarding a non-false
+     * value would apply the wrapper's semantics to nodes its own selector never matched
+     * (see issue #4023's fix history).
+     */
+    baseRuleToScopedVirtualNames;
     /** Rule overrides that apply to child nodes matching specific selectors */
     childNodeRules;
+    /**
+     * `rules` keys that are a genuine NamedRuleGroup in some layer of the
+     * `extends`/override chain, carried over from {@link Config.knownNamedRuleGroupKeys}
+     * even where the final merged value collapsed to `false`. See that field's JSDoc.
+     */
+    knownNamedRuleGroupKeys;
     /**
      * Errors collected during rule mapping (e.g., invalid wildcard usage).
      * Consumed by MLCore and reported as config-error violations.
@@ -23,12 +40,15 @@ export class Ruleset {
     rules;
     /**
      * @param config - The markuplint configuration to extract rules from
-     * @param baseRuleToVirtualNames - Mapping from base rule names to virtual rule names
+     * @param baseRuleToVirtualNames - Mapping from base rule names to top-level-group virtual rule names
+     * @param baseRuleToScopedVirtualNames - Mapping from base rule names to selector-scoped (nodeRules/childNodeRules) virtual rule names
      */
-    constructor(config, baseRuleToVirtualNames) {
+    constructor(config, baseRuleToVirtualNames, baseRuleToScopedVirtualNames) {
         this.rules = config.rules ?? {};
         this.nodeRules = config.nodeRules ?? [];
         this.childNodeRules = config.childNodeRules ?? [];
         this.baseRuleToVirtualNames = baseRuleToVirtualNames ?? new Map();
+        this.baseRuleToScopedVirtualNames = baseRuleToScopedVirtualNames ?? new Map();
+        this.knownNamedRuleGroupKeys = new Set(config.knownNamedRuleGroupKeys);
     }
 }

package/lib/types.d.ts

@@ -2,7 +2,7 @@ import type { AnyMLRule } from './ml-rule/index.js';
 import type { Ruleset } from './ruleset/index.js';
 import type { LocaleSet } from '@markuplint/i18n';
 import type { MLParser, ParserOptions } from '@markuplint/ml-ast';
-import type { Pretender, RuleCommonSettings, SeverityOptions } from '@markuplint/ml-config';
+import type { Pretender, RuleAliasWarning, RuleCommonSettings, SeverityOptions } from '@markuplint/ml-config';
 import type { ExtendedSpec, MLMLSpec } from '@markuplint/ml-spec';
 /**
  * A tuple of the base HTML/ARIA specification and zero or more
@@ -24,4 +24,11 @@ export type MLFabric = {
     readonly severity: SeverityOptions;
     readonly pretenders: readonly Pretender[];
     readonly configErrors?: readonly Readonly<Error>[];
+    /**
+     * Deprecated-rule-name notices found while applying the rule-alias table
+     * (v5 rule-system redesign, #3989). Kept structured, separate from
+     * {@link configErrors}, so `MLCore.verify()` can report them under their
+     * own `rule-deprecation` ruleId instead of `config-error`.
+     */
+    readonly ruleDeprecations?: readonly RuleAliasWarning[];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/ml-core",
-	"version": "5.0.0-rc.5",
+	"version": "5.0.0-rc.7",
 	"description": "The core module of markuplint",
 	"repository": {
 		"type": "git",
@@ -34,20 +34,20 @@
 		"./lib/configs.js": "./lib/configs.browser.js"
 	},
 	"dependencies": {
-		"@markuplint/config-presets": "5.0.0-rc.5",
-		"@markuplint/html-parser": "5.0.0-rc.5",
-		"@markuplint/html-spec": "5.0.0-rc.5",
-		"@markuplint/i18n": "5.0.0-rc.5",
-		"@markuplint/ml-ast": "5.0.0-rc.5",
-		"@markuplint/ml-config": "5.0.0-rc.5",
-		"@markuplint/ml-spec": "5.0.0-rc.5",
-		"@markuplint/parser-utils": "5.0.0-rc.5",
-		"@markuplint/selector": "5.0.0-rc.5",
-		"@markuplint/shared": "5.0.0-rc.5",
+		"@markuplint/config-presets": "5.0.0-rc.7",
+		"@markuplint/html-parser": "5.0.0-rc.7",
+		"@markuplint/html-spec": "5.0.0-rc.7",
+		"@markuplint/i18n": "5.0.0-rc.7",
+		"@markuplint/ml-ast": "5.0.0-rc.7",
+		"@markuplint/ml-config": "5.0.0-rc.7",
+		"@markuplint/ml-spec": "5.0.0-rc.7",
+		"@markuplint/parser-utils": "5.0.0-rc.7",
+		"@markuplint/selector": "5.0.0-rc.7",
+		"@markuplint/shared": "5.0.0-rc.7",
 		"@types/debug": "4.1.13",
 		"debug": "4.4.3",
 		"is-plain-object": "5.0.0",
 		"type-fest": "5.6.0"
 	},
-	"gitHead": "8d87463af2ff3f1b83fb28da20f1819362cf3555"
+	"gitHead": "8d7a3b801e0f5f88438c003e7eee2bd45e6aedd0"
 }