ai-deslop 0.4.4 → 0.4.5

package/README.md

@@ -1,80 +1,100 @@
-# ai-deslop
-
-Opinionated Oxlint rules that reject low-evidence, low-signal, AI-slop code patterns.
-
-Rules are vendored from [dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop) (generic rules) alongside additional deslop rules, all renamed under the `deslop/*` namespace. The vendored source is MIT licensed; see Credits below.
-
-## Install
-
-```bash
-npm install --save-dev ai-deslop
-# @oxlint/plugins comes along as a runtime dependency — keep it in sync with your oxlint version
-```
-
-Ships compiled JavaScript — works with any oxlint JS-plugin runtime (Bun, Deno, or Node.js).
-
-## Usage
-
-```ts
-import { defineConfig } from "oxlint";
-import { configs as deslopConfigs } from "ai-deslop";
-
-export default defineConfig({
-  jsPlugins: ["ai-deslop"],
-  options: deslopConfigs.recommended.options,
-  rules: deslopConfigs.recommended.rules
-});
-```
-
-The recommended config enables type-aware linting for `typescript/no-deprecated` and `typescript/no-floating-promises`. Install `oxlint-tsgolint` when using it.
-
-## Rules
-
-| Rule | Status | Description |
-| --- | --- | --- |
-| `no-array-filter-map` | Recommended | Rejects adjacent eager array filter/map passes; allows lazy iterator pipelines. |
-| `no-reduce-accumulator-copy` | Recommended | Rejects non-spread accumulator copies inside reducers. Enable native `oxc/no-accumulating-spread` alongside it. |
-| `no-chained-type-assertions` | Recommended | Rejects nested `as` / angle-bracket assertions that fabricate evidence. |
-| `no-conditional-empty-object-spread` | Recommended | Reports object spreads using a conditional `{}` branch to omit fields. |
-| `no-known-value-widening` | Recommended | Rejects known expressions flowing into explicit `unknown`, `object`, or open dictionaries. |
-| `no-module-mocking` | Recommended | Rejects Vitest and Jest module mocks. |
-| `no-object-parameters` | Recommended | Rejects `object` on function inputs. |
-| `no-reflect-apply` | Recommended | Rejects global `Reflect.apply`. |
-| `no-reflect-get` | Recommended | Rejects global `Reflect.get`. |
-| `no-runtime-typeof` | Recommended | Requires boundary parsing instead of ad hoc `typeof` narrowing. |
-| `no-shape-in-symbol-names` | Recommended | Rejects `shape` in locally owned symbol names. |
-| `no-unknown-parameters` | Recommended | Rejects `unknown` on function inputs. |
-| `no-unknown-returns` | Recommended | Rejects return contracts resolving to `unknown`. |
-| `no-unknown-type-aliases` | Recommended | Rejects aliases whose resolved type is `unknown`. |
-| `no-unsafe-dictionary-type` | Recommended | Rejects dictionary values based on unsafe escape hatches. |
-| `no-widen-then-assert` | Recommended | Rejects widening known evidence before narrowing assertions. |
-| `require-safety-comment-for-type-assertion` | Recommended | Requires an invariant justification for non-const assertions. |
-| `no-call-only-assertions` | Recommended | Flags tests whose assertions only check mock calls. |
-| `no-poor-substring-tests` | Recommended | Rejects testing that a constant string contains substrings. |
-| `no-pass-through-type-alias` | Recommended | Disallows aliases that only rename another type. |
-| [`no-duplicate-consts`](docs/no-duplicate-consts.md) | Opt-in | Reports all-caps constants with the same static value in different files. |
+# ai-deslop
+
+Opinionated Oxlint rules that reject low-evidence, low-signal, AI-slop code patterns.
+
+Rules are vendored from [dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop) (generic rules) alongside additional deslop rules, all renamed under the `deslop/*` namespace. The vendored source is MIT licensed; see Credits below.
+
+## Install
+
+```bash
+npm install --save-dev ai-deslop
+# @oxlint/plugins comes along as a runtime dependency — keep it in sync with your oxlint version
+```
+
+Ships compiled JavaScript — works with any oxlint JS-plugin runtime (Bun, Deno, or Node.js).
+
+## Usage
+
+```ts
+import { defineConfig } from "oxlint";
+import { configs as deslopConfigs } from "ai-deslop";
+
+export default defineConfig({
+  jsPlugins: ["ai-deslop"],
+  options: deslopConfigs.recommended.options,
+  rules: deslopConfigs.recommended.rules
+});
+```
+
+## Rules
+
+### Type safety and evidence
+
+| Rule | Status | Description |
+| --- | --- | --- |
+| `no-chained-type-assertions` | Recommended | Rejects nested `as` / angle-bracket assertions that fabricate evidence. |
+| `no-conditional-empty-object-spread` | Recommended | Reports object spreads using a conditional `{}` branch to omit fields. |
+| `no-known-value-widening` | Recommended | Rejects known expressions flowing into explicit `unknown`, `object`, or open dictionaries. |
+| `no-object-parameters` | Recommended | Rejects `object` on function inputs. |
+| `no-runtime-typeof` | Recommended | Requires boundary parsing instead of ad hoc `typeof` narrowing. |
+| `no-unknown-parameters` | Recommended | Rejects `unknown` on function inputs. |
+| `no-unknown-returns` | Recommended | Rejects return contracts resolving to `unknown`. |
+| `no-unknown-type-aliases` | Recommended | Rejects aliases whose resolved type is `unknown`. |
+| `no-unsafe-dictionary-type` | Recommended | Rejects dictionary values based on unsafe escape hatches. |
+| `no-widen-then-assert` | Recommended | Rejects widening known evidence before narrowing assertions. |
+| `require-safety-comment-for-type-assertion` | Recommended | Requires an invariant justification for non-const assertions. |
+| `no-pass-through-type-alias` | Recommended | Disallows aliases that only rename another type. |
+
+### Code quality and APIs
+
+| Rule | Status | Description |
+| --- | --- | --- |
+| `no-array-filter-map` | Recommended | Rejects adjacent eager array filter/map passes; allows lazy iterator pipelines. |
+| `no-reduce-accumulator-copy` | Recommended | Rejects non-spread accumulator copies inside reducers. Enable native `oxc/no-accumulating-spread` alongside it. |
+| `no-reflect-apply` | Recommended | Rejects global `Reflect.apply`. |
+| `no-reflect-get` | Recommended | Rejects global `Reflect.get`. |
+| `no-shape-in-symbol-names` | Recommended | Rejects `shape` in locally owned symbol names. |
+
+### Tests
+
+| Rule | Status | Description |
+| --- | --- | --- |
+| `no-call-only-assertions` | Recommended | Flags tests whose assertions only check mock calls. |
+| `no-module-mocking` | Recommended | Rejects Vitest and Jest module mocks. |
+| `no-poor-substring-tests` | Recommended | Rejects testing that a constant string contains substrings. |
+
+### Opt-in rules
+
+| Rule | Status | Description |
+| --- | --- | --- |
+| [`no-duplicate-consts`](docs/no-duplicate-consts.md) | Opt-in | Reports all-caps constants with the same static value in different files. |
 | [`no-duplicate-types`](docs/no-duplicate-types.md) | Opt-in | Reports exact duplicate object contracts. No fixer. |
