rintenki 0.3.0 → 0.4.0

package/README.md

@@ -8,7 +8,7 @@ The name "rintenki" comes from the Japanese word "輪転機" (rintenki), meaning
 
 - Parsing by html5ever (Rust)
 - Node.js native binding via napi-rs
-- 38 built-in rules
+- 58 built-in rules
 - CLI / API / VS Code extension / LSP server
 - Auto-fix with `--fix`
 - JSON output for CI integration
@@ -33,7 +33,7 @@ npx rintenki "src/**/*.html"
 rintenki [options] <files...>
 
   -c, --config <path>       Path to config file (default: .rintenkirc.json)
-  -f, --format <format>     Output format: stylish (default), json
+  -f, --format <format>     Output format: stylish (default), json, sarif
   --fix                     Auto-fix fixable rules
   --max-warnings <number>   Exit with error if warnings exceed this number
   -h, --help                Show help
@@ -134,31 +134,50 @@ Parsers are auto-detected from installed packages, or can be explicitly configur
 | Rule | Default | Description |
 |------|---------|-------------|
 | `attr-duplication` | error | Detect duplicate attributes |
+| `colspan-rowspan-range` | error | Validate colspan (1-1000) and rowspan (0-65534) ranges |
 | `deprecated-attr` | error | Detect deprecated or obsolete attributes |
 | `deprecated-element` | error | Detect deprecated or obsolete elements |
 | `disallowed-element` | off | Detect disallowed elements |
 | `doctype` | error | Detect missing DOCTYPE declaration |
+| `header-footer-nesting` | error | Detect header/footer/main nesting inside header or footer |
 | `heading-levels` | error | Detect skipped heading levels |
 | `id-duplication` | error | Detect duplicate id attribute values |
+| `input-attr-applicability` | warning | Detect attributes that do not apply to the input type |
 | `invalid-attr` | error | Detect attributes not in the spec |
+| `meta-constraints` | error | Validate meta element attribute constraints |
+| `no-duplicate-base` | error | Detect multiple base or title elements |
 | `no-duplicate-dt` | error | Detect duplicate dt names in dl |
 | `no-empty-palpable-content` | warning | Detect empty palpable content elements |
+| `no-nested-forms` | error | Detect nested form elements |
+| `no-nested-interactive` | error | Detect interactive content inside a or button |
 | `no-orphaned-end-tag` | error | Detect end tags without matching start tags |
+| `no-tabindex-on-dialog` | error | Detect tabindex on dialog elements |
+| `obsolete-but-conforming` | warning | Detect obsolete but conforming features |
 | `permitted-contents` | error | Detect children not permitted by the spec |
+| `picture-structure` | error | Validate picture element structure |
 | `placeholder-label-option` | warning | Detect missing placeholder option in required select |
 | `require-datetime` | error | Detect missing datetime attribute on time element |
 | `required-attr` | error | Detect missing required attributes |
 | `required-element` | error | Detect missing required child elements |
+| `summary-first-child` | error | Require summary as first child of details |
+| `th-content-restrictions` | error | Detect disallowed elements inside th |
+| `unique-main` | error | Require at most one visible main element |
+| `valid-attr-value` | error | Validate enumerated attribute values |
+| `valid-autocomplete` | warning | Validate autocomplete attribute values |
+| `valid-rel` | error | Validate rel attribute values |
 
 ### Accessibility
 
 | Rule | Default | Description |
 |------|---------|-------------|
+| `aria-attr-valid-values` | warning | Validate ARIA attribute values |
+| `aria-role-conflicts` | warning | Detect conflicts between explicit role and implicit role |
 | `label-has-control` | error | Detect label elements without associated control |
 | `landmark-roles` | warning | Detect nested landmark roles |
 | `neighbor-popovers` | off | Detect non-adjacent popover triggers and targets |
 | `no-ambiguous-navigable-target-names` | warning | Detect invalid target name keywords |
 | `no-consecutive-br` | warning | Detect consecutive br elements |
