@markuplint/file-resolver 5.0.0-rc.4 → 5.0.0-rc.5

package/CHANGELOG.md

@@ -3,6 +3,25 @@
 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.5](https://github.com/markuplint/markuplint/compare/v5.0.0-rc.4...v5.0.0-rc.5) (2026-08-28)
+
+### Bug Fixes
+
+- **file-resolver:** make generalImport() OS-independent for POSIX absolute paths ([23aa492](https://github.com/markuplint/markuplint/commit/23aa492202a4b305022651210d9fc413e9baef2d)), closes [#3841](https://github.com/markuplint/markuplint/issues/3841) [#3843](https://github.com/markuplint/markuplint/issues/3843) [#3840](https://github.com/markuplint/markuplint/issues/3840)
+- **pretenders:** resolve same-named components via imports, not scan order ([#3957](https://github.com/markuplint/markuplint/issues/3957)) ([d46a514](https://github.com/markuplint/markuplint/commit/d46a5148c4d7afb156962f4ed795f40a9324e6c5)), closes [#3951](https://github.com/markuplint/markuplint/issues/3951) [#3951](https://github.com/markuplint/markuplint/issues/3951) [#3951](https://github.com/markuplint/markuplint/issues/3951)
+
+### Code Refactoring
+
+- **rules:** redesign v5 rule system — naming, splits, specConformance ([#3989](https://github.com/markuplint/markuplint/issues/3989)) ([e925565](https://github.com/markuplint/markuplint/commit/e925565ce537848d7d1573369723cbce724a841b)), closes [#4](https://github.com/markuplint/markuplint/issues/4) [#aside-conditional-role-mapping-aria-13](https://github.com/markuplint/markuplint/issues/aside-conditional-role-mapping-aria-13)
+
+### Features
+
+- add `pretenders.auto` for on-demand import-graph resolution ([#3962](https://github.com/markuplint/markuplint/issues/3962)) ([5870671](https://github.com/markuplint/markuplint/commit/58706711a20c12cff080d49359f3f6443345eca3)), closes [#3951](https://github.com/markuplint/markuplint/issues/3951) [#3957](https://github.com/markuplint/markuplint/issues/3957) [#3951](https://github.com/markuplint/markuplint/issues/3951) [#3957](https://github.com/markuplint/markuplint/issues/3957) [#3951](https://github.com/markuplint/markuplint/issues/3951) [#3957](https://github.com/markuplint/markuplint/issues/3957) [#3951](https://github.com/markuplint/markuplint/issues/3951) [#3957](https://github.com/markuplint/markuplint/issues/3957) [#3951](https://github.com/markuplint/markuplint/issues/3951) [#3957](https://github.com/markuplint/markuplint/issues/3957) [#3959](https://github.com/markuplint/markuplint/issues/3959) [#3951](https://github.com/markuplint/markuplint/issues/3951) [#3957](https://github.com/markuplint/markuplint/issues/3957) [#3951](https://github.com/markuplint/markuplint/issues/3951) [#3957](https://github.com/markuplint/markuplint/issues/3957) [#3959](https://github.com/markuplint/markuplint/issues/3959) [#3951](https://github.com/markuplint/markuplint/issues/3951) [#3951](https://github.com/markuplint/markuplint/issues/3951)
+
+### BREAKING CHANGES
+
+- **rules:** with no alias coverage.
+
 # [5.0.0-rc.4](https://github.com/markuplint/markuplint/compare/v5.0.0-rc.3...v5.0.0-rc.4) (2026-04-19)
 
 **Note:** Version bump only for package @markuplint/file-resolver

package/lib/general-import.js

@@ -1,11 +1,10 @@
 import fs from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import path from 'node:path';
-import { pathToFileURL } from 'node:url';
 import { isFatalError } from '@markuplint/shared';
 import { resolve } from 'import-meta-resolve';
 import { log } from './debug.js';
-import { fromFileURL } from './path-utils.js';
+import { fromFileURL, toFileURL } from './path-utils.js';
 const gLog = log.extend('general-import');
 const gLogSuccess = gLog.extend('success');
 const gLogError = gLog.extend('error');
@@ -27,11 +26,11 @@ export async function generalImport(name) {
         return result;
     }
     try {
-        // Convert absolute paths to file:// URL format
-        let importPath = name;
-        if (path.isAbsolute(name)) {
-            // Use Node.js pathToFileURL function to convert to a proper URL
-            importPath = pathToFileURL(name).href;
+        // Convert absolute paths to file:// URL format. `toFileURL()` is
+        // OS-independent (see #3840 — Node's `pathToFileURL()` resolves a
+        // POSIX-style absolute path against the current Windows drive).
+        const importPath = toFileURL(name);
+        if (importPath !== name) {
             gLog('Converted to file URL: %s', importPath);
         }
         const imported = await import(importPath);
@@ -41,6 +40,18 @@ export async function generalImport(name) {
         return mod;
     }
     catch (error) {
+        // NOTE: `isFatalError()` is intentionally NOT applied at this catch
+        // boundary. `await import()` / `require()` invoke third-party module
+        // code, so any Tier-1-shaped error (TypeError / SyntaxError / etc.)
+        // at this point may originate from inside the imported module and
+        // not from markuplint's own code — we cannot distinguish the two.
+        // The Tier 1 classification (see `isFatalError()` in
+        // `@markuplint/shared`) only covers errors raised by markuplint's
+        // own code, which excludes third-party import failures (e.g. Node 22+ removing
+        // import assertion syntax, or bun's stricter ESM parser). Treating
+        // every error as a recoverable null-return is the correct policy
+        // here; callers (config / parser / plugin loaders) decide how to
+        // surface the missing module.
         if (
         // @ts-ignore
         'code' in error &&
@@ -93,13 +104,10 @@ export async function generalImport(name) {
     }
 }
 /**
- * Detects a bare package subpath specifier (e.g., `@scope/pkg/file.json`)
- * and resolves it to an absolute file path when the package's exports map
- * does not include the subpath.
- *
- * Returns the absolute path if resolution succeeds, or `null` if:
+ * Returns `null` (rather than throwing) in three distinct cases that callers
+ * treat identically — no bypass is needed:
  * - The specifier is not a package subpath (absolute path, relative path, no subpath)
- * - The package's exports map already includes the subpath (no bypass needed)
+ * - The package's exports map already includes the subpath
  * - The package cannot be found at all
  */
 function resolvePackageSubpath(name) {
@@ -138,9 +146,6 @@ function resolvePackageSubpath(name) {
         return null;
     }
 }
-/**
- * Resolves the root directory of a package by name.
- */
 function resolvePackageDir(packageName) {
     // Try CJS require.resolve first — it can often resolve package.json
     // even when the ESM exports map doesn't include it

package/lib/path-utils.d.ts

@@ -1,19 +1,33 @@
-/**
- * Convert OS-native separators to forward slashes.
- * Identity function on POSIX.
- */
+/** Identity function on POSIX. */
 export declare function toSlash(filePath: string): string;
-/**
- * Convert a `file://` URL to a native file path using Node.js built-in.
- * Correctly handles URL encoding, UNC paths, and all drive letters.
- */
 export declare function fromFileURL(fileUrl: string): string;
 /**
- * Normalize a path for the `ignore` library (gitignore-style matching).
- * Removes drive letters, converts to forward slashes, and optionally makes relative.
+ * Convert an absolute file path (Windows or POSIX) into a `file://` URL
+ * suitable for `import()`. Bare module specifiers and relative paths are
+ * returned unchanged.
+ *
+ * Node's `pathToFileURL()` is intentionally avoided: on Windows it
+ * resolves a POSIX-style absolute path against the *current drive* and
+ * emits `file:///D:/tmp/foo` instead of `file:///tmp/foo` (#3840); on
+ * POSIX it likewise mishandles Windows-style drive paths. Constructing
+ * the URL ourselves keeps the function OS-independent so POSIX CI
+ * exercises the Windows code path. Each segment is percent-encoded so
+ * that spaces (`Program Files`), non-ASCII characters (e.g. Japanese
+ * usernames), and URL-reserved characters like `#` / `?` do not get
+ * reinterpreted as fragment / query delimiters by Node's URL parser.
+ *
+ * Mirrors `vscode/src/server/get-module.ts`'s `toImportSpecifier()` —
+ * keep the two in sync when adjusting Windows-path handling.
+ *
+ * Known limitation: UNC paths (`\\server\share\...`) are passed through
+ * unchanged.
+ *
+ * @see https://github.com/markuplint/markuplint/issues/3840
+ * @see https://github.com/markuplint/markuplint/issues/3836
+ * @see https://nodejs.org/api/esm.html#urls
  */
+export declare function toFileURL(filePath: string): string;
+/** Normalizes for the `ignore` library, whose matching is gitignore-style. */
 export declare function normalizeForIgnore(filePath: string, relative?: boolean): string;
-/**
- * Normalize a path for glob libraries (forward slashes required).
- */
+/** Glob libraries require forward slashes. */
 export declare function normalizeForGlob(filePath: string): string;

package/lib/path-utils.js

@@ -1,23 +1,57 @@
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-/**
- * Convert OS-native separators to forward slashes.
- * Identity function on POSIX.
- */
+/** Identity function on POSIX. */
 export function toSlash(filePath) {
     return filePath.replaceAll('\\', '/');
 }
-/**
- * Convert a `file://` URL to a native file path using Node.js built-in.
- * Correctly handles URL encoding, UNC paths, and all drive letters.
- */
 export function fromFileURL(fileUrl) {
     return fileURLToPath(fileUrl);
 }
 /**
- * Normalize a path for the `ignore` library (gitignore-style matching).
- * Removes drive letters, converts to forward slashes, and optionally makes relative.
+ * Convert an absolute file path (Windows or POSIX) into a `file://` URL
+ * suitable for `import()`. Bare module specifiers and relative paths are
+ * returned unchanged.
+ *
+ * Node's `pathToFileURL()` is intentionally avoided: on Windows it
+ * resolves a POSIX-style absolute path against the *current drive* and
+ * emits `file:///D:/tmp/foo` instead of `file:///tmp/foo` (#3840); on
+ * POSIX it likewise mishandles Windows-style drive paths. Constructing
+ * the URL ourselves keeps the function OS-independent so POSIX CI
+ * exercises the Windows code path. Each segment is percent-encoded so
+ * that spaces (`Program Files`), non-ASCII characters (e.g. Japanese
+ * usernames), and URL-reserved characters like `#` / `?` do not get
+ * reinterpreted as fragment / query delimiters by Node's URL parser.
+ *
+ * Mirrors `vscode/src/server/get-module.ts`'s `toImportSpecifier()` —
+ * keep the two in sync when adjusting Windows-path handling.
+ *
+ * Known limitation: UNC paths (`\\server\share\...`) are passed through
+ * unchanged.
+ *
+ * @see https://github.com/markuplint/markuplint/issues/3840
+ * @see https://github.com/markuplint/markuplint/issues/3836
+ * @see https://nodejs.org/api/esm.html#urls
  */
+export function toFileURL(filePath) {
+    const isWindowsAbsolute = /^[a-z]:[/\\]/i.test(filePath);
+    const isPosixAbsolute = filePath.startsWith('/');
+    if (!isWindowsAbsolute && !isPosixAbsolute) {
+        return filePath;
+    }
+    if (isWindowsAbsolute) {
+        // The drive-letter segment (`c:`) is kept as-is to match the
+        // `pathToFileURL` output shape on Windows (`file:///c:/...`).
+        const [drive, ...rest] = filePath.replaceAll('\\', '/').split('/');
+        const encoded = [drive, ...rest.map(segment => encodeURIComponent(segment))].join('/');
+        return `file:///${encoded}`;
+    }
+    // POSIX absolute path. Splitting `/tmp/foo` by `/` yields `['', 'tmp',
+    // 'foo']`; the leading empty element produces the `file:///` prefix
+    // after `join('/')`, so the round-trip is exactly `file:///tmp/foo`.
+    const segments = filePath.split('/').map(segment => encodeURIComponent(segment));
+    return `file://${segments.join('/')}`;
+}
+/** Normalizes for the `ignore` library, whose matching is gitignore-style. */
 export function normalizeForIgnore(filePath, relative = false) {
     const hasBang = filePath.startsWith('!');
     if (hasBang) {
@@ -38,9 +72,7 @@ export function normalizeForIgnore(filePath, relative = false) {
     }
     return filePath;
 }
-/**
- * Normalize a path for glob libraries (forward slashes required).
- */
+/** Glob libraries require forward slashes. */
 export function normalizeForGlob(filePath) {
     return toSlash(filePath);
 }

package/lib/resolve-pretenders.d.ts

@@ -1,8 +1,20 @@
 import type { OptimizedConfig, Pretender } from '@markuplint/ml-config';
 type PretendersConfig = OptimizedConfig['pretenders'];
+/**
+ * The lint target's own identity, needed only to resolve `config.auto`.
+ * Omitting this (or omitting `config.auto`) skips auto-resolution entirely,
+ * so every other resolution source works exactly as before without it.
+ */
+export type ResolvePretendersContext = {
+    /** Absolute path of the file being linted */
+    readonly filePath: string;
+    /** Full source text of the file being linted (may be unsaved editor content) */
+    readonly sourceCode: string;
+};
 /**
  * Resolves pretender definitions from files, imported modules, inline data,
- * and dynamic component scanning in the configuration.
+ * dynamic component scanning, and (when `context` is given) the lint
+ * target's own import graph.
  *
  * Resolution order:
  * 1. `config.files` — direct import of pretender data files
@@ -12,9 +24,53 @@ type PretendersConfig = OptimizedConfig['pretenders'];
  * 3. `config.data` — inline pretender definitions
  * 4. `config.scan` — dynamic component scanning via glob patterns
  *    (`files` accepts `string | string[]`)
+ * 5. `config.auto` — on-demand scan of `context`'s own import graph (requires
+ *    `context`; a no-op without it, e.g. when the caller has no lint target yet)
  *
  * @param config - The pretenders configuration section from the optimized config
+ * @param context - The lint target's path/source, required only for `config.auto`
  * @returns An array of all resolved pretender definitions
  */
-export declare function resolvePretenders(config: PretendersConfig): Promise<Pretender[]>;
+export declare function resolvePretenders(config: PretendersConfig, context?: ResolvePretendersContext): Promise<Pretender[]>;
+/**
+ * Resolves selector collisions in `pretenders` for the specific file about
+ * to be linted, deferring to `@markuplint/pretenders`' `disambiguatePretenders`
+ * only when there's actually a same-selector, file-backed collision to
+ * resolve — this keeps the common case (no ambiguity) free of both the
+ * dynamic import and any file/AST work.
+ *
+ * @param filePath - Absolute path of the file being linted
+ * @param sourceCode - Full source text of the file being linted
+ * @param pretenders - The flat pretender list {@link resolvePretenders} produced
+ * @returns The disambiguated pretender list, or `pretenders` itself (same
+ *   reference) when there was no collision to resolve
+ */
+export declare function disambiguatePretendersForFile(filePath: string, sourceCode: string, pretenders: readonly Pretender[]): Promise<readonly Pretender[]>;
+/**
+ * Deliberately gates on selector+filePath duplication alone — NOT on the
+ * selector name shape `@markuplint/pretenders`' `disambiguatePretenders`
+ * actually resolves (plain identifiers only). Duplicating that name-shape
+ * check here would let the two independently maintained filters drift out
+ * of sync: if the real filter is ever loosened without updating this one,
+ * this fast-path gate would keep skipping the dynamic import for cases the
+ * real logic would now handle, silently disabling disambiguation for them.
+ * Being a strict superset costs at most an unnecessary dynamic import for
+ * selectors the real logic ends up not touching — never a missed one.
+ *
+ * @param pretenders - The flat pretender list to check
+ * @returns `true` if some `selector` is shared by two or more `filePath`-backed entries
+ */
+export declare function hasResolvableCollision(pretenders: readonly Pretender[]): boolean;
+/**
+ * Clears `@markuplint/pretenders`' module-level import/export resolution
+ * caches. Call this whenever a lint host re-resolves config without cache
+ * (e.g. watch mode after a file change) — otherwise a renamed export or a
+ * newly valid tsconfig `paths` alias keeps resolving as it did before the
+ * change for the rest of the process's lifetime. A no-op (not an error) when
+ * `@markuplint/pretenders` isn't installed, since nothing has populated its
+ * caches in that case either.
+ *
+ * @returns A promise that resolves once the caches have been cleared
+ */
+export declare function invalidatePretenderResolutionCaches(): Promise<void>;
 export {};

package/lib/resolve-pretenders.js

@@ -1,9 +1,22 @@
 import path from 'node:path';
+import { rebasePretenderFilePath } from '@markuplint/ml-config';
 import { glob } from 'glob';
 import { generalImport } from './general-import.js';
+/**
+ * `Pretender.filePath` is written by scanners relative to their own base
+ * directory, which is meaningless once entries from files/scan results
+ * scattered across different directories are merged into one flat list.
+ * Rebasing to an absolute path immediately after each source is read is
+ * what lets {@link disambiguatePretendersForFile} later compare a
+ * pretender's origin file against the lint target's resolved imports.
+ */
+function rebasePretenderFilePaths(pretenders, baseDir) {
+    return pretenders.map(pretender => rebasePretenderFilePath(pretender, relPath => path.resolve(baseDir, relPath)));
+}
 /**
  * Resolves pretender definitions from files, imported modules, inline data,
- * and dynamic component scanning in the configuration.
+ * dynamic component scanning, and (when `context` is given) the lint
+ * target's own import graph.
  *
  * Resolution order:
  * 1. `config.files` — direct import of pretender data files
@@ -13,11 +26,14 @@ import { generalImport } from './general-import.js';
  * 3. `config.data` — inline pretender definitions
  * 4. `config.scan` — dynamic component scanning via glob patterns
  *    (`files` accepts `string | string[]`)
+ * 5. `config.auto` — on-demand scan of `context`'s own import graph (requires
+ *    `context`; a no-op without it, e.g. when the caller has no lint target yet)
  *
  * @param config - The pretenders configuration section from the optimized config
+ * @param context - The lint target's path/source, required only for `config.auto`
  * @returns An array of all resolved pretender definitions
  */
-export async function resolvePretenders(config) {
+export async function resolvePretenders(config, context) {
     if (!config) {
         return [];
     }
@@ -28,7 +44,9 @@ export async function resolvePretenders(config) {
             if (!pretenderFile?.data) {
                 continue;
             }
-            data.push(...pretenderFile.data);
+            // `file` is already absolute (resolved by the config provider), so its
+            // own directory is the correct base for the entries it carries.
+            data.push(...rebasePretenderFilePaths(pretenderFile.data, path.dirname(file)));
         }
     }
     if (config.imports) {
@@ -40,6 +58,10 @@ export async function resolvePretenders(config) {
             if (!pretenderFile?.data) {
                 continue;
             }
+            // The on-disk location of an npm package's pretenders data isn't
+            // recoverable from `generalImport`'s return value, so these entries'
+            // filePath is left as-is — disambiguation simply can't confirm them
+            // (see the module JSDoc for the fallback policy this implies).
             data.push(...pretenderFile.data);
         }
     }
@@ -56,9 +78,100 @@ export async function resolvePretenders(config) {
                 const scanned = await scan(resolved, {
                     ignoreComponentNames: entry.ignoreComponentNames ? [...entry.ignoreComponentNames] : undefined,
                 });
-                data.push(...scanned);
+                // `scan()` (with no `cwd` option) reports filePath relative to `process.cwd()`.
+                data.push(...rebasePretenderFilePaths(scanned, process.cwd()));
+            }
+        }
+    }
+    if (config.auto && context) {
+        const { autoScan } = await import('@markuplint/pretenders');
+        const scanned = await autoScan(context.filePath, context.sourceCode);
+        // `autoScan()` reports filePath relative to `process.cwd()`, same as `scan()`.
+        const rebased = rebasePretenderFilePaths(scanned, process.cwd());
+        // `scan` and `auto` can both walk into the same file (e.g. a component
+        // `scan`'s glob already covers that `auto`'s import-graph walk also
+        // reaches); de-duping on (selector, filePath) keeps that file's entry
+        // from appearing twice while still letting a same-selector entry from a
+        // genuinely different file through for `disambiguatePretendersForFile`
+        // to resolve. `selector` is a markuplint CSS-like selector and can
+        // legitimately contain spaces (a descendant combinator), so the pair is
+        // joined via `JSON.stringify` rather than a plain-string delimiter —
+        // otherwise two distinct (selector, filePath) pairs could concatenate to
+        // the same string and be mistaken for a duplicate.
+        const dedupeKey = (p) => JSON.stringify([p.selector, p.filePath]);
+        const seen = new Set(data.filter(p => p.filePath).map(p => dedupeKey(p)));
+        for (const pretender of rebased) {
+            if (pretender.filePath) {
+                const key = dedupeKey(pretender);
+                if (seen.has(key)) {
+                    continue;
+                }
+                seen.add(key);
             }
+            data.push(pretender);
         }
     }
     return data;
 }
+/**
+ * Resolves selector collisions in `pretenders` for the specific file about
+ * to be linted, deferring to `@markuplint/pretenders`' `disambiguatePretenders`
+ * only when there's actually a same-selector, file-backed collision to
+ * resolve — this keeps the common case (no ambiguity) free of both the
+ * dynamic import and any file/AST work.
+ *
+ * @param filePath - Absolute path of the file being linted
+ * @param sourceCode - Full source text of the file being linted
+ * @param pretenders - The flat pretender list {@link resolvePretenders} produced
+ * @returns The disambiguated pretender list, or `pretenders` itself (same
+ *   reference) when there was no collision to resolve
+ */
+export async function disambiguatePretendersForFile(filePath, sourceCode, pretenders) {
+    if (!hasResolvableCollision(pretenders)) {
+        return pretenders;
+    }
+    const { disambiguatePretenders } = await import('@markuplint/pretenders');
+    return disambiguatePretenders(pretenders, { filePath, sourceCode });
+}
+/**
+ * Deliberately gates on selector+filePath duplication alone — NOT on the
+ * selector name shape `@markuplint/pretenders`' `disambiguatePretenders`
+ * actually resolves (plain identifiers only). Duplicating that name-shape
+ * check here would let the two independently maintained filters drift out
+ * of sync: if the real filter is ever loosened without updating this one,
+ * this fast-path gate would keep skipping the dynamic import for cases the
+ * real logic would now handle, silently disabling disambiguation for them.
+ * Being a strict superset costs at most an unnecessary dynamic import for
+ * selectors the real logic ends up not touching — never a missed one.
+ *
+ * @param pretenders - The flat pretender list to check
+ * @returns `true` if some `selector` is shared by two or more `filePath`-backed entries
+ */
+export function hasResolvableCollision(pretenders) {
+    const seen = new Set();
+    for (const pretender of pretenders) {
+        if (!pretender.filePath) {
+            continue;
+        }
+        if (seen.has(pretender.selector)) {
+            return true;
+        }
+        seen.add(pretender.selector);
+    }
+    return false;
+}
+/**
+ * Clears `@markuplint/pretenders`' module-level import/export resolution
+ * caches. Call this whenever a lint host re-resolves config without cache
+ * (e.g. watch mode after a file change) — otherwise a renamed export or a
+ * newly valid tsconfig `paths` alias keeps resolving as it did before the
+ * change for the rest of the process's lifetime. A no-op (not an error) when
+ * `@markuplint/pretenders` isn't installed, since nothing has populated its
+ * caches in that case either.
+ *
+ * @returns A promise that resolves once the caches have been cleared
+ */
+export async function invalidatePretenderResolutionCaches() {
+    const pretendersMod = await import('@markuplint/pretenders').catch(() => null);
+    pretendersMod?.clearPretenderCaches();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/file-resolver",
-	"version": "5.0.0-rc.4",
+	"version": "5.0.0-rc.5",
 	"description": "The file resolver 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": {
@@ -31,18 +31,18 @@
 		"clean": "tsc --build --clean"
 	},
 	"devDependencies": {
-		"@types/node": "24.5.1"
+		"@types/node": "24.13.3"
 	},
 	"dependencies": {
-		"@markuplint/html-parser": "5.0.0-rc.4",
-		"@markuplint/ml-ast": "5.0.0-rc.4",
-		"@markuplint/ml-config": "5.0.0-rc.4",
-		"@markuplint/ml-core": "5.0.0-rc.4",
-		"@markuplint/ml-spec": "5.0.0-rc.4",
-		"@markuplint/parser-utils": "5.0.0-rc.4",
-		"@markuplint/pretenders": "5.0.0-rc.4",
-		"@markuplint/selector": "5.0.0-rc.4",
-		"@markuplint/shared": "5.0.0-rc.4",
+		"@markuplint/html-parser": "5.0.0-rc.5",
+		"@markuplint/ml-ast": "5.0.0-rc.5",
+		"@markuplint/ml-config": "5.0.0-rc.5",
+		"@markuplint/ml-core": "5.0.0-rc.5",
+		"@markuplint/ml-spec": "5.0.0-rc.5",
+		"@markuplint/parser-utils": "5.0.0-rc.5",
+		"@markuplint/pretenders": "5.0.0-rc.5",
+		"@markuplint/selector": "5.0.0-rc.5",
+		"@markuplint/shared": "5.0.0-rc.5",
 		"cosmiconfig": "9.0.1",
 		"debug": "4.4.3",
 		"glob": "13.0.6",
@@ -51,5 +51,5 @@
 		"jsonc": "2.0.0",
 		"minimatch": "10.2.5"
 	},
-	"gitHead": "97a6339bbae23f556de5d307b3ce2ef7cfd9402d"
+	"gitHead": "8d87463af2ff3f1b83fb28da20f1819362cf3555"
 }