+| [`no-renamed-imports`](docs/no-renamed-imports.md) | Opt-in | Fixes unnecessary named-import aliases when the original name has no module-level conflict. |
 | [`canonical-class-names`](docs/tailwind.md) | Opt-in | Fixes non-canonical Tailwind CSS v4 class spellings. |
-
-| Standard rule | Status | Description |
-| --- | --- | --- |
-| `typescript/no-deprecated` | Recommended | Disallows using code marked `@deprecated`. Requires type-aware linting. |
-| `typescript/no-require-imports` | Recommended | Disallows CommonJS `require()` imports. |
-| `typescript/no-floating-promises` | Recommended | Disallows floating promises. Requires type-aware linting. |
-| `no-unreachable` | Recommended | Disallows unreachable code. |
-
-## Guides
-
-| Guide | Contents |
-| --- | --- |
-| [No duplicate consts](docs/no-duplicate-consts.md) | Configuration and exact static-value comparison behavior. |
+
+### Standard rules enabled by the recommended config
+
+| Standard rule | Status | Description |
+| --- | --- | --- |
+| `typescript/no-deprecated` | Recommended | Disallows using code marked `@deprecated`. Requires type-aware linting. |
+| `typescript/no-require-imports` | Recommended | Disallows CommonJS `require()` imports. |
+| `typescript/no-floating-promises` | Recommended | Disallows floating promises. Requires type-aware linting. |
+| `typescript/no-unnecessary-condition` | Recommended | Disallows always truthy/falsy/nullish conditions. Requires type-aware linting. |
+| `no-unreachable` | Recommended | Disallows unreachable code. |
+
+## Guides
+
+| Guide | Contents |
+| --- | --- |
+| [No duplicate consts](docs/no-duplicate-consts.md) | Configuration and exact static-value comparison behavior. |
 | [No duplicate types](docs/no-duplicate-types.md) | Exact comparison behavior, worker scope, complete TypeScript/JSON examples, and every supported option. |