+| `no-positive-tabindex` | warning | Detect positive tabindex values |
 | `no-refer-to-non-existent-id` | error | Detect references to non-existent ids |
 | `require-accessible-name` | error | Detect missing accessible names |
 | `required-h1` | error | Detect missing h1 element |
@@ -177,6 +196,7 @@ Parsers are auto-detected from installed packages, or can be explicitly configur
 | Rule | Default | Description |
 |------|---------|-------------|
 | `no-hard-code-id` | off | Detect hardcoded id attributes |
+| `no-inline-style` | warning | Detect inline style attributes |
 | `no-use-event-handler-attr` | warning | Detect event handler attributes |
 
 ### Style
@@ -196,8 +216,11 @@ Parsers are auto-detected from installed packages, or can be explicitly configur
 
 The following rules can be auto-fixed with `--fix`:
 
-- `case-sensitive-tag-name`
+- `attr-value-quotes`
 - `case-sensitive-attr-name`
+- `case-sensitive-tag-name`
+- `character-reference`
+- `doctype`
 - `no-boolean-attr-value`
 - `no-default-value`
 

package/bin/rintenki.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
-const { existsSync, readFileSync, writeFileSync } = require("fs");
-const { resolve, relative } = require("path");
+const { existsSync, readFileSync, writeFileSync, watch } = require("fs");
+const { resolve, relative, dirname, join } = require("path");
+const { createHash } = require("crypto");
 const { glob } = require("tinyglobby");
 const { lint, fix } = require("../index");
 
