@hublo/sentinel 1.5.1-alpha.1 → 1.5.1-alpha.2

package/dist/bin/sentinel.js

@@ -11,10 +11,10 @@ import {
   presetNotInstalledYet,
   registerAdapters,
   resolve
-} from "../chunk-64H5HBPH.js";
+} from "../chunk-JHLNNIZC.js";
 import {
   resolveContext
-} from "../chunk-J2USE3KV.js";
+} from "../chunk-P7NYSMLS.js";
 import {
   ensureWorkspacePrep,
   findWorkspaceRoot,
@@ -527,7 +527,7 @@ async function runValidate(ctx) {
     );
   }
   if (!ctx.targets.includes("test")) return 1;
-  const { validateModuleTests } = await import("../validate-TIPIECG6.js");
+  const { validateModuleTests } = await import("../validate-5SD5CTTO.js");
   const outcomes = modules.flatMap(
     (module) => validateModuleTests(module.name, module.root)
   );

package/dist/{chunk-64H5HBPH.js → chunk-JHLNNIZC.js}

@@ -20,7 +20,9 @@ import {
   binFromOwnInstall,
   binSearchPath,
   canRunTypeAware,
+  canonicalRuleName,
   describeHolds,
+  describeRuleKey,
   extendsWithBaseline,
   extendsWithPreset,
   formatPresetFor,
@@ -57,7 +59,7 @@ import {
   splitToolArgs,
   walk,
   writtenFileFormatter
-} from "./chunk-J2USE3KV.js";
+} from "./chunk-P7NYSMLS.js";
 import {
   DEFAULT_MAX_DIAGNOSTICS,
   WORKSPACE_ROOT_MARKER,
@@ -4587,6 +4589,19 @@ function validate(preset, rules) {
     }
   }
 }