-| [Tailwind canonical class names](docs/tailwind.md) | Tailwind v4 setup, complete TypeScript/JSON examples, and every supported option. |
-
-## Credits
-
-- Generic rules vendored verbatim from [dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop) (MIT, © Dillon Mulroy), including `src/shared/*`.
-
-## License
-
-MIT
+| [No renamed imports](docs/no-renamed-imports.md) | When named-import aliases are fixed and how conflicts are handled. |
+| [Tailwind canonical class names](docs/tailwind.md) | Tailwind v4 setup, complete TypeScript/JSON examples, and every supported option. |
+
+## Credits
+
+- Generic rules vendored verbatim from [dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop) (MIT, © Dillon Mulroy), including `src/shared/*`.
+
+## License
+
+MIT

package/dist/index.js

@@ -21,6 +21,7 @@ import { noPoorSubstringTestsRule } from "./rules/no-poor-substring-tests.js";
 import { noPassThroughTypeAliasRule } from "./rules/no-pass-through-type-alias.js";
 import { noDuplicateTypesRule } from "./rules/no-duplicate-types.js";
 import { noDuplicateConstsRule } from "./rules/no-duplicate-consts.js";
+import { noRenamedImportsRule } from "./rules/no-renamed-imports.js";
 import { canonicalClassNames } from "./tailwind/rule.js";
 /** Every `deslop/*` rule, plus selected standard rules, each set to `"error"`. Spread into the `rules` field of an oxlint config. */
 export const recommendedRules = {
@@ -47,6 +48,7 @@ export const recommendedRules = {
     "typescript/no-deprecated": "error",
     "typescript/no-require-imports": "error",
     "typescript/no-floating-promises": "error",
+    "typescript/no-unnecessary-condition": "error",
     "no-unreachable": "error",
 };
 /** ESLint flat-config style configs. `recommended` enables every recommended `deslop/*` rule as `"error"` (excluding opt-in rules), plus standard `typescript/*` rules. The `typescript/*` rules require type-aware linting (`options.typeAware`), so `recommended` sets it. */
@@ -84,6 +86,7 @@ const deslopPlugin = eslintCompatPlugin({
         "no-pass-through-type-alias": noPassThroughTypeAliasRule,
         "no-duplicate-types": noDuplicateTypesRule,
         "no-duplicate-consts": noDuplicateConstsRule,
+        "no-renamed-imports": noRenamedImportsRule,
         // Opt-in: NOT in `recommendedRules`. Requires a `cssPath` option, so users add it manually.
         "canonical-class-names": canonicalClassNames,
     },

package/dist/rules/no-renamed-imports.d.ts

@@ -0,0 +1,2 @@
+/** Disallow named import aliases when the imported name is available in module scope. */
+export declare const noRenamedImportsRule: import("@oxlint/plugins").Rule;

package/dist/rules/no-renamed-imports.js

@@ -0,0 +1,53 @@
+import { defineRule } from "@oxlint/plugins";
+function moduleScopeFor(scope) {
+    let current = scope;
+    while (current !== null) {
+        if (current.type === "module")
+            return current;
+        current = current.upper;
+    }
+    return null;
+}
+function importedName(node) {
+    return node.imported.type === "Identifier" ? node.imported.name : null;
+}
+/** Disallow named import aliases when the imported name is available in module scope. */
+export const noRenamedImportsRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Disallow unnecessary aliases for named imports" },
+        fixable: "code",
+        messages: {
+            unnecessaryAlias: "Use {{importedName}} directly instead of renaming this import to {{localName}}.",
+        },
+        schema: [],
+    },
+    createOnce(context) {
+        return {
+            ImportSpecifier(node) {
+                const name = importedName(node);
+                if (name === null || name === node.local.name)
+                    return;
+                const moduleScope = moduleScopeFor(context.sourceCode.getScope(node));
+                if (moduleScope === null || moduleScope.set.has(name))
+                    return;
+                const variable = moduleScope.set.get(node.local.name);
+                if (variable === undefined)
+                    return;
+                context.report({
+                    node,
+                    messageId: "unnecessaryAlias",
+                    data: { importedName: name, localName: node.local.name },
+                    fix(fixer) {
+                        return [
+                            fixer.replaceText(node, name),
+                            ...variable.references
+                                .filter((reference) => reference.resolved === variable)
+                                .map((reference) => fixer.replaceText(reference.identifier, name)),
+                        ];
+                    },
+                });
+            },
+        };
+    },
+});

