@markuplint/ml-core 5.0.0-alpha.2 → 5.0.0-dev.5

package/ARCHITECTURE.ja.md

@@ -439,7 +439,7 @@ sequenceDiagram
 | `remove(token)`             | `startOffset` + `raw` を持つトークン | `range: [start, start+len], text: ""`   |
 | `removeRange(range)`        | 明示的な `[start, end)` レンジ       | `range: [start, end], text: ""`         |
 
-`token` パラメータは `startOffset` と `raw` プロパティを持つ任意のオブジェクトを受け付けます。MLDOM トークン（`MLToken`, `MLAttr` 等）は自然にこの要件を満たします。
+`token` パラメータは `FixToken` 型（`@markuplint/ml-config` で定義）を満たす任意のオブジェクト — つまり `{ startOffset: number; raw: string }` — を受け付けます。MLDOM トークン（`MLToken`, `MLAttr` 等）は自然にこの要件を満たします。
 
 ### FixApplier アルゴリズム
 
@@ -468,6 +468,39 @@ flowchart TD
 - `FixData` 間の重複はスキップ機構で処理される
 - `FixData` 内のいずれかの edit がスキップされると、その `FixData` 全体がスキップとして分類される
 
+### マルチパス Fix ループ
+
+`applyFixes()` がレンジの重複により一部の fix をスキップした場合、エンジンはマルチパスループ（`_multiPassFix()`）に入り、再パース・再検証を繰り返して修正可能な違反をすべて解決します:
+
+```mermaid
+flowchart TD
+    A["violations から fix を抽出"] --> B["applyFixes(code, fixes)"]
+    B --> C{"applied.length === 0?"}
+    C -- Yes --> Z["現在のコードを返す"]
+    C -- No --> D{"output === currentCode?"}
+    D -- Yes --> Z
+    D -- No --> E{"サイクル検出?\n(2パス前の出力と一致)"}
+    E -- Yes --> Z
+    E -- No --> F{"skipped.length === 0?"}
+    F -- Yes --> Z["修正済みコードを返す\n(全 fix 適用完了)"]
+    F -- No --> G["再パース + 再検証"]
+    G --> H{"ParserError?"}
+    H -- Yes --> Z["最後の正常なコードに戻す"]
+    H -- No --> I{"新たな修正可能な違反?"}
+    I -- No --> Z
+    I -- Yes --> B
+```
+
+主な設計ポイント:
+
+- **ゼロコストパス**: fix を持つ violation がなければ、マルチパスループは完全にスキップされる
+- **シングルパス高速パス**: `skipped.length === 0` のとき即座にループを抜ける（Phase 1 と同等の動作）
+- **サイクル検出**: 2パス前の出力と比較し、A→B→A の振動パターンを検出
+- **安全上限**: 最大10パス（ESLint の `SourceCodeFixer` と同じ）
+- **状態復元**: `verify()` は `try/finally` で `#sourceCode`、`#ast`、`#document` を保存・復元
+
+**重要**: `VerifyResult` の `violations` 配列は初回パスの結果のみを反映し、`fixedCode` は複数パスの結果である場合があります。修正後コードの正確な違反リストが必要な場合は、出力を再検証してください。
+
 ### 実例: ルールの Fix 実装
 
 ```typescript

package/ARCHITECTURE.md

@@ -53,6 +53,7 @@ src/
 │   ├── create-rule.ts                — createRule factory
 │   ├── create-test-rule.ts           — Test rule factory
 │   └── types.ts                      — RuleSeed, Checker types
+├── cursor-offset.ts                  — computeCursorOffset (cursor remapping after edits)
 ├── fix-applier.ts                    — applyFixes (overlap-aware TextEdit applicator)
 ├── ruleset/
 │   └── index.ts                      — Ruleset class (rules + nodeRules + childNodeRules)
@@ -133,7 +134,7 @@ flowchart LR
     A["MLCore\nconstructor"]
     B["_parse()\nParser → MLASTDocument"]
     C["_createDocument()\nMLASTDocument → MLDocument"]
-    D["verify(fix?)\nFor each rule:"]
+    D["verify(fix? | options?)\nFor each rule:"]
     E["document.setRule(rule)\nRuleMapper maps config → nodes"]
     F["rule.verify(document)\nMLRuleContext collects reports"]
     G["Violations[]"]
@@ -146,7 +147,7 @@ flowchart LR
 1. **Parse**: `MLCore` invokes the configured parser (`MLParser`) to produce an `MLASTDocument`
 2. **Create Document**: The AST is wrapped in an `MLDocument`, which builds the full MLDOM tree via `createNode()` factory. `RuleMapper` resolves rule configuration for every node
 3. **Verify**: For each `MLRule`, the engine calls `document.setRule(rule)` then `rule.verify(document)`. The rule walks relevant nodes via `document.walkOn()` and reports violations through `MLRuleContext`. Rules may attach inline `fix` callbacks to reports that return `TextEdit` objects
-4. **Fix** (optional): When `fix=true`, fix callbacks on reports are executed via `RuleFixer` to produce `TextEdit[]`. `FixApplier.applyFixes(sourceCode, fixes)` applies all edits to the source text with overlap detection
+4. **Fix** (optional): When `fix=true`, fix callbacks on reports are executed via `RuleFixer` to produce `TextEdit[]`. `FixApplier.applyFixes(sourceCode, fixes)` applies all edits to the source text with overlap detection. When fixes require multiple passes, `_multiPassFix()` orchestrates re-parsing and re-verification, returning a `FixSummary` with pass count, applied/skipped totals, and first-pass edits for cursor offset computation
 
 ## MLDOM Class Hierarchy
 
@@ -423,7 +424,7 @@ sequenceDiagram
 
     Core->>Core: Collect all FixData from violations
     Core->>FA: applyFixes(sourceCode, allFixes)
-    FA-->>Core: FixResult { output, applied, skipped }
+    FA-->>Core: FixResult { output, applied, skipped, appliedEdits }
 ```
 
 ### RuleFixer API
