@jameswyse/oxc-config 0.2.0 → 0.4.0

package/dist/rules/no-uncontrolled-test-clock.js

@@ -0,0 +1,112 @@
+import { defineRule } from "@oxlint/plugins";
+import { importedBinding, isGlobalValue, isPlaywright, staticPropertyName, testContext, unwrapExpression, variableFor, } from "../shared/index.js";
+const fakeClockMethods = new Set(["install", "setFixedTime"]);
+const timerLists = new Set(["apis", "toFake", "doNotFake"]);
+function nameOf(node) {
+    const value = unwrapExpression(node);
+    return value.type === "Identifier" ? value.name : staticPropertyName(value);
+}
+function fakesDate(options) {
+    const value = options === undefined ? undefined : unwrapExpression(options);
+    if (value?.type !== "ObjectExpression") {
+        return true;
+    }
+    return value.properties.every((property) => {
+        const name = property.type === "Property" ? staticPropertyName(property) : null;
+        const list = property.type === "Property" ? unwrapExpression(property.value) : null;
+        if (name === null || !timerLists.has(name) || list?.type !== "ArrayExpression") {
+            return true;
+        }
+        const values = list.elements.map((element) => element?.type === "Literal" ? element.value : undefined);
+        if (values.length === 0 || values.includes(undefined)) {
+            return true;
+        }
+        return name === "doNotFake" ? !values.includes("Date") : values.includes("Date");
+    });
+}
+function isNodeMock(sourceCode, node) {
+    const binding = importedBinding(sourceCode, node);
+    return nameOf(node) === "mock" || (binding?.source === "node:test" && binding.name === "mock");
+}
+function isLocalFunction(sourceCode, node) {
+    const definition = variableFor(sourceCode, node)?.defs[0];
+    return definition !== undefined && definition.type !== "ImportBinding";
+}
+function controlsClock(sourceCode, call) {
+    const callee = unwrapExpression(call.callee);
+    const name = isLocalFunction(sourceCode, callee) ? null : nameOf(callee);
+    if (name === "setSystemTime") {
+        return true;
+    }
+    if (name === "useFakeTimers") {
+        return fakesDate(call.arguments[0]);
+    }
+    if (name === null || callee.type !== "MemberExpression") {
+        return false;
+    }
+    const owner = unwrapExpression(callee.object);
+    return ((nameOf(owner) === "clock" && fakeClockMethods.has(name)) ||
+        (name === "enable" &&
+            owner.type === "MemberExpression" &&
+            nameOf(owner) === "timers" &&
+            isNodeMock(sourceCode, owner.object) &&
+            fakesDate(call.arguments[0])));
+}
+export const noUncontrolledTestClock = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "Require tests that read the current time to control the clock." },
+        schema: [],
+        messages: {
+            clock: "This test reads the real clock, so its result depends on when it runs. Use a fixed date, or control time with fake timers.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        const drivesBrowser = sourceCode.ast.body.some((statement) => statement.type === "ImportDeclaration" && isPlaywright(statement.source.value));
+        if (drivesBrowser) {
+            return {};
+        }
+        const reads = [];
+        const controlledTests = new Set();
+        let controlledFile = false;
+        function enclosingTest(node) {
+            const test = testContext(sourceCode, node);
+            return test?.api.name === "test" || test?.api.name === "it" ? test.callback : null;
+        }
+        return {
+            CallExpression(node) {
+                if (controlsClock(sourceCode, node)) {
+                    const test = enclosingTest(node);
+                    if (test === null) {
+                        controlledFile = true;
+                    }
+                    else {
+                        controlledTests.add(test);
+                    }
+                }
+                if (node.callee.type === "MemberExpression" &&
+                    staticPropertyName(node.callee) === "now" &&
+                    isGlobalValue(sourceCode, node.callee.object, "Date")) {
+                    reads.push(node);
+                }
+            },
+            NewExpression(node) {
+                if (node.arguments.length === 0 && isGlobalValue(sourceCode, node.callee, "Date")) {
+                    reads.push(node);
+                }
+            },
+            "Program:exit"() {
+                if (controlledFile) {
+                    return;
+                }
+                for (const node of reads) {
+                    const test = enclosingTest(node);
+                    if (test === null || !controlledTests.has(test)) {
+                        context.report({ node, messageId: "clock" });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/no-unsettled-promise.d.ts

@@ -0,0 +1 @@
+export declare const noUnsettledPromise: import("@oxlint/plugins").Rule;

package/dist/rules/no-unsettled-promise.js

@@ -0,0 +1,64 @@
+import { defineRule } from "@oxlint/plugins";
+import { isGlobal, isShortCircuited } from "../shared/index.js";
+function isOptionallyReached(reference, executor) {
+    let child = reference.identifier;
+    for (let node = child.parent; node !== null && node !== executor; child = node, node = node.parent) {
+        const argument = child;
+        if (node.type === "CallExpression" &&
+            node.arguments.some((candidate) => candidate === argument) &&
+            isShortCircuited(node)) {
+            return true;
+        }
+    }
+    return false;
+}
+function doesNothing(executor) {
+    const body = executor.body;
+    if (body?.type === "BlockStatement") {
+        return body.body.length === 0;
+    }
+    return ((body?.type === "Identifier" && body.name === "undefined") ||
+        (body?.type === "UnaryExpression" &&
+            body.operator === "void" &&
+            body.argument.type === "Literal"));
+}
+function endsByThrowing(executor) {
+    return (executor.body?.type === "BlockStatement" && executor.body.body.at(-1)?.type === "ThrowStatement");
+}
+export const noUnsettledPromise = defineRule({
+    meta: {
+        type: "problem",
+        docs: { description: "Require a Promise executor that runs code to settle the promise." },
+        schema: [],
+        messages: {
+            unsettled: "This executor never calls `resolve` or `reject`, so the promise never settles. Return the underlying promise instead, or settle it when the work finishes.",
+            optional: "This executor only settles inside an optional call, so the promise never settles when the target is missing. Settle it on both paths.",
+        },
+    },
+    create(context) {
+        const sourceCode = context.sourceCode;
+        return {
+            NewExpression(node) {
+                const [executor] = node.arguments;
+                if (!isGlobal(sourceCode, node.callee, "Promise") ||
+                    (executor?.type !== "ArrowFunctionExpression" &&
+                        executor?.type !== "FunctionExpression") ||
+                    doesNothing(executor) ||
+                    endsByThrowing(executor) ||
+                    executor.params.some((parameter) => parameter.type !== "Identifier")) {
+                    return;
+                }
+                const references = sourceCode
+                    .getDeclaredVariables(executor)
+                    .filter((variable) => variable.defs.some((definition) => definition.type === "Parameter"))
+                    .flatMap((variable) => variable.references);
+                if (references.length === 0) {
+                    context.report({ node: executor, messageId: "unsettled" });
+                }
+                else if (references.every((reference) => isOptionallyReached(reference, executor))) {
+                    context.report({ node: executor, messageId: "optional" });
+                }
+            },
+        };
+    },
+});

package/dist/rules/require-suppression-reason.d.ts

@@ -0,0 +1 @@
+export declare const requireSuppressionReason: import("@oxlint/plugins").Rule;

package/dist/rules/require-suppression-reason.js

@@ -0,0 +1,32 @@
+import { defineRule } from "@oxlint/plugins";
+const disableDirective = /^\s*(?:oxlint|eslint)-disable(?:-next-line|-line)?(?=\s|$)(?<rest>.*)$/su;
+export const requireSuppressionReason = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: { description: "Require each lint suppression to name its rules and give a reason." },
+        schema: [],
+        messages: {
+            rule: "Name the rules this directive suppresses, so it can't hide other diagnostics.",
+            reason: "Give this suppression a reason after `--` that says why the reported code is correct here.",
+        },
+    },
+    create(context) {
+        return {
+            Program() {
+                for (const comment of context.sourceCode.getAllComments()) {
+                    const rest = disableDirective.exec(comment.value)?.groups?.["rest"];
+                    if (rest === undefined) {
+                        continue;
+                    }
+                    const [rules = "", reason = ""] = rest.split(/\s-{2,}(?:\s|$)/u, 2);
+                    if (rules.trim() === "") {
+                        context.report({ loc: comment.loc, messageId: "rule" });
+                    }
+                    else if (reason.trim() === "") {
+                        context.report({ loc: comment.loc, messageId: "reason" });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/shared/index.d.ts

@@ -3,6 +3,10 @@ export type ApiReference = {
     readonly module: string;
     readonly name: string;
 };
+export type ImportedBinding = {
+    readonly source: string;
+    readonly name: string;
+};
 export type TestContext = {
     readonly callback: FunctionNode;
     readonly api: ApiReference;
@@ -17,10 +21,19 @@ export declare function variableFor(sourceCode: SourceCode, node: ESTree.Node):
 export declare function isGlobal(sourceCode: SourceCode, identifier: ESTree.Node | null | undefined, name: string): boolean;
 export declare function propertyName(node: ESTree.Node): string | null;
 export declare function isPlaywright(module: string): boolean;
-export declare function apiReference(sourceCode: SourceCode, node: ESTree.Node, seen?: Set<Variable>): ApiReference | null;
+export declare function unwrapExpression(node: ESTree.Node): ESTree.Node;
+export declare function outermostExpression(node: ESTree.Node): ESTree.Node;
+export declare function staticString(node: ESTree.Node | null | undefined): string | null;
+export declare function staticPropertyName(node: ESTree.Node): string | null;
+export declare function moduleExportName(node: ESTree.ModuleExportName): string;
+export declare function importedBinding(sourceCode: SourceCode, node: ESTree.Node): ImportedBinding | null;
+export declare function apiReference(sourceCode: SourceCode, node: ESTree.Node): ApiReference | null;
 export declare function testContext(sourceCode: SourceCode, node: ESTree.Node): TestContext | null;
 export declare function projectPath(cwd: string, file: string): string;
 export declare function matchesAny(path: string, patterns?: readonly string[]): boolean;
 export declare function isGlobalValue(sourceCode: SourceCode, node: ESTree.Node | null | undefined, name: string): boolean;
+export declare function isNodeGlobalValue(sourceCode: SourceCode, node: ESTree.Node | null | undefined, name: string): boolean;
 export declare function isInjectionSeam(source: ESTree.Node): boolean;
+export declare function isShortCircuited(call: ESTree.CallExpression): boolean;
+export declare function isEffectModule(sourceCode: SourceCode, node: ESTree.Node, module: string): boolean;
 export {};

package/dist/shared/index.js

@@ -89,94 +89,207 @@ export function propertyName(node) {
 export function isPlaywright(module) {
     return module === "@playwright/test" || module === "playwright/test";
 }
-export function apiReference(sourceCode, node, seen = new Set()) {
-    if (node.type === "Identifier") {
-        const variable = variableFor(sourceCode, node);
+export function unwrapExpression(node) {
+    return node.type === "ParenthesizedExpression" ||
+        node.type === "TSAsExpression" ||
+        node.type === "TSSatisfiesExpression" ||
+        node.type === "TSNonNullExpression" ||
+        node.type === "TSTypeAssertion"
+        ? unwrapExpression(node.expression)
+        : node;
+}
+export function outermostExpression(node) {
+    const parent = node.parent;
+    return parent !== null && unwrapExpression(parent) === unwrapExpression(node)
+        ? outermostExpression(parent)
+        : node;
+}
+export function staticString(node) {
+    const value = node ? unwrapExpression(node) : null;
+    if (value?.type === "TemplateLiteral") {
+        const [quasi] = value.quasis;
+        return value.expressions.length === 0 && quasi ? (quasi.value.cooked ?? null) : null;
+    }
+    return value?.type === "Literal" && typeof value.value === "string" ? value.value : null;
+}
+export function staticPropertyName(node) {
+    return "computed" in node && node.computed ? staticString(memberKey(node)) : propertyName(node);
+}
+export function moduleExportName(node) {
+    return node.type === "Identifier" ? node.name : node.value;
+}
+function dynamicImportSource(node) {
+    const awaited = unwrapExpression(node);
+    const loaded = awaited.type === "AwaitExpression" ? unwrapExpression(awaited.argument) : null;
+    if (loaded?.type !== "ImportExpression") {
+        return null;
+    }
+    return staticString(loaded.source);
+}
+const bindingCache = new WeakMap();
+const referenceCache = new WeakMap();
+function memberBinding(owner, name) {
+    return (owner?.name === "*" || owner?.name === "default") && name !== null
+        ? { source: owner.source, name }
+        : null;
+}
+function bindsName(property, name) {
+    if (property.type !== "Property") {
+        return false;
+    }
+    const target = property.value.type === "AssignmentPattern" ? property.value.left : property.value;
+    return target.type === "Identifier" && target.name === name;
+}
+function constAlias(definition) {
+    const declaration = definition.parent;
+    const declarator = definition.node;
+    return definition.type === "Variable" &&
+        declaration?.type === "VariableDeclaration" &&
+        declaration.kind === "const" &&
+        declarator.type === "VariableDeclarator" &&
+        declarator.init
+        ? { init: declarator.init, pattern: declarator.id, name: definition.name.name }
+        : null;
+}
+function destructuredName(pattern, name) {
+    const property = pattern.type === "ObjectPattern"
+        ? pattern.properties.find((candidate) => bindsName(candidate, name))
+        : undefined;
+    return property ? staticPropertyName(property) : null;
+}
+function aliasTarget(alias, resolve, member) {
+    const initial = resolve(alias.init);
+    if (alias.pattern.type === "Identifier") {
+        return initial;
+    }
+    const name = destructuredName(alias.pattern, alias.name);
+    return initial !== null && name !== null ? member(initial, name) : null;
+}
+function cached(cache, variable, resolve) {
+    if (!cache.has(variable)) {
+        cache.set(variable, null);
+        cache.set(variable, resolve());
+    }
+    return cache.get(variable) ?? null;
+}
+function importBinding(definition) {
+    const declaration = definition.parent;
+    const specifier = definition.node;
+    if (definition.type !== "ImportBinding" || declaration?.type !== "ImportDeclaration") {
+        return null;
+    }
+    const source = declaration.source.value;
+    if (specifier.type === "ImportNamespaceSpecifier") {
+        return { source, name: "*" };
+    }
+    if (specifier.type === "ImportDefaultSpecifier") {
+        return { source, name: "default" };
+    }
+    return specifier.type === "ImportSpecifier"
+        ? {
+            source,
+            name: moduleExportName(specifier.imported),
+        }
+        : null;
+}
+export function importedBinding(sourceCode, node) {
+    const value = unwrapExpression(node);
+    const dynamicSource = dynamicImportSource(value);
+    if (dynamicSource !== null) {
+        return { source: dynamicSource, name: "*" };
+    }
+    if (value.type === "MemberExpression") {
+        return memberBinding(importedBinding(sourceCode, value.object), staticPropertyName(value));
+    }
+    const variable = variableFor(sourceCode, value);
+    const definition = variable?.defs[0];
+    if (variable === null || definition === undefined) {
+        return null;
+    }
+    return cached(bindingCache, variable, () => {
+        const alias = constAlias(definition);
+        return alias === null
+            ? importBinding(definition)
+            : aliasTarget(alias, (init) => importedBinding(sourceCode, init), memberBinding);
+    });
+}
+function bindingReference(binding) {
+    const defaultExport = defaultImports.get(binding.source);
+    if (binding.name === "default") {
+        return defaultExport ? { module: binding.source, name: defaultExport } : null;
+    }
+    return defaultExport !== undefined &&
+        testFunctions.has(defaultExport) &&
+        testModifiers.has(binding.name)
+        ? { module: binding.source, name: defaultExport }
+        : { module: binding.source, name: binding.name };
+}
+function memberReference(object, name) {
+    if (object.name === "*") {
+        return bindingReference({ source: object.module, name });
+    }
+    if (testFunctions.has(object.name) && (testModifiers.has(name) || testFactories.has(name))) {
+        return object;
+    }
+    if (object.module === "@effect/vitest" &&
+        ["test", "it"].includes(object.name) &&
+        effectModifiers.has(name)) {
+        return object;
+    }
+    return object.name === "test" && testFunctions.has(name) ? { module: object.module, name } : null;
+}
+export function apiReference(sourceCode, node) {
+    const value = unwrapExpression(node);
+    if (value.type === "Identifier") {
+        const variable = variableFor(sourceCode, value);
         if (!variable?.defs.length) {
-            return testFunctions.has(node.name) || node.name === "expect"
-                ? { module: "global", name: node.name }
+            return testFunctions.has(value.name) || value.name === "expect"
+                ? { module: "global", name: value.name }
                 : null;
         }
         const [definition] = variable.defs;
-        if (seen.has(variable) || definition === undefined || variable.defs.length !== 1) {
+        if (definition === undefined || variable.defs.length !== 1) {
             return null;
         }
-        seen.add(variable);
-        const specifier = definition.node;
-        const declaration = definition.parent;
-        if (definition.type === "ImportBinding" && declaration?.type === "ImportDeclaration") {
-            const module = declaration.source.value;
-            if (specifier.type === "ImportDefaultSpecifier" ||
-                (specifier.type === "ImportSpecifier" &&
-                    specifier.imported.type === "Identifier" &&
-                    specifier.imported.name === "default")) {
-                const name = defaultImports.get(module);
-                return name ? { module, name } : null;
-            }
-            if (specifier.type === "ImportNamespaceSpecifier") {
-                return { module, name: "*" };
+        return cached(referenceCache, variable, () => {
+            const alias = constAlias(definition);
+            if (alias !== null) {
+                return aliasTarget(alias, (init) => apiReference(sourceCode, init), memberReference);
             }
-            if (specifier.type === "ImportSpecifier") {
-                return {
-                    module,
-                    name: specifier.imported.type === "Identifier"
-                        ? specifier.imported.name
-                        : specifier.imported.value,
-                };
-            }
-            return null;
-        }
-        if (definition.type === "Variable" &&
-            declaration?.type === "VariableDeclaration" &&
-            declaration.kind === "const" &&
-            specifier.type === "VariableDeclarator" &&
-            specifier.id.type === "Identifier" &&
-            specifier.init) {
-            return apiReference(sourceCode, specifier.init, seen);
-        }
-        return null;
+            const binding = importBinding(definition);
+            return binding && bindingReference(binding);
+        });
+    }
+    if (value.type === "MemberExpression") {
+        const object = apiReference(sourceCode, value.object);
+        const name = staticPropertyName(value);
+        return object && name !== null ? memberReference(object, name) : null;
     }
-    if (node.type === "MemberExpression") {
-        const object = apiReference(sourceCode, node.object, seen);
-        const name = propertyName(node);
-        if (!object || !name) {
+    if (value.type === "CallExpression") {
+        const callee = unwrapExpression(value.callee);
+        if (callee.type !== "MemberExpression") {
             return null;
         }
-        if (object.name === "*") {
-            return { module: object.module, name };
-        }
-        if (testFunctions.has(object.name) && (testModifiers.has(name) || testFactories.has(name))) {
-            return object;
-        }
-        if (object.module === "@effect/vitest" &&
-            ["test", "it"].includes(object.name) &&
-            effectModifiers.has(name)) {
-            return object;
-        }
-        if (object.name === "test" && testFunctions.has(name)) {
-            return { module: object.module, name };
-        }
-        return null;
-    }
-    if (node.type === "CallExpression" && node.callee.type === "MemberExpression") {
-        const name = propertyName(node.callee);
-        const object = apiReference(sourceCode, node.callee.object, seen);
+        const name = staticPropertyName(callee);
+        const object = apiReference(sourceCode, callee.object);
         if (object && name !== null && testFunctions.has(object.name) && testFactories.has(name)) {
             return object;
         }
-        if (object &&
+        return object &&
             ["test", "it"].includes(object.name) &&
             (isPlaywright(object.module) || ["vitest", "@effect/vitest"].includes(object.module)) &&
-            name === "extend") {
-            return object;
-        }
+            name === "extend"
+            ? object
+            : null;
     }
-    if (node.type === "TaggedTemplateExpression" &&
-        node.tag.type === "MemberExpression" &&
-        propertyName(node.tag) === "each") {
-        return apiReference(sourceCode, node.tag.object, seen);
+    if (value.type === "TaggedTemplateExpression") {
+        const tag = unwrapExpression(value.tag);
+        return tag.type === "MemberExpression" && staticPropertyName(tag) === "each"
+            ? apiReference(sourceCode, tag.object)
+            : null;
     }
-    return null;
+    const dynamicSource = dynamicImportSource(value);
+    return dynamicSource === null ? null : { module: dynamicSource, name: "*" };
 }
 export function testContext(sourceCode, node) {
     for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
@@ -202,50 +315,59 @@ export function projectPath(cwd, file) {
 export function matchesAny(path, patterns = []) {
     return patterns.some((pattern) => matchesGlob(path, pattern));
 }
-const globalObjects = ["globalThis", "global", "window", "self"];
+const nodeGlobalObjects = ["globalThis", "global"];
+const globalObjects = [...nodeGlobalObjects, "window", "self"];
 function isFunctionNode(node) {
     return (node.type === "ArrowFunctionExpression" ||
         node.type === "FunctionExpression" ||
         node.type === "FunctionDeclaration");
 }
-export function isGlobalValue(sourceCode, node, name) {
-    if (isGlobal(sourceCode, node, name)) {
+function isGlobalThrough(sourceCode, node, name, objects) {
+    const value = node ? unwrapExpression(node) : null;
+    if (isGlobal(sourceCode, value, name)) {
         return true;
     }
-    return (node?.type === "MemberExpression" &&
-        propertyName(node) === name &&
-        globalObjects.some((object) => isGlobal(sourceCode, node.object, object)));
+    return (value?.type === "MemberExpression" &&
+        staticPropertyName(value) === name &&
+        objects.some((object) => isGlobal(sourceCode, unwrapExpression(value.object), object)));
+}
+export function isGlobalValue(sourceCode, node, name) {
+    return isGlobalThrough(sourceCode, node, name, globalObjects);
+}
+export function isNodeGlobalValue(sourceCode, node, name) {
+    return isGlobalThrough(sourceCode, node, name, nodeGlobalObjects);
 }
 function returns(callback, value) {
     const body = callback.body;
-    if (body === value) {
-        return true;
-    }
     if (body?.type !== "BlockStatement") {
-        return false;
+        return body !== null && unwrapExpression(body) === value;
     }
     const [statement] = body.body;
-    return (body.body.length === 1 && statement?.type === "ReturnStatement" && statement.argument === value);
+    return (body.body.length === 1 &&
+        statement?.type === "ReturnStatement" &&
+        statement.argument !== null &&
+        unwrapExpression(statement.argument) === value);
 }
 function isProvider(callback, value) {
-    const holder = callback.parent;
-    if (holder.type === "AssignmentPattern") {
-        return holder.right === callback;
+    const provider = outermostExpression(callback);
+    const holder = provider.parent;
+    if (holder?.type === "AssignmentPattern") {
+        return holder.right === provider;
     }
     if (!returns(callback, value)) {
         return false;
     }
-    return ((holder.type === "Property" && holder.value === callback) ||
-        (holder.type === "LogicalExpression" &&
-            holder.right === callback &&
+    return ((holder?.type === "Property" && holder.value === provider) ||
+        (holder?.type === "LogicalExpression" &&
+            holder.right === provider &&
             ["??", "||"].includes(holder.operator)));
 }
 export function isInjectionSeam(source) {
     const parent = source.parent;
     if (source.type !== "NewExpression" && source.type !== "CallExpression") {
-        return parent?.type === "CallExpression" && parent.callee === source
-            ? isInjectionSeam(parent)
-            : true;
+        const callee = outermostExpression(source);
+        const call = callee.parent;
+        return call?.type === "CallExpression" && call.callee === callee ? isInjectionSeam(call) : true;
     }
     let child = source;
     for (let ancestor = parent; ancestor; child = ancestor, ancestor = ancestor.parent) {
@@ -258,3 +380,21 @@ export function isInjectionSeam(source) {
     }
     return false;
 }
+export function isShortCircuited(call) {
+    let current = call;
+    while (current.type === "CallExpression" || current.type === "MemberExpression") {
+        if (current.optional) {
+            return true;
+        }
+        current = current.type === "CallExpression" ? current.callee : current.object;
+        while (current.type === "TSNonNullExpression") {
+            current = current.expression;
+        }
+    }
+    return false;
+}
+export function isEffectModule(sourceCode, node, module) {
+    const binding = importedBinding(sourceCode, node);
+    return ((binding?.source === "effect" && binding.name === module) ||
+        (binding?.source === `effect/${module}` && binding.name === "*"));
+}

package/dist/vendor/anti-slop/effect/rules/no-service-constructor-imports.js

@@ -11,11 +11,16 @@ function getImportedName(specifier) {
     }
     return specifier.imported.value;
 }
+function isCallOrTypeQuery(reference) {
+    const parent = reference.identifier.parent;
+    return (parent.type === "TSTypeQuery" ||
+        (parent.type === "CallExpression" && parent.callee === reference.identifier));
+}
 export const noServiceConstructorImports = defineRule({
     meta: {
         type: "problem",
         docs: {
-            description: "Disallow project-local make<CapabilityName> imports outside test and spec files.",
+            description: "Disallow project-local make<CapabilityName> service values imported outside test and spec files.",
         },
         messages: {
             serviceConstructorImport: 'Do not import Effect service constructor "{{name}}" into runtime code. Import the owning Layer, yield the contextual service, and allow its requirements to propagate to the composition root.',
@@ -33,7 +38,10 @@ export const noServiceConstructorImports = defineRule({
                         continue;
                     }
                     const importedName = getImportedName(specifier);
-                    if (!SERVICE_CONSTRUCTOR_NAME.test(importedName)) {
+                    if (!SERVICE_CONSTRUCTOR_NAME.test(importedName) ||
+                        context.sourceCode
+                            .getDeclaredVariables(specifier)
+                            .every((variable) => variable.references.every(isCallOrTypeQuery))) {
                         continue;
                     }
                     context.report({