@timmo001/oxlint-rules 0.4.0 → 0.6.0

package/dist/configs/recommended-effect.js

@@ -6,18 +6,10 @@ function defineConfig(config) {
 // src/effect/index.ts
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
-// src/effect/rules/no-try-catch-in-effect-generators.ts
+// src/effect/rules/no-raw-gh.ts
 import { defineRule } from "@oxlint/plugins";
-function resolveVariable(sourceCode, identifier) {
-  let scope = sourceCode.getScope(identifier);
-  while (scope) {
-    const variable = scope.set.get(identifier.name);
-    if (variable)
-      return variable;
-    scope = scope.upper;
-  }
-  return null;
-}
+
+// src/shared/ast.ts
 function nearestEnclosingFunction(node) {
   let current = node.parent;
   while (current) {
@@ -33,6 +25,83 @@ function staticMemberName(node) {
     return null;
   return node.property.type === "Identifier" ? node.property.name : null;
 }
+
+// vendor/anti-slop/src/shared/scope.ts
+function resolveVariable(sourceCode, identifier) {
+  let scope = sourceCode.getScope(identifier);
+  while (scope !== null) {
+    const variable = scope.set.get(identifier.name);
+    if (variable !== undefined)
+      return variable;
+    scope = scope.upper;
+  }
+  return null;
+}
+// src/effect/rules/no-raw-gh.ts
+var PACKAGE = "@timmo001/effect-gh";
+var rawMethods = new Set(["execute", "json", "stream"]);
+function isEffectGhImport(sourceCode, identifier, name) {
+  return resolveVariable(sourceCode, identifier)?.defs.some((definition) => {
+    if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration" || definition.parent.source.value !== PACKAGE || definition.node.type !== "ImportSpecifier") {
+      return false;
+    }
+    const imported = definition.node.imported;
+    return (imported.type === "Identifier" ? imported.name : imported.value) === name;
+  }) ?? false;
+}
+function isYieldGh(sourceCode, node) {
+  return node?.type === "YieldExpression" && node.delegate && node.argument?.type === "Identifier" && isEffectGhImport(sourceCode, node.argument, "Gh");
+}
+function isGhBinding(sourceCode, identifier) {
+  return resolveVariable(sourceCode, identifier)?.defs.some((definition) => definition.type === "Variable" && definition.node.type === "VariableDeclarator" && isYieldGh(sourceCode, definition.node.init)) ?? false;
+}
+function isGhArgument(node) {
+  if (node?.type === "Literal")
+    return node.value === "gh";
+  if (node?.type !== "ArrayExpression")
+    return false;
+  const first = node.elements[0];
+  return first?.type === "Literal" && first.value === "gh";
+}
+var noRawGhRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Use @timmo001/effect-gh typed operations instead of the raw Gh methods, Api.raw, or spawning gh directly."
+    },
+    messages: {
+      rawGh: "Use a typed effect-gh operation instead of `Gh.{{method}}` with raw argv. Add one to effect-gh if the command has none.",
+      rawApi: "Use `Api.json`, `Api.pages`, `Api.empty`, `Api.text` or `Api.headers` instead of `Api.raw`, so the response is typed.",
+      spawnGh: "Run gh through a typed @timmo001/effect-gh operation instead of spawning it directly."
+    }
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const callee = node.callee;
+        const method = staticMemberName(callee);
+        if (callee.type === "MemberExpression" && method !== null) {
+          const object = callee.object;
+          if (rawMethods.has(method) && (isYieldGh(context.sourceCode, object) || object.type === "Identifier" && isGhBinding(context.sourceCode, object))) {
+            context.report({ node, messageId: "rawGh", data: { method } });
+            return;
+          }
+          if (method === "raw" && object.type === "Identifier" && isEffectGhImport(context.sourceCode, object, "Api")) {
+            context.report({ node, messageId: "rawApi" });
+            return;
+          }
+        }
+        if (isGhArgument(node.arguments[0]))
+          context.report({ node, messageId: "spawnGh" });
+      }
+    };
+  }
+});
+
+// src/effect/rules/no-try-catch-in-effect-generators.ts
+import { defineRule as defineRule2 } from "@oxlint/plugins";
+
+// src/shared/effect.ts
 function isEffectImport(sourceCode, identifier, namespace) {
   const variable = resolveVariable(sourceCode, identifier);
   return variable?.defs.some((definition) => {
@@ -60,6 +129,11 @@ function isEffectMethod(sourceCode, node, method) {
   }
   return isEffectImport(sourceCode, object.object, true);
 }
+function importsEffect(program) {
+  return program.body.some((statement) => statement.type === "ImportDeclaration" && statement.importKind !== "type" && (statement.source.value === "effect" || statement.source.value.startsWith("effect/") || statement.source.value.startsWith("@effect/")));
+}
+
+// src/effect/rules/no-try-catch-in-effect-generators.ts
 function isDirectArgument(owner, call) {
   return call.arguments.some((argument) => argument === owner);
 }
@@ -73,7 +147,7 @@ function isRecognisedEffectGenerator(sourceCode, owner) {
   const factoryCall = parent.callee;
   return factoryCall.type === "CallExpression" && isEffectMethod(sourceCode, factoryCall.callee, "fn");
 }
-var noTryCatchInEffectGeneratorsRule = defineRule({
+var noTryCatchInEffectGeneratorsRule = defineRule2({
   meta: {
     type: "problem",
     docs: {
@@ -98,11 +172,86 @@ var noTryCatchInEffectGeneratorsRule = defineRule({
   }
 });
 
+// src/effect/rules/prefer-platform-services.ts
+import { defineRule as defineRule3 } from "@oxlint/plugins";
+var moduleServices = new Map([
+  ["child_process", "childProcess"],
+  ["fs", "fileSystem"],
+  ["fs/promises", "fileSystem"]
+]);
+var bunServices = new Map([
+  ["$", "childProcess"],
+  ["file", "fileSystem"],
+  ["spawn", "childProcess"],
+  ["spawnSync", "childProcess"],
+  ["write", "fileSystem"]
+]);
+var preferPlatformServicesRule = defineRule3({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer Effect's ChildProcessSpawner and FileSystem services over Node or Bun process and file system APIs in modules that use Effect."
+    },
+    messages: {
+      childProcess: "Use Effect's `ChildProcessSpawner` service (`effect/process`) instead of `{{api}}`, so scope cleanup, interruption, and test layers apply.",
+      fileSystem: "Use Effect's `FileSystem` service instead of `{{api}}`, so failures stay typed and tests can provide a layer."
+    }
+  },
+  create(context) {
+    let enabled = false;
+    return {
+      Program(node) {
+        enabled = importsEffect(node);
+      },
+      ImportDeclaration(node) {
+        if (!enabled || node.importKind === "type")
+          return;
+        const source = node.source.value;
+        const service = moduleServices.get(source.replace(/^node:/u, ""));
+        if (service) {
+          context.report({ node, messageId: service, data: { api: source } });
+          return;
+        }
+        if (source !== "bun")
+          return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type") {
+            continue;
+          }
+          const imported = specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+          const bunService = bunServices.get(imported);
+          if (bunService) {
+            context.report({
+              node: specifier,
+              messageId: bunService,
+              data: { api: `Bun.${imported}` }
+            });
+          }
+        }
+      },
+      MemberExpression(node) {
+        const name = staticMemberName(node);
+        const service = name ? bunServices.get(name) : undefined;
+        if (!enabled || !service || node.object.type !== "Identifier" || node.object.name !== "Bun" || (resolveVariable(context.sourceCode, node.object)?.defs.length ?? 0) > 0) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: service,
+          data: { api: `Bun.${name}` }
+        });
+      }
+    };
+  }
+});
+
 // src/effect/index.ts
 var timmoEffectPlugin = eslintCompatPlugin({
   meta: { name: "timmo-effect" },
   rules: {
-    "no-try-catch-in-effect-generators": noTryCatchInEffectGeneratorsRule
+    "no-raw-gh": noRawGhRule,
+    "no-try-catch-in-effect-generators": noTryCatchInEffectGeneratorsRule,
+    "prefer-platform-services": preferPlatformServicesRule
   }
 });
 var effect_default = timmoEffectPlugin;
@@ -111,7 +260,7 @@ var effect_default = timmoEffectPlugin;
 import { eslintCompatPlugin as eslintCompatPlugin2 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/effect/rules/no-manual-effect-error-tag.ts
-import { defineRule as defineRule2 } from "@oxlint/plugins";
+import { defineRule as defineRule4 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/effect/shared/tagged-values.ts
 var equalityOperators = new Set(["==", "===", "!=", "!=="]);
@@ -158,7 +307,7 @@ var isMatchPatternObject = (node) => {
 };
 
 // vendor/anti-slop/src/effect/rules/no-manual-effect-error-tag.ts
-var noManualEffectErrorTagRule = defineRule2({
+var noManualEffectErrorTagRule = defineRule4({
   meta: {
     type: "problem",
     docs: {
@@ -195,8 +344,8 @@ var noManualEffectErrorTagRule = defineRule2({
 });
 
 // vendor/anti-slop/src/effect/rules/no-manual-tag-comparison.ts
-import { defineRule as defineRule3 } from "@oxlint/plugins";
-var noManualTagComparisonRule = defineRule3({
+import { defineRule as defineRule5 } from "@oxlint/plugins";
+var noManualTagComparisonRule = defineRule5({
   meta: {
     type: "problem",
     docs: {
@@ -226,8 +375,8 @@ var noManualTagComparisonRule = defineRule3({
 });
 
 // vendor/anti-slop/src/effect/rules/no-manual-tagged-construction.ts
-import { defineRule as defineRule4 } from "@oxlint/plugins";
-var noManualTaggedConstructionRule = defineRule4({
+import { defineRule as defineRule6 } from "@oxlint/plugins";
+var noManualTaggedConstructionRule = defineRule6({
   meta: {
     type: "problem",
     docs: {
@@ -252,7 +401,7 @@ var noManualTaggedConstructionRule = defineRule4({
 });
 
 // vendor/anti-slop/src/effect/rules/no-service-constructor-imports.ts
-import { defineRule as defineRule5 } from "@oxlint/plugins";
+import { defineRule as defineRule7 } from "@oxlint/plugins";
 var SERVICE_CONSTRUCTOR_NAME = /^make[A-Z]/u;
 var TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/u;
 function isProjectLocalImport(source) {
@@ -263,7 +412,7 @@ function getImportedName(specifier) {
     return specifier.imported.name;
   return specifier.imported.value;
 }
-var noServiceConstructorImportsRule = defineRule5({
+var noServiceConstructorImportsRule = defineRule7({
   meta: {
     type: "problem",
     docs: {
@@ -297,9 +446,9 @@ var noServiceConstructorImportsRule = defineRule5({
 });
 
 // vendor/anti-slop/src/effect/rules/prefer-effect-match.ts
-import { defineRule as defineRule6 } from "@oxlint/plugins";
+import { defineRule as defineRule8 } from "@oxlint/plugins";
 var equalityOperators2 = new Set(["==", "===", "!=", "!=="]);
-var preferEffectMatchRule = defineRule6({
+var preferEffectMatchRule = defineRule8({
   meta: {
     type: "problem",
     docs: {
@@ -365,7 +514,7 @@ function enablePluginRules(namespace, plugin) {
 import { eslintCompatPlugin as eslintCompatPlugin3 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/rules/no-array-filter-map.ts
-import { defineRule as defineRule7 } from "@oxlint/plugins";
+import { defineRule as defineRule9 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/shared/array-method.ts
 function unwrapArrayExpression(node) {
@@ -440,7 +589,7 @@ function isKnownArrayExpression(sourceCode, node, visited = new Set) {
 }
 
 // vendor/anti-slop/src/rules/no-array-filter-map.ts
-var noArrayFilterMapRule = defineRule7({
+var noArrayFilterMapRule = defineRule9({
   meta: {
     type: "suggestion",
     docs: { description: "Disallow adjacent array filter/map passes in favor of lazy iterator helpers or a single transformation." },
@@ -469,7 +618,7 @@ var noArrayFilterMapRule = defineRule7({
 });
 
 // vendor/anti-slop/src/rules/no-reduce-accumulator-copy.ts
-import { defineRule as defineRule8 } from "@oxlint/plugins";
+import { defineRule as defineRule10 } from "@oxlint/plugins";
 function enclosingReducer(node) {
   let parent = node.parent;
   while (parent !== null) {
@@ -519,7 +668,7 @@ function isGlobalCopyOwner(sourceCode, node, name) {
   const variable = resolveArrayBinding(sourceCode, node);
   return variable === null || variable.defs.length === 0;
 }
-var noReduceAccumulatorCopyRule = defineRule8({
+var noReduceAccumulatorCopyRule = defineRule10({
   meta: {
     type: "problem",
     docs: { description: "Disallow copying growing reducer accumulators with Object.assign, Array.from, or array copy methods." },
@@ -560,7 +709,7 @@ var noReduceAccumulatorCopyRule = defineRule8({
 });
 
 // vendor/anti-slop/src/rules/no-chained-type-assertions.ts
-import { defineRule as defineRule9 } from "@oxlint/plugins";
+import { defineRule as defineRule11 } from "@oxlint/plugins";
 function isTypeAssertionExpression(node) {
   return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
 }
@@ -595,7 +744,7 @@ function isForbiddenAssertionChain(node) {
   }
   return assertionCount > 1 && hasNonConstAssertion;
 }
-var noChainedTypeAssertionsRule = defineRule9({
+var noChainedTypeAssertionsRule = defineRule11({
   meta: {
     type: "problem",
     docs: {
@@ -619,7 +768,7 @@ var noChainedTypeAssertionsRule = defineRule9({
 });
 
 // vendor/anti-slop/src/rules/no-conditional-empty-object-spread.ts
-import { defineRule as defineRule10 } from "@oxlint/plugins";
+import { defineRule as defineRule12 } from "@oxlint/plugins";
 function unwrapParentheses(node) {
   let current = node;
   while (current.type === "ParenthesizedExpression") {
@@ -634,7 +783,7 @@ function isConditionalEmptyObjectSpread(node) {
   const conditional = unwrapParentheses(node);
   return conditional.type === "ConditionalExpression" && (isEmptyObjectExpression(conditional.consequent) || isEmptyObjectExpression(conditional.alternate));
 }
-var noConditionalEmptyObjectSpreadRule = defineRule10({
+var noConditionalEmptyObjectSpreadRule = defineRule12({
   meta: {
     type: "suggestion",
     docs: {
@@ -658,7 +807,7 @@ var noConditionalEmptyObjectSpreadRule = defineRule10({
 });
 
 // vendor/anti-slop/src/rules/no-known-value-widening.ts
-import { defineRule as defineRule11 } from "@oxlint/plugins";
+import { defineRule as defineRule13 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/shared/lexical-type-parameters.ts
 function isNode(value) {
@@ -1187,18 +1336,6 @@ function functionParameterBindingName(parameter, sourceCode) {
   return annotationStart === undefined ? sourceText : sourceText.slice(0, annotationStart - parameter.start).trimEnd();
 }
 
-// vendor/anti-slop/src/shared/scope.ts
-function resolveVariable2(sourceCode, identifier) {
-  let scope = sourceCode.getScope(identifier);
-  while (scope !== null) {
-    const variable = scope.set.get(identifier.name);
-    if (variable !== undefined)
-      return variable;
-    scope = scope.upper;
-  }
-  return null;
-}
-
 // vendor/anti-slop/src/rules/no-known-value-widening.ts
 function unwrapExpression(expression) {
   let current = expression;
@@ -1222,7 +1359,7 @@ function hasKnownEvidence(sourceCode, expression, visitedVariables = new Set) {
   const unwrapped = unwrapExpression(expression);
   if (unwrapped.type !== "Identifier")
     return false;
-  const variable = resolveVariable2(sourceCode, unwrapped);
+  const variable = resolveVariable(sourceCode, unwrapped);
   if (variable === null || visitedVariables.has(variable))
     return false;
   const declarator = variableDeclarator(variable);
@@ -1241,7 +1378,7 @@ function localFunctionForCall(sourceCode, callee) {
     return unwrapped;
   if (unwrapped.type !== "Identifier")
     return null;
-  const variable = resolveVariable2(sourceCode, unwrapped);
+  const variable = resolveVariable(sourceCode, unwrapped);
   if (variable === null || variable.defs.length !== 1)
     return null;
   const [definition] = variable.defs;
@@ -1294,7 +1431,7 @@ function hasKnownCallArgumentEvidence(sourceCode, expression, environment, visit
   }
   if (expression.type !== "Identifier")
     return isKnownEvidenceExpression(expression);
-  const variable = resolveVariable2(sourceCode, expression);
+  const variable = resolveVariable(sourceCode, expression);
   if (variable === null || visitedVariables.has(variable))
     return false;
   const annotation = variableTypeAnnotation(sourceCode, variable);
@@ -1359,7 +1496,7 @@ function isDictionaryAccumulatorTarget(destination) {
 function hasParentAssertion(node) {
   return node.parent?.type === "TSAsExpression" || node.parent?.type === "TSTypeAssertion";
 }
-var noKnownValueWideningRule = defineRule11({
+var noKnownValueWideningRule = defineRule13({
   meta: {
     type: "problem",
     docs: {
@@ -1408,7 +1545,7 @@ var noKnownValueWideningRule = defineRule11({
       AssignmentExpression(node) {
         if (node.operator !== "=" || node.left.type !== "Identifier")
           return;
-        const variable = resolveVariable2(context.sourceCode, node.left);
+        const variable = resolveVariable(context.sourceCode, node.left);
         if (variable === null)
           return;
         const declarator = variableDeclarator(variable);
@@ -1472,7 +1609,7 @@ var noKnownValueWideningRule = defineRule11({
 });
 
 // vendor/anti-slop/src/rules/no-module-mocking.ts
-import { defineRule as defineRule12 } from "@oxlint/plugins";
+import { defineRule as defineRule14 } from "@oxlint/plugins";
 var moduleMockMethods = new Set(["doMock", "mock", "unstable_mockModule"]);
 function importedName(node) {
   if (node.type !== "ImportSpecifier")
@@ -1485,7 +1622,7 @@ function isTestFrameworkObject(sourceCode, expression) {
   if ((expression.name === "vi" || expression.name === "jest") && sourceCode.isGlobalReference(expression)) {
     return true;
   }
-  const variable = resolveVariable2(sourceCode, expression);
+  const variable = resolveVariable(sourceCode, expression);
   if (variable === null || variable.defs.length === 0) {
     return expression.name === "vi" || expression.name === "jest";
   }
@@ -1507,7 +1644,7 @@ function moduleMockCall(sourceCode, callee) {
   const method = callee.computed ? property.type === "Literal" && (property.value === "doMock" || property.value === "mock" || property.value === "unstable_mockModule") ? property.value : null : property.type === "Identifier" ? property.name : null;
   return method !== null && moduleMockMethods.has(method);
 }
-var noModuleMockingRule = defineRule12({
+var noModuleMockingRule = defineRule14({
   meta: {
     type: "problem",
     docs: {
@@ -1531,8 +1668,8 @@ var noModuleMockingRule = defineRule12({
 });
 
 // vendor/anti-slop/src/rules/no-object-parameters.ts
-import { defineRule as defineRule13 } from "@oxlint/plugins";
-var noObjectParametersRule = defineRule13({
+import { defineRule as defineRule15 } from "@oxlint/plugins";
+var noObjectParametersRule = defineRule15({
   meta: {
     type: "problem",
     docs: {
@@ -1585,7 +1722,7 @@ var noObjectParametersRule = defineRule13({
 });
 
 // vendor/anti-slop/src/rules/no-reflect-apply.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
+import { defineRule as defineRule16 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/shared/reflect-method.ts
 function isGlobalReflect(sourceCode, expression) {
@@ -1593,7 +1730,7 @@ function isGlobalReflect(sourceCode, expression) {
     return false;
   if (sourceCode.isGlobalReference(expression))
     return true;
-  const variable = resolveVariable2(sourceCode, expression);
+  const variable = resolveVariable(sourceCode, expression);
   return variable === null || variable.defs.length === 0;
 }
 function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
@@ -1606,7 +1743,7 @@ function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
 }
 
 // vendor/anti-slop/src/rules/no-reflect-apply.ts
-var noReflectApplyRule = defineRule14({
+var noReflectApplyRule = defineRule16({
   meta: {
     type: "problem",
     docs: {
@@ -1630,8 +1767,8 @@ var noReflectApplyRule = defineRule14({
 });
 
 // vendor/anti-slop/src/rules/no-reflect-get.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
-var noReflectGetRule = defineRule15({
+import { defineRule as defineRule17 } from "@oxlint/plugins";
+var noReflectGetRule = defineRule17({
   meta: {
     type: "problem",
     docs: {
@@ -1655,7 +1792,7 @@ var noReflectGetRule = defineRule15({
 });
 
 // vendor/anti-slop/src/rules/no-runtime-typeof.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
+import { defineRule as defineRule18 } from "@oxlint/plugins";
 function isRuntimeFunction(node) {
   return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
 }
@@ -1678,7 +1815,7 @@ function isExistenceProbe(node) {
   const other = parent.left === node ? parent.right : parent.left;
   return other.type === "Literal" && other.value === "undefined";
 }
-var noRuntimeTypeofRule = defineRule16({
+var noRuntimeTypeofRule = defineRule18({
   meta: {
     type: "problem",
     docs: {
@@ -1712,7 +1849,7 @@ var noRuntimeTypeofRule = defineRule16({
 });
 
 // vendor/anti-slop/src/rules/no-shape-in-symbol-names.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
+import { defineRule as defineRule19 } from "@oxlint/plugins";
 var FORBIDDEN_SYMBOL_NAME = "shape";
 function containsForbiddenSymbolName(name) {
   return name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME);
@@ -1723,7 +1860,7 @@ function isBorrowedMemberName(node) {
     return false;
   return parent.property === node && parent.computed === false;
 }
-var noForbiddenTermInSymbolNamesRule = defineRule17({
+var noForbiddenTermInSymbolNamesRule = defineRule19({
   meta: {
     type: "problem",
     docs: {
@@ -1752,12 +1889,12 @@ var noForbiddenTermInSymbolNamesRule = defineRule17({
 });
 
 // vendor/anti-slop/src/rules/no-unknown-parameters.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
+import { defineRule as defineRule20 } from "@oxlint/plugins";
 function isTypePredicateSubject(owner, parameterName) {
   const predicate = owner.returnType?.typeAnnotation;
   return predicate?.type === "TSTypePredicate" && predicate.parameterName.type === "Identifier" && predicate.parameterName.name === parameterName;
 }
-var noUnknownParametersRule = defineRule18({
+var noUnknownParametersRule = defineRule20({
   meta: {
     type: "problem",
     docs: {
@@ -1801,8 +1938,8 @@ var noUnknownParametersRule = defineRule18({
 });
 
 // vendor/anti-slop/src/rules/no-unknown-returns.ts
-import { defineRule as defineRule19 } from "@oxlint/plugins";
-var noUnknownReturnsRule = defineRule19({
+import { defineRule as defineRule21 } from "@oxlint/plugins";
+var noUnknownReturnsRule = defineRule21({
   meta: {
     type: "problem",
     docs: {
@@ -1855,8 +1992,8 @@ var noUnknownReturnsRule = defineRule19({
 });
 
 // vendor/anti-slop/src/rules/no-unknown-type-aliases.ts
-import { defineRule as defineRule20 } from "@oxlint/plugins";
-var noUnknownTypeAliasesRule = defineRule20({
+import { defineRule as defineRule22 } from "@oxlint/plugins";
+var noUnknownTypeAliasesRule = defineRule22({
   meta: {
     type: "problem",
     docs: {
@@ -1894,7 +2031,7 @@ var noUnknownTypeAliasesRule = defineRule20({
 });
 
 // vendor/anti-slop/src/rules/no-unsafe-dictionary-type.ts
-import { defineRule as defineRule21 } from "@oxlint/plugins";
+import { defineRule as defineRule23 } from "@oxlint/plugins";
 var typeNodeKinds = new Set([
   "JSDocNonNullableType",
   "JSDocNullableType",
@@ -1981,7 +2118,7 @@ function shouldReportType(node, environment) {
   }
   return true;
 }
-var noUnsafeDictionaryTypeRule = defineRule21({
+var noUnsafeDictionaryTypeRule = defineRule23({
   meta: {
     type: "problem",
     docs: {
@@ -2023,7 +2160,7 @@ var noUnsafeDictionaryTypeRule = defineRule21({
 });
 
 // vendor/anti-slop/src/rules/no-widen-then-assert.ts
-import { defineRule as defineRule22 } from "@oxlint/plugins";
+import { defineRule as defineRule24 } from "@oxlint/plugins";
 var functionBoundaryTypes = new Set([
   "ArrowFunctionExpression",
   "FunctionDeclaration",
@@ -2219,7 +2356,7 @@ function assertionIsNarrower(sourceText, broadKind, evidence, assertedType) {
     return isDefinitelyObjectType(assertedType);
   return isDefinitelyNarrowerRecordType(assertedType);
 }
-var noWidenThenAssertRule = defineRule22({
+var noWidenThenAssertRule = defineRule24({
   meta: {
     type: "problem",
     docs: {
@@ -2781,7 +2918,7 @@ var requireReadableSpacingRule = {
 };
 
 // vendor/anti-slop/src/rules/require-safety-comment-for-type-assertion.ts
-import { defineRule as defineRule23 } from "@oxlint/plugins";
+import { defineRule as defineRule25 } from "@oxlint/plugins";
 var DEFAULT_SAFETY_MARKERS = ["SAFETY"];
 var commentOwnerKinds = new Set([
   "ExpressionStatement",
@@ -2824,7 +2961,7 @@ function hasSafetyComment(sourceCode, node, pattern) {
     current = current.parent;
   }
 }
-var requireSafetyCommentForTypeAssertionRule = defineRule23({
+var requireSafetyCommentForTypeAssertionRule = defineRule25({
   meta: {
     type: "problem",
     docs: {
@@ -2901,42 +3038,277 @@ var src_default = antiSlopPlugin;
 // src/generic/index.ts
 import { eslintCompatPlugin as eslintCompatPlugin4 } from "@oxlint/plugins";
 
-// src/generic/rules/prefer-event-parameter-type.ts
-import { defineRule as defineRule24 } from "@oxlint/plugins";
-function nearestEnclosingFunction2(node) {
-  let current = node.parent;
-  while (current) {
-    if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") {
-      return current;
+// src/generic/rules/no-explicit-inferable-type-predicate.ts
+import { defineRule as defineRule26 } from "@oxlint/plugins";
+function isNamed(node, name) {
+  return node.type === "Identifier" && node.name === name;
+}
+function isNullish(node) {
+  return node.type === "Literal" && node.value === null || isNamed(node, "undefined");
+}
+function isNullishExclusion(node, name) {
+  return node.type === "BinaryExpression" && (node.operator === "!==" || node.operator === "!=") && (isNamed(node.left, name) && isNullish(node.right) || isNullish(node.left) && isNamed(node.right, name));
+}
+function isTypeofCheck(node, name) {
+  if (node.type !== "BinaryExpression" || node.operator !== "===" && node.operator !== "==") {
+    return false;
+  }
+  const isTypeof = (side) => side.type === "UnaryExpression" && side.operator === "typeof" && isNamed(side.argument, name);
+  const isLiteral = (side) => side.type === "Literal";
+  return isTypeof(node.left) && isLiteral(node.right) || isLiteral(node.left) && isTypeof(node.right);
+}
+function isInferableCheck(node, name) {
+  if (node.type === "LogicalExpression") {
+    return node.operator === "&&" && isNullishExclusion(node.left, name) && isNullishExclusion(node.right, name);
+  }
+  return isNullishExclusion(node, name) || isTypeofCheck(node, name) || node.type === "BinaryExpression" && node.operator === "instanceof" && isNamed(node.left, name);
+}
+function returnedExpression(owner) {
+  const body = owner.body;
+  if (!body)
+    return null;
+  if (body.type !== "BlockStatement")
+    return body;
+  const [statement] = body.body;
+  return body.body.length === 1 && statement?.type === "ReturnStatement" ? statement.argument : null;
+}
+function isPublicSignature(owner) {
+  const parent = owner.parent;
+  if (parent.type === "MethodDefinition" || parent.type === "ExportNamedDeclaration" || parent.type === "ExportDefaultDeclaration") {
+    return true;
+  }
+  return parent.type === "VariableDeclarator" && parent.parent.parent?.type === "ExportNamedDeclaration";
+}
+var noExplicitInferableTypePredicateRule = defineRule26({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow explicit type predicates on simple null, typeof, or instanceof checks that TypeScript 5.5+ infers."
+    },
+    messages: {
+      removeTypePredicate: "TypeScript infers the type predicate for `{{parameter}}` from this check, while an explicit predicate is never checked against the body. Remove the annotation and rely on the inferred predicate."
     }
-    current = current.parent;
+  },
+  create(context) {
+    const check = (owner) => {
+      const annotation = owner.returnType?.typeAnnotation;
+      if (annotation?.type !== "TSTypePredicate" || annotation.asserts || annotation.parameterName.type !== "Identifier" || isPublicSignature(owner)) {
+        return;
+      }
+      const parameter = annotation.parameterName.name;
+      const expression = returnedExpression(owner);
+      if (!owner.params.some((param) => isNamed(param, parameter)) || !expression || !isInferableCheck(expression, parameter)) {
+        return;
+      }
+      context.report({
+        node: annotation,
+        messageId: "removeTypePredicate",
+        data: { parameter }
+      });
+    };
+    return {
+      ArrowFunctionExpression: check,
+      FunctionDeclaration: check,
+      FunctionExpression: check
+    };
+  }
+});
+
+// src/generic/rules/no-unchecked-query-selector-type.ts
+import { defineRule as defineRule27 } from "@oxlint/plugins";
+
+// src/shared/json.ts
+function jsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+
+// src/shared/lit.ts
+var renderRoots = new Set(["renderRoot", "shadowRoot"]);
+function litElementBaseClasses(settings) {
+  const configured = jsonObject(settings.lit)?.elementBaseClasses;
+  return new Set([
+    "LitElement",
+    ...Array.isArray(configured) ? configured.map(String) : []
+  ]);
+}
+function isWrapperExpression(node) {
+  return node?.type === "ChainExpression" || node?.type === "ParenthesizedExpression" || node?.type === "TSAsExpression" || node?.type === "TSNonNullExpression" || node?.type === "TSSatisfiesExpression" || node?.type === "TSTypeAssertion";
+}
+function unwrapExpression2(node) {
+  let current = node;
+  while (isWrapperExpression(current))
+    current = current.expression;
+  return current;
+}
+function extendsLitBase(node, bases) {
+  if (node.type === "Identifier")
+    return bases.has(node.name);
+  return node.type === "CallExpression" && node.arguments.some((argument) => extendsLitBase(argument, bases));
+}
+function isLitClass(node, bases) {
+  const hasCustomElementDecorator = node.decorators.some((decorator) => decorator.expression.type === "CallExpression" && decorator.expression.callee.type === "Identifier" && decorator.expression.callee.name === "customElement");
+  return hasCustomElementDecorator || node.superClass !== null && extendsLitBase(node.superClass, bases);
+}
+function classOfBody(body) {
+  const owner = body.parent;
+  return owner?.type === "ClassDeclaration" || owner?.type === "ClassExpression" ? owner : null;
+}
+function thisClass(node) {
+  let current = node;
+  while (current.parent) {
+    const parent = current.parent;
+    if (parent.type === "FunctionDeclaration" || parent.type === "FunctionExpression") {
+      const owner = parent.parent;
+      return (owner?.type === "MethodDefinition" || owner?.type === "TSAbstractMethodDefinition") && !owner.static && owner.value === parent ? classOfBody(owner.parent) : null;
+    }
+    if ((parent.type === "PropertyDefinition" || parent.type === "AccessorProperty") && parent.value === current) {
+      return parent.static ? null : classOfBody(parent.parent);
+    }
+    if (parent.type === "StaticBlock" || parent.type === "ClassBody" || parent.type === "Program") {
+      return null;
+    }
+    current = parent;
   }
   return null;
 }
-function assertedEventParameter(node) {
-  const expression = node.expression;
-  if (expression.type !== "MemberExpression" || expression.computed || expression.object.type !== "Identifier" || expression.property.type !== "Identifier" || expression.property.name !== "currentTarget" && expression.property.name !== "target") {
+function isStaticSelector(node) {
+  return node?.type === "Literal" || node?.type === "TemplateLiteral" && node.expressions.length === 0;
+}
+function renderRootQuery(node, bases) {
+  const method = staticMemberName(node.callee);
+  if (method !== "querySelector" && method !== "querySelectorAll" || node.callee.type !== "MemberExpression" || !isStaticSelector(node.arguments[0])) {
     return null;
   }
-  const parameterName = expression.object.name;
-  const property = expression.property.name;
-  const owner = nearestEnclosingFunction2(node);
-  if (!owner?.params.some((parameter) => parameter.type === "Identifier" && parameter.name === parameterName)) {
+  const receiver = unwrapExpression2(node.callee.object);
+  const root = staticMemberName(receiver);
+  if (!root || !renderRoots.has(root) || receiver.type !== "MemberExpression" || receiver.object.type !== "ThisExpression") {
+    return null;
+  }
+  const owner = thisClass(receiver.object);
+  return owner && isLitClass(owner, bases) ? { method, root } : null;
+}
+function isAssignedMethod(name) {
+  return name === "assignedElements" || name === "assignedNodes";
+}
+function feedsAssignedCall(node) {
+  let current = node;
+  while (isWrapperExpression(current.parent))
+    current = current.parent;
+  const member = current.parent;
+  return member?.type === "MemberExpression" && member.object === current && isAssignedMethod(staticMemberName(member));
+}
+function litQueryDecoratorCall(node, bases) {
+  const method = staticMemberName(node.callee);
+  if (!isAssignedMethod(method)) {
+    return feedsAssignedCall(node) ? null : renderRootQuery(node, bases);
+  }
+  if (node.callee.type !== "MemberExpression")
+    return null;
+  const inner = unwrapExpression2(node.callee.object);
+  if (inner.type !== "CallExpression")
+    return null;
+  const query = renderRootQuery(inner, bases);
+  return query?.method === "querySelector" ? { method, root: query.root } : null;
+}
+function isLitRenderRootQuery(node, bases) {
+  return renderRootQuery(node, bases) !== null;
+}
+
+// src/generic/rules/no-unchecked-query-selector-type.ts
+var queryMethods = new Set(["closest", "querySelector", "querySelectorAll"]);
+var noUncheckedQuerySelectorTypeRule = defineRule27({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow type arguments on `querySelector`, `querySelectorAll`, and `closest`, which cast the result without checking it."
+    },
+    messages: {
+      checkQueryResult: "`{{method}}<T>` casts the result without checking it. Check it with `instanceof`, use a checked lookup helper, or query a tag name so TypeScript infers the element type."
+    }
+  },
+  create(context) {
+    const bases = litElementBaseClasses(context.settings);
+    return {
+      CallExpression(node) {
+        const method = staticMemberName(node.callee);
+        if (!node.typeArguments || !method || !queryMethods.has(method) || isLitRenderRootQuery(node, bases)) {
+          return;
+        }
+        context.report({
+          node: node.typeArguments,
+          messageId: "checkQueryResult",
+          data: { method }
+        });
+      }
+    };
+  }
+});
+
+// src/generic/rules/no-untyped-custom-event.ts
+import { defineRule as defineRule28 } from "@oxlint/plugins";
+var noUntypedCustomEventRule = defineRule28({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow `CustomEvent` type references without a detail type, which leave `detail` as `any`."
+    },
+    messages: {
+      typeCustomEventDetail: "`CustomEvent` without a type argument leaves `detail` as `any`. Reuse the project's typed event helper if one fits, or add one, instead of a bare `CustomEvent`."
+    }
+  },
+  create(context) {
+    return {
+      TSTypeReference(node) {
+        if (node.typeName.type !== "Identifier" || node.typeName.name !== "CustomEvent" || node.typeArguments) {
+          return;
+        }
+        context.report({ node, messageId: "typeCustomEventDetail" });
+      }
+    };
+  }
+});
+
+// src/generic/rules/prefer-event-parameter-type.ts
+import { defineRule as defineRule29 } from "@oxlint/plugins";
+function staticMemberPath(node) {
+  const path = [];
+  let current = node.type === "ChainExpression" ? node.expression : node;
+  while (current.type === "MemberExpression") {
+    if (current.computed || current.property.type !== "Identifier") {
+      return null;
+    }
+    path.unshift(current.property.name);
+    current = current.object;
+  }
+  return current.type === "Identifier" && path.length > 0 ? { root: current.name, path } : null;
+}
+function isEventMemberPath(path) {
+  const [first] = path;
+  if (first === "detail")
+    return true;
+  return path.length === 1 && (first === "currentTarget" || first === "target");
+}
+function assertedEventParameter(node) {
+  const member = staticMemberPath(node.expression);
+  if (!member || !isEventMemberPath(member.path))
+    return null;
+  const owner = nearestEnclosingFunction(node);
+  if (!owner?.params.some((parameter) => parameter.type === "Identifier" && parameter.name === member.root)) {
     return null;
   }
   return {
-    parameter: parameterName,
-    property
+    parameter: member.root,
+    property: member.path.join(".")
   };
 }
-var preferEventParameterTypeRule = defineRule24({
+var preferEventParameterTypeRule = defineRule29({
   meta: {
     type: "suggestion",
     docs: {
-      description: "Prefer typing event target properties in the handler parameter instead of asserting them at use sites."
+      description: "Prefer typing event target and detail properties in the handler parameter instead of asserting them at use sites."
     },
     messages: {
-      typeEventParameter: "Type `{{parameter}}.{{property}}` in the function signature instead of asserting it at the use site."
+      typeEventParameter: "Type `{{parameter}}.{{property}}` in the function signature instead of asserting it at the use site. Reuse the project's typed event helper if one fits, or add one."
     }
   },
   create(context) {
@@ -2957,9 +3329,69 @@ var preferEventParameterTypeRule = defineRule24({
   }
 });
 
+// src/generic/rules/prefer-lit-query-decorators.ts
+import { defineRule as defineRule30 } from "@oxlint/plugins";
+var messageIds = {
+  assignedElements: "preferQueryAssignedElements",
+  assignedNodes: "preferQueryAssignedNodes",
+  querySelector: "preferQuery",
+  querySelectorAll: "preferQueryAll"
+};
+var preferLitQueryDecoratorsRule = defineRule30({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Require Lit query decorators instead of static render-root queries in Lit elements."
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          querySelector: { type: "boolean" },
+          querySelectorAll: { type: "boolean" },
+          assignedElements: { type: "boolean" },
+          assignedNodes: { type: "boolean" }
+        },
+        additionalProperties: false
+      }
+    ],
+    defaultOptions: [
+      {
+        querySelector: true,
+        querySelectorAll: true,
+        assignedElements: true,
+        assignedNodes: true
+      }
+    ],
+    messages: {
+      preferQuery: "Use the @query decorator instead of this.{{root}}.querySelector().",
+      preferQueryAll: "Use the @queryAll decorator instead of this.{{root}}.querySelectorAll().",
+      preferQueryAssignedElements: "Use the @queryAssignedElements decorator instead of this.{{root}}.querySelector().assignedElements().",
+      preferQueryAssignedNodes: "Use the @queryAssignedNodes decorator instead of this.{{root}}.querySelector().assignedNodes()."
+    }
+  },
+  create(context) {
+    const bases = litElementBaseClasses(context.settings);
+    const options = jsonObject(context.options[0]);
+    const disabled = new Set(options ? Object.keys(options).filter((method) => options[method] === false) : []);
+    return {
+      CallExpression(node) {
+        const query = litQueryDecoratorCall(node, bases);
+        if (!query || disabled.has(query.method))
+          return;
+        context.report({
+          node,
+          messageId: messageIds[query.method],
+          data: { root: query.root }
+        });
+      }
+    };
+  }
+});
+
 // src/generic/rules/prefer-types-over-assertions.ts
-import { defineRule as defineRule25 } from "@oxlint/plugins";
-var preferTypesOverAssertionsRule = defineRule25({
+import { defineRule as defineRule31 } from "@oxlint/plugins";
+var preferTypesOverAssertionsRule = defineRule31({
   meta: {
     type: "problem",
     docs: {
@@ -2971,7 +3403,7 @@ var preferTypesOverAssertionsRule = defineRule25({
   },
   create(context) {
     const checkAssertion = (node) => {
-      if (node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const") {
+      if (node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const" || assertedEventParameter(node)) {
         return;
       }
       context.report({ node, messageId: "avoidAssertion" });
@@ -2987,7 +3419,11 @@ var preferTypesOverAssertionsRule = defineRule25({
 var timmoPlugin = eslintCompatPlugin4({
   meta: { name: "timmo" },
   rules: {
+    "no-explicit-inferable-type-predicate": noExplicitInferableTypePredicateRule,
+    "no-unchecked-query-selector-type": noUncheckedQuerySelectorTypeRule,
+    "no-untyped-custom-event": noUntypedCustomEventRule,
     "prefer-event-parameter-type": preferEventParameterTypeRule,
+    "prefer-lit-query-decorators": preferLitQueryDecoratorsRule,
     "prefer-types-over-assertions": preferTypesOverAssertionsRule
   }
 });
@@ -3005,7 +3441,11 @@ var recommended = defineConfig({
   rules: {
     ...enablePluginRules("anti-slop", src_default),
     ...enablePluginRules("timmo", generic_default),
-    "anti-slop/require-safety-comment-for-type-assertion": "off"
+    "anti-slop/require-safety-comment-for-type-assertion": "off",
+    "typescript/no-non-null-assertion": "error",
+    "typescript/no-unnecessary-type-arguments": "error",
+    "typescript/no-unnecessary-type-assertion": "error",
+    "typescript/no-unnecessary-type-parameters": "error"
   }
 });
 var recommended_default = recommended;