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

package/lib/ml-rule/ml-rule.d.ts

@@ -2,6 +2,7 @@ import type { RuleSeed } from './types.js';
 import type { MLDocument } from '../ml-dom/node/document.js';
 import type { Ruleset } from '../ruleset/index.js';
 import type { LocaleSet } from '@markuplint/i18n';
+import type { MLASTParseErrorCode } from '@markuplint/ml-ast';
 import type { GlobalRuleInfo, SpecConformance, PlainData, Rule, RuleConfigValue, RuleInfo, Severity, Violation } from '@markuplint/ml-config';
 /**
  * Represents a single markuplint rule that can verify documents and report violations.
@@ -28,8 +29,26 @@ export declare class MLRule<T extends RuleConfigValue, O extends PlainData = und
     /**
      * The spec conformance classification of this rule, based on RFC 2119 keyword strength.
      * Set on virtual rules derived from named nodeRules in presets.
+     *
+     * Intentionally restricted to named (preset-authored) entries: built-in
+     * rules already bake normative strength into `defaultSeverity`, and
+     * user-defined nodeRules express project conventions rather than spec
+     * requirements — allowing it on arbitrary config would blur "the HTML spec
+     * requires this" with "our team prefers this". The `/`-containing `name`
+     * requirement acts as the gatekeeper. It is reporting metadata only and
+     * never influences severity; severity changes require an explicit
+     * `defaultSeverity` override on the alias.
      */
     readonly specConformance?: SpecConformance;