@@ -85,11 +86,15 @@ function formatDiagnostic(diagnostic) {
       ? `${COLORS.red}error${COLORS.reset}`
       : `${COLORS.yellow}warning${COLORS.reset}`;
   const loc = diagnostic.line != null ? `${COLORS.gray}line ${diagnostic.line}${COLORS.reset}  ` : "";
-  return `  ${loc}${severity}  ${diagnostic.message}  ${COLORS.gray}${diagnostic.rule}${COLORS.reset}`;
+  let line = `  ${loc}${severity}  ${diagnostic.message}  ${COLORS.gray}${diagnostic.rule}${COLORS.reset}`;
+  if (diagnostic.hint) {
+    line += `\n       ${COLORS.gray}hint: ${diagnostic.hint}${COLORS.reset}`;
+  }
+  return line;
 }
 
 function parseArgs(argv) {
-  const args = { files: [], config: undefined, help: false, maxWarnings: -1, format: "stylish", fix: false };
+  const args = { files: [], config: undefined, help: false, maxWarnings: -1, format: "stylish", fix: false, watch: false };
   let i = 0;
   while (i < argv.length) {
     const arg = argv[i];
@@ -103,6 +108,8 @@ function parseArgs(argv) {
       args.format = argv[++i];
     } else if (arg === "--fix") {
       args.fix = true;
+    } else if (arg === "--watch" || arg === "-w") {
+      args.watch = true;
     } else if (!arg.startsWith("-")) {
       args.files.push(arg);
     }
@@ -111,6 +118,69 @@ function parseArgs(argv) {
   return args;
 }
 
+function buildSarif(jsonOutput) {
+  const ruleSet = new Map();
+  const results = [];
+
+  for (const { file, diagnostics } of jsonOutput) {
+    for (const d of diagnostics) {
+      if (!ruleSet.has(d.rule)) {
+        ruleSet.set(d.rule, {
+          id: d.rule,
+          shortDescription: { text: d.message },
+        });
+      }
+
+      const region = {};
+      if (d.line != null) {
+        region.startLine = d.line;
+        region.startColumn = (d.col ?? 0) + 1;
+      }
+      if (d.endLine != null) {
+        region.endLine = d.endLine;
+        region.endColumn = (d.endCol ?? 0) + 1;
+      }
+
+      const result = {
+        ruleId: d.rule,
+        level: d.severity === "error" ? "error" : "warning",
+        message: { text: d.hint ? `${d.message}\nhint: ${d.hint}` : d.message },
+        locations: [
+          {
+            physicalLocation: {
+              artifactLocation: { uri: file, uriBaseId: "%SRCROOT%" },
+              region,
+            },
+          },
+        ],
+      };
+
+      if (d.fixable) {
+        result.properties = { fixable: true };
+      }
+
+      results.push(result);
+    }
+  }
+
+  return {
+    $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "rintenki",
+            informationUri: "https://github.com/kzhrk/rintenki",
+            rules: [...ruleSet.values()],
+          },
+        },
+        results,
+      },
+    ],
+  };
+}
+
 async function main() {
   const args = parseArgs(process.argv.slice(2));
 
@@ -119,8 +189,9 @@ async function main() {
 
 Options:
   -c, --config <path>       Path to config file (default: .rintenkirc.json)
-  -f, --format <format>     Output format: stylish (default), json
+  -f, --format <format>     Output format: stylish (default), json, sarif
   --fix                     Auto-fix fixable issues
+  -w, --watch               Watch files for changes and re-lint
   --max-warnings <number>   Exit with error if warnings exceed this number
   -h, --help                Show help
 
@@ -144,69 +215,179 @@ Examples:
     process.exit(1);
   }
 
-  let totalErrors = 0;
-  let totalWarnings = 0;
-  const jsonOutput = [];
+  const { totalErrors, totalWarnings } = await lintFiles(files, config, args);
 
-  let totalFixed = 0;
+  if (args.watch) {
+    console.log(`\n${COLORS.gray}Watching for changes...${COLORS.reset}\n`);
+
+    const cache = new Map();
+    const dirs = [...new Set(files.map((f) => dirname(f)))];
+    let debounceTimer = null;
+
+    for (const dir of dirs) {
+      watch(dir, { recursive: true }, (_eventType, filename) => {
+        if (!filename) return;
+        const abs = resolve(dir, filename);
+        if (!files.includes(abs)) return;
 
-  for (const file of files) {
-    let source = readFileSync(file, "utf-8");
-    let lineOffset = 0;
-
-    // Preprocess non-HTML files (Vue, ERB, etc.)
-    const parser = loadParser(file, config?.parser);
-    if (parser) {
-      const preprocessed = parser.preprocess(source);
-      source = preprocessed.html;
-      lineOffset = preprocessed.lineOffset;
-      if (!source) continue;
+        // Invalidate cache for changed file
+        cache.delete(abs);
+
+        clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(async () => {
+          process.stdout.write("\x1Bc");
+          await lintFiles(files, config, args, cache);
+          console.log(`\n${COLORS.gray}Watching for changes...${COLORS.reset}\n`);
+        }, 100);
+      });
     }
+    return;
+  }
 
-    let html = source;
+  if (totalErrors > 0) {
+    process.exit(1);
+  }
 
-    if (args.fix) {
-      const fixResult = fix(html, config);
-      if (fixResult.fixedCount > 0) {
-        writeFileSync(file, fixResult.output, "utf-8");
-        html = fixResult.output;
-        totalFixed += fixResult.fixedCount;
-      }
+  if (args.maxWarnings >= 0 && totalWarnings > args.maxWarnings) {
+    process.exit(1);
+  }
+}
+
+const PARALLEL_THRESHOLD = 20;
+
+function lintOneFile(file, config, args) {
+  let source = readFileSync(file, "utf-8");
+  let lineOffset = 0;
+
+  const parser = loadParser(file, config?.parser);
+  if (parser) {
+    const preprocessed = parser.preprocess(source);
+    source = preprocessed.html;
+    lineOffset = preprocessed.lineOffset;
+    if (!source) return null;
+  }
+
+  let html = source;
+  let fixedCount = 0;
+
+  if (args.fix) {
+    const fixResult = fix(html, config);
+    if (fixResult.fixedCount > 0) {
+      writeFileSync(file, fixResult.output, "utf-8");
+      html = fixResult.output;
+      fixedCount = fixResult.fixedCount;
     }
+  }
+
+  const result = lint(html, config);
+
+  if (lineOffset > 0) {
+    for (const d of result.diagnostics) {
+      if (d.line != null) d.line += lineOffset;
+      if (d.endLine != null) d.endLine += lineOffset;
+    }
+  }
+
+  return { diagnostics: result.diagnostics, fixedCount };
+}
+
+function fileHash(content) {
+  return createHash("md5").update(content).digest("hex");
+}
+
+async function lintFilesParallel(files, config, args) {
+  const { Worker } = require("worker_threads");
+  const cpus = require("os").cpus().length;
+  const workerCount = Math.min(cpus, 4, files.length);
+  const workerPath = join(__dirname, "worker.js");
+
+  const chunks = Array.from({ length: workerCount }, () => []);
+  files.forEach((f, i) => chunks[i % workerCount].push(f));
+
+  const results = await Promise.all(
+    chunks.map(
+      (chunk) =>
+        new Promise((resolve, reject) => {
+          const worker = new Worker(workerPath, {
+            workerData: { files: chunk, config, fix: args.fix },
+          });
+          worker.on("message", resolve);
+          worker.on("error", reject);
+        })
+    )
+  );
+
+  // Merge results: array of { file, diagnostics, fixedCount }[]
+  return results.flat();
+}
+
+async function lintFiles(files, config, args, cache) {
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  const jsonOutput = [];
+  let totalFixed = 0;
+
+  let fileResults;
+
+  if (!args.fix && !cache && files.length >= PARALLEL_THRESHOLD) {
+    // Parallel mode: no fix, no cache, many files
+    const parallel = await lintFilesParallel(files, config, args);
+    fileResults = parallel.map((r) => ({
+      file: r.file,
+      rel: relative(process.cwd(), r.file),
+      diagnostics: r.diagnostics,
+      fixedCount: r.fixedCount,
+    }));
+  } else {
+    // Sequential mode (with optional cache for watch)
+    fileResults = [];
+    for (const file of files) {
+      const source = readFileSync(file, "utf-8");
+      const hash = fileHash(source);
+
+      if (cache) {
+        const cached = cache.get(file);
+        if (cached && cached.hash === hash) {
+          fileResults.push({ file, rel: relative(process.cwd(), file), diagnostics: cached.diagnostics, fixedCount: 0 });
+          continue;
+        }
+      }
 
-    const result = lint(html, config);
-    const rel = relative(process.cwd(), file);
+      const result = lintOneFile(file, config, args);
+      if (!result) continue;
 
-    // Remap line numbers to original file positions
-    if (lineOffset > 0) {
-      for (const d of result.diagnostics) {
-        if (d.line != null) d.line += lineOffset;
-        if (d.endLine != null) d.endLine += lineOffset;
+      if (cache) {
+        cache.set(file, { hash, diagnostics: result.diagnostics });
       }
+
+      fileResults.push({ file, rel: relative(process.cwd(), file), diagnostics: result.diagnostics, fixedCount: result.fixedCount });
     }
+  }
 
-    for (const d of result.diagnostics) {
+  for (const { rel, diagnostics, fixedCount } of fileResults) {
+    totalFixed += fixedCount;
+
+    for (const d of diagnostics) {
       if (d.severity === "error") totalErrors++;
       else totalWarnings++;
     }
 
-    if (args.format === "json") {
-      if (result.diagnostics.length > 0) {
-        jsonOutput.push({
-          file: rel,
-          diagnostics: result.diagnostics,
-        });
+    if (args.format === "json" || args.format === "sarif") {
+      if (diagnostics.length > 0) {
+        jsonOutput.push({ file: rel, diagnostics });
       }
     } else {
-      if (result.diagnostics.length === 0) continue;
+      if (diagnostics.length === 0) continue;
       console.log(`\n${COLORS.bold}${rel}${COLORS.reset}`);
-      for (const d of result.diagnostics) {
+      for (const d of diagnostics) {
         console.log(formatDiagnostic(d));
       }
     }
   }
 
-  if (args.format === "json") {
+  if (args.format === "sarif") {
+    console.log(JSON.stringify(buildSarif(jsonOutput), null, 2));
+  } else if (args.format === "json") {
     console.log(JSON.stringify(jsonOutput, null, 2));
   } else if (totalErrors > 0 || totalWarnings > 0) {
     const parts = [];
@@ -221,13 +402,7 @@ Examples:
     console.log("No issues found.");
   }
 
-  if (totalErrors > 0) {
-    process.exit(1);
-  }
-
-  if (args.maxWarnings >= 0 && totalWarnings > args.maxWarnings) {
-    process.exit(1);
-  }
+  return { totalErrors, totalWarnings };
 }
 
 main().catch((err) => {

package/bin/worker.js

@@ -0,0 +1,51 @@
+const { workerData, parentPort } = require("worker_threads");
+const { readFileSync, writeFileSync } = require("fs");
+const { lint, fix } = require("../index");
+
+let loadParser;
+try {
+  loadParser = require("@rintenki/parser-utils").loadParser;
+} catch {
+  loadParser = () => undefined;
+}
+
+const { files, config, fix: shouldFix } = workerData;
+const results = [];
+
+for (const file of files) {
+  let source = readFileSync(file, "utf-8");
+  let lineOffset = 0;
+
+  const parser = loadParser(file, config?.parser);
+  if (parser) {
+    const preprocessed = parser.preprocess(source);
+    source = preprocessed.html;
+    lineOffset = preprocessed.lineOffset;
+    if (!source) continue;
+  }
+
+  let html = source;
+  let fixedCount = 0;
+
+  if (shouldFix) {
+    const fixResult = fix(html, config);
+    if (fixResult.fixedCount > 0) {
+      writeFileSync(file, fixResult.output, "utf-8");
+      html = fixResult.output;
+      fixedCount = fixResult.fixedCount;
+    }
+  }
+
+  const result = lint(html, config);
+
+  if (lineOffset > 0) {
+    for (const d of result.diagnostics) {
+      if (d.line != null) d.line += lineOffset;
+      if (d.endLine != null) d.endLine += lineOffset;
+    }
+  }
+
+  results.push({ file, diagnostics: result.diagnostics, fixedCount });
+}
+
+parentPort.postMessage(results);

package/index.d.ts

@@ -7,6 +7,7 @@ export interface LintDiagnostic {
   endLine: number | null;
   endCol: number | null;
   fixable: boolean;
+  hint: string | null;
 }
 
 export interface LintResult {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rintenki",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "A fast HTML linter powered by html5ever + napi-rs",
   "author": "Kazuhiro Kobayashi <https://github.com/kzhrk>",
   "license": "MIT",
@@ -32,8 +32,10 @@
     "index.js",
     "index.d.ts",
     "bin/rintenki.js",
+    "bin/worker.js",
     "rintenki.*.node",
-    "README.md"
+    "README.md",
+    "rintenkirc.schema.json"
   ],
   "napi": {
     "binaryName": "rintenki",

package/rintenkirc.schema.json

@@ -0,0 +1,336 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "Rintenki Configuration",
+  "description": "Configuration file for the rintenki HTML linter",
+  "type": "object",
+  "properties": {
+    "rules": {
+      "type": "object",
+      "description": "Rule severity overrides",
+      "properties": {
+        "aria-attr-valid-values": {
+          "$ref": "#/definitions/severity",
+          "description": "Validate ARIA attribute values",
+          "default": "warning"
+        },
+        "aria-role-conflicts": {
+          "$ref": "#/definitions/severity",
+          "description": "Detect conflicts between explicit role and element's implicit role",
+          "default": "warning"
+        },
+        "attr-duplication": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow duplicate attributes on the same element",
+          "default": "error"
+        },
+        "attr-value-quotes": {
+          "$ref": "#/definitions/severity",
+          "description": "Require attribute values to be quoted",
+          "default": "warning"
+        },
+        "case-sensitive-attr-name": {
+          "$ref": "#/definitions/severity",
+          "description": "Enforce lowercase attribute names (auto-fixable)",
+          "default": "warning"
+        },
+        "colspan-rowspan-range": {
+          "$ref": "#/definitions/severity",
+          "description": "Require colspan and rowspan values to be within valid ranges",
+          "default": "error"
+        },
+        "case-sensitive-tag-name": {
+          "$ref": "#/definitions/severity",
+          "description": "Enforce lowercase tag names (auto-fixable)",
+          "default": "warning"
+        },
+        "character-reference": {
+          "$ref": "#/definitions/severity",
+          "description": "Require unescaped & to be written as &",
+          "default": "warning"
+        },
+        "class-naming": {
+          "$ref": "#/definitions/severity",
+          "description": "Enforce class name conventions (opt-in)",
+          "default": "off"
+        },
+        "deprecated-attr": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow deprecated HTML attributes",
+          "default": "error"
+        },
+        "deprecated-element": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow deprecated HTML elements",
+          "default": "error"
+        },
+        "disallowed-element": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow specified elements (opt-in)",
+          "default": "off"
+        },
+        "doctype": {
+          "$ref": "#/definitions/severity",
+          "description": "Require DOCTYPE declaration",
+          "default": "error"
+        },
+        "end-tag": {
+          "$ref": "#/definitions/severity",
+          "description": "Require closing tags for non-void elements",
+          "default": "warning"
+        },
+        "header-footer-nesting": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow header/footer/main nesting inside header or footer",
+          "default": "error"
+        },
+        "heading-levels": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow skipping heading levels (e.g. h1 to h3)",
+          "default": "error"
+        },
+        "id-duplication": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow duplicate id attribute values",
+          "default": "error"
+        },
+        "input-attr-applicability": {
+          "$ref": "#/definitions/severity",
+          "description": "Detect attributes that do not apply to the input type",
+          "default": "warning"
+        },
+        "ineffective-attr": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow attributes that have no effect on the element",
+          "default": "warning"
+        },
+        "invalid-attr": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow non-standard attributes",
+          "default": "error"
+        },
+        "meta-constraints": {
+          "$ref": "#/definitions/severity",
+          "description": "Validate meta element attribute constraints",
+          "default": "error"
+        },
+        "label-has-control": {
+          "$ref": "#/definitions/severity",
+          "description": "Require label elements to have an associated control",
+          "default": "error"
+        },
+        "landmark-roles": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow nested landmark roles",
+          "default": "warning"
+        },
+        "neighbor-popovers": {
+          "$ref": "#/definitions/severity",
+          "description": "Require popover triggers to be adjacent to their targets (opt-in)",
+          "default": "off"
+        },
+        "no-ambiguous-navigable-target-names": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow ambiguous target attribute values",
+          "default": "warning"
+        },
+        "no-boolean-attr-value": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow redundant boolean attribute values (auto-fixable)",
+          "default": "warning"
+        },
+        "no-consecutive-br": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow consecutive br elements",
+          "default": "warning"
+        },
+        "no-default-value": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow default attribute values (auto-fixable)",
+          "default": "warning"
+        },
+        "no-duplicate-base": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow multiple base or title elements in the document",
+          "default": "error"
+        },
+        "no-duplicate-dt": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow duplicate dt elements in a dl",
+          "default": "error"
+        },
+        "no-empty-palpable-content": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow empty interactive or palpable content elements",
+          "default": "warning"
+        },
+        "no-hard-code-id": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow hardcoded id attributes (opt-in)",
+          "default": "off"
+        },
+        "no-nested-forms": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow nested form elements",
+          "default": "error"
+        },
+        "no-nested-interactive": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow interactive content inside a or button elements",
+          "default": "error"
+        },
+        "no-inline-style": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow inline style attributes",
+          "default": "warning"
+        },
+        "no-orphaned-end-tag": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow unmatched closing tags",
+          "default": "error"
+        },
+        "no-tabindex-on-dialog": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow tabindex attribute on dialog elements",
+          "default": "error"
+        },
+        "no-refer-to-non-existent-id": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow references to non-existent id values",
+          "default": "error"
+        },
+        "no-positive-tabindex": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow positive tabindex values",
+          "default": "warning"
+        },
+        "no-use-event-handler-attr": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow inline event handler attributes",
+          "default": "warning"
+        },
+        "obsolete-but-conforming": {
+          "$ref": "#/definitions/severity",
+          "description": "Warn about obsolete but conforming features",
+          "default": "warning"
+        },
+        "picture-structure": {
+          "$ref": "#/definitions/severity",
+          "description": "Validate picture element structure",
+          "default": "error"
+        },
+        "permitted-contents": {
+          "$ref": "#/definitions/severity",
+          "description": "Enforce HTML content model restrictions",
+          "default": "error"
+        },
+        "placeholder-label-option": {
+          "$ref": "#/definitions/severity",
+          "description": "Require placeholder option in select elements with required attribute",
+          "default": "warning"
+        },
+        "require-accessible-name": {
+          "$ref": "#/definitions/severity",
+          "description": "Require accessible names for interactive elements",
+          "default": "error"
+        },
+        "require-datetime": {
+          "$ref": "#/definitions/severity",
+          "description": "Require datetime attribute on time elements",
+          "default": "error"
+        },
+        "required-attr": {
+          "$ref": "#/definitions/severity",
+          "description": "Require specification-mandated attributes",
+          "default": "error"
+        },
+        "required-element": {
+          "$ref": "#/definitions/severity",
+          "description": "Require specification-mandated child elements",
+          "default": "error"
+        },
+        "required-h1": {
+          "$ref": "#/definitions/severity",
+          "description": "Require exactly one h1 element per document",
+          "default": "error"
+        },
+        "summary-first-child": {
+          "$ref": "#/definitions/severity",
+          "description": "Require summary to be the first child of details",
+          "default": "error"
+        },
+        "table-row-column-alignment": {
+          "$ref": "#/definitions/severity",
+          "description": "Require consistent column counts in table rows",
+          "default": "warning"
+        },
+        "th-content-restrictions": {
+          "$ref": "#/definitions/severity",
+          "description": "Disallow header, footer, sectioning, and heading elements inside th",
+          "default": "error"
+        },
+        "unique-main": {
+          "$ref": "#/definitions/severity",
+          "description": "Require at most one visible main element per document",
+          "default": "error"
+        },
+        "use-list": {
+          "$ref": "#/definitions/severity",
+          "description": "Suggest using list elements for bullet-like text patterns",
+          "default": "warning"
+        },
+        "valid-attr-value": {
+          "$ref": "#/definitions/severity",
+          "description": "Validate enumerated attribute values",
+          "default": "error"
+        },
+        "valid-autocomplete": {
+          "$ref": "#/definitions/severity",
+          "description": "Validate autocomplete attribute values on form elements",
+          "default": "warning"
+        },
+        "valid-rel": {
+          "$ref": "#/definitions/severity",
+          "description": "Validate rel attribute values for a, area, link, and form elements",
+          "default": "error"
+        },
+        "wai-aria": {
+          "$ref": "#/definitions/severity",
+          "description": "Validate WAI-ARIA roles and attributes",
+          "default": "error"
+        }
+      },
+      "additionalProperties": {
+        "$ref": "#/definitions/severity"
+      }
+    },
+    "ignore": {
+      "type": "array",
+      "description": "Glob patterns for files to exclude from linting",
+      "items": {
+        "type": "string"
+      }
+    },
+    "parser": {
+      "type": "object",
+      "description": "File extension to parser package mapping (e.g. { \".vue\": \"@rintenki/vue-parser\" })",
+      "additionalProperties": {
+        "type": "string"
+      }
+    }
+  },
+  "additionalProperties": false,
+  "definitions": {
+    "severity": {
+      "oneOf": [
+        {
+          "type": "string",
+          "enum": ["error", "warning", "warn", "off"]
+        },
+        {
+          "type": "boolean"
+        }
+      ],
+      "description": "Rule severity: \"error\", \"warning\"/\"warn\", \"off\", true (default severity), or false (off)"
+    }
+  }
+}