package/dist/tailwind/design-system.d.ts

@@ -1,3 +1,4 @@
 export declare function resolveCssPath(cssPath: string | undefined, cwd?: string): string;
 export declare function ensureDesignSystem(cssFile: string): string;
+export declare function getDesignSystemVersion(key: string): number | undefined;
 export declare function canonicalizeTokens(key: string, tokens: Array<string>, rem: number): Map<string, string>;

package/dist/tailwind/design-system.js

@@ -8,6 +8,7 @@ import { createSyncFn } from "synckit";
 const workerPath = fileURLToPath(new URL("./worker.js", import.meta.url));
 let syncCall = null;
 const loadedSystems = new Map();
+const canonicalResults = new Map();
 function getSyncCall() {
     if (syncCall === null) {
         syncCall = createSyncFn(workerPath);
@@ -26,16 +27,31 @@ export function ensureDesignSystem(cssFile) {
     const cssContent = fs.readFileSync(cssFile, "utf8");
     getSyncCall()({ type: "load", key: cssFile, cssContent, base: path.dirname(cssFile) });
     loadedSystems.set(cssFile, stat.mtimeMs);
+    canonicalResults.delete(cssFile);
     return cssFile;
 }
+export function getDesignSystemVersion(key) {
+    return loadedSystems.get(key);
+}
 export function canonicalizeTokens(key, tokens, rem) {
     if (tokens.length === 0)
         return new Map();
-    const canonical = getSyncCall()({ type: "canonicalize", key, candidates: tokens, rem });
-    if (!Array.isArray(canonical))
-        throw new Error("Tailwind canonicalization returned an invalid result");
+    let byRem = canonicalResults.get(key);
+    if (!byRem)
+        canonicalResults.set(key, byRem = new Map());
+    let cached = byRem.get(rem);
+    if (!cached)
+        byRem.set(rem, cached = new Map());
+    const missing = [...new Set(tokens.filter(token => !cached.has(token)))];
+    if (missing.length > 0) {
+        const canonical = getSyncCall()({ type: "canonicalize", key, candidates: missing, rem });
+        if (!Array.isArray(canonical))
+            throw new Error("Tailwind canonicalization returned an invalid result");
+        for (let i = 0; i < missing.length; i++)
+            cached.set(missing[i], canonical[i] ?? missing[i]);
+    }
     const result = new Map();
-    for (let i = 0; i < tokens.length; i++)
-        result.set(tokens[i], canonical[i] ?? tokens[i]);
+    for (const token of tokens)
+        result.set(token, cached.get(token));
     return result;
 }

package/dist/tailwind/optimize-system.d.ts

@@ -0,0 +1,4 @@
+import type { __unstable__loadDesignSystem } from "@tailwindcss/node";
+type DesignSystem = Awaited<ReturnType<typeof __unstable__loadDesignSystem>>;
+export declare function optimizeDesignSystem(system: DesignSystem): DesignSystem;
+export {};

package/dist/tailwind/optimize-system.js

@@ -0,0 +1,127 @@
+function propertyKey(system, candidates, raw = false) {
+    const properties = new Set();
+    function visit(node) {
+        if (node.kind === "at-rule" && node.name === "@property")
+            return;
+        if (node.kind === "declaration" && node.value !== undefined && !node.property.startsWith("--tw-"))
+            properties.add(node.property);
+        if ("nodes" in node)
+            for (const child of node.nodes)
+                visit(child);
+    }
+    for (const candidate of candidates) {
+        if (!raw || candidate.kind === "arbitrary") {
+            for (const { node } of system.compileAstNodes({ ...candidate, variants: [], important: false }))
+                visit(node);
+            continue;
+        }
+        // Property discovery needs utility declarations, not selector generation,
+        // importance propagation, or Tailwind's expensive declaration sort order.
+        const utilities = system.utilities.get(candidate.root) ?? [];
+        const isFallback = (utility) => (utility.options?.types?.length ?? 0) > 1 && utility.options.types.includes("any");
+        for (const fallback of [false, true]) {
+            let accepted = false;
+            for (const utility of utilities) {
+                if (utility.kind !== candidate.kind || isFallback(utility) !== fallback)
+                    continue;
+                const nodes = utility.compileFn(candidate);
+                if (nodes === null && utility.options?.types?.length) {
+                    accepted = true;
+                    break;
+                }
+                if (nodes === null || nodes === undefined)
+                    continue;
+                accepted = true;
+                for (const node of nodes)
+                    visit(node);
+            }
+            if (accepted)
+                break;
+        }
+    }
+    return [...properties].sort().join("\0");
+}
+// Canonicalization only compares equivalent declaration sets. Partition its
+// eager class index without changing the compiler, theme, or candidate parser.
+export function optimizeDesignSystem(system) {
+    const parseVariant = system.parseVariant.bind(system);
+    const getVariantOrder = system.getVariantOrder.bind(system);
+    const seenVariants = new Set();
+    let variantVersion = 0;
+    let orderVersion = -1;
+    let order;
+    system.parseVariant = raw => {
+        const variant = parseVariant(raw);
+        if (variant !== null && !seenVariants.has(variant)) {
+            seenVariants.add(variant);
+            variantVersion++;
+        }
+        return variant;
+    };
+    system.getVariantOrder = () => {
+        if (orderVersion !== variantVersion) {
+            order = getVariantOrder();
+            for (const variant of order.keys())
+                seenVariants.add(variant);
+            orderVersion = variantVersion;
+        }
+        return order;
+    };
+    let groups;
+    const scopedSystems = new Map();
+    function getGroups() {
+        if (groups)
+            return groups;
+        const built = new Map();
+        for (const entry of system.getClassList()) {
+            // Match Tailwind's index: quarter-step numeric modifiers use its
+            // on-demand fallback rather than the enumerated class signatures.
+            const modifiers = entry[1].modifiers.filter((modifier) => {
+                const number = Number(modifier);
+                return !(number >= 0 && number % 0.25 === 0 && String(number) === modifier);
+            });
+            const spellings = [entry[0], ...modifiers.map((modifier) => `${entry[0]}/${modifier}`)];
+            for (const spelling of spellings) {
+                let key;
+                const token = system.theme.prefix ? `${system.theme.prefix}:${spelling}` : spelling;
+                try {
+                    key = propertyKey(system, system.parseCandidate(token), true);
+                }
+                catch {
+                    continue;
+                }
+                let group = built.get(key);
+                if (!group)
+                    built.set(key, group = new Set());
+                group.add(entry);
+            }
+        }
+        return groups = built;
+    }
+    return {
+        ...system,
+        canonicalizeCandidates(tokens, options) {
+            return tokens.map(token => {
+                const candidates = system.parseCandidate(token);
+                if (candidates.every(candidate => candidate.kind === "static"))
+                    return system.canonicalizeCandidates([token], options)[0] ?? token;
+                const keys = new Set([propertyKey(system, candidates)]);
+                const withoutModifiers = candidates.map(candidate => candidate.kind === "static" ? candidate : { ...candidate, modifier: null });
+                keys.add(propertyKey(system, withoutModifiers));
+                const scopeKey = [...keys].sort().join("\x01");
+                let scoped = scopedSystems.get(scopeKey);
+                if (!scoped) {
+                    const entries = new Set();
+                    const index = getGroups();
+                    for (const key of keys)
+                        for (const entry of index.get(key) ?? [])
+                            entries.add(entry);
+                    const list = [...entries];
+                    scoped = { ...system, storage: {}, getClassList: () => list };
+                    scopedSystems.set(scopeKey, scoped);
+                }
+                return scoped.canonicalizeCandidates([token], options)[0] ?? token;
+            });
+        },
+    };
+}

package/dist/tailwind/rule.js

@@ -1,11 +1,12 @@
 import { defineRule } from "@oxlint/plugins";
 import { rewriteClassValue, summarizeChanges, uniqueTokens } from "./candidates.js";
-import { canonicalizeTokens, ensureDesignSystem, resolveCssPath } from "./design-system.js";
+import { canonicalizeTokens, ensureDesignSystem, getDesignSystemVersion, resolveCssPath } from "./design-system.js";
 export const PLUGIN_NAME = "deslop";
 export const RULE_ID = "canonical-class-names";
 const DEFAULT_ATTRIBUTES = ["class", "className"];
 const DEFAULT_CALLEE_FUNCTIONS = ["cn", "clsx", "cva", "twMerge", "tw", "classNames", "cx"];
 const DEFAULT_ROOT_FONT_SIZE = 16;
+const MAX_CACHED_VALUES = 10_000;
 const OPTIONS_SCHEMA = {
     type: "object",
     properties: {
@@ -34,7 +35,11 @@ export const canonicalClassNames = defineRule({
         let rem = DEFAULT_ROOT_FONT_SIZE;
         let cssFile = "";
         let designKey = null;
+        const checkedValues = new Map();
+        let checkedVersion;
         function initFile() {
+            const previousRem = rem;
+            const previousCssFile = cssFile;
             const options = (context.options?.[0] ?? {});
             attributes = new Set(options.attributes ?? DEFAULT_ATTRIBUTES);
             callees = new Set(options.calleeFunctions ?? DEFAULT_CALLEE_FUNCTIONS);
@@ -46,11 +51,18 @@ export const canonicalClassNames = defineRule({
                 cssFile = options.cssPath ?? "";
             }
             designKey = null;
+            if (previousRem !== rem || previousCssFile !== cssFile)
+                checkedValues.clear();
         }
         function getDesignKey() {
             if (designKey === null) {
                 try {
                     designKey = ensureDesignSystem(cssFile);
+                    const version = getDesignSystemVersion(designKey);
+                    if (checkedVersion !== version) {
+                        checkedValues.clear();
+                        checkedVersion = version;
+                    }
                 }
                 catch {
                     designKey = false;
@@ -59,22 +71,29 @@ export const canonicalClassNames = defineRule({
             return designKey === false ? null : designKey;
         }
         function checkStringNode(node, value) {
-            const tokens = uniqueTokens(value);
-            if (tokens.length === 0)
+            if (!/\S/.test(value))
                 return;
             const key = getDesignKey();
             if (key === null) {
                 context.report({ node, messageId: "cssNotFound", data: { path: cssFile } });
                 return;
             }
-            let canonicalOf;
-            try {
-                canonicalOf = canonicalizeTokens(key, tokens, rem);
-            }
-            catch {
-                return;
+            let rewritten = checkedValues.get(value);
+            if (!rewritten) {
+                const tokens = uniqueTokens(value);
+                let canonicalOf;
+                try {
+                    canonicalOf = canonicalizeTokens(key, tokens, rem);
+                }
+                catch {
+                    return;
+                }
+                rewritten = rewriteClassValue(value, canonicalOf);
+                if (checkedValues.size >= MAX_CACHED_VALUES)
+                    checkedValues.clear();
+                checkedValues.set(value, rewritten);
             }
-            const { fixed, changes } = rewriteClassValue(value, canonicalOf);
+            const { fixed, changes } = rewritten;
             if (changes.length === 0)
                 return;
             const summary = summarizeChanges(changes);

package/dist/tailwind/worker.js

@@ -1,13 +1,15 @@
 import { __unstable__loadDesignSystem } from "@tailwindcss/node";
 import { runAsWorker } from "synckit";
+import { optimizeDesignSystem } from "./optimize-system.js";
 const designSystems = new Map();
 runAsWorker(async (job) => {
     if (job.type === "load") {
-        designSystems.set(job.key, await __unstable__loadDesignSystem(job.cssContent, { base: job.base }));
+        designSystems.set(job.key, optimizeDesignSystem(await __unstable__loadDesignSystem(job.cssContent, { base: job.base })));
         return { ok: true };
     }
     const designSystem = designSystems.get(job.key);
     if (!designSystem)
         throw new Error(`Tailwind design system not loaded for "${job.key}"`);
-    return designSystem.canonicalizeCandidates(job.candidates, { rem: job.rem });
+    // Tailwind deduplicates canonical spellings, so a batch result is not positional.
+    return job.candidates.map(candidate => designSystem.canonicalizeCandidates([candidate], { rem: job.rem })[0] ?? candidate);
 });

package/package.json

@@ -1,64 +1,65 @@
-{
-  "name": "ai-deslop",
-  "version": "0.4.4",
-  "description": "Opinionated Oxlint rules that reject low-evidence, low-signal, AI-slop code patterns.",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "default": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist"
-  ],
+{
+  "name": "ai-deslop",
+  "version": "0.4.5",
+  "description": "Opinionated Oxlint rules that reject low-evidence, low-signal, AI-slop code patterns.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "prepublishOnly": "npm run build",
-    "check": "npm run build && oxlint src && tsc --noEmit",
-    "lint": "oxlint src",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@oxlint/plugins": "1.82.0",
-    "@tailwindcss/node": "^4.3.3",
-    "synckit": "^0.11.13"
-  },
-  "peerDependencies": {
-    "tailwindcss": "^4.0.0"
-  },
-  "peerDependenciesMeta": {
-    "tailwindcss": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "@types/node": "26.2.0",
-    "oxlint": "1.82.0",
-    "typescript": "7.0.2",
-    "vitest": "^5.0.1"
-  },
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/maharshi365/deslop.git"
-  },
-  "homepage": "https://github.com/maharshi365/deslop#readme",
-  "bugs": {
-    "url": "https://github.com/maharshi365/deslop/issues"
-  },
-  "keywords": [
-    "oxlint",
-    "oxlint-plugin",
-    "eslint",
-    "ai-slop",
-    "code-quality",
-    "typescript"
-  ],
-  "publishConfig": {
-    "access": "public"
-  }
-}
+    "bench": "npm run build && node bench.mjs",
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build",
+    "check": "npm run build && oxlint src && tsc --noEmit",
+    "lint": "oxlint src",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@oxlint/plugins": "1.82.0",
+    "@tailwindcss/node": "^4.3.3",
+    "synckit": "^0.11.13"
+  },
+  "peerDependencies": {
+    "tailwindcss": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "tailwindcss": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "26.2.0",
+    "oxlint": "1.82.0",
+    "typescript": "7.0.2",
+    "vitest": "^5.0.1"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/maharshi365/deslop.git"
+  },
+  "homepage": "https://github.com/maharshi365/deslop#readme",
+  "bugs": {
+    "url": "https://github.com/maharshi365/deslop/issues"
+  },
+  "keywords": [
+    "oxlint",
+    "oxlint-plugin",
+    "eslint",
+    "ai-slop",
+    "code-quality",
+    "typescript"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}