ai-deslop 0.2.3 → 0.4.0

package/README.md

@@ -13,30 +13,45 @@ npm install --save-dev ai-deslop
 
 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`](docs/deslop.md) | Recommended | Rejects adjacent eager array filter/map passes; allows lazy iterator pipelines. |
-| [`no-reduce-accumulator-copy`](docs/deslop.md) | Recommended | Rejects non-spread accumulator copies inside reducers. Enable native `oxc/no-accumulating-spread` alongside it. |
-| [`no-chained-type-assertions`](docs/deslop.md) | Recommended | Rejects nested `as` / angle-bracket assertions that fabricate evidence. |
-| [`no-conditional-empty-object-spread`](docs/deslop.md) | Recommended | Reports object spreads using a conditional `{}` branch to omit fields. |
-| [`no-known-value-widening`](docs/deslop.md) | Recommended | Rejects known expressions flowing into explicit `unknown`, `object`, or open dictionaries. |
-| [`no-module-mocking`](docs/deslop.md) | Recommended | Rejects Vitest and Jest module mocks. |
-| [`no-object-parameters`](docs/deslop.md) | Recommended | Rejects `object` on function inputs. |
-| [`no-reflect-apply`](docs/deslop.md) | Recommended | Rejects global `Reflect.apply`. |
-| [`no-reflect-get`](docs/deslop.md) | Recommended | Rejects global `Reflect.get`. |
-| [`no-runtime-typeof`](docs/deslop.md) | Recommended | Requires boundary parsing instead of ad hoc `typeof` narrowing. |
-| [`no-shape-in-symbol-names`](docs/deslop.md) | Recommended | Rejects `shape` in locally owned symbol names. |
-| [`no-unknown-parameters`](docs/deslop.md) | Recommended | Rejects `unknown` on function inputs. |
-| [`no-unknown-returns`](docs/deslop.md) | Recommended | Rejects return contracts resolving to `unknown`. |
-| [`no-unknown-type-aliases`](docs/deslop.md) | Recommended | Rejects aliases whose resolved type is `unknown`. |
-| [`no-unsafe-dictionary-type`](docs/deslop.md) | Recommended | Rejects dictionary values based on unsafe escape hatches. |
-| [`no-widen-then-assert`](docs/deslop.md) | Recommended | Rejects widening known evidence before narrowing assertions. |
-| [`require-safety-comment-for-type-assertion`](docs/deslop.md) | Recommended | Requires an invariant justification for non-const assertions. |
-| [`no-call-only-assertions`](docs/deslop.md) | Recommended | Flags tests whose assertions only check mock calls. |
-| [`no-pass-through-type-alias`](docs/deslop.md) | Recommended | Disallows aliases that only rename another type. |
-| [`no-duplicate-types`](docs/deslop.md#no-duplicate-types) | Opt-in | Reports exact duplicate object contracts. No fixer. |
+| `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-pass-through-type-alias` | Recommended | Disallows aliases that only rename another type. |
+| [`no-duplicate-types`](docs/no-duplicate-types.md) | Opt-in | Reports exact duplicate object contracts. No fixer. |
 | [`canonical-class-names`](docs/tailwind.md) | Opt-in | Fixes non-canonical Tailwind CSS v4 class spellings. |
 
 | Standard rule | Status | Description |
@@ -48,7 +63,7 @@ Ships compiled JavaScript — works with any oxlint JS-plugin runtime (Bun, Deno
 
 | Guide | Contents |
 | --- | --- |
-| [Deslop rules](docs/deslop.md) | Recommended and opt-in deslop configuration, complete TypeScript/JSON examples, and `no-duplicate-types` options. |
+| [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

package/dist/rules/no-duplicate-types.js

@@ -1,4 +1,10 @@
 import { defineRule } from "@oxlint/plugins";
+const ignoredZodMethods = new Set([
+    "min", "max", "length", "nonempty", "email", "url", "uuid", "guid", "cuid", "cuid2", "ulid", "xid", "ksuid",
+    "nanoid", "regex", "includes", "startsWith", "endsWith", "datetime", "date", "time", "duration", "ip", "cidr",
+    "emoji", "base64", "base64url", "jwt", "int", "safe", "finite", "multipleOf", "step", "positive", "negative",
+    "nonpositive", "nonnegative", "gt", "gte", "lt", "lte", "describe", "brand", "readonly", "default",
+]);
 function propertyKey(node) {
     const value = node;
     if (value.type === "Identifier" && typeof value.name === "string")
@@ -109,23 +115,323 @@ function canonicalDeclaration(node) {
         return null;
     return canonicalMembers(node.body.body, parameters);
 }
+function memberCall(node) {
+    if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression" || node.callee.computed || node.callee.property.type !== "Identifier")
+        return null;
+    if (node.arguments.some((argument) => argument.type === "SpreadElement"))
+        return null;
+    return { name: node.callee.property.name, object: node.callee.object, arguments_: node.arguments };
+}
+function factoryCall(node, namespaces, functions) {
+    if (node.type !== "CallExpression" || node.arguments.some((argument) => argument.type === "SpreadElement"))
+        return null;
+    if (node.callee.type === "Identifier") {
+        const name = functions.get(node.callee.name);
+        return name === undefined ? null : { name, arguments_: node.arguments };
+    }
+    if (node.callee.type !== "MemberExpression" || node.callee.computed || node.callee.object.type !== "Identifier" || node.callee.property.type !== "Identifier" || !namespaces.has(node.callee.object.name))
+        return null;
+    return { name: node.callee.property.name, arguments_: node.arguments };
+}
+function schemaLiteral(node) {
+    if (node.type !== "Literal")
+        return null;
+    if (typeof node.value === "string")
+        return JSON.stringify(node.value);
+    if (typeof node.value === "number" || typeof node.value === "boolean")
+        return String(node.value);
+    if (typeof node.value === "bigint")
+        return `${node.value}n`;
+    return null;
+}
+function canonicalSchemaProperty(node, zodNamespaces) {
+    let current = node;
+    let optional = false;
+    let nullable = false;
+    while (true) {
+        const call = memberCall(current);
+        if (call === null || !(["optional", "nullish"].includes(call.name) && call.arguments_.length === 0 || ignoredZodMethods.has(call.name)))
+            break;
+        if (call.name === "optional")
+            optional = true;
+        if (call.name === "nullish") {
+            optional = true;
+            nullable = true;
+        }
+        current = call.object;
+    }
+    const type = canonicalSchema(current, zodNamespaces);
+    return type === null ? null : { type: nullable ? `union(${["TSNullKeyword", type].sort().join(",")})` : type, optional };
+}
+function canonicalSchemaObject(node, zodNamespaces) {
+    if (node.type !== "ObjectExpression")
+        return null;
+    const members = [];
+    for (const property of node.properties) {
+        if (property.type !== "Property" || property.computed || property.kind !== "init")
+            return null;
+        const key = propertyKey(property.key);
+        if (key === null)
+            return null;
+        const value = canonicalSchemaProperty(property.value, zodNamespaces);
+        if (value === null)
+            return null;
+        members.push(`prop(${key},${value.optional ? "?" : "!"},rw,${value.type})`);
+    }
+    members.sort();
+    return { fingerprint: `{${members.join(",")}}`, properties: members.length };
+}
+function canonicalSchema(node, zodNamespaces) {
+    const call = memberCall(node);
+    if (call === null)
+        return null;
+    if (call.object.type === "Identifier" && zodNamespaces.has(call.object.name)) {
+        switch (call.name) {
+            case "string": return call.arguments_.length === 0 ? "TSStringKeyword" : null;
+            case "number": return call.arguments_.length === 0 ? "TSNumberKeyword" : null;
+            case "boolean": return call.arguments_.length === 0 ? "TSBooleanKeyword" : null;
+            case "bigint": return call.arguments_.length === 0 ? "TSBigIntKeyword" : null;
+            case "unknown": return call.arguments_.length === 0 ? "TSUnknownKeyword" : null;
+            case "any": return call.arguments_.length === 0 ? "TSAnyKeyword" : null;
+            case "never": return call.arguments_.length === 0 ? "TSNeverKeyword" : null;
+            case "null": return call.arguments_.length === 0 ? "TSNullKeyword" : null;
+            case "undefined": return call.arguments_.length === 0 ? "TSUndefinedKeyword" : null;
+            case "void": return call.arguments_.length === 0 ? "TSVoidKeyword" : null;
+            case "literal": {
+                if (call.arguments_.length !== 1)
+                    return null;
+                const value = schemaLiteral(call.arguments_[0]);
+                return value === null ? null : `literal(${value})`;
+            }
+            case "enum": {
+                if (call.arguments_.length !== 1 || call.arguments_[0].type !== "ArrayExpression")
+                    return null;
+                const values = call.arguments_[0].elements.map((element) => element === null || element.type === "SpreadElement" ? null : schemaLiteral(element));
+                if (values.some((value) => value === null))
+                    return null;
+                return `union(${[...new Set(values)].sort().join(",")})`;
+            }
+            case "object": {
+                if (call.arguments_.length !== 1)
+                    return null;
+                return canonicalSchemaObject(call.arguments_[0], zodNamespaces)?.fingerprint ?? null;
+            }
+            case "array": {
+                if (call.arguments_.length !== 1)
+                    return null;
+                const element = canonicalSchema(call.arguments_[0], zodNamespaces);
+                return element === null ? null : `array(${element})`;
+            }
+            case "union": {
+                if (call.arguments_.length !== 1 || call.arguments_[0].type !== "ArrayExpression")
+                    return null;
+                const types = call.arguments_[0].elements.map((element) => element === null || element.type === "SpreadElement" ? null : canonicalSchema(element, zodNamespaces));
+                if (types.some((type) => type === null))
+                    return null;
+                return `union(${[...new Set(types)].sort().join(",")})`;
+            }
+            default: return null;
+        }
+    }
+    const inner = canonicalSchema(call.object, zodNamespaces);
+    if (inner === null)
+        return null;
+    switch (call.name) {
+        case "optional": return `union(${["TSUndefinedKeyword", inner].sort().join(",")})`;
+        case "nullable": return `union(${["TSNullKeyword", inner].sort().join(",")})`;
+        case "nullish": return `union(${["TSNullKeyword", "TSUndefinedKeyword", inner].sort().join(",")})`;
+        case "array": return call.arguments_.length === 0 ? `array(${inner})` : null;
+        default: return ignoredZodMethods.has(call.name) ? inner : null;
+    }
+}
+function canonicalValibotProperty(node, namespaces, functions) {
+    const call = factoryCall(node, namespaces, functions);
+    if (call !== null && ["optional", "nullable", "nullish"].includes(call.name)) {
+        if (call.arguments_.length !== 1)
+            return null;
+        const inner = canonicalValibot(call.arguments_[0], namespaces, functions);
+        if (inner === null)
+            return null;
+        const nullable = call.name === "nullable" || call.name === "nullish";
+        return { type: nullable ? `union(${["TSNullKeyword", inner].sort().join(",")})` : inner, optional: call.name === "optional" || call.name === "nullish" };
+    }
+    const type = canonicalValibot(node, namespaces, functions);
+    return type === null ? null : { type, optional: false };
+}
+function canonicalValibotObject(node, namespaces, functions) {
+    if (node.type !== "ObjectExpression")
+        return null;
+    const members = [];
+    for (const property of node.properties) {
+        if (property.type !== "Property" || property.computed || property.kind !== "init")
+            return null;
+        const key = propertyKey(property.key);
+        if (key === null)
+            return null;
+        const value = canonicalValibotProperty(property.value, namespaces, functions);
+        if (value === null)
+            return null;
+        members.push(`prop(${key},${value.optional ? "?" : "!"},rw,${value.type})`);
+    }
+    members.sort();
+    return { fingerprint: `{${members.join(",")}}`, properties: members.length };
+}
+function canonicalValibot(node, namespaces, functions) {
+    const call = factoryCall(node, namespaces, functions);
+    if (call === null)
+        return null;
+    switch (call.name) {
+        case "string": return call.arguments_.length === 0 ? "TSStringKeyword" : null;
+        case "number": return call.arguments_.length === 0 ? "TSNumberKeyword" : null;
+        case "boolean": return call.arguments_.length === 0 ? "TSBooleanKeyword" : null;
+        case "bigint": return call.arguments_.length === 0 ? "TSBigIntKeyword" : null;
+        case "unknown": return call.arguments_.length === 0 ? "TSUnknownKeyword" : null;
+        case "any": return call.arguments_.length === 0 ? "TSAnyKeyword" : null;
+        case "never": return call.arguments_.length === 0 ? "TSNeverKeyword" : null;
+        case "null": return call.arguments_.length === 0 ? "TSNullKeyword" : null;
+        case "undefined": return call.arguments_.length === 0 ? "TSUndefinedKeyword" : null;
+        case "void": return call.arguments_.length === 0 ? "TSVoidKeyword" : null;
+        case "literal": {
+            if (call.arguments_.length !== 1)
+                return null;
+            const value = schemaLiteral(call.arguments_[0]);
+            return value === null ? null : `literal(${value})`;
+        }
+        case "picklist":
+        case "union": {
+            if (call.arguments_.length !== 1 || call.arguments_[0].type !== "ArrayExpression")
+                return null;
+            const types = call.arguments_[0].elements.map((element) => element === null || element.type === "SpreadElement" ? null : call.name === "picklist" ? schemaLiteral(element) : canonicalValibot(element, namespaces, functions));
+            if (types.some((type) => type === null))
+                return null;
+            return `union(${[...new Set(types)].sort().join(",")})`;
+        }
+        case "array": {
+            if (call.arguments_.length !== 1)
+                return null;
+            const element = canonicalValibot(call.arguments_[0], namespaces, functions);
+            return element === null ? null : `array(${element})`;
+        }
+        case "object": {
+            if (call.arguments_.length !== 1)
+                return null;
+            return canonicalValibotObject(call.arguments_[0], namespaces, functions)?.fingerprint ?? null;
+        }
+        default: return null;
+    }
+}
+function canonicalArkString(value) {
+    let current = value.trim();
+    while (current.startsWith("(") && current.endsWith(")"))
+        current = current.slice(1, -1).trim();
+    if (current.endsWith("[]")) {
+        const element = canonicalArkString(current.slice(0, -2));
+        return element === null ? null : `array(${element})`;
+    }
+    if (current.includes("|")) {
+        const types = current.split("|").map((part) => canonicalArkString(part));
+        if (types.some((type) => type === null))
+            return null;
+        return `union(${[...new Set(types)].sort().join(",")})`;
+    }
+    if (/^'(?:[^'\\]|\\.)*'$/.test(current) || /^"(?:[^"\\]|\\.)*"$/.test(current))
+        return `literal(${JSON.stringify(current.slice(1, -1))})`;
+    if (/^-?\d+(?:\.\d+)?$/.test(current) || current === "true" || current === "false")
+        return `literal(${current})`;
+    const keywords = { string: "TSStringKeyword", number: "TSNumberKeyword", boolean: "TSBooleanKeyword", bigint: "TSBigIntKeyword", unknown: "TSUnknownKeyword", any: "TSAnyKeyword", never: "TSNeverKeyword", null: "TSNullKeyword", undefined: "TSUndefinedKeyword", void: "TSVoidKeyword" };
+    return keywords[current] ?? null;
+}
+function canonicalArkObject(node) {
+    if (node.type !== "ObjectExpression")
+        return null;
+    const members = [];
+    for (const property of node.properties) {
+        if (property.type !== "Property" || property.computed || property.kind !== "init")
+            return null;
+        const keyValue = property.key;
+        const rawKey = typeof keyValue.value === "string" ? keyValue.value : propertyKey(property.key);
+        if (rawKey === null)
+            return null;
+        const optional = rawKey.endsWith("?");
+        const key = optional ? rawKey.slice(0, -1) : rawKey;
+        const literal = property.value;
+        const type = typeof literal.value === "string" ? canonicalArkString(literal.value) : canonicalArkObject(property.value)?.fingerprint;
+        if (type === null || type === undefined)
+            return null;
+        members.push(`prop(${key},${optional ? "?" : "!"},rw,${type})`);
+    }
+    members.sort();
+    return { fingerprint: `{${members.join(",")}}`, properties: members.length };
+}
+function canonicalDrizzleColumn(node, builders) {
+    let current = node;
+    let notNull = false;
+    let hasDefault = false;
+    while (true) {
+        const call = memberCall(current);
+        if (call === null)
+            break;
+        if ((call.name === "notNull" || call.name === "primaryKey") && call.arguments_.length === 0)
+            notNull = true;
+        else if (["default", "defaultNow", "defaultRandom", "$default", "$defaultFn"].includes(call.name))
+            hasDefault = true;
+        else if (!["primaryKey", "unique", "references", "onUpdate", "$onUpdate", "$onUpdateFn"].includes(call.name))
+            return null;
+        current = call.object;
+    }
+    if (current.type !== "CallExpression" || current.callee.type !== "Identifier")
+        return null;
+    const type = builders.get(current.callee.name);
+    if (type === undefined)
+        return null;
+    if (current.callee.name === "serial")
+        hasDefault = true;
+    return { type, notNull, hasDefault };
+}
+function canonicalDrizzleTable(node, tableFactories, builders, model) {
+    if (node.type !== "CallExpression" || node.callee.type !== "Identifier" || !tableFactories.has(node.callee.name) || node.arguments.length < 2 || node.arguments[1].type === "SpreadElement")
+        return null;
+    const columns = node.arguments[1];
+    if (columns.type !== "ObjectExpression")
+        return null;
+    const members = [];
+    for (const property of columns.properties) {
+        if (property.type !== "Property" || property.computed || property.kind !== "init")
+            return null;
+        const key = propertyKey(property.key);
+        if (key === null)
+            return null;
+        const column = canonicalDrizzleColumn(property.value, builders);
+        if (column === null)
+            return null;
+        const optional = model === "insert" && (!column.notNull || column.hasDefault);
+        const type = column.notNull ? column.type : `union(${["TSNullKeyword", column.type].sort().join(",")})`;
+        members.push(`prop(${key},${optional ? "?" : "!"},rw,${type})`);
+    }
+    members.sort();
+    return { fingerprint: `{${members.join(",")}}`, properties: members.length };
+}
 /** Report exact structural duplicates without TypeScript assignability or fuzzy matching. */
 export const noDuplicateTypesRule = defineRule({
     meta: {
         type: "suggestion",
         docs: { description: "Report structurally identical TypeScript declarations" },
         messages: { duplicate: "{{message}} First seen as {{firstName}} in {{firstFile}}." },
-        schema: [{ type: "object", properties: { message: { type: "string" }, minProperties: { type: "integer", minimum: 0 } }, additionalProperties: false }],
+        schema: [{ type: "object", properties: { message: { type: "string" }, minProperties: { type: "integer", minimum: 0 }, schemas: { type: "object", properties: { libraries: { type: "array", items: { enum: ["zod", "valibot", "arktype"] } }, matchTypes: { type: "boolean" } }, additionalProperties: false }, drizzle: { type: "object", properties: { models: { type: "array", items: { enum: ["select", "insert"] } }, matchTypes: { type: "boolean" } }, additionalProperties: false } }, additionalProperties: false }],
     },
     createOnce(context) {
         const seen = new Map();
         let options = {};
-        const report = (node, fingerprint) => {
-            const first = seen.get(fingerprint);
+        const report = (node, name, fingerprint, kind) => {
+            const isolates = kind === "schema" ? options.schemas?.matchTypes === false : kind.startsWith("drizzle-") && options.drizzle?.matchTypes === false;
+            const key = isolates ? `${kind}:${fingerprint}` : fingerprint;
+            const first = seen.get(key);
             if (first === undefined) {
-                seen.set(fingerprint, { name: node.id.name, filename: context.filename });
+                seen.set(key, { node, name, filename: context.filename });
                 return;
             }
+            if (first.node === node)
+                return;
             context.report({ node, messageId: "duplicate", data: { message: options.message ?? "This type is structurally identical to an existing declaration.", firstName: first.name, firstFile: first.filename } });
         };
         const inspect = (node) => {
@@ -143,12 +449,103 @@ export const noDuplicateTypesRule = defineRule({
                 return;
             if (properties < (options.minProperties ?? 2))
                 return;
-            report(node, fingerprint);
+            report(node, node.id.name, fingerprint, "type");
+        };
+        const zodNamespaces = new Set();
+        const valibotNamespaces = new Set();
+        const valibotFunctions = new Map();
+        const arkTypeFunctions = new Set();
+        let hasArkTypeImport = false;
+        const drizzleTables = new Set();
+        const drizzleBuilders = new Map();
+        const inspectSchema = (node) => {
+            if (options.schemas?.libraries?.includes("zod") !== true || node.id.type !== "Identifier" || node.init === null)
+                return;
+            const call = memberCall(node.init);
+            if (call === null || call.name !== "object" || call.arguments_.length !== 1 || call.object.type !== "Identifier" || !zodNamespaces.has(call.object.name))
+                return;
+            const schema = canonicalSchemaObject(call.arguments_[0], zodNamespaces);
+            if (schema === null || schema.properties < (options.minProperties ?? 2))
+                return;
+            report(node, node.id.name, schema.fingerprint, "schema");
+        };
+        const inspectValibot = (node) => {
+            if (options.schemas?.libraries?.includes("valibot") !== true || node.id.type !== "Identifier" || node.init === null)
+                return;
+            const call = factoryCall(node.init, valibotNamespaces, valibotFunctions);
+            if (call === null || call.name !== "object" || call.arguments_.length !== 1)
+                return;
+            const schema = canonicalValibotObject(call.arguments_[0], valibotNamespaces, valibotFunctions);
+            if (schema === null || schema.properties < (options.minProperties ?? 2))
+                return;
+            report(node, node.id.name, schema.fingerprint, "schema");
+        };
+        const inspectArkType = (node) => {
+            const callee = node.init?.type === "CallExpression" ? node.init.callee : null;
+            if (options.schemas?.libraries?.includes("arktype") !== true || node.id.type !== "Identifier" || node.init === null || node.init.type !== "CallExpression" || typeof callee?.name !== "string" || !(arkTypeFunctions.has(callee.name) || hasArkTypeImport && callee.name === "type") || node.init.arguments.length !== 1 || node.init.arguments[0].type === "SpreadElement")
+                return;
+            const schema = canonicalArkObject(node.init.arguments[0]);
+            if (schema === null || schema.properties < (options.minProperties ?? 2))
+                return;
+            report(node, node.id.name, schema.fingerprint, "schema");
+        };
+        const inspectDrizzle = (node) => {
+            if (options.drizzle === undefined || node.id.type !== "Identifier" || node.init === null)
+                return;
+            for (const model of options.drizzle.models ?? ["select", "insert"]) {
+                const table = canonicalDrizzleTable(node.init, drizzleTables, drizzleBuilders, model);
+                if (table !== null && table.properties >= (options.minProperties ?? 2))
+                    report(node, node.id.name, table.fingerprint, `drizzle-${model}`);
+            }
         };
         return {
             Program() { options = context.options[0] ?? {}; },
+            ImportDeclaration(node) {
+                if (node.source.value === "zod") {
+                    for (const specifier of node.specifiers) {
+                        if (specifier.type === "ImportNamespaceSpecifier" || specifier.type === "ImportDefaultSpecifier")
+                            zodNamespaces.add(specifier.local.name);
+                        if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier" && specifier.imported.name === "z")
+                            zodNamespaces.add(specifier.local.name);
+                    }
+                }
+                if (node.source.value === "valibot") {
+                    for (const specifier of node.specifiers) {
+                        if (specifier.type === "ImportNamespaceSpecifier")
+                            valibotNamespaces.add(specifier.local.name);
+                        if (specifier.type === "ImportSpecifier" && specifier.imported.type === "Identifier")
+                            valibotFunctions.set(specifier.local.name, specifier.imported.name);
+                    }
+                }
+                if (node.source.value === "arktype") {
+                    hasArkTypeImport = true;
+                    for (const specifier of node.specifiers) {
+                        const imported = specifier.type === "ImportSpecifier" ? specifier.imported : null;
+                        if (typeof imported?.name === "string" && imported.name === "type")
+                            arkTypeFunctions.add(specifier.local.name);
+                    }
+                }
+                if (/^drizzle-orm\/(pg|mysql|sqlite)-core$/.test(String(node.source.value))) {
+                    for (const specifier of node.specifiers) {
+                        if (specifier.type !== "ImportSpecifier" || specifier.imported.type !== "Identifier")
+                            continue;
+                        if (["pgTable", "mysqlTable", "sqliteTable"].includes(specifier.imported.name))
+                            drizzleTables.add(specifier.local.name);
+                        const types = { text: "TSStringKeyword", varchar: "TSStringKeyword", uuid: "TSStringKeyword", char: "TSStringKeyword", integer: "TSNumberKeyword", int: "TSNumberKeyword", serial: "TSNumberKeyword", smallint: "TSNumberKeyword", boolean: "TSBooleanKeyword" };
+                        const type = types[specifier.imported.name];
+                        if (type !== undefined)
+                            drizzleBuilders.set(specifier.local.name, type);
+                    }
+                }
+            },
             TSTypeAliasDeclaration: inspect,
             TSInterfaceDeclaration: inspect,
+            VariableDeclarator(node) {
+                inspectSchema(node);
+                inspectValibot(node);
+                inspectArkType(node);
+                inspectDrizzle(node);
+            },
         };
     },
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-deslop",
-  "version": "0.2.3",
+  "version": "0.4.0",
   "description": "Opinionated Oxlint rules that reject low-evidence, low-signal, AI-slop code patterns.",
   "type": "module",
   "main": "./dist/index.js",