@@ -439,7 +440,7 @@ sequenceDiagram
 | `remove(token)`             | Token with `startOffset` + `raw` | `range: [start, start+len], text: ""`      |
 | `removeRange(range)`        | Explicit `[start, end)` range    | `range: [start, end], text: ""`            |
 
-The `token` parameter accepts any object with `startOffset` and `raw` properties. MLDOM tokens (`MLToken`, `MLAttr`, etc.) satisfy this naturally.
+The `token` parameter accepts any object satisfying the `FixToken` type (defined in `@markuplint/ml-config`) — i.e., `{ startOffset: number; raw: string }`. MLDOM tokens (`MLToken`, `MLAttr`, etc.) satisfy this naturally.
 
 ### FixApplier Algorithm
 
@@ -454,7 +455,7 @@ flowchart TD
     E["Skip edit\n(mark parent FixData as skipped)"]
     F["Apply edit\n(splice into output)"]
     G["Classify: each FixData as\napplied or skipped"]
-    H["Return FixResult\n{ output, applied, skipped }"]
+    H["Return FixResult\n{ output, applied, skipped, appliedEdits }"]
 
     A --> B --> C --> D
     D -- Yes --> E --> C
@@ -467,6 +468,88 @@ Key constraints:
 - Edits within a single `FixData` must not overlap each other
 - Inter-`FixData` overlap is handled by the skip mechanism
 - If any edit in a `FixData` is skipped, the entire `FixData` is classified as skipped