+function rejectTwoSpellings(label, rules) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const rule of Object.keys(rules)) {
+    const canonical = canonicalRuleName(rule);
+    const other = seen.get(canonical);
+    if (other !== void 0) {
+      throw new Error(
+        `${label}: "${other}" and "${rule}" are the same rule to oxlint (${canonical}). Configure it once, under one name: oxlint keeps both and picks one by hash order.`
+      );
+    }
+    seen.set(canonical, rule);
+  }
+}
 function layered(preset) {
   const base = sharedRules();
   const layer = presetRules(preset);
@@ -4596,6 +4611,7 @@ function layered(preset) {
 }
 function toRuleMap(label, rules) {
   validate(label, rules);
+  rejectTwoSpellings(label, rules);
   const entries = Object.entries(rules).map(([rule, value]) => {
     if (!isDecision(value)) return [rule, value];
     const options = value.options ?? [];
@@ -4663,6 +4679,110 @@ function committedExtendsList(cwd, configFile) {
   }
 }
 
+// src/roles/lint/module-own-config.ts
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function pluginKey(entry) {
+  if (typeof entry === "string") return entry;
+  if (isRecord(entry) && typeof entry.name === "string") return entry.name;
+  if (isRecord(entry) && typeof entry.specifier === "string") return entry.specifier;
+  return void 0;
+}
+function governedRuleNames(preset) {
+  return /* @__PURE__ */ new Set([
+    ...Object.keys(preset.rules),
+    ...(preset.overrides ?? []).flatMap((override) => Object.keys(override.rules))
+  ]);
+}
+function governedRules(preset) {
+  const governed = /* @__PURE__ */ new Map();
+  for (const name of governedRuleNames(preset)) {
+    const canonical = canonicalRuleName(name);
+    if (!governed.has(canonical)) governed.set(canonical, name);
+  }
+  return governed;
+}
+function moduleOwnBlocks(committed, preset) {
+  const blocks = {};
+  const kept = [];
+  const dropped = [];
+  if (Array.isArray(committed.plugins)) {
+    const own = committed.plugins.filter(
+      (name) => typeof name === "string" && !preset.plugins.includes(name)
+    );
+    if (own.length > 0) {
+      blocks.plugins = own;
+      kept.push(
+        `kept this module's own plugins (${own.join(", ")}): the preset does not enable them`
+      );
+    }
+  }
+  if (Array.isArray(committed.jsPlugins)) {
+    const presetKeys = new Set(preset.jsPlugins.map((entry) => pluginKey(entry)));
+    const own = [];
+    for (const entry of committed.jsPlugins) {
+      const key = pluginKey(entry);
+      if (key !== void 0 && presetKeys.has(key)) dropped.push(`jsPlugins ${key}`);
+      else own.push(entry);
+    }
+    if (own.length > 0) {
+      blocks.jsPlugins = own;
+      kept.push(
+        `kept ${own.length} jsPlugin(s) this module added (${own.map((entry) => pluginKey(entry) ?? "?").join(", ")})`
+      );
+    }
+  }
+  if (isRecord(committed.settings)) {
+    const presetSettings = preset.settings ?? {};
+    const own = {};
+    for (const [key, value] of Object.entries(committed.settings)) {
+      if (key in presetSettings) dropped.push(`settings.${key}`);
+      else own[key] = value;
+    }
+    if (Object.keys(own).length > 0) {
+      blocks.settings = own;
+      kept.push(`kept this module's own settings (${Object.keys(own).join(", ")})`);
+    }
+  }
+  if (Array.isArray(committed.overrides)) {
+    const governed = governedRules(preset);
+    const byFiles = /* @__PURE__ */ new Map();
+    for (const block of committed.overrides) {
+      if (!isRecord(block) || !Array.isArray(block.files)) continue;
+      const files = JSON.stringify([...block.files].map(String).sort());
+      const rules = {};
+      for (const [rule, value] of Object.entries(isRecord(block.rules) ? block.rules : {})) {
+        const presetSpelling = governed.get(canonicalRuleName(rule));
+        if (presetSpelling === void 0) rules[rule] = value;
+        else
+          dropped.push(
+            `overrides[${block.files.join(", ")}] ${describeRuleKey(rule, presetSpelling)}`
+          );
+      }
+      const { rules: _rules, ...rest } = block;
+      const merged = byFiles.get(files);
+      if (merged === void 0) {
+        byFiles.set(files, { ...rest, ...Object.keys(rules).length > 0 ? { rules } : {} });
+        continue;
+      }
+      const { files: _sameFiles, ...others } = rest;
+      const mergedRules = { ...isRecord(merged.rules) ? merged.rules : {}, ...rules };
+      Object.assign(
+        merged,
+        others,
+        Object.keys(mergedRules).length > 0 ? { rules: mergedRules } : {}
+      );
+    }
+    const own = [...byFiles.values()].filter((block) => Object.keys(block).length > 1);
+    if (own.length > 0) {
+      blocks.overrides = own;
+      kept.push(
+        `kept ${own.length} override block(s) this module set (${own.map((block) => block.files.join(", ")).join("; ")})`
+      );
+    }
+  }
+  return { blocks, kept, dropped };
+}
+
 // src/roles/lint/parse-diagnostics.ts
 function ruleId(code) {
   const inner = /\(([^)]+)\)/.exec(code);
@@ -4712,6 +4832,26 @@ function errorCountsByConfigRule(stdout) {
   return counts;
 }
 
+// src/roles/lint/presets.ts
+var hasRuleData = (name) => GENERATED_LINT_PRESETS.includes(name);
+function lintPresetFor(preset) {
+  const file = presetFile(preset);
+  const resolved = hasRuleData(preset) ? preset : "node";
+  return {
+    plugins: file.plugins,
+    jsPlugins: file.jsPlugins,
+    ...file.settings === null ? {} : { settings: file.settings },
+    ...file.renames ? { renames: file.renames } : {},
+    ...file.overrides ? {
+      overrides: file.overrides.map((override, index) => ({
+        files: override.files,
+        rules: toRuleMap(`${preset} override ${index}`, override.rules)
+      }))
+    } : {},
+    rules: rulesFor(resolved)
+  };
+}
+
 // src/roles/lint/adapters/oxlint/plan.ts
 import { existsSync as existsSync11, readFileSync as readFileSync13 } from "node:fs";
 import { join as join16 } from "node:path";
@@ -4804,118 +4944,6 @@ function keepsOtherCommands3(script) {
   return keepsOtherCommands(script, SENTINEL_LINT_COMMAND);
 }
 
-// src/roles/lint/module-own-config.ts
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-function pluginKey(entry) {
-  if (typeof entry === "string") return entry;
-  if (isRecord(entry) && typeof entry.name === "string") return entry.name;
-  if (isRecord(entry) && typeof entry.specifier === "string") return entry.specifier;
-  return void 0;
-}
-function governedRuleNames(preset) {
-  return /* @__PURE__ */ new Set([
-    ...Object.keys(preset.rules),
-    ...(preset.overrides ?? []).flatMap((override) => Object.keys(override.rules))
-  ]);
-}
-function moduleOwnBlocks(committed, preset) {
-  const blocks = {};
-  const kept = [];
-  const dropped = [];
-  if (Array.isArray(committed.plugins)) {
-    const own = committed.plugins.filter(
-      (name) => typeof name === "string" && !preset.plugins.includes(name)
-    );
-    if (own.length > 0) {
-      blocks.plugins = own;
-      kept.push(
-        `kept this module's own plugins (${own.join(", ")}): the preset does not enable them`
-      );
-    }
-  }
-  if (Array.isArray(committed.jsPlugins)) {
-    const presetKeys = new Set(preset.jsPlugins.map((entry) => pluginKey(entry)));
-    const own = [];
-    for (const entry of committed.jsPlugins) {
-      const key = pluginKey(entry);
-      if (key !== void 0 && presetKeys.has(key)) dropped.push(`jsPlugins ${key}`);
-      else own.push(entry);
-    }
-    if (own.length > 0) {
-      blocks.jsPlugins = own;
-      kept.push(
-        `kept ${own.length} jsPlugin(s) this module added (${own.map((entry) => pluginKey(entry) ?? "?").join(", ")})`
-      );
-    }
-  }
-  if (isRecord(committed.settings)) {
-    const presetSettings = preset.settings ?? {};
-    const own = {};
-    for (const [key, value] of Object.entries(committed.settings)) {
-      if (key in presetSettings) dropped.push(`settings.${key}`);
-      else own[key] = value;
-    }
-    if (Object.keys(own).length > 0) {
-      blocks.settings = own;
-      kept.push(`kept this module's own settings (${Object.keys(own).join(", ")})`);
-    }
-  }
-  if (Array.isArray(committed.overrides)) {
-    const governed = governedRuleNames(preset);
-    const byFiles = /* @__PURE__ */ new Map();
-    for (const block of committed.overrides) {
-      if (!isRecord(block) || !Array.isArray(block.files)) continue;
-      const files = JSON.stringify([...block.files].map(String).sort());
-      const rules = {};
-      for (const [rule, value] of Object.entries(isRecord(block.rules) ? block.rules : {})) {
-        if (governed.has(rule)) dropped.push(`overrides[${block.files.join(", ")}] ${rule}`);
-        else rules[rule] = value;
-      }
-      const { rules: _rules, ...rest } = block;
-      const merged = byFiles.get(files);
-      if (merged === void 0) {
-        byFiles.set(files, { ...rest, ...Object.keys(rules).length > 0 ? { rules } : {} });
-        continue;
-      }
-      const { files: _sameFiles, ...others } = rest;
-      const mergedRules = { ...isRecord(merged.rules) ? merged.rules : {}, ...rules };
-      Object.assign(
-        merged,
-        others,
-        Object.keys(mergedRules).length > 0 ? { rules: mergedRules } : {}
-      );
-    }
-    const own = [...byFiles.values()].filter((block) => Object.keys(block).length > 1);
-    if (own.length > 0) {
-      blocks.overrides = own;
-      kept.push(
-        `kept ${own.length} override block(s) this module set (${own.map((block) => block.files.join(", ")).join("; ")})`
-      );
-    }
-  }
-  return { blocks, kept, dropped };
-}
-
-// src/roles/lint/presets.ts
-var hasRuleData = (name) => GENERATED_LINT_PRESETS.includes(name);
-function lintPresetFor(preset) {
-  const file = presetFile(preset);
-  const resolved = hasRuleData(preset) ? preset : "node";
-  return {
-    plugins: file.plugins,
-    jsPlugins: file.jsPlugins,
-    ...file.settings === null ? {} : { settings: file.settings },
-    ...file.renames ? { renames: file.renames } : {},
-    ...file.overrides ? {
-      overrides: file.overrides.map((override, index) => ({
-        files: override.files,
-        rules: toRuleMap(`${preset} override ${index}`, override.rules)
-      }))
-    } : {},
-    rules: rulesFor(resolved)
-  };
-}
-
 // src/roles/lint/rename-suppressions.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync12, statSync as statSync3 } from "node:fs";
 import { join as join15, relative as relative3 } from "node:path";
@@ -5172,7 +5200,7 @@ function plan2(context2) {
   }
   if (droppedRules.length > 0) {
     notes.push(
-      `dropped ${droppedRules.length} rule(s) this module set over the preset (${droppedRules.join(", ")}): the preset governs them`
+      `dropped ${droppedRules.length} rule(s) this module set over the preset (${droppedRules.map((rule) => describeGoverned(rule, variant)).join(", ")}): the preset governs them`
     );
   }
   notes.push(...teamBlocks.kept);
@@ -5266,15 +5294,18 @@ function committedConfig(cwd) {
   }
 }
 function moduleOwnRules(committed, preset) {
-  const governedNames = governedRuleNames(preset);
+  const governedNames = governedRules(preset);
   const kept = {};
   const governed = [];
   for (const [rule, value] of Object.entries(committed)) {
-    if (governedNames.has(rule)) governed.push(rule);
+    if (governedNames.has(canonicalRuleName(rule))) governed.push(rule);
     else kept[rule] = value;
   }
   return { kept, governed };
 }
+function describeGoverned(rule, variant) {
+  return describeRuleKey(rule, governedRules(lintPresetFor(variant)).get(canonicalRuleName(rule)));
+}
 function committedIgnorePatterns(cwd) {
   try {
     const parsed = parseJsonc(
@@ -5516,7 +5547,10 @@ ${result.stderr ?? ""}`);
       );
       return;
     }
-    const holds = holdsFrom(errorCountsByConfigRule(measured.stdout ?? ""));
+    const holds = holdsFrom(
+      errorCountsByConfigRule(measured.stdout ?? ""),
+      governedRules(lintPresetFor(presetVariant(ctx.preset, ctx.cwd)))
+    );
     const next = extendsWithBaseline(current, holds.length > 0);
     if (holds.length > 0) {
       writeFileSync3(baselinePath, renderBaseline(holds, readOwnPackage().version));
@@ -5672,7 +5706,8 @@ ${result.stderr ?? ""}`);
    *    exactly when something is broken.
    *
    * Counted as a SET of rule names, so the baseline re-stating a preset rule at `warn` is
-   * the same rule, not a second one.
+   * the same rule, not a second one. The rule oxlint RUNS (`canonicalRuleName`), so a layer
+   * spelling it `no-unused-vars` beside the preset's `typescript/no-unused-vars` is one rule too.
    */
   presetRuleCount(cwd) {
     const target = this.unresolvedPreset(cwd);
@@ -5693,7 +5728,7 @@ ${result.stderr ?? ""}`);
           readFileSync14(join17(cwd, entry), "utf8"),
           entry
         );
-        for (const rule of Object.keys(preset.rules ?? {})) names.add(rule);
+        for (const rule of Object.keys(preset.rules ?? {})) names.add(canonicalRuleName(rule));
       } catch {
         continue;
       }

package/dist/{chunk-J2USE3KV.js → chunk-P7NYSMLS.js}

@@ -5940,11 +5940,682 @@ import { join as join30 } from "node:path";
 // src/roles/lint/module-baseline.ts
 import { existsSync as existsSync20, readFileSync as readFileSync22 } from "node:fs";
 import { join as join26 } from "node:path";
+
+// src/roles/lint/oxlint-rule-owners.json
+var oxlint_rule_owners_default = {
+  "adjacent-overload-signatures": "typescript",
+  "alt-text": "jsx_a11y",
+  "always-return": "promise",
+  "anchor-ambiguous-text": "jsx_a11y",
+  "anchor-has-content": "jsx_a11y",
+  "anchor-is-valid": "jsx_a11y",
+  "approx-constant": "oxc",
+  "aria-activedescendant-has-tabindex": "jsx_a11y",
+  "aria-props": "jsx_a11y",
+  "aria-proptypes": "jsx_a11y",
+  "aria-role": "jsx_a11y",
+  "aria-unsupported-elements": "jsx_a11y",
+  "array-type": "typescript",
+  "autocomplete-valid": "jsx_a11y",
+  "avoid-new": "promise",
+  "await-thenable": "typescript",
+  "bad-array-method-on-arguments": "oxc",
+  "bad-bitwise-operator": "oxc",
+  "bad-char-at-comparison": "oxc",
+  "bad-comparison-sequence": "oxc",
+  "bad-match-all-arg": "oxc",
+  "bad-min-max-func": "oxc",
+  "bad-object-literal-comparison": "oxc",
+  "bad-replace-all-arg": "oxc",
+  "ban-ts-comment": "typescript",
+  "ban-tslint-comment": "typescript",
+  "ban-types": "typescript",
+  "branches-sharing-code": "oxc",
+  "button-has-type": "react",
+  "callback-return": "node",
+  "catch-error-name": "unicorn",
+  "catch-or-return": "promise",
+  "check-access": "jsdoc",
+  "check-property-names": "jsdoc",
+  "check-tag-names": "jsdoc",
+  "checked-requires-onchange-or-readonly": "react",
+  "class-literal-property-style": "typescript",
+  "click-events-have-key-events": "jsx_a11y",
+  "component-definition-name-casing": "vue",
+  "consistent-assert": "unicorn",
+  "consistent-date-clone": "unicorn",
+  "consistent-each-for": "vitest",
+  "consistent-empty-array-spread": "unicorn",
+  "consistent-existence-index-check": "unicorn",
+  "consistent-function-scoping": "unicorn",
+  "consistent-generic-constructors": "typescript",
+  "consistent-indexed-object-style": "typescript",
+  "consistent-return": "typescript",
+  "consistent-template-literal-escape": "unicorn",
+  "consistent-test-filename": "vitest",
+  "consistent-test-it": "jest",
+  "consistent-type-assertions": "typescript",
+  "consistent-type-definitions": "typescript",
+  "consistent-type-exports": "typescript",
+  "consistent-type-imports": "typescript",
+  "consistent-type-specifier-style": "import",
+  "consistent-vitest-vi": "vitest",
+  "const-comparisons": "oxc",
+  "control-has-associated-label": "jsx_a11y",
+  "custom-error-definition": "unicorn",
+  default: "import",
+  "define-emits-declaration": "vue",
+  "define-props-declaration": "vue",
+  "define-props-destructuring": "vue",
+  "display-name": "react",
+  "dot-notation": "typescript",
+  "double-comparisons": "oxc",
+  "empty-brace-spaces": "unicorn",
+  "empty-tags": "jsdoc",
+  "erasing-op": "oxc",
+  "error-message": "unicorn",
+  "escape-case": "unicorn",
+  "exhaustive-deps": "react",
+  "expect-expect": "jest",
+  "explicit-function-return-type": "typescript",
+  "explicit-length-check": "unicorn",
+  "explicit-member-accessibility": "typescript",
+  "explicit-module-boundary-types": "typescript",
+  "explicit-timer-delay": "unicorn",
+  export: "import",
+  "exports-last": "import",
+  "exports-style": "node",
+  extensions: "import",
+  "filename-case": "unicorn",
+  first: "import",
+  "forbid-component-props": "react",
+  "forbid-dom-props": "react",
+  "forbid-elements": "react",
+  "forward-ref-uses-ref": "react",
+  "function-component-definition": "react",
+  "global-require": "node",
+  "google-font-display": "nextjs",
+  "google-font-preconnect": "nextjs",
+  "group-exports": "import",
+  "handle-callback-err": "node",
+  "heading-has-content": "jsx_a11y",
+  "hoisted-apis-on-top": "vitest",
+  "hook-use-state": "react",
+  "html-has-lang": "jsx_a11y",
+  "iframe-has-title": "jsx_a11y",
+  "iframe-missing-sandbox": "react",
+  "img-redundant-alt": "jsx_a11y",
+  "implements-on-classes": "jsdoc",
+  "import-style": "unicorn",
+  "inline-script-id": "nextjs",
+  "interactive-supports-focus": "jsx_a11y",
+  "jsx-boolean-value": "react",
+  "jsx-curly-brace-presence": "react",
+  "jsx-filename-extension": "react",
+  "jsx-fragments": "react",
+  "jsx-handler-names": "react",
+  "jsx-key": "react",
+  "jsx-max-depth": "react",
+  "jsx-no-comment-textnodes": "react",
+  "jsx-no-constructed-context-values": "react",
+  "jsx-no-duplicate-props": "react",
+  "jsx-no-jsx-as-prop": "react_perf",
+  "jsx-no-literals": "react",
+  "jsx-no-new-array-as-prop": "react_perf",
+  "jsx-no-new-function-as-prop": "react_perf",
+  "jsx-no-new-object-as-prop": "react_perf",
+  "jsx-no-script-url": "react",
+  "jsx-no-target-blank": "react",
+  "jsx-no-undef": "react",
+  "jsx-no-useless-fragment": "react",
+  "jsx-pascal-case": "react",
+  "jsx-props-no-spread-multi": "react",
+  "jsx-props-no-spreading": "react",
+  "label-has-associated-control": "jsx_a11y",
+  lang: "jsx_a11y",
+  "max-dependencies": "import",
+  "max-expects": "jest",
+  "max-nested-calls": "unicorn",
+  "max-nested-describe": "jest",
+  "max-props": "vue",
+  "media-has-caption": "jsx_a11y",
+  "method-signature-style": "typescript",
+  "misrefactored-assign-op": "oxc",
+  "missing-throw": "oxc",
+  "mouse-events-have-key-events": "jsx_a11y",
+  named: "import",
+  namespace: "import",
+  "new-for-builtins": "unicorn",
+  "newline-after-import": "import",
+  "next-script-for-ga": "nextjs",
+  "next-tick-style": "vue",
+  "no-absolute-path": "import",
+  "no-abusive-eslint-disable": "unicorn",
+  "no-access-key": "jsx_a11y",
+  "no-accessor-recursion": "unicorn",
+  "no-accumulating-spread": "oxc",
+  "no-alias-methods": "jest",
+  "no-amd": "import",
+  "no-anonymous-default-export": "import",
+  "no-aria-hidden-on-focusable": "jsx_a11y",
+  "no-array-callback-reference": "unicorn",
+  "no-array-delete": "typescript",
+  "no-array-fill-with-reference-type": "unicorn",
+  "no-array-for-each": "unicorn",
+  "no-array-index-key": "react",
+  "no-array-method-this-argument": "unicorn",
+  "no-array-reduce": "unicorn",
+  "no-array-reverse": "unicorn",
+  "no-array-sort": "unicorn",
+  "no-arrow-functions-in-watch": "vue",
+  "no-assign-module-variable": "nextjs",
+  "no-async-await": "oxc",
+  "no-async-client-component": "nextjs",
+  "no-async-endpoint-handlers": "oxc",
+  "no-async-in-computed-properties": "vue",
+  "no-autofocus": "jsx_a11y",
+  "no-await-expression-member": "unicorn",
+  "no-await-in-promise-methods": "unicorn",
+  "no-barrel-file": "oxc",
+  "no-base-to-string": "typescript",
+  "no-before-interactive-script-outside-document": "nextjs",
+  "no-callback-in-promise": "promise",
+  "no-children-prop": "react",
+  "no-clone-element": "react",
+  "no-commented-out-tests": "jest",
+  "no-commonjs": "import",
+  "no-computed-properties-in-data": "vue",
+  "no-conditional-expect": "jest",
+  "no-conditional-in-test": "jest",
+  "no-conditional-tests": "vitest",
+  "no-confusing-array-with": "unicorn",
+  "no-confusing-non-null-assertion": "typescript",
+  "no-confusing-set-timeout": "jest",
+  "no-confusing-void-expression": "typescript",
+  "no-console-spaces": "unicorn",
+  "no-const-enum": "oxc",
+  "no-css-tags": "nextjs",
+  "no-cycle": "import",
+  "no-danger": "react",
+  "no-danger-with-children": "react",
+  "no-default-export": "import",
+  "no-defaults": "jsdoc",
+  "no-deprecated": "typescript",
+  "no-deprecated-data-object-declaration": "vue",
+  "no-deprecated-delete-set": "vue",
+  "no-deprecated-destroyed-lifecycle": "vue",
+  "no-deprecated-events-api": "vue",
+  "no-deprecated-functions": "jest",
+  "no-deprecated-model-definition": "vue",
+  "no-deprecated-props-default-this": "vue",
+  "no-deprecated-vue-config-keycodes": "vue",
+  "no-did-mount-set-state": "react",
+  "no-did-update-set-state": "react",
+  "no-direct-mutation-state": "react",
+  "no-disabled-tests": "jest",
+  "no-distracting-elements": "jsx_a11y",
+  "no-document-cookie": "unicorn",
+  "no-document-import-in-page": "nextjs",
+  "no-done-callback": "jest",
+  "no-duplicate-enum-values": "typescript",
+  "no-duplicate-head": "nextjs",
+  "no-duplicate-hooks": "jest",
+  "no-duplicate-type-constituents": "typescript",
+  "no-duplicates": "import",
+  "no-dynamic-delete": "typescript",
+  "no-dynamic-require": "import",
+  "no-empty-file": "unicorn",
+  "no-empty-interface": "typescript",
+  "no-empty-named-blocks": "import",
+  "no-empty-object-type": "typescript",
+  "no-explicit-any": "typescript",
+  "no-export": "jest",
+  "no-export-in-script-setup": "vue",
+  "no-exports-assign": "node",
+  "no-expose-after-await": "vue",
+  "no-extra-non-null-assertion": "typescript",
+  "no-extraneous-class": "typescript",
+  "no-find-dom-node": "react",
+  "no-floating-promises": "typescript",
+  "no-focused-tests": "jest",
+  "no-for-in-array": "typescript",
+  "no-head-element": "nextjs",
+  "no-head-import-in-document": "nextjs",
+  "no-hex-escape": "unicorn",
+  "no-hooks": "jest",
+  "no-html-link-for-pages": "nextjs",
+  "no-identical-title": "jest",
+  "no-img-element": "nextjs",
+  "no-immediate-mutation": "unicorn",
+  "no-import-compiler-macros": "vue",
+  "no-import-node-test": "vitest",
+  "no-import-type-side-effects": "typescript",
+  "no-importing-vitest-globals": "vitest",
+  "no-inferrable-types": "typescript",
+  "no-instanceof-array": "unicorn",
+  "no-instanceof-builtins": "unicorn",
+  "no-interactive-element-to-noninteractive-role": "jsx_a11y",
+  "no-interpolation-in-snapshots": "jest",
+  "no-invalid-fetch-options": "unicorn",
+  "no-invalid-remove-event-listener": "unicorn",
+  "no-invalid-void-type": "typescript",
+  "no-is-mounted": "react",
+  "no-jasmine-globals": "jest",
+  "no-large-snapshots": "jest",
+  "no-length-as-slice-end": "unicorn",
+  "no-lifecycle-after-await": "vue",
+  "no-magic-array-flat-depth": "unicorn",
+  "no-map-spread": "oxc",
+  "no-meaningless-void-operator": "typescript",
+  "no-misused-new": "typescript",
+  "no-misused-promises": "typescript",
+  "no-misused-spread": "typescript",
+  "no-mixed-enums": "typescript",
+  "no-mixed-requires": "node",
+  "no-mocks-import": "jest",
+  "no-multi-comp": "react",
+  "no-multiple-resolved": "promise",
+  "no-multiple-slot-args": "vue",
+  "no-mutable-exports": "import",
+  "no-named-as-default": "import",
+  "no-named-as-default-member": "import",
+  "no-named-default": "import",
+  "no-named-export": "import",
+  "no-namespace": "import",
+  "no-negation-in-equality-check": "unicorn",
+  "no-nesting": "promise",
+  "no-new-array": "unicorn",
+  "no-new-buffer": "unicorn",
+  "no-new-require": "node",
+  "no-new-statics": "promise",
+  "no-nodejs-modules": "import",
+  "no-non-null-asserted-nullish-coalescing": "typescript",
+  "no-non-null-asserted-optional-chain": "typescript",
+  "no-non-null-assertion": "typescript",
+  "no-noninteractive-element-interactions": "jsx_a11y",
+  "no-noninteractive-element-to-interactive-role": "jsx_a11y",
+  "no-noninteractive-tabindex": "jsx_a11y",
+  "no-null": "unicorn",
+  "no-object-as-default-parameter": "unicorn",
+  "no-object-type-as-default-prop": "react",
+  "no-optional-chaining": "oxc",
+  "no-page-custom-font": "nextjs",
+  "no-path-concat": "node",
+  "no-process-env": "node",
+  "no-process-exit": "unicorn",
+  "no-promise-in-callback": "promise",
+  "no-react-children": "react",
+  "no-redundant-roles": "jsx_a11y",
+  "no-redundant-should-component-update": "react",
+  "no-redundant-type-constituents": "typescript",
+  "no-relative-parent-imports": "import",
+  "no-render-return-value": "react",
+  "no-require-imports": "typescript",
+  "no-required-prop-with-default": "vue",
+  "no-reserved-component-names": "vue",
+  "no-reserved-keys": "vue",
+  "no-reserved-props": "vue",
+  "no-rest-spread-properties": "oxc",
+  "no-restricted-jest-methods": "jest",
+  "no-restricted-matchers": "jest",
+  "no-restricted-types": "typescript",
+  "no-restricted-vi-methods": "vitest",
+  "no-return-in-finally": "promise",
+  "no-return-wrap": "promise",
+  "no-script-component-in-head": "nextjs",
+  "no-self-import": "import",
+  "no-set-state": "react",
+  "no-shared-component-data": "vue",
+  "no-side-effects-in-computed-properties": "vue",
+  "no-single-promise-in-promise-methods": "unicorn",
+  "no-standalone-expect": "jest",
+  "no-static-element-interactions": "jsx_a11y",
+  "no-static-only-class": "unicorn",
+  "no-string-refs": "react",
+  "no-styled-jsx-in-document": "nextjs",
+  "no-sync": "node",
+  "no-sync-scripts": "nextjs",
+  "no-test-prefixes": "jest",
+  "no-test-return-statement": "jest",
+  "no-thenable": "unicorn",
+  "no-this-alias": "typescript",
+  "no-this-assignment": "unicorn",
+  "no-this-in-before-route-enter": "vue",
+  "no-this-in-exported-function": "oxc",
+  "no-this-in-sfc": "react",
+  "no-title-in-document-head": "nextjs",
+  "no-top-level-await": "node",
+  "no-typeof-undefined": "unicorn",
+  "no-typos": "nextjs",
+  "no-unassigned-import": "import",
+  "no-unescaped-entities": "react",
+  "no-unknown-property": "react",
+  "no-unnecessary-array-flat-depth": "unicorn",
+  "no-unnecessary-array-splice-count": "unicorn",
+  "no-unnecessary-await": "unicorn",
+  "no-unnecessary-boolean-literal-compare": "typescript",
+  "no-unnecessary-condition": "typescript",
+  "no-unnecessary-parameter-property-assignment": "typescript",
+  "no-unnecessary-qualifier": "typescript",
+  "no-unnecessary-slice-end": "unicorn",
+  "no-unnecessary-template-expression": "typescript",
+  "no-unnecessary-type-arguments": "typescript",
+  "no-unnecessary-type-assertion": "typescript",
+  "no-unnecessary-type-constraint": "typescript",
+  "no-unnecessary-type-conversion": "typescript",
+  "no-unnecessary-type-parameters": "typescript",
+  "no-unneeded-async-expect-function": "jest",
+  "no-unreadable-array-destructuring": "unicorn",
+  "no-unreadable-iife": "unicorn",
+  "no-unsafe": "react",
+  "no-unsafe-argument": "typescript",
+  "no-unsafe-assignment": "typescript",
+  "no-unsafe-call": "typescript",
+  "no-unsafe-declaration-merging": "typescript",
+  "no-unsafe-enum-comparison": "typescript",
+  "no-unsafe-function-type": "typescript",
+  "no-unsafe-member-access": "typescript",
+  "no-unsafe-return": "typescript",
+  "no-unsafe-type-assertion": "typescript",
+  "no-unsafe-unary-minus": "typescript",
+  "no-unstable-nested-components": "react",
+  "no-untyped-mock-factory": "jest",
+  "no-unwanted-polyfillio": "nextjs",
+  "no-useless-collection-argument": "unicorn",
+  "no-useless-default-assignment": "typescript",
+  "no-useless-empty-export": "typescript",
+  "no-useless-error-capture-stack-trace": "unicorn",
+  "no-useless-fallback-in-spread": "unicorn",
+  "no-useless-iterator-to-array": "unicorn",
+  "no-useless-length-check": "unicorn",
+  "no-useless-promise-resolve-reject": "unicorn",
+  "no-useless-spread": "unicorn",
+  "no-useless-switch-case": "unicorn",
+  "no-useless-undefined": "unicorn",
+  "no-var-requires": "typescript",
+  "no-watch-after-await": "vue",
+  "no-webpack-loader-syntax": "import",
+  "no-will-update-set-state": "react",
+  "no-wrapper-object-types": "typescript",
+  "no-zero-fractions": "unicorn",
+  "non-nullable-type-assertion-style": "typescript",
+  "number-arg-out-of-range": "oxc",
+  "number-literal-case": "unicorn",
+  "numeric-separators-style": "unicorn",
+  "only-export-components": "react",
+  "only-throw-error": "typescript",
+  "only-used-in-recursion": "oxc",
+  "padding-around-after-all-blocks": "jest",
+  "padding-around-test-blocks": "jest",
+  "param-names": "promise",
+  "parameter-properties": "typescript",
+  "prefer-add-event-listener": "unicorn",
+  "prefer-array-find": "unicorn",
+  "prefer-array-flat": "unicorn",
+  "prefer-array-flat-map": "unicorn",
+  "prefer-array-index-of": "unicorn",
+  "prefer-array-some": "unicorn",
+  "prefer-as-const": "typescript",
+  "prefer-at": "unicorn",
+  "prefer-await-to-callbacks": "promise",
+  "prefer-await-to-then": "promise",
+  "prefer-bigint-literals": "unicorn",
+  "prefer-blob-reading-methods": "unicorn",
+  "prefer-called-exactly-once-with": "vitest",
+  "prefer-called-once": "vitest",
+  "prefer-called-times": "vitest",
+  "prefer-called-with": "jest",
+  "prefer-catch": "promise",
+  "prefer-class-fields": "unicorn",
+  "prefer-classlist-toggle": "unicorn",
+  "prefer-code-point": "unicorn",
+  "prefer-comparison-matcher": "jest",
+  "prefer-date-now": "unicorn",
+  "prefer-default-export": "import",
+  "prefer-default-parameters": "unicorn",
+  "prefer-describe-function-title": "vitest",
+  "prefer-dom-node-append": "unicorn",
+  "prefer-dom-node-dataset": "unicorn",
+  "prefer-dom-node-remove": "unicorn",
+  "prefer-dom-node-text-content": "unicorn",
+  "prefer-each": "jest",
+  "prefer-ending-with-an-expect": "jest",
+  "prefer-enum-initializers": "typescript",
+  "prefer-equality-matcher": "jest",
+  "prefer-es6-class": "react",
+  "prefer-event-target": "unicorn",
+  "prefer-expect-assertions": "jest",
+  "prefer-expect-resolves": "jest",
+  "prefer-expect-type-of": "vitest",
+  "prefer-export-from": "unicorn",
+  "prefer-find": "typescript",
+  "prefer-for-of": "typescript",
+  "prefer-function-component": "react",
+  "prefer-function-type": "typescript",
+  "prefer-global-this": "unicorn",
+  "prefer-hooks-in-order": "jest",
+  "prefer-hooks-on-top": "jest",
+  "prefer-import-from-vue": "vue",
+  "prefer-import-in-mock": "vitest",
+  "prefer-import-meta-properties": "unicorn",
+  "prefer-importing-jest-globals": "jest",
+  "prefer-importing-vitest-globals": "vitest",
+  "prefer-includes": "typescript",
+  "prefer-jest-mocked": "jest",
+  "prefer-keyboard-event-key": "unicorn",
+  "prefer-literal-enum-member": "typescript",
+  "prefer-logical-operator-over-ternary": "unicorn",
+  "prefer-lowercase-title": "jest",
+  "prefer-math-min-max": "unicorn",
+  "prefer-math-trunc": "unicorn",
+  "prefer-mock-promise-shorthand": "jest",
+  "prefer-mock-return-shorthand": "jest",
+  "prefer-modern-dom-apis": "unicorn",
+  "prefer-modern-math-apis": "unicorn",
+  "prefer-module": "unicorn",
+  "prefer-namespace-keyword": "typescript",
+  "prefer-native-coercion-functions": "unicorn",
+  "prefer-negative-index": "unicorn",
+  "prefer-node-protocol": "unicorn",
+  "prefer-nullish-coalescing": "typescript",
+  "prefer-number-coercion": "unicorn",
+  "prefer-number-properties": "unicorn",
+  "prefer-object-from-entries": "unicorn",
+  "prefer-optional-catch-binding": "unicorn",
+  "prefer-optional-chain": "typescript",
+  "prefer-prototype-methods": "unicorn",
+  "prefer-query-selector": "unicorn",
+  "prefer-readonly": "typescript",
+  "prefer-readonly-parameter-types": "typescript",
+  "prefer-reduce-type-parameter": "typescript",
+  "prefer-reflect-apply": "unicorn",
+  "prefer-regexp-exec": "typescript",
+  "prefer-regexp-test": "unicorn",
+  "prefer-response-static-json": "unicorn",
+  "prefer-return-this-type": "typescript",
+  "prefer-set-has": "unicorn",
+  "prefer-set-size": "unicorn",
+  "prefer-single-call": "unicorn",
+  "prefer-snapshot-hint": "jest",
+  "prefer-spy-on": "jest",
+  "prefer-strict-boolean-matchers": "vitest",
+  "prefer-strict-equal": "jest",
+  "prefer-string-raw": "unicorn",
+  "prefer-string-replace-all": "unicorn",
+  "prefer-string-slice": "unicorn",
+  "prefer-string-starts-ends-with": "typescript",
+  "prefer-string-trim-start-end": "unicorn",
+  "prefer-structured-clone": "unicorn",
+  "prefer-tag-over-role": "jsx_a11y",
+  "prefer-ternary": "unicorn",
+  "prefer-to-be": "jest",
+  "prefer-to-be-falsy": "vitest",
+  "prefer-to-be-object": "vitest",
+  "prefer-to-be-truthy": "vitest",
+  "prefer-to-contain": "jest",
+  "prefer-to-have-been-called": "jest",
+  "prefer-to-have-been-called-times": "jest",
+  "prefer-to-have-length": "jest",
+  "prefer-todo": "jest",
+  "prefer-top-level-await": "unicorn",
+  "prefer-ts-expect-error": "typescript",
+  "prefer-type-error": "unicorn",
+  "promise-function-async": "typescript",
+  "prop-name-casing": "vue",
+  "react-compiler": "react",
+  "react-in-jsx-scope": "react",
+  "related-getter-setter-pairs": "typescript",
+  "relative-url-style": "unicorn",
+  "require-array-join-separator": "unicorn",
+  "require-array-sort-compare": "typescript",
+  "require-awaited-expect-poll": "vitest",
+  "require-default-export": "vue",
+  "require-default-prop": "vue",
+  "require-direct-export": "vue",
+  "require-hook": "jest",
+  "require-local-test-context-for-concurrent-snapshots": "vitest",
+  "require-mock-type-parameters": "vitest",
+  "require-module-attributes": "unicorn",
+  "require-module-specifiers": "unicorn",
+  "require-number-to-fixed-digits-argument": "unicorn",
+  "require-param": "jsdoc",
+  "require-param-description": "jsdoc",
+  "require-param-name": "jsdoc",
+  "require-param-type": "jsdoc",
+  "require-post-message-target-origin": "unicorn",
+  "require-prop-type-constructor": "vue",
+  "require-prop-types": "vue",
+  "require-property": "jsdoc",
+  "require-property-description": "jsdoc",
+  "require-property-name": "jsdoc",
+  "require-property-type": "jsdoc",
+  "require-render-return": "react",
+  "require-returns": "jsdoc",
+  "require-returns-description": "jsdoc",
+  "require-returns-type": "jsdoc",
+  "require-slots-as-functions": "vue",
+  "require-test-timeout": "vitest",
+  "require-throws-description": "jsdoc",
+  "require-throws-type": "jsdoc",
+  "require-to-throw-message": "jest",
+  "require-top-level-describe": "jest",
+  "require-typed-ref": "vue",
+  "require-yields": "jsdoc",
+  "require-yields-description": "jsdoc",
+  "require-yields-type": "jsdoc",
+  "restrict-plus-operands": "typescript",
+  "restrict-template-expressions": "typescript",
+  "return-await": "typescript",
+  "return-in-computed-property": "vue",
+  "return-in-emits-validator": "vue",
+  "role-has-required-aria-props": "jsx_a11y",
+  "role-supports-aria-props": "jsx_a11y",
+  "rules-of-hooks": "react",
+  scope: "jsx_a11y",
+  "self-closing-comp": "react",
+  "spec-only": "promise",
+  "state-in-constructor": "react",
+  "strict-boolean-expressions": "typescript",
+  "strict-void-return": "typescript",
+  "style-prop-object": "react",
+  "switch-case-braces": "unicorn",
+  "switch-case-break-position": "unicorn",
+  "switch-exhaustiveness-check": "typescript",
+  "tabindex-no-positive": "jsx_a11y",
+  "text-encoding-identifier-case": "unicorn",
+  "throw-new-error": "unicorn",
+  "triple-slash-reference": "typescript",
+  unambiguous: "import",
+  "unbound-method": "typescript",
+  "unified-signatures": "typescript",
+  "uninvoked-array-callback": "oxc",
+  "use-unknown-in-catch-callback-variable": "typescript",
+  "valid-define-emits": "vue",
+  "valid-define-options": "vue",
+  "valid-define-props": "vue",
+  "valid-describe-callback": "jest",
+  "valid-expect": "jest",
+  "valid-expect-in-promise": "jest",
+  "valid-next-tick": "vue",
+  "valid-params": "promise",
+  "valid-title": "jest",
+  "void-dom-elements-no-children": "react",
+  "warn-todo": "vitest"
+};
+
+// src/roles/lint/rule-name.ts
+var PLUGIN_ALIASES = {
+  "@typescript-eslint": "typescript",
+  "import-x": "import",
+  "jsx-a11y": "jsx_a11y",
+  "jsx-a11y-x": "jsx_a11y",
+  "jsx_a11y-x": "jsx_a11y",
+  "react-perf": "react_perf",
+  "@next": "nextjs",
+  "@next/next": "nextjs",
+  "react-hooks": "react",
+  deepscan: "oxc"
+};
+var TYPESCRIPT_COMPATIBLE_ESLINT_RULES = /* @__PURE__ */ new Set([
+  "class-methods-use-this",
+  "default-param-last",
+  "init-declarations",
+  "max-params",
+  "no-array-constructor",
+  "no-dupe-class-members",
+  "no-empty-function",
+  "no-invalid-this",
+  "no-loop-func",
+  "no-loss-of-precision",
+  "no-magic-numbers",
+  "no-redeclare",
+  "no-restricted-imports",
+  "no-shadow",
+  "no-unused-expressions",
+  "no-unused-vars",
+  "no-use-before-define",
+  "no-useless-constructor"
+]);
+var OWNERS = oxlint_rule_owners_default;
+var PLUGIN_PREFIXES = ["eslint-plugin", "oxlint-plugin"];
+function normalizePluginName(plugin) {
+  const slash = plugin.indexOf("/");
+  if (slash !== -1) {
+    const scope = plugin.slice(0, slash);
+    const rest = plugin.slice(slash + 1);
+    for (const prefix of PLUGIN_PREFIXES) {
+      if (rest === prefix) return scope;
+      if (rest.startsWith(`${prefix}-`)) return `${scope}/${rest.slice(prefix.length + 1)}`;
+    }
+  }
+  for (const prefix of PLUGIN_PREFIXES) {
+    if (plugin.startsWith(`${prefix}-`)) return plugin.slice(prefix.length + 1);
+  }
+  return plugin;
+}
+function canonicalRuleName(key) {
+  const at = key.startsWith("@") ? key.lastIndexOf("/") : key.indexOf("/");
+  if (at === -1) return `${OWNERS[key] ?? "eslint"}/${key}`;
+  const normalized = normalizePluginName(key.slice(0, at));
+  const rule = key.slice(at + 1);
+  const plugin = PLUGIN_ALIASES[normalized] ?? normalized;
+  return plugin === "typescript" && TYPESCRIPT_COMPATIBLE_ESLINT_RULES.has(rule) ? `eslint/${rule}` : `${plugin}/${rule}`;
+}
+function describeRuleKey(key, presetSpelling) {
+  return presetSpelling === void 0 || presetSpelling === key ? key : `${key} (oxlint runs it as ${presetSpelling})`;
+}
+
+// src/roles/lint/module-baseline.ts
 var LINT_BASELINE_FILE = ".oxlintrc.baseline.json";
 var LINT_MEASURE_FILE = ".oxlintrc.measure.json";
 var LINT_BASELINE_SPECIFIER = `./${LINT_BASELINE_FILE}`;
-function holdsFrom(errorCounts) {
-  return [...errorCounts].map(([rule, count]) => ({ rule, count })).sort((left, right) => right.count - left.count || left.rule.localeCompare(right.rule));
+function holdsFrom(errorCounts, presetSpellings = /* @__PURE__ */ new Map()) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const [id, count] of errorCounts) {
+    const rule = presetSpellings.get(canonicalRuleName(id)) ?? id;
+    counts.set(rule, (counts.get(rule) ?? 0) + count);
+  }
+  return [...counts].map(([rule, count]) => ({ rule, count })).sort((left, right) => right.count - left.count || left.rule.localeCompare(right.rule));
 }
 function renderBaseline(holds, version) {
   const entries = holds.map(({ rule }) => `    ${JSON.stringify(rule)}: "warn"`).join(",\n");
@@ -6607,6 +7278,8 @@ export {
   rewriteToolchainImports,
   resolveOxfmt,
   oxfmtRejects,
+  canonicalRuleName,
+  describeRuleKey,
   LINT_BASELINE_FILE,
   LINT_MEASURE_FILE,
   LINT_BASELINE_SPECIFIER,

package/dist/index.js

@@ -6,10 +6,10 @@ import {
   registerAdapters,
   resolve,
   setDefaultRunner
-} from "./chunk-64H5HBPH.js";
+} from "./chunk-JHLNNIZC.js";
 import {
   BaseAdapter
-} from "./chunk-J2USE3KV.js";
+} from "./chunk-P7NYSMLS.js";
 import "./chunk-JRZI5IIN.js";
 import "./chunk-WBDBRGLV.js";
 import "./chunk-O7REVMOC.js";

package/dist/{validate-TIPIECG6.js → validate-5SD5CTTO.js}

@@ -7,7 +7,7 @@ import {
   readTestAdoption,
   resolveVitest,
   suiteOf
-} from "./chunk-J2USE3KV.js";
+} from "./chunk-P7NYSMLS.js";
 import "./chunk-JRZI5IIN.js";
 import "./chunk-O7REVMOC.js";
 import "./chunk-QXFCZON7.js";

package/docs/lint-adoption.md

@@ -215,6 +215,16 @@ Two limits, both the preset's governance:
   it and names it. That includes `no-console` and `no-restricted-imports` in the react preset. To
   set one of those for your module, put it in an `extends` layer after the preset (above): a
   layer is reviewed as yours and `--inspect` shows it.
+- **"The same rule" is the rule oxlint runs, not the name you wrote** (since 1.5.1). Oxlint
+  accepts several names for one rule: `eslint/x` is `x`, `typescript/x` is the eslint rule `x`
+  for 18 rules that typescript-eslint extends (`no-restricted-imports`, `no-unused-vars`,
+  `no-unused-expressions`, ...), `@typescript-eslint/` is `typescript/`, `react-hooks/` is
+  `react/`, `jsx-a11y/` is `jsx_a11y/`, `import-x/` is `import/`, `eslint-plugin-` prefixes are
+  dropped, and a bare name belongs to the first built-in rule of that name. Measured on 1.77.0, a
+  react stub setting `typescript/no-restricted-imports` beside console's two rules linted with
+  its own patterns and none of the preset's, so `@nestjs/*` imports passed. A re-`init` now drops
+  an alias like the name it stands for, and says which preset rule it is:
+  `typescript/no-restricted-imports (oxlint runs it as no-restricted-imports)`.
 - **Your `overrides` blocks are kept as written**, with their `files`, and their rules go through
   the same filter. Two of your blocks with the same `files` are merged into one on re-`init`; a
   block is never merged into a preset override, which lives behind `extends` where the stub
@@ -283,7 +293,12 @@ things follow, and they are the point:
 - your own config stays `extends` + `ignorePatterns`, so a rule **you** change by hand is
   still reported as drift and is never confused with a hold sentinel made;
 - `--init` says what it held and how many violations each hold covers, so the debt is
-  announced rather than discovered.
+  announced rather than discovered;
+- a hold is written under the **preset's** name for the rule (since 1.5.1). Oxlint reports
+  `eslint(no-unused-expressions)` for a rule the nest preset configures as
+  `typescript/no-unused-expressions`, and a hold keyed `no-unused-expressions` did not hold:
+  measured on 1.77.0, the violation stayed an `error` on react and nest, because oxlint keeps the
+  two names side by side and picks one by hash order.
 
 Do not edit `.oxlintrc.baseline.json` by hand. Commit it: it is part of the adoption, and it
 is what makes the promise above true on the day you adopt rather than on the day the preset

package/docs/validating-a-change.md

@@ -137,7 +137,7 @@ majority of the migration, and only a sweep over every real module found it.
 
 ## The `--init` matrix for 1.5.1, 29 October 2026
 
-Six fixes, found by re-initializing the monorepo's 63 adopted modules with 1.5.1-alpha.0. Every
+Six fixes, then a seventh (below) found by the alpha.1 validation. Found by re-initializing the monorepo's 63 adopted modules with 1.5.1-alpha.0. Every
 cell below is a test in this repo, against the built CLI unless it says unit, and every fix has a
 negative control: the fix reverted in the source, the cells run again, and the cells that must
 fail do. No existing cell changed: against the alpha, the test tree gains lines and loses none
@@ -240,6 +240,47 @@ Negative controls, one per block, each reverting one read-back: plugins 5 cells
 6, settings 5, overrides 6, extends 5, rules 6, sortImports 7, format `ignorePatterns` 1. Each
 fails its own cells plus the every-block cells, and nothing else.
 
+### 7. an alias of a governed rule is governed (`init-drops-governed-aliases`, unit `lint-governed-aliases`, `lint-rule-name`)
+
+Oxlint 1.77.0 runs several names as one rule, and sentinel compared names. Proven first, outside
+sentinel, react preset, a file importing `@nestjs/common` and one importing `lodash`:
+
+| stub `rules` beside the preset                                                        | what fires                     |
+| ------------------------------------------------------------------------------------- | ------------------------------ |
+| five unrelated rules (control)                                                        | the preset's `@nestjs/*` ban   |
+| the same, plus `typescript/no-restricted-imports` with a lodash pattern               | the lodash ban only            |
+| `typescript/no-restricted-imports` alone                                              | the preset's ban only          |
+| `eslint/no-restricted-imports` alone                                                  | the lodash ban only, every run |
+| baseline `no-unused-expressions: warn` over nest's `typescript/no-unused-expressions` | still an `error`               |
+
+The `typescript/` outcome moves with the rest of the rule set because oxlint keeps both names
+through the `extends` merge and picks one by hash order; `eslint/` collapses with the canonical
+name in the merge, where the stub wins. The canonical form is ported from oxc at
+`oxlint_v1.77.0` (`parse_rule_key`, `normalize_plugin_name`, `unalias_plugin_name`,
+`TYPESCRIPT_COMPATIBLE_ESLINT_RULES`), with the bare-name owners taken from `oxlint --rules -f json`.
+
+| cell                                                                                      | result                                                |
+| ----------------------------------------------------------------------------------------- | ----------------------------------------------------- |
+| re-init, react, console's rules + `typescript/no-restricted-imports` / `eslint/...`       | alias dropped and named, the two team rules kept      |
+| the same, then a file importing `@nestjs/common`, `--run --lint`                          | fails on the preset's ban                             |
+| control: the canonical `no-restricted-imports`                                            | dropped, message unchanged                            |
+| nest module violating `no-unused-expressions` at adoption                                 | holds `typescript/no-unused-expressions`, lints green |
+| team layer `no-unused-vars` over nest's `typescript/no-unused-vars`, `--inspect`          | rule count unchanged                                  |
+| unit: `@typescript-eslint/`, bare `no-unused-vars`, `react/rules-of-hooks`, an override   | dropped (override named with the preset rule)         |
+| unit: `typescript/require-await`, `unicorn/no-nested-ternary`, `typescript/no-namespace`  | kept: different rules to oxlint too                   |
+| every governed built-in rule of every preset, in every spelling, through `--print-config` | resolves where sentinel says                          |
+| a preset rule set naming one rule twice                                                   | refused at build                                      |
+
+Negative control, `canonicalRuleName` made the identity: 31 of the 48 new cells fail, the 17 that
+pass are the negative ones (the non-aliases, the preset-builds, the owners file, the canonical
+control). With the source fix reverted (`git checkout` of the five files, new files kept), 6 of
+the 7 e2e cells fail, the canonical control passes, and the `--run --lint` cell lints the
+`@nestjs/common` import clean. No existing cell changed.
+
+Checked in the monorepo at 7177eb86038: none of the 66 committed `.oxlintrc*.json` files and
+team layers spells a governed rule under another name, so no adopted module carries the gap
+today.
+
 ### against the consumer, the 63 adopted modules
 
 The packed branch, through a pnpm `file:` override, on a fresh worktree of the monorepo at

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hublo/sentinel",
-  "version": "1.5.1-alpha.1",
+  "version": "1.5.1-alpha.2",
   "description": "One CLI that guards code health across Hublo repos: shared lint/typescript/build/test presets, static & dynamic analysis, and architecture checks.",
   "type": "module",
   "license": "MIT",