+    /**
+     * parse5 `ERR` codes this rule's detection covers. When the rule is active
+     * in the ruleset, ml-core's built-in `parse-error` channel skips events
+     * whose code is in this list, so users do not see duplicate violations.
+     *
+     * Declared per-rule in `meta.mirrorsParseErrorCodes`; defaults to an empty
+     * array when the rule does not mirror any parse5 event.
+     */
+    readonly mirrorsParseErrorCodes: readonly MLASTParseErrorCode[];
     constructor(o: Readonly<RuleSeed<T, O>> & {
         readonly name: string;
         readonly baseRuleId?: string;

package/lib/ml-rule/ml-rule.js

@@ -28,8 +28,26 @@ export class MLRule {
     /**
      * The spec conformance classification of this rule, based on RFC 2119 keyword strength.
      * Set on virtual rules derived from named nodeRules in presets.
+     *
+     * Intentionally restricted to named (preset-authored) entries: built-in
+     * rules already bake normative strength into `defaultSeverity`, and
+     * user-defined nodeRules express project conventions rather than spec
+     * requirements — allowing it on arbitrary config would blur "the HTML spec
+     * requires this" with "our team prefers this". The `/`-containing `name`
+     * requirement acts as the gatekeeper. It is reporting metadata only and
+     * never influences severity; severity changes require an explicit
+     * `defaultSeverity` override on the alias.
      */
     specConformance;
+    /**
+     * parse5 `ERR` codes this rule's detection covers. When the rule is active
+     * in the ruleset, ml-core's built-in `parse-error` channel skips events
+     * whose code is in this list, so users do not see duplicate violations.
+     *
+     * Declared per-rule in `meta.mirrorsParseErrorCodes`; defaults to an empty
+     * array when the rule does not mirror any parse5 event.
+     */
+    mirrorsParseErrorCodes;
     #v;
     constructor(o) {
         this.name = o.name;
@@ -42,6 +60,7 @@ export class MLRule {
         // See: https://github.com/markuplint/markuplint/issues/808
         this.defaultValue = (o.defaultValue === undefined ? true : o.defaultValue);
         this.defaultOptions = o.defaultOptions;
+        this.mirrorsParseErrorCodes = o.meta?.mirrorsParseErrorCodes ?? [];
         this.#v = o.verify;
     }
     /**
@@ -62,6 +81,10 @@ export class MLRule {
             defaultSeverity: options?.defaultSeverity ?? this.defaultSeverity,
             defaultValue: this.defaultValue,
             defaultOptions: this.defaultOptions,
+            // Inherit `mirrorsParseErrorCodes` so virtual rules (alias-named
+            // nodeRules) participate in the parse-error dedupe under their
+            // base rule's mirror list.
+            meta: { mirrorsParseErrorCodes: this.mirrorsParseErrorCodes },
             verify: this.#v,
         });
     }
@@ -116,6 +139,7 @@ export class MLRule {
                     : configSettings.value,
                 options: mergeOptions(this.defaultOptions, configSettings.options),
                 reason: configSettings.reason,
+                ...(configSettings.reasonOnly === undefined ? {} : { reasonOnly: configSettings.reasonOnly }),
             };
         }
         return {
@@ -147,7 +171,6 @@ export class MLRule {
         // Only include name and specConformance for virtual rules (named nodeRules)
         const aliasName = this.baseRuleId ? this.name : undefined;
         const violations = context.reports.map(report => {
-            // Execute fix callback if fix mode is enabled
             let fixData;
             if (fix && report.fix) {
                 const edits = report.fix(sharedFixer);
@@ -167,29 +190,25 @@ export class MLRule {
                 }
                 return {
                     severity: report.scope.rule.severity,
-                    message: report.message,
+                    ...resolveMessageAndReason(report.message, report.scope.rule.reason ?? document.rule.reason, report.scope.rule.reasonOnly ?? document.rule.reasonOnly),
                     line,
                     col,
                     raw,
                     ruleId,
                     ...(aliasName != null && { name: aliasName }),
                     ...(this.specConformance != null && { specConformance: this.specConformance }),
-                    ...((report.scope.rule.reason ?? document.rule.reason)
-                        ? { reason: report.scope.rule.reason ?? document.rule.reason }
-                        : {}),
                     ...(fixData != null && { fix: fixData }),
                 };
             }
             return {
                 severity: document.rule.severity,
-                message: report.message,
+                ...resolveMessageAndReason(report.message, document.rule.reason, document.rule.reasonOnly),
                 line: report.line,
                 col: report.col,
                 raw: report.raw,
                 ruleId,
                 ...(aliasName != null && { name: aliasName }),
                 ...(this.specConformance != null && { specConformance: this.specConformance }),
-                ...(document.rule.reason ? { reason: document.rule.reason } : {}),
                 ...(fixData != null && { fix: fixData }),
             };
         });
@@ -205,6 +224,18 @@ export class MLRule {
 function isRuleConfig(data) {
     return isPlainObject(data);
 }
+/**
+ * Resolves a violation's `message`/`reason` pair from the rule's configured `reason`/`reasonOnly`.
+ * When `reasonOnly` is set and a `reason` is configured, `reason` replaces `message` entirely and
+ * is omitted from the result (it is now redundant with `message`); otherwise `reason` is appended
+ * as a separate field, preserving the original `message`.
+ */
+function resolveMessageAndReason(message, reason, reasonOnly) {
+    if (reason && reasonOnly) {
+        return { message: reason };
+    }
+    return { message, ...(reason ? { reason } : {}) };
+}
 function mergeOptions(a, b) {
     if (Array.isArray(a) && Array.isArray(b)) {
         // @ts-ignore

package/lib/ml-rule/types.d.ts

@@ -1,7 +1,77 @@
 import type { MLRuleContext } from './ml-rule-context.js';
 import type { Attr, Element } from '../ml-dom/index.js';
 import type { Translator } from '@markuplint/i18n';
+import type { MLASTParseErrorCode } from '@markuplint/ml-ast';
 import type { PlainData, Report, RuleConfigValue, Severity } from '@markuplint/ml-config';
+/**
+ * The specification, standard, or guidance document a rule's check derives from.
+ * A rule may cite more than one (e.g. a check spanning HTML LS and WAI-ARIA).
+ *
+ * - `'html'` — WHATWG HTML Living Standard
+ * - `'wai-aria'` — W3C WAI-ARIA
+ * - `'aria-in-html'` — W3C ARIA in HTML
+ * - `'dpub-aria'` — W3C Digital Publishing WAI-ARIA Module
+ * - `'graphics-aria'` — W3C Graphics ARIA
+ * - `'accname'` — W3C Accessible Name and Description Computation
+ * - `'apg'` — W3C ARIA Authoring Practices Guide (non-normative)
+ * - `'wcag'` — W3C Web Content Accessibility Guidelines (success criteria or
+ *   non-normative techniques — see {@link RuleConformanceLevel})
+ * - `'bcd'` — MDN `browser-compat-data` (a factual dataset, not a specification)
+ * - `'none'` — no spec basis; a tool-defined or user-configurable check
+ */
+export type RuleConformanceSource = 'html' | 'wai-aria' | 'aria-in-html' | 'dpub-aria' | 'graphics-aria' | 'accname' | 'apg' | 'wcag' | 'bcd' | 'none';
+/**
+ * How strongly a rule's check is backed by its {@link RuleConformanceSource}s.
+ * This is the basis {@link deriveDefaultSeverityFromConformanceLevel} uses to
+ * derive the policy default severity — see that function for the mapping.
+ *
+ * - `'must'` — a normative MUST/MUST NOT (including HTML parse errors, and a
+ *   WCAG success criterion violation)
+ * - `'should'` — a normative SHOULD/SHOULD NOT
+ * - `'non-normative'` — a spec Note, an APG practice, or a WCAG technique
+ * - `'factual'` — checked against factual data (e.g. `bcd`) rather than a
+ *   conformance requirement
+ * - `'opinion'` — the spec permits the pattern; the rule enforces a tool or
+ *   team preference
+ * - `'configurable'` — a user-defined constraint with no spec basis; the rule
+ *   is a mechanism the user configures, not a fixed check
+ */
+export type RuleConformanceLevel = 'must' | 'should' | 'non-normative' | 'factual' | 'opinion' | 'configurable';
+/**
+ * A citation for a rule's {@link RuleConformance}: either a bare spec URL, or
+ * a WCAG success criterion reference (`sc`/`level`) alongside its URL.
+ */
+export type RuleConformanceCite = string | {
+    readonly url: string;
+    readonly sc?: string;
+    readonly level?: 'A' | 'AA' | 'AAA';
+};
+/**
+ * A rule's specification-conformance classification: what it's checking
+ * against, how strongly that source requires it, and where to read the
+ * requirement. Distinct from `@markuplint/ml-config`'s `SpecConformance`
+ * (`'normative' | 'non-normative'`), which is a coarse, optional tag a
+ * *user* attaches to their own named nodeRule groups for reporting and never
+ * affects severity. This classification is authored by the *rule*, is (in
+ * the medium term) mandatory on every built-in rule, and is the basis for
+ * the rule's default severity and its eligibility for spec-conformance
+ * presets such as `markuplint:html-standard`.
+ */
+export type RuleConformance = {
+    readonly sources: readonly RuleConformanceSource[];
+    readonly level: RuleConformanceLevel;
+    readonly cites: readonly RuleConformanceCite[];
+};
+/**
+ * Derives the policy default `Severity` for a {@link RuleConformanceLevel},
+ * or `undefined` for `'configurable'` (no policy applies — see
+ * {@link CONFORMANCE_LEVEL_DEFAULT_SEVERITY}).
+ *
+ * Used by `@markuplint/rules`'s registry test to flag rules whose
+ * `defaultSeverity` disagrees with their declared `specConformance.level`
+ * without an accompanying `severityRationale`.
+ */
+export declare function deriveDefaultSeverityFromConformanceLevel(level: RuleConformanceLevel): Severity | undefined;
 /**
  * The definition of a markuplint rule, including verification logic
  * and default configuration values.
@@ -11,7 +81,46 @@ import type { PlainData, Report, RuleConfigValue, Severity } from '@markuplint/m
  */
 export type RuleSeed<T extends RuleConfigValue = boolean, O extends PlainData = undefined> = {
     readonly meta?: {
-        readonly category?: 'validation' | 'style' | 'naming-convention' | 'a11y' | 'maintainability';
+        readonly category?: 'syntax' | 'structure' | 'attributes' | 'references' | 'forms' | 'a11y' | 'style' | 'maintainability' | 'compat';
+        /**
+         * This rule's specification-conformance classification. See
+         * {@link RuleConformance}. Intended to become mandatory on every
+         * built-in rule; until the v5 rule-system redesign finishes rolling
+         * it out across `@markuplint/rules`, it remains optional so partially
+         * migrated rules do not fail the build.
+         */
+        readonly specConformance?: RuleConformance;
+        /**
+         * Explains why this rule's `defaultSeverity` deliberately departs
+         * from the policy value {@link deriveDefaultSeverityFromConformanceLevel}
+         * derives from `meta.specConformance.level`. Required whenever the
+         * two disagree; the `@markuplint/rules` registry test enforces this.
+         */
+        readonly severityRationale?: string;
+        /**
+         * parse5 `ERR` codes whose detection this rule covers. When the rule is
+         * active in the ruleset, `@markuplint/ml-core`'s built-in `parse-error`
+         * channel skips events whose `code` appears in this list — so the user
+         * does not get duplicate violations for the same underlying parse5
+         * event (one from this rule, one from the parse-error channel).
+         *
+         * Declare a code here only if the rule's detection scope is at least
+         * as broad as the parse5 event (i.e. every situation where parse5
+         * fires the code, the rule reports it too). For rules whose detection
+         * is wider than parse5 (e.g. `no-duplicate-attr` also covers JSX where
+         * parse5 never runs) this still holds because the rule fires first.
+         *
+         * The dedupe is global (the rule is checked at the ruleset level, not
+         * per node), so partial-scope rules like `no-duplicate-attr` (HTML
+         * elements only via parse5; JSX / SVG via the rule itself) are safe:
+         * parse5 only fires on HTML anyway. Note that `nodeRules` entries that
+         * locally disable a mirroring rule do not change this decision.
+         *
+         * A mirroring rule typically produces its own violation by reading
+         * `document.parseErrors`; see the `character-reference` rule in
+         * `@markuplint/rules` for the canonical hook example.
+         */
+        readonly mirrorsParseErrorCodes?: readonly MLASTParseErrorCode[];
     };
     readonly defaultSeverity?: Severity;
     readonly defaultValue?: T;

package/lib/ml-rule/types.js

@@ -1 +1,28 @@
-export {};
+/**
+ * The policy-derived default `Severity` for each {@link RuleConformanceLevel}.
+ * `'configurable'` has no policy value — a rule at that level either omits
+ * `defaultSeverity` (falling back to the engine's own `'error'` default,
+ * matching `no-restricted-*`-style rules that are inert until configured) or
+ * sets one deliberately to fit how it's typically used.
+ *
+ * @see deriveDefaultSeverityFromConformanceLevel
+ */
+const CONFORMANCE_LEVEL_DEFAULT_SEVERITY = {
+    must: 'error',
+    should: 'warning',
+    'non-normative': 'warning',
+    factual: 'warning',
+    opinion: 'warning',
+};
+/**
+ * Derives the policy default `Severity` for a {@link RuleConformanceLevel},
+ * or `undefined` for `'configurable'` (no policy applies — see
+ * {@link CONFORMANCE_LEVEL_DEFAULT_SEVERITY}).
+ *
+ * Used by `@markuplint/rules`'s registry test to flag rules whose
+ * `defaultSeverity` disagrees with their declared `specConformance.level`
+ * without an accompanying `severityRationale`.
+ */
+export function deriveDefaultSeverityFromConformanceLevel(level) {
+    return CONFORMANCE_LEVEL_DEFAULT_SEVERITY[level];
+}

package/lib/ruleset/index.d.ts

@@ -6,7 +6,8 @@ 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/wai-aria` wraps `wai-aria`, this maps `"wai-aria"` → `["a11y/wai-aria"]`.
+     * 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.
      */
     readonly baseRuleToVirtualNames: ReadonlyMap<string, readonly string[]>;

package/lib/ruleset/index.js

@@ -5,7 +5,8 @@
 export class Ruleset {
     /**
      * Maps base rule names to their virtual rule names created by NamedRuleGroups.
-     * For example, if `a11y/wai-aria` wraps `wai-aria`, this maps `"wai-aria"` → `["a11y/wai-aria"]`.
+     * 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.
      */
     baseRuleToVirtualNames;

package/lib/test/index.js

@@ -19,7 +19,7 @@ export function createTestDocument(sourceCode, options) {
             : options.parser.parse(sourceCode, options.config?.parserOptions)
         : parser.parse(sourceCode, options?.config?.parserOptions);
     const ruleset = convertRuleset(options?.config);
-    const document = new MLDocument(ast, ruleset, [options?.specs ?? {}, {}], { ariaVersion: ARIA_RECOMMENDED_VERSION }, options?.pretenders ? { pretenders: options.pretenders } : undefined);
+    const document = new MLDocument(ast, ruleset, [options?.specs ?? spec, {}], { ariaVersion: ARIA_RECOMMENDED_VERSION }, options?.pretenders ? { pretenders: options.pretenders } : undefined);
     return document;
 }
 /**

package/lib/virtual-rule.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Terminology policy: "virtual rule" is an internal implementation term for
+ * contributors only. User-facing documentation (website, migration guides,
+ * README) must say "named rule" instead — from a config user's perspective
+ * there are only two concepts, a base rule (e.g. `required-attr`) and a named
+ * rule (e.g. `a11y/html-lang`); the `MLRule` aliasing mechanics implemented
+ * here are intentionally not exposed.
+ *
+ * @module
+ */
 import type { AnyMLRule } from './ml-rule/index.js';
 import type { Rules, SpecConformance } from '@markuplint/ml-config';
 /**

package/lib/virtual-rule.js

@@ -32,17 +32,14 @@ export function expandNamedNodeRules(nodeRules, existingRules) {
     const usedAliasNames = new Set();
     for (const nodeRule of nodeRules) {
         if (!nodeRule.name) {
-            // Unnamed nodeRule: pass through unchanged
             transformedNodeRules.push(nodeRule);
             continue;
         }
         const namedRuleName = nodeRule.name;
-        // Validate name format (must contain /)
         if (!NAMED_NODE_RULE_PATTERN.test(namedRuleName)) {
             errors.push(new Error(`Named nodeRule name must contain "/" (e.g., "scope/rule-name"): "${namedRuleName}"`));
             continue;
         }
-        // Separate false entries from non-false entries
         const allEntries = Object.entries(nodeRule.rules ?? {});
         const nonFalseEntries = allEntries.filter(([, config]) => config !== false);
         const falseEntries = allEntries.filter(([, config]) => config === false);
@@ -50,13 +47,11 @@ export function expandNamedNodeRules(nodeRules, existingRules) {
             errors.push(new Error(`Named nodeRule "${namedRuleName}" must have at least one non-false rule entry`));
             continue;
         }
-        // Check for duplicate alias names
         if (usedAliasNames.has(namedRuleName)) {
             errors.push(new Error(`Duplicate named nodeRule: "${namedRuleName}"`));
             continue;
         }
         usedAliasNames.add(namedRuleName);
-        // Check for name collision with existing rules
         if (existingRuleMap.has(namedRuleName)) {
             errors.push(new Error(`Named nodeRule "${namedRuleName}" conflicts with an existing rule of the same name`));
             continue;
@@ -71,7 +66,6 @@ export function expandNamedNodeRules(nodeRules, existingRules) {
             // then adds replacement rules. T's extra properties (e.g., ChildNodeRule.inheritance) are preserved.
             transformedNodeRules.push(stripNamedProperties(nodeRule, falseRules));
         }
-        // Determine whether we need derived names (multi-entry)
         const useGroupName = nonFalseEntries.length > 1;
         const groupName = useGroupName ? namedRuleName : undefined;
         for (const [baseRuleName, ruleConfig] of nonFalseEntries) {
@@ -80,10 +74,7 @@ export function expandNamedNodeRules(nodeRules, existingRules) {
                 errors.push(new Error(`Base rule "${baseRuleName}" not found for named nodeRule "${namedRuleName}"`));
                 continue;
             }
-            // For multi-entry: derived name = "groupName/baseRuleName"
-            // For single-entry: use the name directly
             const aliasName = useGroupName ? `${namedRuleName}/${baseRuleName}` : namedRuleName;
-            // Check derived name collision
             if (existingRuleMap.has(aliasName)) {
                 errors.push(new Error(`Named nodeRule "${aliasName}" conflicts with an existing rule of the same name`));
                 continue;
@@ -95,14 +86,11 @@ export function expandNamedNodeRules(nodeRules, existingRules) {
             if (aliasName !== namedRuleName) {
                 usedAliasNames.add(aliasName);
             }
-            // Create virtual rule by aliasing the base rule
             const virtualRule = baseRule.createAlias(aliasName, {
                 specConformance: nodeRule.specConformance,
                 groupName,
             });
             virtualRules.push(virtualRule);
-            // Transform the nodeRule: change the rules key from base rule name to alias name,
-            // and strip the name/specConformance properties (consumed by the virtual rule)
             // Safety: same as above — T's structural properties are preserved by stripNamedProperties.
             transformedNodeRules.push(stripNamedProperties(nodeRule, { [aliasName]: ruleConfig }));
         }
@@ -110,9 +98,7 @@ export function expandNamedNodeRules(nodeRules, existingRules) {
     return { virtualRules, transformedNodeRules, errors };
 }
 /**
- * Creates a copy of the nodeRule with `name`, `specConformance`, and `rules` removed,
- * then adds the given replacement rules. Used to transform named nodeRules into
- * their expanded form.
+ * Used to transform named nodeRules into their expanded form.
  */
 function stripNamedProperties(nodeRule, replacementRules) {
     const result = {};
@@ -142,22 +128,18 @@ export function expandNamedRules(rules, existingRules) {
     const existingRuleMap = new Map(existingRules.map(r => [r.name, r]));
     const usedAliasNames = new Set();
     for (const [key, value] of Object.entries(rules)) {
-        // Non-namespaced keys: pass through as regular rules
         if (!key.includes('/')) {
             resolvedRules[key] = value;
             continue;
         }
-        // Wildcard patterns (e.g., "a11y/*"): pass through
         if (key.endsWith('/*')) {
             resolvedRules[key] = value;
             continue;
         }
-        // `false`: disable signal — pass through
         if (value === false) {
             resolvedRules[key] = false;
             continue;
         }
-        // NamedRuleGroup: expand into virtual rules
         if (isNamedRuleGroup(value)) {
             const groupKey = key;
             const { specConformance, severity: groupSeverity } = value;
@@ -168,13 +150,11 @@ export function expandNamedRules(rules, existingRules) {
                 errors.push(new Error(`Named rule group "${groupKey}" must have at least one non-false rule entry`));
                 continue;
             }
-            // Check for duplicate
             if (usedAliasNames.has(groupKey)) {
                 errors.push(new Error(`Duplicate named rule group: "${groupKey}"`));
                 continue;
             }
             usedAliasNames.add(groupKey);
-            // Check for name collision with existing rules
             if (existingRuleMap.has(groupKey)) {
                 errors.push(new Error(`Named rule group "${groupKey}" conflicts with an existing rule of the same name`));
                 continue;
@@ -192,7 +172,6 @@ export function expandNamedRules(rules, existingRules) {
                     continue;
                 }
                 const aliasName = useGroupName ? `${groupKey}/${baseRuleName}` : groupKey;
-                // Check collisions
                 if (existingRuleMap.has(aliasName)) {
                     errors.push(new Error(`Named rule group "${aliasName}" conflicts with an existing rule of the same name`));
                     continue;
@@ -204,14 +183,12 @@ export function expandNamedRules(rules, existingRules) {
                 if (aliasName !== groupKey) {
                     usedAliasNames.add(aliasName);
                 }
-                // Create virtual rule
                 const virtualRule = baseRule.createAlias(aliasName, {
                     specConformance,
                     groupName: gName,
                     defaultSeverity: effectiveDefaultSeverity,
                 });
                 virtualRules.push(virtualRule);
-                // Add the rule config under the alias name
                 resolvedRules[aliasName] = ruleConfig;
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/ml-core",
-	"version": "5.0.0-rc.2",
+	"version": "5.0.0-rc.5",
 	"description": "The core module of markuplint",
 	"repository": {
 		"type": "git",
@@ -10,7 +10,7 @@
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
 	"license": "MIT",
 	"engines": {
-		"node": ">=22"
+		"node": ">=24"
 	},
 	"type": "module",
 	"exports": {
@@ -34,20 +34,20 @@
 		"./lib/configs.js": "./lib/configs.browser.js"
 	},
 	"dependencies": {
-		"@markuplint/config-presets": "5.0.0-rc.2",
-		"@markuplint/html-parser": "5.0.0-rc.2",
-		"@markuplint/html-spec": "5.0.0-rc.2",
-		"@markuplint/i18n": "5.0.0-rc.2",
-		"@markuplint/ml-ast": "5.0.0-rc.2",
-		"@markuplint/ml-config": "5.0.0-rc.2",
-		"@markuplint/ml-spec": "5.0.0-rc.2",
-		"@markuplint/parser-utils": "5.0.0-rc.2",
-		"@markuplint/selector": "5.0.0-rc.2",
-		"@markuplint/shared": "5.0.0-rc.2",
+		"@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",
 		"@types/debug": "4.1.13",
 		"debug": "4.4.3",
 		"is-plain-object": "5.0.0",
-		"type-fest": "5.5.0"
+		"type-fest": "5.6.0"
 	},
-	"gitHead": "e43763858d9234c417053becc73dbd088c1e7ea6"
+	"gitHead": "8d87463af2ff3f1b83fb28da20f1819362cf3555"
 }