oxlint-plugin-vue-sfc 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Togetic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,124 @@
+# oxlint-plugin-vue-sfc
+
+Vue SFC template rules for [oxlint](https://oxc.rs), as a JS plugin.
+
+oxlint cannot read Vue templates natively ([oxc#15761](https://github.com/oxc-project/oxc/issues/15761)),
+so projects keep ESLint around for `eslint-plugin-vue`. These 24 rules self-parse the SFC with
+`@vue/compiler-sfc` and walk the real template AST, so the checks run under oxlint instead.
+
+Ports of `eslint-plugin-vue` rules that oxlint has no native equivalent for. Validated against a
+production Nuxt monorepo — 1581 SFCs, all template-first — where they replaced the corresponding
+`vue/*` ESLint rules outright.
+
+## Install
+
+```bash
+npm i -D oxlint-plugin-vue-sfc
+```
+
+## Usage
+
+Extend a preset from your `.oxlintrc.json`:
+
+```jsonc
+{
+    "extends": ["./node_modules/oxlint-plugin-vue-sfc/configs/recommended.json"]
+}
+```
+
+Two presets:
+
+| Preset | Rules | For |
+| --- | --- | --- |
+| `configs/recommended.json` | all 24 | plain oxlint — you want the full set |
+| `configs/complement.json` | 13 | you also run [`oxlint-vue`](https://github.com/vad1ym/oxlint-vue), which covers the other 11 |
+
+Or wire it up by hand:
+
+```jsonc
+{
+    "jsPlugins": ["./node_modules/oxlint-plugin-vue-sfc/index.mjs"],
+    "rules": {
+        "vue-sfc/require-v-for-key": "error",
+        "vue-sfc/no-raw-text": "off"
+    }
+}
+```
+
+The plugin namespace is `vue-sfc`, not `vue` — oxlint reserves `vue` for its native plugin and
+rejects a JS plugin that claims it.
+
+## Rules
+
+| Rule | Default | In `complement` | Description |
+| --- | --- | --- | --- |
+| `vue-sfc/no-child-content` | error |  | disallow element's child contents which would be overwritten by a directive like `v-html` or `v-text` |
+| `vue-sfc/no-dupe-v-else-if` | error |  | disallow duplicate conditions in `v-if` / `v-else-if` chains |
+| `vue-sfc/no-duplicate-attributes` | error |  | disallow duplication of attributes on the same element |
+| `vue-sfc/no-lone-template` | warn | yes | disallow unnecessary `<template>` |
+| `vue-sfc/no-mutating-props` | error |  | disallow mutation of component props |
+| `vue-sfc/no-parsing-error` | error | yes | disallow parsing errors in `<template>` |
+| `vue-sfc/no-raw-text` | off | yes | disallow untranslated raw text in Vue templates (use i18n) |
+| `vue-sfc/no-ref-as-operand` | error | yes | require `.value` when using a `ref` as an operand |
+| `vue-sfc/no-template-key` | error |  | disallow `key` attribute on `<template>` without `v-for` |
+| `vue-sfc/no-template-shadow` | warn | yes | disallow variable declarations from shadowing variables declared in the outer scope |
+| `vue-sfc/no-textarea-mustache` | error |  | disallow mustaches in `<textarea>` |
+| `vue-sfc/no-unused-components` | error | yes | disallow registering components that are not used inside templates |
+| `vue-sfc/no-unused-vars` | error | yes | disallow unused variable definitions of v-for directives or scope attributes |
+| `vue-sfc/no-use-v-if-with-v-for` | error |  | disallow use of `v-if` on the same element as `v-for` |
+| `vue-sfc/no-useless-template-attributes` | error | yes | disallow useless attribute on `<template>` |
+| `vue-sfc/no-v-text-v-html-on-component` | warn |  | disallow `v-text` / `v-html` on component |
+| `vue-sfc/require-component-is` | error |  | require `v-bind:is` of `<component>` elements |
+| `vue-sfc/require-explicit-emits` | warn | yes | require `emits` option with name triggered by `$emit()` |
+| `vue-sfc/require-toggle-inside-transition` | error | yes | require control the display of the content inside `<transition>` |
+| `vue-sfc/require-v-for-key` | error |  | require `v-bind:key` with `v-for` directives |
+| `vue-sfc/require-valid-default-prop` | error | yes | enforce props default values to be valid |
+| `vue-sfc/this-in-template` | warn |  | disallow usage of `this` in template |
+| `vue-sfc/use-v-on-exact` | error | yes | enforce usage of `exact` modifier on `v-on` |
+| `vue-sfc/v-on-event-hyphenation` | warn | yes | enforce `v-on` event naming style on custom components in template |
+
+`no-raw-text` defaults to `off`: it is an i18n rule (a replacement for
+`@intlify/vue-i18n/no-raw-text`) and only makes sense in a translated app. It takes
+`{ ignoreTags, ignorePattern }`.
+
+## Known limitation: diagnostic positions
+
+Template diagnostics currently render on the `<script>` block, with the true template position
+prepended to the message:
+
+```
+Comp.vue:13:1  error  vue-sfc(require-v-for-key): [template 3:9] <li> uses v-for without a :key...
+```
+
+oxlint gives JS-plugin rules a script-relative view of an SFC, so a template position — which in a
+template-first file is a negative offset — cannot be expressed. The workaround clamps the range and
+puts the real location in the message text.
+
+[oxc#26001](https://github.com/oxc-project/oxc/pull/26001) fixes this upstream with an `actualRange`
+on the diagnostic, and would give every rule here correct positions **with no rule changes**. Until
+it lands, editor jump-to-error goes to the script block.
+
+## Reduced-scope ports
+
+Six rules deliberately implement less than their upstream counterpart. Each says so in its own file
+header:
+
+- `no-dupe-v-else-if` — exact duplicate conditions only, not subsumption
+- `this-in-template`, `no-mutating-props` — lexical template scan
+- `require-explicit-emits` — silent on an unresolvable named type reference
+- `no-unused-vars`, `no-template-shadow` — positioned scan, not a full destructuring-pattern parse
+- `no-unused-components` — upstream only inspects Options API `components: {}`, so it is inert in a
+  `<script setup>` codebase; ported so the check does not vanish if that changes
+
+They gate new violations rather than opening a migration: all 24 report zero diagnostics across the
+1581-SFC corpus they were built against.
+
+## Tests
+
+```bash
+npm test    # node:test, 320 specs across 24 rules
+```
+
+## License
+
+MIT

package/configs/complement.json

@@ -0,0 +1,20 @@
+{
+    "jsPlugins": [
+        "../index.mjs"
+    ],
+    "rules": {
+        "vue-sfc/no-lone-template": "warn",
+        "vue-sfc/no-parsing-error": "error",
+        "vue-sfc/no-raw-text": "off",
+        "vue-sfc/no-ref-as-operand": "error",
+        "vue-sfc/no-template-shadow": "warn",
+        "vue-sfc/no-unused-components": "error",
+        "vue-sfc/no-unused-vars": "error",
+        "vue-sfc/no-useless-template-attributes": "error",
+        "vue-sfc/require-explicit-emits": "warn",
+        "vue-sfc/require-toggle-inside-transition": "error",
+        "vue-sfc/require-valid-default-prop": "error",
+        "vue-sfc/use-v-on-exact": "error",
+        "vue-sfc/v-on-event-hyphenation": "warn"
+    }
+}

package/configs/recommended.json

@@ -0,0 +1,31 @@
+{
+    "jsPlugins": [
+        "../index.mjs"
+    ],
+    "rules": {
+        "vue-sfc/no-child-content": "error",
+        "vue-sfc/no-dupe-v-else-if": "error",
+        "vue-sfc/no-duplicate-attributes": "error",
+        "vue-sfc/no-lone-template": "warn",
+        "vue-sfc/no-mutating-props": "error",
+        "vue-sfc/no-parsing-error": "error",
+        "vue-sfc/no-raw-text": "off",
+        "vue-sfc/no-ref-as-operand": "error",
+        "vue-sfc/no-template-key": "error",
+        "vue-sfc/no-template-shadow": "warn",
+        "vue-sfc/no-textarea-mustache": "error",
+        "vue-sfc/no-unused-components": "error",
+        "vue-sfc/no-unused-vars": "error",
+        "vue-sfc/no-use-v-if-with-v-for": "error",
+        "vue-sfc/no-useless-template-attributes": "error",
+        "vue-sfc/no-v-text-v-html-on-component": "warn",
+        "vue-sfc/require-component-is": "error",
+        "vue-sfc/require-explicit-emits": "warn",
+        "vue-sfc/require-toggle-inside-transition": "error",
+        "vue-sfc/require-v-for-key": "error",
+        "vue-sfc/require-valid-default-prop": "error",
+        "vue-sfc/this-in-template": "warn",
+        "vue-sfc/use-v-on-exact": "error",
+        "vue-sfc/v-on-event-hyphenation": "warn"
+    }
+}

package/index.mjs

@@ -0,0 +1,56 @@
+import noChildContentRule from "./rules/no-child-content.mjs";
+import noDupeVElseIfRule from "./rules/no-dupe-v-else-if.mjs";
+import noDuplicateAttributesRule from "./rules/no-duplicate-attributes.mjs";
+import noLoneTemplateRule from "./rules/no-lone-template.mjs";
+import noMutatingPropsRule from "./rules/no-mutating-props.mjs";
+import noParsingErrorRule from "./rules/no-parsing-error.mjs";
+import noRawTextRule from "./rules/no-raw-text.mjs";
+import noRefAsOperandRule from "./rules/no-ref-as-operand.mjs";
+import noTemplateKeyRule from "./rules/no-template-key.mjs";
+import noTemplateShadowRule from "./rules/no-template-shadow.mjs";
+import noTextareaMustacheRule from "./rules/no-textarea-mustache.mjs";
+import noUnusedComponentsRule from "./rules/no-unused-components.mjs";
+import noUnusedVarsRule from "./rules/no-unused-vars.mjs";
+import noUseVIfWithVForRule from "./rules/no-use-v-if-with-v-for.mjs";
+import noUselessTemplateAttributesRule from "./rules/no-useless-template-attributes.mjs";
+import noVTextVHtmlOnComponentRule from "./rules/no-v-text-v-html-on-component.mjs";
+import requireComponentIsRule from "./rules/require-component-is.mjs";
+import requireExplicitEmitsRule from "./rules/require-explicit-emits.mjs";
+import requireToggleInsideTransitionRule from "./rules/require-toggle-inside-transition.mjs";
+import requireVForKeyRule from "./rules/require-v-for-key.mjs";
+import requireValidDefaultPropRule from "./rules/require-valid-default-prop.mjs";
+import thisInTemplateRule from "./rules/this-in-template.mjs";
+import useVOnExactRule from "./rules/use-v-on-exact.mjs";
+import vOnEventHyphenationRule from "./rules/v-on-event-hyphenation.mjs";
+
+const plugin = {
+    meta: { name: "vue-sfc" },
+    rules: {
+        "no-child-content": noChildContentRule,
+        "no-dupe-v-else-if": noDupeVElseIfRule,
+        "no-duplicate-attributes": noDuplicateAttributesRule,
+        "no-lone-template": noLoneTemplateRule,
+        "no-mutating-props": noMutatingPropsRule,
+        "no-parsing-error": noParsingErrorRule,
+        "no-raw-text": noRawTextRule,
+        "no-ref-as-operand": noRefAsOperandRule,
+        "no-template-key": noTemplateKeyRule,
+        "no-template-shadow": noTemplateShadowRule,
+        "no-textarea-mustache": noTextareaMustacheRule,
+        "no-unused-components": noUnusedComponentsRule,
+        "no-unused-vars": noUnusedVarsRule,
+        "no-use-v-if-with-v-for": noUseVIfWithVForRule,
+        "no-useless-template-attributes": noUselessTemplateAttributesRule,
+        "no-v-text-v-html-on-component": noVTextVHtmlOnComponentRule,
+        "require-component-is": requireComponentIsRule,
+        "require-explicit-emits": requireExplicitEmitsRule,
+        "require-toggle-inside-transition": requireToggleInsideTransitionRule,
+        "require-v-for-key": requireVForKeyRule,
+        "require-valid-default-prop": requireValidDefaultPropRule,
+        "this-in-template": thisInTemplateRule,
+        "use-v-on-exact": useVOnExactRule,
+        "v-on-event-hyphenation": vOnEventHyphenationRule,
+    },
+};
+
+export default plugin;

package/package.json

@@ -0,0 +1,57 @@
+{
+    "name": "oxlint-plugin-vue-sfc",
+    "version": "0.1.0",
+    "type": "module",
+    "description": "Vue SFC template rules for oxlint, as a JS plugin. Ports of eslint-plugin-vue rules oxlint has no native equivalent for.",
+    "license": "MIT",
+    "keywords": [
+        "oxlint",
+        "oxc",
+        "vue",
+        "sfc",
+        "linter",
+        "eslint-plugin-vue",
+        "vue3",
+        "nuxt"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Togetic/oxlint-plugin-vue.git"
+    },
+    "bugs": {
+        "url": "https://github.com/Togetic/oxlint-plugin-vue/issues"
+    },
+    "homepage": "https://github.com/Togetic/oxlint-plugin-vue#readme",
+    "author": "Togetic",
+    "exports": {
+        ".": "./index.mjs",
+        "./configs/recommended": "./configs/recommended.json",
+        "./configs/complement": "./configs/complement.json"
+    },
+    "main": "./index.mjs",
+    "files": [
+        "index.mjs",
+        "rules",
+        "!rules/*.spec.mjs",
+        "utils",
+        "configs",
+        "README.md",
+        "LICENSE"
+    ],
+    "scripts": {
+        "test": "node --test \"rules/*.spec.mjs\""
+    },
+    "dependencies": {
+        "@vue/compiler-sfc": "^3.5.0"
+    },
+    "devDependencies": {
+        "oxc-parser": "^0.90.0",
+        "oxlint": "^1.78.0"
+    },
+    "peerDependencies": {
+        "oxlint": ">=1.0.0"
+    },
+    "engines": {
+        "node": ">=20.19.0"
+    }
+}

package/rules/no-child-content.mjs

@@ -0,0 +1,80 @@
+import {
+    NODE_ELEMENT,
+    NODE_TEXT,
+    findDirective,
+    parseSfc,
+    reportAtFileOffset,
+    walkTemplate,
+} from "../utils/vue-sfc.mjs";
+
+/**
+ * Replacement for `vue/no-child-content` (no native oxlint equivalent — oxc#15761).
+ *
+ * `v-text` and `v-html` REPLACE an element's children. So markup written inside such an
+ * element never renders — it reads as live content but is dead. Typically a leftover from
+ * converting static markup to a binding, or a merge that kept both.
+ *
+ * Judging "has children" carefully, because the naive check reports on formatting:
+ * - Whitespace-only text children are ignored; `<p v-text="x">\n</p>` is just indentation.
+ * - A comment child is ignored: it renders nothing, so `v-text` overwrites nothing.
+ * - Anything else — real text, an element, an interpolation — is content that will be
+ *   silently discarded, and is reported.
+ */
+
+function meaningfulChildren(node) {
+    return (node.children ?? []).filter((child) => {
+        if (child.type === NODE_TEXT) {
+            return (child.content ?? "").trim() !== "";
+        }
+        // NodeTypes.COMMENT === 3; renders nothing, so it is not lost content.
+        return child.type !== 3;
+    });
+}
+
+export default {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "disallow element's child contents which would be overwritten by a directive like `v-html` or `v-text`",
+            recommended: true,
+        },
+        schema: [],
+        messages: { m: "" },
+    },
+    create(context) {
+        if (!context.filename.endsWith(".vue")) {
+            return {};
+        }
+        return {
+            Program() {
+                const entry = parseSfc(context.filename);
+                const ast = entry.descriptor.template?.ast;
+                if (!ast) {
+                    return;
+                }
+                walkTemplate(ast, (node) => {
+                    if (node.type !== NODE_ELEMENT) {
+                        return;
+                    }
+                    const directive = findDirective(node, "text") ?? findDirective(node, "html");
+                    if (!directive) {
+                        return;
+                    }
+                    const children = meaningfulChildren(node);
+                    if (!children.length) {
+                        return;
+                    }
+                    const first = children[0];
+                    const last = children[children.length - 1];
+                    reportAtFileOffset(
+                        context,
+                        entry,
+                        first.loc.start.offset,
+                        last.loc.end.offset,
+                        `This content is never rendered: \`v-${directive.name}\` on <${node.tag}> replaces the element's children. Remove the content, or remove the directive.`,
+                    );
+                });
+            },
+        };
+    },
+};

package/rules/no-dupe-v-else-if.mjs

@@ -0,0 +1,114 @@
+import {
+    NODE_ELEMENT,
+    findDirective,
+    parseSfc,
+    reportAtFileOffset,
+    walkTemplate,
+} from "../utils/vue-sfc.mjs";
+
+/**
+ * Replacement for `vue/no-dupe-v-else-if` (no native oxlint equivalent — oxc#15761).
+ *
+ * A condition repeated later in a `v-if` / `v-else-if` chain can never be reached: the
+ * earlier branch always wins. So one of the two branches is dead code, and the author
+ * almost certainly meant a different condition in the second one.
+ *
+ * Chain reconstruction: `@vue/compiler-sfc`'s `parse()` returns the UNTRANSFORMED template,
+ * where `v-if` / `v-else-if` / `v-else` are plain directives on sibling elements rather than
+ * a branches structure. A chain is therefore a run of consecutive element siblings starting
+ * at `v-if`, continuing while each next sibling has `v-else-if` (or `v-else`, which ends it).
+ * Non-element siblings (whitespace text, comments) are skipped rather than breaking the run,
+ * because they do not break the chain for Vue either.
+ *
+ * DELIBERATELY NARROWER than eslint-plugin-vue: this compares normalized condition SOURCE
+ * TEXT for exact equality only. eslint-plugin-vue additionally detects logical subsets
+ * (`a` after `a && b`, and `a || b` overlaps). Doing that safely needs real expression
+ * analysis; getting it wrong reports working code. False negatives are acceptable here,
+ * false positives are not — so subset detection stays with ESLint until it is worth building
+ * properly. Any rule ported at reduced scope must say so; see OXLINT_MIGRATION.md.
+ */
+
+const NODE_COMMENT = 3;
+const NODE_TEXT = 2;
+
+/** Condition source, whitespace-normalized so formatting differences don't hide a duplicate. */
+function conditionText(directive) {
+    return (directive.exp?.content ?? "").replace(/\s+/g, " ").trim();
+}
+
+function isSkippable(node) {
+    if (node.type === NODE_COMMENT) {
+        return true;
+    }
+    return node.type === NODE_TEXT && (node.content ?? "").trim() === "";
+}
+
+export default {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "disallow duplicate conditions in `v-if` / `v-else-if` chains",
+            recommended: true,
+        },
+        schema: [],
+        messages: { m: "" },
+    },
+    create(context) {
+        if (!context.filename.endsWith(".vue")) {
+            return {};
+        }
+        return {
+            Program() {
+                const entry = parseSfc(context.filename);
+                const ast = entry.descriptor.template?.ast;
+                if (!ast) {
+                    return;
+                }
+                // Every node with children can host a chain among those children.
+                walkTemplate(ast, (parent) => {
+                    const children = (parent.children ?? []).filter((c) => !isSkippable(c));
+                    let seen = null;
+                    for (const child of children) {
+                        if (child.type !== NODE_ELEMENT) {
+                            seen = null;
+                            continue;
+                        }
+                        const vIf = findDirective(child, "if");
+                        const vElseIf = findDirective(child, "else-if");
+                        if (vIf) {
+                            seen = new Set([conditionText(vIf)]);
+                            continue;
+                        }
+                        if (vElseIf) {
+                            if (!seen) {
+                                // `v-else-if` with no preceding `v-if` is a different error
+                                // (vue/valid-v-else-if); not this rule's business.
+                                continue;
+                            }
+                            const text = conditionText(vElseIf);
+                            if (text && seen.has(text)) {
+                                // Anchor on the CONDITION, not the whole directive: that is
+                                // where eslint-plugin-vue points (verified at exact column
+                                // parity), and it is the part the author must change.
+                                const at = vElseIf.exp?.loc ?? vElseIf.loc;
+                                reportAtFileOffset(
+                                    context,
+                                    entry,
+                                    at.start.offset,
+                                    at.end.offset,
+                                    `This condition is a duplicate of an earlier branch in the same v-if chain, so this branch is unreachable: \`${text}\`.`,
+                                );
+                            } else if (text) {
+                                seen.add(text);
+                            }
+                            continue;
+                        }
+                        // `v-else` terminates the chain, and an element with no chain directive
+                        // breaks it. Either way the run ends here.
+                        seen = null;
+                    }
+                });
+            },
+        };
+    },
+};

package/rules/no-duplicate-attributes.mjs

@@ -0,0 +1,106 @@
+import {
+    NODE_ELEMENT,
+    PROP_ATTRIBUTE,
+    PROP_DIRECTIVE,
+    parseSfc,
+    reportAtFileOffset,
+    walkTemplate,
+} from "../utils/vue-sfc.mjs";
+
+/**
+ * Replacement for `vue/no-duplicate-attributes` (no native oxlint equivalent — oxc#15761).
+ *
+ * Two attributes with the same name on one element: the browser/compiler keeps one and
+ * drops the other silently, so the dropped one is dead code that reads as live. Usually a
+ * bad merge or a copy-paste.
+ *
+ * Name resolution, and why it is not just `prop.name`:
+ * - A static attribute contributes its own name (`class`, `id`).
+ * - A `v-bind` directive contributes its ARGUMENT (`:class` → `class`), not "bind".
+ * - `v-bind="obj"` (no argument) is a spread; it has no single name and is skipped.
+ * - Non-bind directives (`v-if`, `v-on`, `v-model`) are out of scope: duplicates there
+ *   mean different things (two `@click` handlers both fire) and belong to other rules.
+ *
+ * `class` and `style` are deliberately exempt from the static+bound pair, matching
+ * eslint-plugin-vue's `allowCoexistClass`/`allowCoexistStyle` defaults: Vue MERGES
+ * `class="a" :class="b"` rather than dropping one, so it is idiomatic, not a bug. Two
+ * static `class` attributes, or two bound `:class`, are still flagged — merging only
+ * applies across the static/bound boundary.
+ */
+
+const MERGEABLE = new Set(["class", "style"]);
+
+/** Resolved attribute name for duplicate purposes, or null when it has none. */
+function attributeName(prop) {
+    if (prop.type === PROP_ATTRIBUTE) {
+        return prop.name;
+    }
+    if (
+        prop.type === PROP_DIRECTIVE &&
+        prop.name === "bind" &&
+        prop.arg?.type === 4 /* SIMPLE_EXPRESSION */ &&
+        prop.arg.isStatic !== false
+    ) {
+        return prop.arg.content;
+    }
+    return null;
+}
+
+export default {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "disallow duplication of attributes on the same element",
+            recommended: true,
+        },
+        schema: [],
+        messages: { m: "" },
+    },
+    create(context) {
+        if (!context.filename.endsWith(".vue")) {
+            return {};
+        }
+        return {
+            Program() {
+                const entry = parseSfc(context.filename);
+                const ast = entry.descriptor.template?.ast;
+                if (!ast) {
+                    return;
+                }
+                walkTemplate(ast, (node) => {
+                    if (node.type !== NODE_ELEMENT) {
+                        return;
+                    }
+                    // Track static and bound occurrences separately so the class/style
+                    // merge exemption can apply across the boundary but not within it.
+                    const seen = new Map();
+                    for (const prop of node.props ?? []) {
+                        const name = attributeName(prop);
+                        if (name === null) {
+                            continue;
+                        }
+                        const isStatic = prop.type === PROP_ATTRIBUTE;
+                        const bucket = seen.get(name);
+                        if (!bucket) {
+                            seen.set(name, { static: isStatic, bound: !isStatic });
+                            continue;
+                        }
+                        const sameKind = isStatic ? bucket.static : bucket.bound;
+                        const exempt = MERGEABLE.has(name) && !sameKind;
+                        if (!exempt) {
+                            reportAtFileOffset(
+                                context,
+                                entry,
+                                prop.loc.start.offset,
+                                prop.loc.end.offset,
+                                `Duplicate attribute \`${name}\` on <${node.tag}>. Only one survives compilation, so the other is silently ignored.`,
+                            );
+                        }
+                        bucket.static ||= isStatic;
+                        bucket.bound ||= !isStatic;
+                    }
+                });
+            },
+        };
+    },
+};