+- `appliedEdits` is a flat list of all successfully applied `TextEdit` objects, sorted by `range[0]` ascending — used for cursor offset computation
+
+### Multi-Pass Fix Loop
+
+When `applyFixes()` skips some fixes due to range overlap, the engine enters a multi-pass loop (`_multiPassFix()`) that re-parses and re-verifies until all fixable violations are resolved:
+
+```mermaid
+flowchart TD
+    A["Extract fixes from violations"] --> B["applyFixes(code, fixes)"]
+    B --> C{"applied.length === 0?"}
+    C -- Yes --> Z["Return current code"]
+    C -- No --> D{"output === currentCode?"}
+    D -- Yes --> Z
+    D -- No --> E{"Cycle detected?\n(output === code from 2 passes ago)"}
+    E -- Yes --> Z
+    E -- No --> F{"skipped.length === 0?"}
+    F -- Yes --> Z["Return fixed code\n(all fixes applied)"]
+    F -- No --> G["Re-parse + re-verify"]
+    G --> H{"ParserError?"}
+    H -- Yes --> Z["Revert to last good code"]
+    H -- No --> I{"New fixable violations?"}
+    I -- No --> Z
+    I -- Yes --> B
+```
+
+Key design points:
+
+- **Zero-cost path**: If no violations have fixes, the multi-pass loop is skipped entirely
+- **Single-pass fast path**: When `skipped.length === 0`, the loop exits immediately — equivalent to Phase 1 behavior
+- **Cycle detection**: Compares current output against the output from two passes ago to detect A→B→A oscillation
+- **Safety cap**: Maximum 10 passes (same as ESLint's `SourceCodeFixer`)
+- **State restoration**: `verify()` saves and restores `#sourceCode`, `#ast`, and `#document` via `try/finally`
+
+**Important**: The `violations` array in `VerifyResult` reflects the first pass only, while `fixedCode` may be the result of multiple passes. Callers needing an accurate violation list for the fixed code should re-verify the output.
+
+### VerifyResult and FixSummary
+
+`MLCore.verify()` accepts either a `boolean` or a `VerifyOptions` object:
+
+```typescript
+verify(fix?: boolean): Promise<VerifyResult>;
+verify(options?: VerifyOptions): Promise<VerifyResult>;
+```
+
+`VerifyResult` contains:
+
+| Field        | Type                      | Description                                                   |
+| ------------ | ------------------------- | ------------------------------------------------------------- |
+| `violations` | `readonly Violation[]`    | Violations from the first verification pass                   |
+| `fixedCode`  | `string \| undefined`     | Source after all fix passes; `undefined` when fix is disabled |
+| `fixSummary` | `FixSummary \| undefined` | Fix process summary; present when `fix=true`                  |
+
+`FixSummary` provides diagnostics about the multi-pass fix process:
+
+| Field              | Type                  | Description                                                      |
+| ------------------ | --------------------- | ---------------------------------------------------------------- |
+| `passCount`        | `number`              | Number of fix passes executed                                    |
+| `totalApplied`     | `number`              | Total fixes applied across all passes                            |
+| `totalSkipped`     | `number`              | Total fixes skipped (overlap) across all passes                  |
+| `reachedMaxPasses` | `boolean`             | Whether the 10-pass safety cap was reached                       |
+| `firstPassEdits`   | `readonly TextEdit[]` | Applied edits from the first pass only (original source offsets) |
+
+`firstPassEdits` references the original source code offsets, making them suitable for cursor remapping via `computeCursorOffset()`.
+
+### Cursor Offset Computation
+
+`computeCursorOffset()` (in `cursor-offset.ts`) maps a cursor position from the original source to the fixed source using the first-pass applied edits:
+
+```typescript
+import { computeCursorOffset } from '@markuplint/ml-core';
+
+const newOffset = computeCursorOffset(fixSummary.firstPassEdits, originalCursorOffset);
+```
+
+Algorithm:
+
+1. Walk through edits sorted by `range[0]` ascending
+2. For each edit before the cursor: accumulate `delta = text.length - (end - start)`
+3. For edits after the cursor: stop (no effect)
+4. If the cursor falls inside a replaced range `[start, end)`: place at `start + text.length`
+
+Ranges use half-open intervals: a cursor at position `end` is considered **outside** the edit.
 
 ### Example: Rule Fix in Practice
 

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [5.0.0-alpha.3](https://github.com/markuplint/markuplint/compare/v5.0.0-alpha.2...v5.0.0-alpha.3) (2026-02-26)
+
+### Bug Fixes
+
+- **ml-core:** treat edits within a single FixData as atomic unit ([0bb980b](https://github.com/markuplint/markuplint/commit/0bb980b7cc6fc9b89a82f3d4df58b7137a6b8766))
+
+### Features
+
+- **ml-core:** add cursor offset computation and fix summary metadata ([74b6e28](https://github.com/markuplint/markuplint/commit/74b6e28e4be2802e841697899f57f6ae04e4ffe9))
+- **ml-core:** add multi-pass fix loop and cycle detection ([866b1d5](https://github.com/markuplint/markuplint/commit/866b1d54199ed1f1b5195cd0f61f3ee392b1d8a7))
+
 # [5.0.0-alpha.2](https://github.com/markuplint/markuplint/compare/v5.0.0-alpha.1...v5.0.0-alpha.2) (2026-02-23)
 
 ### Features

package/lib/cursor-offset.d.ts

@@ -0,0 +1,13 @@
+import type { TextEdit } from '@markuplint/ml-config';
+/**
+ * Computes the new cursor offset after text edits have been applied.
+ *
+ * For each edit before the cursor: delta += text.length - (end - start).
+ * If the cursor falls inside a replaced range [start, end), it is placed
+ * at start + text.length (immediately after the replacement).
+ *
+ * @param appliedEdits - Applied edits sorted by range[0] ascending
+ * @param cursorOffset - Original 0-based cursor offset
+ * @returns New cursor offset in the fixed code
+ */
+export declare function computeCursorOffset(appliedEdits: readonly TextEdit[], cursorOffset: number): number;

package/lib/cursor-offset.js

@@ -0,0 +1,34 @@
+/**
+ * Computes the new cursor offset after text edits have been applied.
+ *
+ * For each edit before the cursor: delta += text.length - (end - start).
+ * If the cursor falls inside a replaced range [start, end), it is placed
+ * at start + text.length (immediately after the replacement).
+ *
+ * @param appliedEdits - Applied edits sorted by range[0] ascending
+ * @param cursorOffset - Original 0-based cursor offset
+ * @returns New cursor offset in the fixed code
+ */
+export function computeCursorOffset(appliedEdits, cursorOffset) {
+    let newOffset = cursorOffset;
+    for (const edit of appliedEdits) {
+        const [start, end] = edit.range;
+        const delta = edit.text.length - (end - start);
+        if (start > cursorOffset) {
+            // Edit is after cursor — no effect
+            break;
+        }
+        if (end <= cursorOffset) {
+            // Edit is entirely before cursor — shift by delta.
+            // Range is half-open [start, end), so cursor at `end` is outside the edit.
+            newOffset += delta;
+        }
+        else {
+            // Cursor falls inside the replaced range [start, end)
+            newOffset = start + edit.text.length;
+            break;
+        }
+    }
+    // Defensive guard: should never go negative with well-formed, non-overlapping edits
+    return Math.max(0, newOffset);
+}

package/lib/fix-applier.d.ts

@@ -1,4 +1,4 @@
-import type { FixData } from '@markuplint/ml-config';
+import type { FixData, TextEdit } from '@markuplint/ml-config';
 /**
  * The result of applying fixes to source code.
  */
@@ -9,6 +9,8 @@ export type FixResult = {
     readonly applied: readonly FixData[];
     /** Fixes that were skipped due to overlapping ranges */
     readonly skipped: readonly FixData[];
+    /** Flat list of successfully applied edits, sorted by range[0] ascending */
+    readonly appliedEdits: readonly TextEdit[];
 };
 /**
  * Applies a set of text edits to the source code.

package/lib/fix-applier.js

@@ -17,7 +17,7 @@
  */
 export function applyFixes(sourceCode, fixes) {
     if (fixes.length === 0) {
-        return { output: sourceCode, applied: [], skipped: [] };
+        return { output: sourceCode, applied: [], skipped: [], appliedEdits: [] };
     }
     // Tag each edit with its parent FixData index
     const taggedEdits = [];
@@ -34,18 +34,22 @@ export function applyFixes(sourceCode, fixes) {
     });
     // Track which FixData indices had at least one skipped edit
     const skippedFixIndices = new Set();
+    const appliedEdits = [];
     let lastAppliedEnd = -1;
     const parts = [];
     let cursor = 0;
     for (const { edit, fixIndex } of taggedEdits) {
         const [start, end] = edit.range;
-        // Overlap check: if this edit starts before the end of the last applied edit, skip it
-        if (start < lastAppliedEnd) {
+        // Overlap check: if this edit starts before the end of the last applied edit, skip it.
+        // Also skip if a sibling edit from the same FixData was already skipped —
+        // edits within a single FixData are atomic (all-or-nothing).
+        if (start < lastAppliedEnd || skippedFixIndices.has(fixIndex)) {
             skippedFixIndices.add(fixIndex);
             continue;
         }
         // Append the source text between the last edit and this one
         parts.push(sourceCode.slice(cursor, start), edit.text);
+        appliedEdits.push(edit);
         cursor = end;
         lastAppliedEnd = end;
     }
@@ -66,5 +70,6 @@ export function applyFixes(sourceCode, fixes) {
         output: parts.join(''),
         applied,
         skipped,
+        appliedEdits,
     };
 }

package/lib/index.d.ts

@@ -2,6 +2,7 @@ export type { RuleInfo, RuleConfig, RuleConfigValue } from '@markuplint/ml-confi
 export { ariaSpecs, contentModelCategoryToTagNames, getAttrSpecs, getComputedRole, getImplicitRole, getPermittedRoles, getRoleSpec, getSpec, resolveNamespace, } from '@markuplint/ml-spec';
 export { Ruleset } from './ruleset/index.js';
 export { enableDebug } from './debug.js';
+export { computeCursorOffset } from './cursor-offset.js';
 export { applyFixes } from './fix-applier.js';
 export type { FixResult } from './fix-applier.js';
 export { getIndent } from './ml-dom/helper/get-indent.js';

package/lib/index.js

@@ -1,6 +1,7 @@
 export { ariaSpecs, contentModelCategoryToTagNames, getAttrSpecs, getComputedRole, getImplicitRole, getPermittedRoles, getRoleSpec, getSpec, resolveNamespace, } from '@markuplint/ml-spec';
 export { Ruleset } from './ruleset/index.js';
 export { enableDebug } from './debug.js';
+export { computeCursorOffset } from './cursor-offset.js';
 export { applyFixes } from './fix-applier.js';
 export { getIndent } from './ml-dom/helper/get-indent.js';
 export * from './convert-ruleset.js';

package/lib/ml-core.d.ts

@@ -1,7 +1,34 @@
 import type { MLFabric } from './types.js';
-import type { PlainData, RuleConfigValue, Violation } from '@markuplint/ml-config';
+import type { PlainData, RuleConfigValue, TextEdit, Violation } from '@markuplint/ml-config';
 import { ParserError } from '@markuplint/parser-utils';
 import { Document } from './ml-dom/index.js';
+/**
+ * Summary of the multi-pass fix process.
+ */
+export type FixSummary = {
+    /** Number of fix passes executed (i.e., the number of times applyFixes was called) */
+    readonly passCount: number;
+    /** Total fixes applied across all passes */
+    readonly totalApplied: number;
+    /** Total fixes skipped (overlap) across all passes */
+    readonly totalSkipped: number;
+    /** Whether the maximum pass count was reached */
+    readonly reachedMaxPasses: boolean;
+    /**
+     * Applied edits from the FIRST pass only.
+     * These reference the original source code offsets, making them suitable
+     * for cursor offset computation via {@link computeCursorOffset}.
+     * Note: `firstPassEdits.length` may differ from `totalApplied` when
+     * multiple passes are executed.
+     */
+    readonly firstPassEdits: readonly TextEdit[];
+};
+/**
+ * Options for {@link MLCore.verify}.
+ */
+export type VerifyOptions = {
+    readonly fix?: boolean;
+};
 /**
  * The result of running {@link MLCore.verify}.
  */
@@ -10,6 +37,8 @@ export type VerifyResult = {
     readonly violations: readonly Violation[];
     /** The source code after applying fixes. `undefined` when fix is not enabled. */
     readonly fixedCode: string | undefined;
+    /** Fix process summary. Present when fix=true. */
+    readonly fixSummary?: FixSummary;
 };
 /**
  * Parameters for constructing an {@link MLCore} instance.
@@ -35,7 +64,7 @@ export declare class MLCore {
     /**
      * The parsed document, or a {@link ParserError} if parsing failed.
      */
-    get document(): ParserError | Document<RuleConfigValue, PlainData>;
+    get document(): Document<RuleConfigValue, PlainData> | ParserError;
     /**
      * Replaces the source code and re-parses the document.
      *
@@ -56,13 +85,17 @@ export declare class MLCore {
      * (unless parse errors are suppressed via severity options).
      *
      * When `fix` is true, fix callbacks are executed and the resulting TextEdits
-     * are applied to produce `fixedCode`.
+     * are applied via a multi-pass loop to produce `fixedCode`.
+     *
+     * **Important**: `violations` reflects the *first* pass only, while `fixedCode`
+     * may be the result of multiple fix passes. This means some violations in the
+     * array may already be resolved in `fixedCode`, and new violations introduced
+     * during later passes are not included in the array. Callers needing an accurate
+     * violation list for the fixed code should re-verify the output.
      *
-     * @param fix - Whether to attempt auto-fixing violations
-     * @returns Violations and the (possibly fixed) source code
+     * @param fixOrOptions - Whether to attempt auto-fixing violations, or an options object
+     * @returns Violations from the initial analysis and the (possibly fixed) source code
      */
     verify(fix?: boolean): Promise<VerifyResult>;
-    private _createDocument;
-    private _createParseError;
-    private _parse;
+    verify(options?: VerifyOptions): Promise<VerifyResult>;
 }

package/lib/ml-core.js

@@ -70,8 +70,8 @@ export class MLCore {
         };
         this.#disabledNamespaces = extractDisabledNamespaces(resolvedRules);
         this.#configErrors.push(...namedRulesResult.errors, ...nodeRuleResult.errors, ...childNodeRuleResult.errors);
-        this._parse();
-        this._createDocument();
+        this.#parse();
+        this.#createDocument();
     }
     /**
      * The parsed document, or a {@link ParserError} if parsing failed.
@@ -86,8 +86,8 @@ export class MLCore {
      */
     setCode(sourceCode) {
         this.#sourceCode = sourceCode;
-        this._parse();
-        this._createDocument();
+        this.#parse();
+        this.#createDocument();
     }
     /**
      * Updates the linting configuration and re-creates the document.
@@ -129,27 +129,17 @@ export class MLCore {
         if (parserOptions &&
             (parserOptions.ignoreFrontMatter !== this.#parserOptions.ignoreFrontMatter ||
                 parserOptions.authoredElementName !== this.#parserOptions.authoredElementName)) {
-            this._parse();
+            this.#parse();
         }
-        this._createDocument();
+        this.#createDocument();
     }
-    /**
-     * Runs all configured rules against the parsed document and returns violations.
-     *
-     * If the document failed to parse, a single parse-error violation is returned
-     * (unless parse errors are suppressed via severity options).
-     *
-     * When `fix` is true, fix callbacks are executed and the resulting TextEdits
-     * are applied to produce `fixedCode`.
-     *
-     * @param fix - Whether to attempt auto-fixing violations
-     * @returns Violations and the (possibly fixed) source code
-     */
-    async verify(fix = false) {
+    async verify(fixOrOptions) {
+        const options = typeof fixOrOptions === 'boolean' ? { fix: fixOrOptions } : (fixOrOptions ?? {});
+        const fix = options.fix ?? false;
         log('verify: start');
         const violations = [];
         if (this.#document instanceof ParserError) {
-            const parseError = this._createParseError(this.#document.message, this.#document.line, this.#document.col, this.#document.raw);
+            const parseError = this.#createParseError(this.#document.message, this.#document.line, this.#document.col, this.#document.raw);
             if (!parseError) {
                 return { violations: [], fixedCode: fix ? this.#sourceCode : undefined };
             }
@@ -189,42 +179,8 @@ export class MLCore {
                 raw: '',
             });
         }
-        for (const rule of this.#rules) {
-            // For virtual rules, check disable conditions:
-            // 1. Exact name match: rules["alias/name"]: false
-            // 2. Group disable: rules["groupName"]: false (multi-entry named nodeRules)
-            // 3. Namespace wildcard: rules["scope/*"]: false
-            // Note: base rule name disable (rules["baseRuleName"]: false) is handled
-            // during expandNamedRules for named rule groups in the rules section.
-            if (rule.baseRuleId &&
-                (this.#ruleset.rules[rule.name] === false ||
-                    (rule.groupName && this.#ruleset.rules[rule.groupName] === false) ||
-                    this.#disabledNamespaces.some(ns => rule.name.startsWith(ns)))) {
-                continue;
-            }
-            const ruleInfo = rule.getRuleInfo(this.#ruleset, rule.name);
-            if (ruleInfo.disabled && ruleInfo.nodeRules.length === 0 && ruleInfo.childNodeRules.length === 0) {
-                continue;
-            }
-            log('%s Rule: verify', rule.name);
-            const results = await rule.verify(this.#document, this.#locale, fix).catch(error => {
-                if (error instanceof ParserError) {
-                    return error;
-                }
-                throw error;
-            });
-            if (results instanceof ParserError) {
-                const parseError = this._createParseError(results.message, results.line, results.col, results.raw);
-                if (parseError) {
-                    log('%s Rule: verify error %o', rule.name, results.message);
-                    violations.push(parseError);
-                }
-            }
-            else {
-                violations.push(...results);
-            }
-            log('%s Rule: verify end', rule.name);
-        }
+        const ruleViolations = await this.#runAllRules(fix);
+        violations.push(...ruleViolations);
         if (resultLog.enabled) {
             // eslint-disable-next-line unicorn/no-array-reduce
             const { e, w, i } = violations.reduce((c, v) => {
@@ -242,25 +198,40 @@ export class MLCore {
         }
         // Apply fixes if enabled
         let fixedCode;
+        let fixSummary;
         if (fix) {
-            fixedCode = this.#sourceCode;
-            const allFixes = [];
-            for (const v of violations) {
-                if (v.fix) {
-                    allFixes.push(v.fix);
+            const hasFixes = violations.some(v => v.fix);
+            if (hasFixes) {
+                const originalSourceCode = this.#sourceCode;
+                const originalAst = this.#ast;
+                const originalDocument = this.#document;
+                try {
+                    const fixResult = await this.#multiPassFix(violations);
+                    fixedCode = fixResult.code;
+                    fixSummary = fixResult.summary;
+                }
+                finally {
+                    // Restore original state - verify() must be non-mutating
+                    this.#sourceCode = originalSourceCode;
+                    this.#ast = originalAst;
+                    this.#document = originalDocument;
                 }
             }
-            if (allFixes.length > 0) {
-                const result = applyFixes(this.#sourceCode, allFixes);
-                fixedCode = result.output;
-                // TODO(Phase 2): If skipped fixes exist, implement multi-pass re-verify loop
-                // (similar to ESLint's 10-pass fix loop) to resolve conflicts iteratively.
+            else {
+                fixedCode = this.#sourceCode;
+                fixSummary = {
+                    passCount: 0,
+                    totalApplied: 0,
+                    totalSkipped: 0,
+                    reachedMaxPasses: false,
+                    firstPassEdits: [],
+                };
             }
         }
         log('verify: end');
-        return { violations, fixedCode };
+        return { violations, fixedCode, fixSummary };
     }
-    _createDocument() {
+    #createDocument() {
         if (!this.#ast) {
             return;
         }
@@ -282,7 +253,7 @@ export class MLCore {
             }
         }
     }
-    _createParseError(message, line, col, raw) {
+    #createParseError(message, line, col, raw) {
         if (this.#severity.parseError === false || this.#severity.parseError === 'off') {
             return null;
         }
@@ -299,7 +270,138 @@ export class MLCore {
             raw,
         };
     }
-    _parse() {
+    /**
+     * Iteratively applies fixes, re-parses, and re-verifies until no overlapping
+     * fixes remain or the maximum pass count is reached (ESLint-style multi-pass loop).
+     *
+     * **Callers must save/restore `#sourceCode`, `#ast`, and `#document`** because
+     * this method mutates them during intermediate re-parse steps.
+     *
+     * @param initialViolations - Violations from the first verification pass
+     * @returns The final fixed source code and a summary of the fix process
+     */
+    async #multiPassFix(initialViolations) {
+        const MAX_FIX_PASSES = 10;
+        let currentCode = this.#sourceCode;
+        let previousCode;
+        let fixes = extractFixes(initialViolations);
+        let totalApplied = 0;
+        let totalSkipped = 0;
+        let firstPassEdits = [];
+        let pass = 0;
+        for (; pass < MAX_FIX_PASSES; pass++) {
+            log('fix pass %d: %d fixes', pass, fixes.length);
+            const result = applyFixes(currentCode, fixes);
+            totalApplied += result.applied.length;
+            totalSkipped += result.skipped.length;
+            if (pass === 0) {
+                firstPassEdits = result.appliedEdits;
+            }
+            if (result.applied.length === 0) {
+                log('fix pass %d: no fixes applied, stopping', pass);
+                break;
+            }
+            if (result.output === currentCode) {
+                log('fix pass %d: output unchanged, stopping', pass);
+                break;
+            }
+            // Cycle detection: if the output matches the code from two passes ago,
+            // fixes are oscillating (A → B → A) and will never converge.
+            if (previousCode !== undefined && result.output === previousCode) {
+                log('fix pass %d: cycle detected (output matches pass %d), stopping', pass, pass - 2);
+                currentCode = result.output;
+                break;
+            }
+            previousCode = currentCode;
+            currentCode = result.output;
+            if (result.skipped.length === 0) {
+                log('fix pass %d: all fixes applied, stopping', pass);
+                break;
+            }
+            // --- Multi-pass path (only when overlapping fixes exist) ---
+            log('fix pass %d: %d skipped, re-parsing for next pass', pass, result.skipped.length);
+            const previousGoodCode = currentCode;
+            this.#sourceCode = currentCode;
+            this.#parse();
+            this.#createDocument();
+            if (this.#document instanceof ParserError) {
+                log('fix pass %d: produced unparsable code, reverting to previous state', pass);
+                currentCode = previousGoodCode;
+                break;
+            }
+            const newViolations = await this.#runAllRules(true);
+            fixes = extractFixes(newViolations);
+            if (fixes.length === 0) {
+                log('fix pass %d: no more fixable violations, stopping', pass);
+                break;
+            }
+        }
+        const reachedMaxPasses = pass === MAX_FIX_PASSES;
+        if (reachedMaxPasses) {
+            log('fix: reached maximum number of passes (%d), some fixes may not have been applied', MAX_FIX_PASSES);
+        }
+        return {
+            code: currentCode,
+            summary: {
+                passCount: Math.min(pass + 1, MAX_FIX_PASSES),
+                totalApplied,
+                totalSkipped,
+                reachedMaxPasses,
+                firstPassEdits,
+            },
+        };
+    }
+    /**
+     * Executes all configured rules against the current document and collects violations.
+     * Skips disabled rules and handles virtual rule disable conditions.
+     *
+     * @param fix - Whether to execute fix callbacks on violations
+     * @returns All violations produced by the rule set
+     */
+    async #runAllRules(fix) {
+        const violations = [];
+        if (this.#document instanceof ParserError) {
+            return violations;
+        }
+        for (const rule of this.#rules) {
+            // For virtual rules, check disable conditions:
+            // 1. Exact name match: rules["alias/name"]: false
+            // 2. Group disable: rules["groupName"]: false (multi-entry named nodeRules)
+            // 3. Namespace wildcard: rules["scope/*"]: false
+            // Note: base rule name disable (rules["baseRuleName"]: false) is handled
+            // during expandNamedRules for named rule groups in the rules section.
+            if (rule.baseRuleId &&
+                (this.#ruleset.rules[rule.name] === false ||
+                    (rule.groupName && this.#ruleset.rules[rule.groupName] === false) ||
+                    this.#disabledNamespaces.some(ns => rule.name.startsWith(ns)))) {
+                continue;
+            }
+            const ruleInfo = rule.getRuleInfo(this.#ruleset, rule.name);
+            if (ruleInfo.disabled && ruleInfo.nodeRules.length === 0 && ruleInfo.childNodeRules.length === 0) {
+                continue;
+            }
+            log('%s Rule: verify', rule.name);
+            const results = await rule.verify(this.#document, this.#locale, fix).catch(error => {
+                if (error instanceof ParserError) {
+                    return error;
+                }
+                throw error;
+            });
+            if (results instanceof ParserError) {
+                const parseError = this.#createParseError(results.message, results.line, results.col, results.raw);
+                if (parseError) {
+                    log('%s Rule: verify error %o', rule.name, results.message);
+                    violations.push(parseError);
+                }
+            }
+            else {
+                violations.push(...results);
+            }
+            log('%s Rule: verify end', rule.name);
+        }
+        return violations;
+    }
+    #parse() {
         try {
             this.#ast = this.#parser.parse(this.#sourceCode, this.#parserOptions);
         }
@@ -324,3 +426,18 @@ function extractDisabledNamespaces(rules) {
         .filter(([key, value]) => key.endsWith('/*') && value === false)
         .map(([key]) => key.slice(0, -1)); // "a11y/*" → "a11y/"
 }
+/**
+ * Collects all `FixData` from violations that have a fix callback result.
+ *
+ * @param violations - The violations to extract fixes from
+ * @returns An array of `FixData` objects ready for `applyFixes()`
+ */
+function extractFixes(violations) {
+    const fixes = [];
+    for (const v of violations) {
+        if (v.fix) {
+            fixes.push(v.fix);
+        }
+    }
+    return fixes;
+}

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

@@ -28,7 +28,8 @@ export class MLBlock extends MLNode {
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     document) {
         super(astNode, document, astNode.isFragment);
-        // TODO:
+        // Always transparent: blockBehavior may restrict child treatment in the future,
+        // but currently all preprocessor blocks are transparent for tree traversal.
         this.isTransparent = true;
         this.blockBehavior = astNode.blockBehavior;
     }

package/lib/ml-dom/node/character-data.d.ts

@@ -42,21 +42,56 @@ export declare abstract class MLCharacterData<T extends RuleConfigValue, O exten
      * @implements DOM API: `CharacterData`
      */
     after(...nodes: (string | MLElement<any, any>)[]): void;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-appenddata
+     */
     appendData(data: string): void;
     /**
      * @implements DOM API: `CharacterData`
      */
     before(...nodes: (string | MLElement<any, any>)[]): void;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-deletedata
+     */
     deleteData(offset: number, count: number): void;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-insertdata
+     */
     insertData(offset: number, data: string): void;
     /**
      * @implements DOM API: `CharacterData`
      */
     remove(): void;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-replacedata
+     */
     replaceData(offset: number, count: number, data: string): void;
     /**
      * @implements DOM API: `CharacterData`
      */
     replaceWith(...nodes: (string | MLElement<any, any>)[]): void;
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-substringdata
+     */
     substringData(offset: number, count: number): string;
 }

package/lib/ml-dom/node/character-data.js

@@ -7,7 +7,6 @@ export class MLCharacterData extends MLNode {
      * @see https://dom.spec.whatwg.org/#dom-characterdata-data
      */
     get data() {
-        // TODO:
         return this.raw;
     }
     /**
@@ -58,7 +57,13 @@ export class MLCharacterData extends MLNode {
     ...nodes) {
         after(this, ...nodes);
     }
-    // TODO
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-appenddata
+     */
     appendData(data) { }
     /**
      * @implements DOM API: `CharacterData`
@@ -68,9 +73,21 @@ export class MLCharacterData extends MLNode {
     ...nodes) {
         before(this, ...nodes);
     }
-    // TODO
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-deletedata
+     */
     deleteData(offset, count) { }
-    // TODO
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-insertdata
+     */
     insertData(offset, data) { }
     /**
      * @implements DOM API: `CharacterData`
@@ -78,7 +95,13 @@ export class MLCharacterData extends MLNode {
     remove() {
         remove(this);
     }
-    // TODO
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-replacedata
+     */
     replaceData(offset, count, data) { }
     /**
      * @implements DOM API: `CharacterData`
@@ -88,7 +111,13 @@ export class MLCharacterData extends MLNode {
     ...nodes) {
         replaceWith(this, ...nodes);
     }
-    // TODO
+    /**
+     * **IT THROWS AN ERROR WHEN CALLING THIS.**
+     *
+     * @unsupported
+     * @implements DOM API: `CharacterData`
+     * @see https://dom.spec.whatwg.org/#dom-characterdata-substringdata
+     */
     substringData(offset, count) {
         return '';
     }

package/lib/ml-dom/node/document.d.ts

@@ -1721,18 +1721,4 @@ export declare class MLDocument<T extends RuleConfigValue, O extends PlainData =
      * @implements DOM API: `Document`
      */
     writeln(...text: readonly string[]): void;
-    /**
-     * Initializes pretender contexts for all element nodes in the document.
-     *
-     * @param pretenders - Optional pretender configurations from the document options
-     */
-    private _pretending;
-    /**
-     * Maps the ruleset configuration to each node in the document.
-     * Applies global rules, node-specific rules (by selector), and
-     * child-node rules to build the per-node rule configuration.
-     *
-     * @param ruleset - The ruleset containing rules, nodeRules, and childNodeRules
-     */
-    private _ruleMapping;
 }

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

@@ -107,9 +107,9 @@ export class MLDocument extends MLParentNode {
             return createNode(astNode, this);
         })
             .filter((n) => !!n));
-        this._pretending(options?.pretenders);
+        this.#pretending(options?.pretenders);
         try {
-            this._ruleMapping(ruleset);
+            this.#ruleMapping(ruleset);
         }
         catch (error) {
             if (error instanceof InvalidSelectorError) {
@@ -2039,7 +2039,6 @@ export class MLDocument extends MLParentNode {
      * @implements DOM API: `Document`
      */
     getElementById(elementId) {
-        // TODO:
         return this.querySelector(`#${elementId}`);
     }
     /**
@@ -2281,7 +2280,7 @@ export class MLDocument extends MLParentNode {
      *
      * @param pretenders - Optional pretender configurations from the document options
      */
-    _pretending(pretenders) {
+    #pretending(pretenders) {
         if (docLog.enabled) {
             docLog('Pretending: %O', pretenders);
         }
@@ -2298,7 +2297,7 @@ export class MLDocument extends MLParentNode {
      *
      * @param ruleset - The ruleset containing rules, nodeRules, and childNodeRules
      */
-    _ruleMapping(ruleset) {
+    #ruleMapping(ruleset) {
         if (docLog.enabled) {
             docLog('Rule Mapping: %O', Object.keys(ruleset.rules));
         }

package/lib/ml-dom/node/dom-token-list.d.ts

@@ -28,6 +28,5 @@ export declare class MLDomTokenList extends Array<string> implements DOMTokenLis
     supports(token: string): boolean;
     toString(): string;
     toggle(token: string, force?: boolean): boolean;
-    private _pick;
 }
 export {};

package/lib/ml-dom/node/dom-token-list.js

@@ -45,7 +45,7 @@ export class MLDomTokenList extends Array {
             if (!token) {
                 break;
             }
-            const loc = this._pick(token, offset);
+            const loc = this.#pick(token, offset);
             if (!loc) {
                 offset = 0;
                 continue;
@@ -74,7 +74,7 @@ export class MLDomTokenList extends Array {
      * @implements `@markuplint/ml-core` API: `MLDomTokenList`
      */
     pick(token) {
-        const r = this._pick(token);
+        const r = this.#pick(token);
         if (!r) {
             return null;
         }
@@ -101,7 +101,7 @@ export class MLDomTokenList extends Array {
     toggle(token, force) {
         throw new UnexpectedCallError('Not supported "toggle" method');
     }
-    _pick(token, _offset = 0) {
+    #pick(token, _offset = 0) {
         token = token.trim().split(/\s+/)[0] ?? '';
         if (!token) {
             return null;

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

@@ -2725,7 +2725,6 @@ export class MLElement extends MLParentNode {
     insertAdjacentElement(where, 
     // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
     element) {
-        // TODO:
         throw new UnexpectedCallError('Does not implement "insertAdjacentElement" method yet');
     }
     /**
@@ -2736,7 +2735,6 @@ export class MLElement extends MLParentNode {
      * @see https://w3c.github.io/DOM-Parsing/#widl-Element-insertAdjacentHTML-void-DOMString-position-DOMString-text
      */
     insertAdjacentHTML(position, text) {
-        // TODO:
         throw new UnexpectedCallError('Does not implement "insertAdjacentHTML" method yet');
     }
     /**
@@ -2747,7 +2745,6 @@ export class MLElement extends MLParentNode {
      * @see https://dom.spec.whatwg.org/#dom-element-insertadjacenttext
      */
     insertAdjacentText(where, data) {
-        // TODO:
         throw new UnexpectedCallError('Does not implement "insertAdjacentText" method yet');
     }
     /**

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

@@ -21,5 +21,4 @@ export declare class MLRuleContext<T extends RuleConfigValue, O extends PlainDat
     };
     report(report: Report<T, O>): undefined;
     report(report: CheckerReport<T, O>): boolean;
-    private _push;
 }

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

@@ -28,14 +28,14 @@ export class MLRuleContext {
         if (typeof report === 'function') {
             const r = report(this.translate);
             if (r) {
-                this._push(r);
+                this.#push(r);
                 return true;
             }
             return false;
         }
-        this._push(report);
+        this.#push(report);
     }
-    _push(report) {
+    #push(report) {
         const key = reportKey(report);
         if (!this.#reportKeys.has(key)) {
             this.#reportKeys.add(key);

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

@@ -83,7 +83,6 @@ export declare class MLRule<T extends RuleConfigValue, O extends PlainData = und
      * @returns An array of violations found by this rule
      */
     verify(document: MLDocument<T, O>, locale: LocaleSet, fix: boolean): Promise<Violation[]>;
-    private _optimize;
 }
 /**
  * An MLRule with any value and option types. Used when the specific types are not known.

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

@@ -81,11 +81,11 @@ export class MLRule {
      * @returns The global rule info with node and child-node overrides
      */
     getRuleInfo(ruleSet, ruleName) {
-        const info = this._optimize(ruleSet.rules, ruleName);
+        const info = this.#optimize(ruleSet.rules, ruleName);
         return {
             ...info,
-            nodeRules: ruleSet.nodeRules.map(r => this._optimize(r.rules, ruleName)).filter(r => !r.disabled),
-            childNodeRules: ruleSet.childNodeRules.map(r => this._optimize(r.rules, ruleName)).filter(r => !r.disabled),
+            nodeRules: ruleSet.nodeRules.map(r => this.#optimize(r.rules, ruleName)).filter(r => !r.disabled),
+            childNodeRules: ruleSet.childNodeRules.map(r => this.#optimize(r.rules, ruleName)).filter(r => !r.disabled),
         };
     }
     /**
@@ -196,7 +196,7 @@ export class MLRule {
         document.setRule(null);
         return violations;
     }
-    _optimize(rules, ruleName) {
+    #optimize(rules, ruleName) {
         const rule = (rules?.[ruleName] ?? false);
         const info = this.optimizeOption(rule);
         return info;

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

@@ -1,25 +1,20 @@
-import type { IRuleFixer, TextEdit } from '@markuplint/ml-config';
+import type { FixToken, IRuleFixer, TextEdit } from '@markuplint/ml-config';
 /**
  * Stateless implementation of {@link IRuleFixer}.
  * Provides helper methods for building {@link TextEdit} objects
  * inside rule fix callbacks.
  */
 export declare class RuleFixer implements IRuleFixer {
-    replaceText(token: {
-        readonly startOffset: number;
-        readonly raw: string;
-    }, text: string): TextEdit;
+    /** @see {@link IRuleFixer.replaceText} */
+    replaceText(token: FixToken, text: string): TextEdit;
+    /** @see {@link IRuleFixer.replaceRange} */
     replaceRange(range: readonly [number, number], text: string): TextEdit;
-    insertBefore(token: {
-        readonly startOffset: number;
-    }, text: string): TextEdit;
-    insertAfter(token: {
-        readonly startOffset: number;
-        readonly raw: string;
-    }, text: string): TextEdit;
-    remove(token: {
-        readonly startOffset: number;
-        readonly raw: string;
-    }): TextEdit;
+    /** @see {@link IRuleFixer.insertBefore} */
+    insertBefore(token: Pick<FixToken, 'startOffset'>, text: string): TextEdit;
+    /** @see {@link IRuleFixer.insertAfter} */
+    insertAfter(token: FixToken, text: string): TextEdit;
+    /** @see {@link IRuleFixer.remove} */
+    remove(token: FixToken): TextEdit;
+    /** @see {@link IRuleFixer.removeRange} */
     removeRange(range: readonly [number, number]): TextEdit;
 }

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

@@ -4,28 +4,34 @@
  * inside rule fix callbacks.
  */
 export class RuleFixer {
+    /** @see {@link IRuleFixer.replaceText} */
     replaceText(token, text) {
         return {
             range: [token.startOffset, token.startOffset + token.raw.length],
             text,
         };
     }
+    /** @see {@link IRuleFixer.replaceRange} */
     replaceRange(range, text) {
         return { range, text };
     }
+    /** @see {@link IRuleFixer.insertBefore} */
     insertBefore(token, text) {
         return { range: [token.startOffset, token.startOffset], text };
     }
+    /** @see {@link IRuleFixer.insertAfter} */
     insertAfter(token, text) {
         const end = token.startOffset + token.raw.length;
         return { range: [end, end], text };
     }
+    /** @see {@link IRuleFixer.remove} */
     remove(token) {
         return {
             range: [token.startOffset, token.startOffset + token.raw.length],
             text: '',
         };
     }
+    /** @see {@link IRuleFixer.removeRange} */
     removeRange(range) {
         return { range, text: '' };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@markuplint/ml-core",
-	"version": "5.0.0-alpha.2",
+	"version": "5.0.0-dev.5+e96392f56",
 	"description": "The core module of markuplint",
 	"repository": "git@github.com:markuplint/markuplint.git",
 	"author": "Yusuke Hirao <yusukehirao@me.com>",
@@ -30,20 +30,20 @@
 		"./lib/configs.js": "./lib/configs.browser.js"
 	},
 	"dependencies": {
-		"@markuplint/config-presets": "5.0.0-alpha.2",
-		"@markuplint/html-parser": "5.0.0-alpha.2",
-		"@markuplint/html-spec": "5.0.0-alpha.2",
-		"@markuplint/i18n": "5.0.0-alpha.2",
-		"@markuplint/ml-ast": "5.0.0-alpha.2",
-		"@markuplint/ml-config": "5.0.0-alpha.2",
-		"@markuplint/ml-spec": "5.0.0-alpha.2",
-		"@markuplint/parser-utils": "5.0.0-alpha.2",
-		"@markuplint/selector": "5.0.0-alpha.2",
-		"@markuplint/shared": "5.0.0-alpha.2",
+		"@markuplint/config-presets": "5.0.0-dev.5+e96392f56",
+		"@markuplint/html-parser": "5.0.0-dev.5+e96392f56",
+		"@markuplint/html-spec": "5.0.0-dev.5+e96392f56",
+		"@markuplint/i18n": "5.0.0-dev.5+e96392f56",
+		"@markuplint/ml-ast": "5.0.0-dev.5+e96392f56",
+		"@markuplint/ml-config": "5.0.0-dev.5+e96392f56",
+		"@markuplint/ml-spec": "5.0.0-dev.5+e96392f56",
+		"@markuplint/parser-utils": "5.0.0-dev.5+e96392f56",
+		"@markuplint/selector": "5.0.0-dev.5+e96392f56",
+		"@markuplint/shared": "5.0.0-dev.5+e96392f56",
 		"@types/debug": "4.1.12",
 		"debug": "4.4.3",
 		"is-plain-object": "5.0.0",
 		"type-fest": "5.4.4"
 	},
-	"gitHead": "31ccf1e81443ea3f93597d287595211f1823ddcf"
+	"gitHead": "e96392f56e4bc8165ba59622b41c822703a96372"
 }