@timmo001/oxlint-rules 0.3.0 → 0.3.2

package/dist/configs/recommended-effect.js

@@ -1,8 +1,566 @@
-// vendor/anti-slop/src/index.ts
+// node_modules/oxlint/dist/index.js
+function defineConfig(config) {
+  return config;
+}
+
+// src/effect/index.ts
 import { eslintCompatPlugin } from "@oxlint/plugins";
 
+// src/effect/rules/no-try-catch-in-effect-generators.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;
+}
+function nearestEnclosingFunction(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+function staticMemberName(node) {
+  if (node.type !== "MemberExpression" || node.computed)
+    return null;
+  return node.property.type === "Identifier" ? node.property.name : null;
+}
+function isEffectImport(sourceCode, identifier, namespace) {
+  const variable = resolveVariable(sourceCode, identifier);
+  return variable?.defs.some((definition) => {
+    if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration" || definition.parent.source.value !== "effect") {
+      return false;
+    }
+    if (namespace)
+      return definition.node.type === "ImportNamespaceSpecifier";
+    if (definition.node.type !== "ImportSpecifier")
+      return false;
+    const imported = definition.node.imported;
+    return (imported.type === "Identifier" ? imported.name : imported.value) === "Effect";
+  }) ?? false;
+}
+function isEffectMethod(sourceCode, node, method) {
+  if (staticMemberName(node) !== method || node.type !== "MemberExpression") {
+    return false;
+  }
+  const object = node.object;
+  if (object.type === "Identifier") {
+    return isEffectImport(sourceCode, object, false);
+  }
+  if (staticMemberName(object) !== "Effect" || object.type !== "MemberExpression" || object.object.type !== "Identifier") {
+    return false;
+  }
+  return isEffectImport(sourceCode, object.object, true);
+}
+function isDirectArgument(owner, call) {
+  return call.arguments.some((argument) => argument === owner);
+}
+function isRecognisedEffectGenerator(sourceCode, owner) {
+  const parent = owner.parent;
+  if (parent.type !== "CallExpression" || !isDirectArgument(owner, parent)) {
+    return false;
+  }
+  if (isEffectMethod(sourceCode, parent.callee, "gen"))
+    return true;
+  const factoryCall = parent.callee;
+  return factoryCall.type === "CallExpression" && isEffectMethod(sourceCode, factoryCall.callee, "fn");
+}
+var noTryCatchInEffectGeneratorsRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow synchronous try/catch owned by recognised Effect generator callbacks."
+    },
+    messages: {
+      useEffectErrorChannel: "Keep expected failures in the Effect error channel. Use Effect.try for synchronous throwing work, Effect.tryPromise for asynchronous throwing work, Effect-returning schema APIs for decoding, and Effect recovery combinators for recovery."
+    }
+  },
+  create(context) {
+    return {
+      TryStatement(node) {
+        if (!node.handler)
+          return;
+        const owner = nearestEnclosingFunction(node);
+        if (!owner?.generator || !isRecognisedEffectGenerator(context.sourceCode, owner)) {
+          return;
+        }
+        context.report({ node, messageId: "useEffectErrorChannel" });
+      }
+    };
+  }
+});
+
+// src/effect/index.ts
+var timmoEffectPlugin = eslintCompatPlugin({
+  meta: { name: "timmo-effect" },
+  rules: {
+    "no-try-catch-in-effect-generators": noTryCatchInEffectGeneratorsRule
+  }
+});
+var effect_default = timmoEffectPlugin;
+
+// vendor/anti-slop/src/effect/index.ts
+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";
+
+// vendor/anti-slop/src/effect/shared/tagged-values.ts
+var equalityOperators = new Set(["==", "===", "!=", "!=="]);
+var broadEffectCatchMethods = new Set(["catch", "catchAll", "catchIf"]);
+var isStringLiteral = (node) => node?.type === "Literal" && typeof node.value === "string";
+var isTagMember = (node) => node?.type === "MemberExpression" && (!node.computed && node.property.type === "Identifier" && node.property.name === "_tag" || node.computed && isStringLiteral(node.property) && node.property.value === "_tag");
+var tagMemberFromComparison = (node) => {
+  if (!equalityOperators.has(node.operator))
+    return;
+  if (isTagMember(node.left) && isStringLiteral(node.right))
+    return node.left;
+  if (isTagMember(node.right) && isStringLiteral(node.left))
+    return node.right;
+  return;
+};
+var isBroadEffectCatchCall = (node) => node?.type === "CallExpression" && node.callee.type === "MemberExpression" && node.callee.object.type === "Identifier" && node.callee.object.name === "Effect" && !node.callee.computed && node.callee.property.type === "Identifier" && broadEffectCatchMethods.has(node.callee.property.name);
+var isInsideBroadEffectHandler = (node) => {
+  let current = node.parent;
+  while (current !== null && current !== undefined) {
+    if (current.type === "ArrowFunctionExpression" || current.type === "FunctionExpression") {
+      return isBroadEffectCatchCall(current.parent) && current.parent.arguments.includes(current);
+    }
+    current = current.parent;
+  }
+  return false;
+};
+var isReasonTagMember = (node) => node.object.type === "MemberExpression" && (!node.object.computed && node.object.property.type === "Identifier" && node.object.property.name === "reason" || node.object.computed && isStringLiteral(node.object.property) && node.object.property.value === "reason");
+var propertyName = (property) => {
+  if (!property.computed && property.key.type === "Identifier") {
+    return property.key.name;
+  }
+  if (property.key.type === "Literal" && typeof property.key.value === "string") {
+    return property.key.value;
+  }
+  return;
+};
+var isMatchPatternObject = (node) => {
+  const call = node.parent;
+  if (call?.type !== "CallExpression" || !call.arguments.includes(node)) {
+    return false;
+  }
+  const callee = call.callee;
+  return callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "Match" && !callee.computed && callee.property.type === "Identifier" && (callee.property.name === "when" || callee.property.name === "not");
+};
+
+// vendor/anti-slop/src/effect/rules/no-manual-effect-error-tag.ts
+var noManualEffectErrorTagRule = defineRule2({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Use Effect tagged error handlers instead of manually branching on `_tag` in a catch handler."
+    },
+    messages: {
+      tag: "Use Effect.catchTag or Effect.catchTags instead of manually discriminating a tagged error in a broad Effect catch handler.",
+      reason: "Use Effect.catchReason or Effect.catchReasons instead of manually discriminating a tagged `reason` in a broad Effect catch handler."
+    }
+  },
+  createOnce(context) {
+    return {
+      BinaryExpression(node) {
+        const tagMember = tagMemberFromComparison(node);
+        if (tagMember === undefined || !isInsideBroadEffectHandler(node)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: isReasonTagMember(tagMember) ? "reason" : "tag"
+        });
+      },
+      SwitchStatement(node) {
+        if (!isTagMember(node.discriminant) || !isInsideBroadEffectHandler(node)) {
+          return;
+        }
+        context.report({
+          node,
+          messageId: isReasonTagMember(node.discriminant) ? "reason" : "tag"
+        });
+      }
+    };
+  }
+});
+
+// vendor/anti-slop/src/effect/rules/no-manual-tag-comparison.ts
+import { defineRule as defineRule3 } from "@oxlint/plugins";
+var noManualTagComparisonRule = defineRule3({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Use Effect Match or Predicate helpers instead of manually branching on `_tag`."
+    },
+    messages: {
+      manualComparison: "Use Match.tag/Match.tags for tagged-value branching, or Predicate.isTagged for a simple reusable predicate.",
+      manualSwitch: "Use Match.value(value).pipe(Match.tag/Match.tags/Match.tagsExhaustive) or the tagged enum `$match` helper instead of switching on `_tag`."
+    }
+  },
+  createOnce(context) {
+    return {
+      BinaryExpression(node) {
+        if (tagMemberFromComparison(node) === undefined || isInsideBroadEffectHandler(node)) {
+          return;
+        }
+        context.report({ node, messageId: "manualComparison" });
+      },
+      SwitchStatement(node) {
+        if (!isTagMember(node.discriminant) || isInsideBroadEffectHandler(node)) {
+          return;
+        }
+        context.report({ node, messageId: "manualSwitch" });
+      }
+    };
+  }
+});
+
+// vendor/anti-slop/src/effect/rules/no-manual-tagged-construction.ts
+import { defineRule as defineRule4 } from "@oxlint/plugins";
+var noManualTaggedConstructionRule = defineRule4({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Construct tagged values with their existing Effect constructor instead of writing `_tag` manually."
+    },
+    messages: {
+      manualConstruction: "Use the existing Schema tagged `.make`, tagged class/error constructor, or Data.taggedEnum variant constructor instead of writing a literal `_tag` object."
+    }
+  },
+  createOnce(context) {
+    return {
+      ObjectExpression(node) {
+        if (isMatchPatternObject(node))
+          return;
+        const tag = node.properties.find((property) => property.type === "Property" && propertyName(property) === "_tag" && isStringLiteral(property.value));
+        if (tag !== undefined) {
+          context.report({ node: tag, messageId: "manualConstruction" });
+        }
+      }
+    };
+  }
+});
+
+// vendor/anti-slop/src/effect/rules/no-service-constructor-imports.ts
+import { defineRule as defineRule5 } from "@oxlint/plugins";
+var SERVICE_CONSTRUCTOR_NAME = /^make[A-Z]/u;
+var TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/u;
+function isProjectLocalImport(source) {
+  return source.startsWith("./") || source.startsWith("../");
+}
+function getImportedName(specifier) {
+  if (specifier.imported.type === "Identifier")
+    return specifier.imported.name;
+  return specifier.imported.value;
+}
+var noServiceConstructorImportsRule = defineRule5({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow project-local make<CapabilityName> imports 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.'
+    }
+  },
+  create(context) {
+    const isTestFile = TEST_FILE.test(context.filename.replaceAll("\\", "/"));
+    return {
+      ImportDeclaration(node) {
+        if (isTestFile || !isProjectLocalImport(node.source.value))
+          return;
+        for (const specifier of node.specifiers) {
+          if (specifier.type !== "ImportSpecifier")
+            continue;
+          const importedName = getImportedName(specifier);
+          if (!SERVICE_CONSTRUCTOR_NAME.test(importedName))
+            continue;
+          context.report({
+            node: specifier,
+            messageId: "serviceConstructorImport",
+            data: { name: importedName }
+          });
+        }
+      }
+    };
+  }
+});
+
+// vendor/anti-slop/src/effect/rules/prefer-effect-match.ts
+import { defineRule as defineRule6 } from "@oxlint/plugins";
+var equalityOperators2 = new Set(["==", "===", "!=", "!=="]);
+var preferEffectMatchRule = defineRule6({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Use Match from Effect for chained literal ternaries over the same value."
+    },
+    messages: {
+      preferMatch: "Use Match from Effect instead of a chained literal ternary."
+    }
+  },
+  createOnce(context) {
+    const isLiteral = (node) => node.type === "Literal" || node.type === "TemplateLiteral" && node.expressions.length === 0;
+    const comparedValue = (node) => {
+      if (node.type !== "BinaryExpression" || !equalityOperators2.has(node.operator)) {
+        return;
+      }
+      if (isLiteral(node.left))
+        return context.sourceCode.getText(node.right);
+      if (isLiteral(node.right))
+        return context.sourceCode.getText(node.left);
+      return;
+    };
+    return {
+      ConditionalExpression(node) {
+        if (node.parent?.type === "ConditionalExpression")
+          return;
+        const value = comparedValue(node.test);
+        if (value === undefined)
+          return;
+        let alternate = node.alternate;
+        let literalChecks = 1;
+        while (alternate.type === "ConditionalExpression") {
+          if (comparedValue(alternate.test) !== value)
+            return;
+          literalChecks += 1;
+          alternate = alternate.alternate;
+        }
+        if (literalChecks > 1) {
+          context.report({ node, messageId: "preferMatch" });
+        }
+      }
+    };
+  }
+});
+
+// vendor/anti-slop/src/effect/index.ts
+var antiSlopEffectPlugin = eslintCompatPlugin2({
+  meta: { name: "anti-slop-effect" },
+  rules: {
+    "no-manual-effect-error-tag": noManualEffectErrorTagRule,
+    "no-manual-tag-comparison": noManualTagComparisonRule,
+    "no-manual-tagged-construction": noManualTaggedConstructionRule,
+    "no-service-constructor-imports": noServiceConstructorImportsRule,
+    "prefer-effect-match": preferEffectMatchRule
+  }
+});
+var effect_default2 = antiSlopEffectPlugin;
+// src/configs/enable-plugin-rules.ts
+function enablePluginRules(namespace, plugin) {
+  return Object.fromEntries(Object.keys(plugin.rules).sort().map((rule) => [`${namespace}/${rule}`, "error"]));
+}
+
+// vendor/anti-slop/src/index.ts
+import { eslintCompatPlugin as eslintCompatPlugin3 } from "@oxlint/plugins";
+
+// vendor/anti-slop/src/rules/no-array-filter-map.ts
+import { defineRule as defineRule7 } from "@oxlint/plugins";
+
+// vendor/anti-slop/src/shared/array-method.ts
+function unwrapArrayExpression(node) {
+  while (node.type === "ParenthesizedExpression" || node.type === "ChainExpression" || node.type === "TSAsExpression" || node.type === "TSTypeAssertion" || node.type === "TSNonNullExpression" || node.type === "TSSatisfiesExpression") {
+    node = node.expression;
+  }
+  return node;
+}
+function resolveArrayBinding(sourceCode, node) {
+  node = unwrapArrayExpression(node);
+  if (node.type !== "Identifier")
+    return null;
+  let scope = sourceCode.getScope(node);
+  while (scope !== null) {
+    const variable = scope.set.get(node.name);
+    if (variable !== undefined)
+      return variable;
+    scope = scope.upper;
+  }
+  return null;
+}
+function arrayMethodTarget(node) {
+  node = unwrapArrayExpression(node);
+  if (node.type !== "MemberExpression")
+    return null;
+  const property = node.property;
+  if (!node.computed && property.type === "Identifier") {
+    return { name: property.name, object: node.object };
+  }
+  if (node.computed && property.type === "Literal" && typeof property.value === "string") {
+    return { name: property.value, object: node.object };
+  }
+  return null;
+}
+function isArrayAnnotation(type) {
+  if (type.type === "TSArrayType" || type.type === "TSTupleType")
+    return true;
+  if (type.type === "TSParenthesizedType")
+    return isArrayAnnotation(type.typeAnnotation);
+  if (type.type === "TSTypeOperator" && type.operator === "readonly") {
+    return isArrayAnnotation(type.typeAnnotation);
+  }
+  return type.type === "TSTypeReference" && type.typeName.type === "Identifier" && (type.typeName.name === "Array" || type.typeName.name === "ReadonlyArray");
+}
+function isKnownArrayExpression(sourceCode, node, visited = new Set) {
+  node = unwrapArrayExpression(node);
+  if (node.type === "ArrayExpression")
+    return true;
+  if (node.type === "CallExpression") {
+    const method = arrayMethodTarget(node.callee);
+    return method !== null && ["map", "filter", "flatMap", "slice", "concat", "toSorted", "toReversed", "toSpliced"].includes(method.name) && isKnownArrayExpression(sourceCode, method.object, visited);
+  }
+  if (node.type !== "Identifier")
+    return false;
+  const variable = resolveArrayBinding(sourceCode, node);
+  if (variable === null || visited.has(variable))
+    return false;
+  visited.add(variable);
+  if (variable.references.some((reference) => reference.isWrite() && !reference.init))
+    return false;
+  for (const identifier of variable.identifiers) {
+    const annotation = identifier.typeAnnotation?.typeAnnotation;
+    if (annotation !== undefined)
+      return isArrayAnnotation(annotation);
+  }
+  for (const definition of variable.defs) {
+    if (definition.type === "Variable" && definition.node.type === "VariableDeclarator" && definition.node.id.type === "Identifier" && definition.node.init !== null && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const") {
+      return isKnownArrayExpression(sourceCode, definition.node.init, visited);
+    }
+  }
+  return false;
+}
+
+// vendor/anti-slop/src/rules/no-array-filter-map.ts
+var noArrayFilterMapRule = defineRule7({
+  meta: {
+    type: "suggestion",
+    docs: { description: "Disallow adjacent array filter/map passes in favor of lazy iterator helpers or a single transformation." },
+    messages: {
+      arrayFilterMap: "Avoid consecutive array `{{first}}` and `{{second}}` passes. Prefer `.values().{{first}}(...).{{second}}(...).toArray()` where iterator helpers are supported, or a single `flatMap`/mutating reducer. Preserve callback ordering, indexes, and filtering semantics."
+    }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const outer = arrayMethodTarget(node.callee);
+        if (outer === null || outer.name !== "map" && outer.name !== "filter")
+          return;
+        const innerCall = unwrapArrayExpression(outer.object);
+        if (innerCall.type !== "CallExpression")
+          return;
+        const inner = arrayMethodTarget(innerCall.callee);
+        if (inner === null || inner.name !== (outer.name === "map" ? "filter" : "map"))
+          return;
+        if (!isKnownArrayExpression(context.sourceCode, inner.object))
+          return;
+        context.report({ node, messageId: "arrayFilterMap", data: { first: inner.name, second: outer.name } });
+      }
+    };
+  }
+});
+
+// vendor/anti-slop/src/rules/no-reduce-accumulator-copy.ts
+import { defineRule as defineRule8 } from "@oxlint/plugins";
+function enclosingReducer(node) {
+  let parent = node.parent;
+  while (parent !== null) {
+    if (parent.type === "FunctionDeclaration")
+      return null;
+    if (parent.type === "ArrowFunctionExpression" || parent.type === "FunctionExpression") {
+      const callback = parent;
+      let owner = callback.parent;
+      while (owner !== null && unwrapArrayExpression(owner) === callback)
+        owner = owner.parent;
+      if (owner?.type !== "CallExpression")
+        return null;
+      const method = arrayMethodTarget(owner.callee);
+      const firstArgument = owner.arguments[0];
+      if (method === null || method.name !== "reduce" && method.name !== "reduceRight" || owner.arguments.length > 2 || firstArgument === undefined || unwrapArrayExpression(firstArgument) !== callback)
+        return null;
+      const firstParameter = callback.params[0];
+      const accumulator = firstParameter?.type === "AssignmentPattern" ? firstParameter.left : firstParameter;
+      if (accumulator?.type !== "Identifier")
+        return null;
+      return { callback, accumulator, initialValue: owner.arguments[1] };
+    }
+    parent = parent.parent;
+  }
+  return null;
+}
+function referencesAccumulator(sourceCode, node, accumulator, visited = new Set) {
+  const variable = resolveArrayBinding(sourceCode, node);
+  if (variable === null || visited.has(variable))
+    return false;
+  if (variable === accumulator)
+    return true;
+  visited.add(variable);
+  if (variable.references.some((reference) => reference.isWrite() && !reference.init))
+    return false;
+  for (const definition of variable.defs) {
+    if (definition.type === "Variable" && definition.node.type === "VariableDeclarator" && definition.node.id.type === "Identifier" && definition.node.init !== null && definition.node.parent.type === "VariableDeclaration" && definition.node.parent.kind === "const") {
+      return referencesAccumulator(sourceCode, definition.node.init, accumulator, visited);
+    }
+  }
+  return false;
+}
+function isGlobalCopyOwner(sourceCode, node, name) {
+  node = unwrapArrayExpression(node);
+  if (node.type !== "Identifier" || node.name !== name)
+    return false;
+  const variable = resolveArrayBinding(sourceCode, node);
+  return variable === null || variable.defs.length === 0;
+}
+var noReduceAccumulatorCopyRule = defineRule8({
+  meta: {
+    type: "problem",
+    docs: { description: "Disallow copying growing reducer accumulators with Object.assign, Array.from, or array copy methods." },
+    messages: {
+      accumulatorCopy: "Do not copy the reducer accumulator on every iteration; growing copies can cause quadratic work. Mutate a fresh, locally owned accumulator and return it, or use an iterator pipeline/flatMap."
+    }
+  },
+  createOnce(context) {
+    return {
+      CallExpression(node) {
+        const method = arrayMethodTarget(node.callee);
+        if (method === null)
+          return;
+        const reducer = enclosingReducer(node);
+        if (reducer === null)
+          return;
+        const accumulator = context.sourceCode.getDeclaredVariables(reducer.callback).find((variable) => variable.identifiers.some((identifier) => identifier.start === reducer.accumulator.start));
+        if (accumulator === undefined)
+          return;
+        const isAccumulator = (expression) => referencesAccumulator(context.sourceCode, expression, accumulator);
+        let copiesAccumulator = false;
+        if (method.name === "assign" && isGlobalCopyOwner(context.sourceCode, method.object, "Object")) {
+          const target = node.arguments[0];
+          copiesAccumulator = target !== undefined && unwrapArrayExpression(target).type === "ObjectExpression" && node.arguments.slice(1).some(isAccumulator);
+        } else if (method.name === "from" && isGlobalCopyOwner(context.sourceCode, method.object, "Array")) {
+          const source = node.arguments[0];
+          copiesAccumulator = source !== undefined && isAccumulator(source);
+        } else if (["concat", "slice", "toSpliced", "toSorted", "toReversed", "with"].includes(method.name)) {
+          const initialValue = reducer.initialValue;
+          const arrayAccumulator = initialValue !== undefined && isKnownArrayExpression(context.sourceCode, initialValue);
+          copiesAccumulator = arrayAccumulator && isAccumulator(method.object);
+        }
+        if (copiesAccumulator)
+          context.report({ node, messageId: "accumulatorCopy" });
+      }
+    };
+  }
+});
+
 // vendor/anti-slop/src/rules/no-chained-type-assertions.ts
-import { defineRule } from "@oxlint/plugins";
+import { defineRule as defineRule9 } from "@oxlint/plugins";
 function isTypeAssertionExpression(node) {
   return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
 }
@@ -37,7 +595,7 @@ function isForbiddenAssertionChain(node) {
   }
   return assertionCount > 1 && hasNonConstAssertion;
 }
-var noChainedTypeAssertionsRule = defineRule({
+var noChainedTypeAssertionsRule = defineRule9({
   meta: {
     type: "problem",
     docs: {
@@ -61,7 +619,7 @@ var noChainedTypeAssertionsRule = defineRule({
 });
 
 // vendor/anti-slop/src/rules/no-conditional-empty-object-spread.ts
-import { defineRule as defineRule2 } from "@oxlint/plugins";
+import { defineRule as defineRule10 } from "@oxlint/plugins";
 function unwrapParentheses(node) {
   let current = node;
   while (current.type === "ParenthesizedExpression") {
@@ -76,7 +634,7 @@ function isConditionalEmptyObjectSpread(node) {
   const conditional = unwrapParentheses(node);
   return conditional.type === "ConditionalExpression" && (isEmptyObjectExpression(conditional.consequent) || isEmptyObjectExpression(conditional.alternate));
 }
-var noConditionalEmptyObjectSpreadRule = defineRule2({
+var noConditionalEmptyObjectSpreadRule = defineRule10({
   meta: {
     type: "suggestion",
     docs: {
@@ -100,7 +658,7 @@ var noConditionalEmptyObjectSpreadRule = defineRule2({
 });
 
 // vendor/anti-slop/src/rules/no-known-value-widening.ts
-import { defineRule as defineRule3 } from "@oxlint/plugins";
+import { defineRule as defineRule11 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/shared/lexical-type-parameters.ts
 function isNode(value) {
@@ -503,9 +1061,9 @@ function classifyWideningTarget(type, environment) {
   if (alias === null)
     return null;
   if ((alias.typeParameters?.params.length ?? 0) > 0) {
-    const substitutions2 = aliasSubstitution(alias, unwrapped, new Map);
-    const resolved2 = substitutions2 === null ? null : classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions2, new Set([name]));
-    return resolved2?.kind === "open dictionary" ? { kind: "generic container" } : null;
+    const substitutions = aliasSubstitution(alias, unwrapped, new Map);
+    const resolved = substitutions === null ? null : classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, new Set([name]));
+    return resolved?.kind === "open dictionary" ? { kind: "generic container" } : null;
   }
   const substitutions = aliasSubstitution(alias, unwrapped, new Map);
   if (substitutions === null)
@@ -629,15 +1187,8 @@ function functionParameterBindingName(parameter, sourceCode) {
   return annotationStart === undefined ? sourceText : sourceText.slice(0, annotationStart - parameter.start).trimEnd();
 }
 
-// vendor/anti-slop/src/rules/no-known-value-widening.ts
-function unwrapExpression(expression) {
-  let current = expression;
-  while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") {
-    current = current.expression;
-  }
-  return current;
-}
-function resolveVariable(sourceCode, identifier) {
+// 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);
@@ -647,6 +1198,15 @@ function resolveVariable(sourceCode, identifier) {
   }
   return null;
 }
+
+// vendor/anti-slop/src/rules/no-known-value-widening.ts
+function unwrapExpression(expression) {
+  let current = expression;
+  while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") {
+    current = current.expression;
+  }
+  return current;
+}
 function variableDeclarator(variable) {
   if (variable.defs.length !== 1)
     return null;
@@ -662,7 +1222,7 @@ function hasKnownEvidence(sourceCode, expression, visitedVariables = new Set) {
   const unwrapped = unwrapExpression(expression);
   if (unwrapped.type !== "Identifier")
     return false;
-  const variable = resolveVariable(sourceCode, unwrapped);
+  const variable = resolveVariable2(sourceCode, unwrapped);
   if (variable === null || visitedVariables.has(variable))
     return false;
   const declarator = variableDeclarator(variable);
@@ -681,7 +1241,7 @@ function localFunctionForCall(sourceCode, callee) {
     return unwrapped;
   if (unwrapped.type !== "Identifier")
     return null;
-  const variable = resolveVariable(sourceCode, unwrapped);
+  const variable = resolveVariable2(sourceCode, unwrapped);
   if (variable === null || variable.defs.length !== 1)
     return null;
   const [definition] = variable.defs;
@@ -734,7 +1294,7 @@ function hasKnownCallArgumentEvidence(sourceCode, expression, environment, visit
   }
   if (expression.type !== "Identifier")
     return isKnownEvidenceExpression(expression);
-  const variable = resolveVariable(sourceCode, expression);
+  const variable = resolveVariable2(sourceCode, expression);
   if (variable === null || visitedVariables.has(variable))
     return false;
   const annotation = variableTypeAnnotation(sourceCode, variable);
@@ -799,7 +1359,7 @@ function isDictionaryAccumulatorTarget(destination) {
 function hasParentAssertion(node) {
   return node.parent?.type === "TSAsExpression" || node.parent?.type === "TSTypeAssertion";
 }
-var noKnownValueWideningRule = defineRule3({
+var noKnownValueWideningRule = defineRule11({
   meta: {
     type: "problem",
     docs: {
@@ -848,7 +1408,7 @@ var noKnownValueWideningRule = defineRule3({
       AssignmentExpression(node) {
         if (node.operator !== "=" || node.left.type !== "Identifier")
           return;
-        const variable = resolveVariable(context.sourceCode, node.left);
+        const variable = resolveVariable2(context.sourceCode, node.left);
         if (variable === null)
           return;
         const declarator = variableDeclarator(variable);
@@ -912,18 +1472,8 @@ var noKnownValueWideningRule = defineRule3({
 });
 
 // vendor/anti-slop/src/rules/no-module-mocking.ts
-import { defineRule as defineRule4 } from "@oxlint/plugins";
+import { defineRule as defineRule12 } from "@oxlint/plugins";
 var moduleMockMethods = new Set(["doMock", "mock", "unstable_mockModule"]);
-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;
-}
 function importedName(node) {
   if (node.type !== "ImportSpecifier")
     return null;
@@ -957,7 +1507,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 = defineRule4({
+var noModuleMockingRule = defineRule12({
   meta: {
     type: "problem",
     docs: {
@@ -981,8 +1531,8 @@ var noModuleMockingRule = defineRule4({
 });
 
 // vendor/anti-slop/src/rules/no-object-parameters.ts
-import { defineRule as defineRule5 } from "@oxlint/plugins";
-var noObjectParametersRule = defineRule5({
+import { defineRule as defineRule13 } from "@oxlint/plugins";
+var noObjectParametersRule = defineRule13({
   meta: {
     type: "problem",
     docs: {
@@ -1035,25 +1585,15 @@ var noObjectParametersRule = defineRule5({
 });
 
 // vendor/anti-slop/src/rules/no-reflect-apply.ts
-import { defineRule as defineRule6 } from "@oxlint/plugins";
+import { defineRule as defineRule14 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/shared/reflect-method.ts
-function resolveVariable3(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;
-}
 function isGlobalReflect(sourceCode, expression) {
   if (expression.type !== "Identifier" || expression.name !== "Reflect")
     return false;
   if (sourceCode.isGlobalReference(expression))
     return true;
-  const variable = resolveVariable3(sourceCode, expression);
+  const variable = resolveVariable2(sourceCode, expression);
   return variable === null || variable.defs.length === 0;
 }
 function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
@@ -1066,7 +1606,7 @@ function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
 }
 
 // vendor/anti-slop/src/rules/no-reflect-apply.ts
-var noReflectApplyRule = defineRule6({
+var noReflectApplyRule = defineRule14({
   meta: {
     type: "problem",
     docs: {
@@ -1090,8 +1630,8 @@ var noReflectApplyRule = defineRule6({
 });
 
 // vendor/anti-slop/src/rules/no-reflect-get.ts
-import { defineRule as defineRule7 } from "@oxlint/plugins";
-var noReflectGetRule = defineRule7({
+import { defineRule as defineRule15 } from "@oxlint/plugins";
+var noReflectGetRule = defineRule15({
   meta: {
     type: "problem",
     docs: {
@@ -1115,7 +1655,7 @@ var noReflectGetRule = defineRule7({
 });
 
 // vendor/anti-slop/src/rules/no-runtime-typeof.ts
-import { defineRule as defineRule8 } from "@oxlint/plugins";
+import { defineRule as defineRule16 } from "@oxlint/plugins";
 function isRuntimeFunction(node) {
   return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
 }
@@ -1138,7 +1678,7 @@ function isExistenceProbe(node) {
   const other = parent.left === node ? parent.right : parent.left;
   return other.type === "Literal" && other.value === "undefined";
 }
-var noRuntimeTypeofRule = defineRule8({
+var noRuntimeTypeofRule = defineRule16({
   meta: {
     type: "problem",
     docs: {
@@ -1172,7 +1712,7 @@ var noRuntimeTypeofRule = defineRule8({
 });
 
 // vendor/anti-slop/src/rules/no-shape-in-symbol-names.ts
-import { defineRule as defineRule9 } from "@oxlint/plugins";
+import { defineRule as defineRule17 } from "@oxlint/plugins";
 var FORBIDDEN_SYMBOL_NAME = "shape";
 function containsForbiddenSymbolName(name) {
   return name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME);
@@ -1183,7 +1723,7 @@ function isBorrowedMemberName(node) {
     return false;
   return parent.property === node && parent.computed === false;
 }
-var noForbiddenTermInSymbolNamesRule = defineRule9({
+var noForbiddenTermInSymbolNamesRule = defineRule17({
   meta: {
     type: "problem",
     docs: {
@@ -1212,12 +1752,12 @@ var noForbiddenTermInSymbolNamesRule = defineRule9({
 });
 
 // vendor/anti-slop/src/rules/no-unknown-parameters.ts
-import { defineRule as defineRule10 } from "@oxlint/plugins";
+import { defineRule as defineRule18 } 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 = defineRule10({
+var noUnknownParametersRule = defineRule18({
   meta: {
     type: "problem",
     docs: {
@@ -1261,8 +1801,8 @@ var noUnknownParametersRule = defineRule10({
 });
 
 // vendor/anti-slop/src/rules/no-unknown-returns.ts
-import { defineRule as defineRule11 } from "@oxlint/plugins";
-var noUnknownReturnsRule = defineRule11({
+import { defineRule as defineRule19 } from "@oxlint/plugins";
+var noUnknownReturnsRule = defineRule19({
   meta: {
     type: "problem",
     docs: {
@@ -1315,8 +1855,8 @@ var noUnknownReturnsRule = defineRule11({
 });
 
 // vendor/anti-slop/src/rules/no-unknown-type-aliases.ts
-import { defineRule as defineRule12 } from "@oxlint/plugins";
-var noUnknownTypeAliasesRule = defineRule12({
+import { defineRule as defineRule20 } from "@oxlint/plugins";
+var noUnknownTypeAliasesRule = defineRule20({
   meta: {
     type: "problem",
     docs: {
@@ -1354,7 +1894,7 @@ var noUnknownTypeAliasesRule = defineRule12({
 });
 
 // vendor/anti-slop/src/rules/no-unsafe-dictionary-type.ts
-import { defineRule as defineRule13 } from "@oxlint/plugins";
+import { defineRule as defineRule21 } from "@oxlint/plugins";
 var typeNodeKinds = new Set([
   "JSDocNonNullableType",
   "JSDocNullableType",
@@ -1441,7 +1981,7 @@ function shouldReportType(node, environment) {
   }
   return true;
 }
-var noUnsafeDictionaryTypeRule = defineRule13({
+var noUnsafeDictionaryTypeRule = defineRule21({
   meta: {
     type: "problem",
     docs: {
@@ -1483,7 +2023,7 @@ var noUnsafeDictionaryTypeRule = defineRule13({
 });
 
 // vendor/anti-slop/src/rules/no-widen-then-assert.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
+import { defineRule as defineRule22 } from "@oxlint/plugins";
 var functionBoundaryTypes = new Set([
   "ArrowFunctionExpression",
   "FunctionDeclaration",
@@ -1643,83 +2183,605 @@ function knownValueEvidence(expression, scopes, boundary, visitedVariables) {
     if (functionBoundary(annotatedIdentifier) !== boundary || broadTypeKind(annotation) !== null) {
       return null;
     }
-    return { type: annotation };
-  }
-  const declarator = variableDeclarator2(variable);
-  if (declarator === null || declarator.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const" || declarator.init === null || variable.references.some((reference) => reference.isWrite() && !reference.init) || functionBoundary(declarator) !== boundary) {
-    return null;
-  }
-  return knownValueEvidence(declarator.init, scopes, boundary, new Set([...visitedVariables, variable]));
+    return { type: annotation };
+  }
+  const declarator = variableDeclarator2(variable);
+  if (declarator === null || declarator.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const" || declarator.init === null || variable.references.some((reference) => reference.isWrite() && !reference.init) || functionBoundary(declarator) !== boundary) {
+    return null;
+  }
+  return knownValueEvidence(declarator.init, scopes, boundary, new Set([...visitedVariables, variable]));
+}
+function widenedBinding(variable, scopes) {
+  const declarator = variableDeclarator2(variable);
+  if (declarator === null || declarator.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const" || declarator.id.type !== "Identifier" || declarator.init === null || variable.references.some((reference) => reference.isWrite() && !reference.init)) {
+    return null;
+  }
+  const boundary = functionBoundary(declarator);
+  const declaredType = declarator.id.typeAnnotation?.typeAnnotation;
+  const initializerAssertion = assertionFromExpression(declarator.init);
+  const initializerBroadKind = initializerAssertion === null ? null : broadTypeKind(initializerAssertion.typeAnnotation);
+  const declaredBroadKind = declaredType === undefined ? null : broadTypeKind(declaredType);
+  const broadKind = declaredBroadKind ?? initializerBroadKind;
+  if (broadKind === null)
+    return null;
+  const originalExpression = initializerAssertion !== null && initializerBroadKind !== null ? assertedExpression(initializerAssertion) : declarator.init;
+  const evidence = knownValueEvidence(originalExpression, scopes, boundary, new Set([variable]));
+  return evidence === null ? null : { broadKind, evidence, declaredAt: declarator.end, boundary };
+}
+function assertionIsNarrower(sourceText, broadKind, evidence, assertedType) {
+  if (broadTypeKind(assertedType) !== null)
+    return false;
+  if (broadKind === "top")
+    return true;
+  if (typesHaveSameSyntax(sourceText, evidence.type, assertedType))
+    return true;
+  if (broadKind === "object")
+    return isDefinitelyObjectType(assertedType);
+  return isDefinitelyNarrowerRecordType(assertedType);
+}
+var noWidenThenAssertRule = defineRule22({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow local const flows that explicitly widen a known value before asserting the widened binding to a narrower type."
+    },
+    messages: {
+      widenThenAssert: 'Binding "{{name}}" discards type evidence and later recreates it with an assertion. Keep the precise type from initialization through use; parse boundary input once.'
+    }
+  },
+  createOnce(context) {
+    let scopes = [];
+    const checkAssertion = (node) => {
+      const expression = assertedExpression(node);
+      if (expression.type !== "Identifier")
+        return;
+      const variable = resolvedVariableForIdentifier(scopes, expression);
+      if (variable === null)
+        return;
+      const widened = widenedBinding(variable, scopes);
+      if (widened === null || node.start <= widened.declaredAt || functionBoundary(node) !== widened.boundary || !assertionIsNarrower(context.sourceCode.text, widened.broadKind, widened.evidence, node.typeAnnotation)) {
+        return;
+      }
+      context.report({
+        node,
+        messageId: "widenThenAssert",
+        data: { name: expression.name }
+      });
+    };
+    return {
+      Program() {
+        scopes = context.sourceCode.scopeManager.scopes;
+      },
+      TSAsExpression: checkAssertion,
+      TSTypeAssertion: checkAssertion
+    };
+  }
+});
+
+// vendor/anti-slop/src/vendor/eslint-stylistic/padding-line-ast.ts
+var LINEBREAKS = new Set([`\r
+`, "\r", `
+`, "\u2028", "\u2029"]);
+var isClosingBraceToken = (token) => token.type === "Punctuator" && token.value === "}";
+var isSemicolonToken = (token) => token.type === "Punctuator" && token.value === ";";
+var isNotSemicolonToken = (token) => !isSemicolonToken(token);
+var isTokenOnSameLine = (left, right) => left.loc.end.line === right.loc.start.line;
+var isFunction = (node) => node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+var isSingleLine = (node) => node.loc.start.line === node.loc.end.line;
+var skipChainExpression = (node) => node.type === "ChainExpression" ? node.expression : node;
+var isTopLevelExpressionStatement = (node) => node.type === "ExpressionStatement" && (node.parent.type === "Program" || node.parent.type === "BlockStatement" && isFunction(node.parent.parent));
+function isParenthesized(node, sourceCode) {
+  const before = sourceCode.getTokenBefore(node);
+  const after = sourceCode.getTokenAfter(node);
+  return before?.value === "(" && after?.value === ")";
+}
+
+// vendor/anti-slop/src/vendor/eslint-stylistic/padding-line-between-statements.ts
+var CJS_EXPORT = /^(?:module\s*\.\s*)?exports(?:\s*\.|\s*\[|$)/u;
+var CJS_IMPORT = /^require\(/u;
+var LT = `[${Array.from(LINEBREAKS).join("")}]`;
+var PADDING_LINE_SEQUENCE = new RegExp(String.raw`^(\s*?${LT})\s*${LT}(\s*;?)$`, "u");
+function isSelectorOption(option) {
+  return typeof option === "object" && !Array.isArray(option);
+}
+function newKeywordTester(type, keyword) {
+  return {
+    test(node, sourceCode) {
+      const isSameKeyword = sourceCode.getFirstToken(node)?.value === keyword;
+      const isSameType = Array.isArray(type) ? type.includes(node.type) : type === node.type;
+      return isSameKeyword && isSameType;
+    }
+  };
+}
+function newNodeTypeTester(type) {
+  return {
+    test: (node) => node.type === type
+  };
+}
+function isIIFEStatement(node) {
+  if (node.type === "ExpressionStatement") {
+    let expression = skipChainExpression(node.expression);
+    if (expression.type === "UnaryExpression")
+      expression = skipChainExpression(expression.argument);
+    if (expression.type === "CallExpression") {
+      let node = expression.callee;
+      while (node.type === "SequenceExpression") {
+        const lastExpression = node.expressions.at(-1);
+        if (lastExpression === undefined)
+          throw new Error("Padding rule invariant: sequence expression is empty");
+        node = lastExpression;
+      }
+      return isFunction(node);
+    }
+  }
+  return false;
+}
+function isCJSRequire(node) {
+  if (node.type === "VariableDeclaration") {
+    const declaration = node.declarations[0];
+    if (declaration?.init) {
+      let call = declaration?.init;
+      while (call.type === "MemberExpression")
+        call = call.object;
+      if (call.type === "CallExpression" && call.callee.type === "Identifier") {
+        return call.callee.name === "require";
+      }
+    }
+  }
+  return false;
+}
+function isBlockLikeStatement(node, sourceCode) {
+  if (node.type === "DoWhileStatement" && node.body.type === "BlockStatement") {
+    return true;
+  }
+  if (isIIFEStatement(node))
+    return true;
+  const lastToken = sourceCode.getLastToken(node, isNotSemicolonToken);
+  const belongingNode = lastToken && isClosingBraceToken(lastToken) ? sourceCode.getNodeByRangeIndex(lastToken.range[0]) : null;
+  return !!belongingNode && (belongingNode.type === "BlockStatement" || belongingNode.type === "SwitchStatement");
+}
+function isDirective(node, sourceCode) {
+  return isTopLevelExpressionStatement(node) && node.expression.type === "Literal" && typeof node.expression.value === "string" && !isParenthesized(node.expression, sourceCode);
+}
+function isDirectivePrologue(node, sourceCode) {
+  if (isDirective(node, sourceCode) && node.parent && "body" in node.parent && Array.isArray(node.parent.body)) {
+    for (const sibling of node.parent.body) {
+      if (sibling === node)
+        break;
+      if (!isDirective(sibling, sourceCode))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function isCJSExport(node) {
+  if (node.type === "ExpressionStatement") {
+    const expression = node.expression;
+    if (expression.type === "AssignmentExpression") {
+      let left = expression.left;
+      if (left.type === "MemberExpression") {
+        while (left.object.type === "MemberExpression")
+          left = left.object;
+        return left.object.type === "Identifier" && (left.object.name === "exports" || left.object.name === "module" && left.property.type === "Identifier" && left.property.name === "exports");
+      }
+    }
+  }
+  return false;
+}
+function isExpression(node, sourceCode) {
+  return node.type === "ExpressionStatement" && !isDirectivePrologue(node, sourceCode);
+}
+function getActualLastToken(node, sourceCode) {
+  const semiToken = sourceCode.getLastToken(node);
+  const prevToken = sourceCode.getTokenBefore(semiToken);
+  const nextToken = sourceCode.getTokenAfter(semiToken);
+  const isSemicolonLessStyle = prevToken && nextToken && prevToken.range[0] >= node.range[0] && isSemicolonToken(semiToken) && !isTokenOnSameLine(prevToken, semiToken) && isTokenOnSameLine(semiToken, nextToken);
+  return isSemicolonLessStyle ? prevToken : semiToken;
+}
+function replacerToRemovePaddingLines(_, trailingSpaces, indentSpaces) {
+  return trailingSpaces + indentSpaces;
+}
+function getReportLoc(node, sourceCode) {
+  if (isSingleLine(node))
+    return node.loc;
+  const line = node.loc.start.line;
+  const sourceLine = sourceCode.lines[line - 1];
+  if (sourceLine === undefined)
+    throw new Error("Padding rule invariant: statement source line is missing");
+  return {
+    start: node.loc.start,
+    end: {
+      line,
+      column: sourceLine.length
+    }
+  };
+}
+function verifyForAny() {}
+function verifyForNever(context, _, nextNode, paddingLines) {
+  if (paddingLines.length === 0)
+    return;
+  context.report({
+    node: nextNode,
+    messageId: "unexpectedBlankLine",
+    loc: getReportLoc(nextNode, context.sourceCode),
+    fix(fixer) {
+      if (paddingLines.length >= 2)
+        return null;
+      const paddingPair = paddingLines[0];
+      if (paddingPair === undefined)
+        throw new Error("Padding rule invariant: reported padding pair is missing");
+      const [prevToken, nextToken] = paddingPair;
+      const start = prevToken.range[1];
+      const end = nextToken.range[0];
+      const text = context.sourceCode.text.slice(start, end).replace(PADDING_LINE_SEQUENCE, replacerToRemovePaddingLines);
+      return fixer.replaceTextRange([start, end], text);
+    }
+  });
+}
+function verifyForAlways(context, prevNode, nextNode, paddingLines) {
+  if (paddingLines.length > 0)
+    return;
+  context.report({
+    node: nextNode,
+    messageId: "expectedBlankLine",
+    loc: getReportLoc(nextNode, context.sourceCode),
+    fix(fixer) {
+      const sourceCode = context.sourceCode;
+      let prevToken = getActualLastToken(prevNode, sourceCode);
+      const nextToken = sourceCode.getFirstTokenBetween(prevToken, nextNode, {
+        includeComments: true,
+        filter(token) {
+          if (isTokenOnSameLine(prevToken, token)) {
+            prevToken = token;
+            return false;
+          }
+          return true;
+        }
+      }) || nextNode;
+      const insertText = isTokenOnSameLine(prevToken, nextToken) ? `
+
+` : `
+`;
+      return fixer.insertTextAfter(prevToken, insertText);
+    }
+  });
+}
+var PaddingTypes = {
+  any: { verify: verifyForAny },
+  never: { verify: verifyForNever },
+  always: { verify: verifyForAlways }
+};
+var MaybeMultilineStatementType = {
+  "block-like": { test: isBlockLikeStatement },
+  expression: { test: isExpression },
+  return: newKeywordTester("ReturnStatement", "return"),
+  export: newKeywordTester([
+    "ExportAllDeclaration",
+    "ExportDefaultDeclaration",
+    "ExportNamedDeclaration"
+  ], "export"),
+  var: newKeywordTester("VariableDeclaration", "var"),
+  let: newKeywordTester("VariableDeclaration", "let"),
+  const: newKeywordTester("VariableDeclaration", "const"),
+  using: {
+    test: (node) => node.type === "VariableDeclaration" && (node.kind === "using" || node.kind === "await using")
+  },
+  type: newKeywordTester("TSTypeAliasDeclaration", "type")
+};
+var StatementTypes = {
+  "*": { test: () => true },
+  exports: { test: isCJSExport },
+  require: { test: isCJSRequire },
+  directive: { test: isDirectivePrologue },
+  iife: { test: isIIFEStatement },
+  block: newNodeTypeTester("BlockStatement"),
+  empty: newNodeTypeTester("EmptyStatement"),
+  function: newNodeTypeTester("FunctionDeclaration"),
+  "ts-method": newNodeTypeTester("TSMethodSignature"),
+  break: newKeywordTester("BreakStatement", "break"),
+  case: newKeywordTester("SwitchCase", "case"),
+  class: newKeywordTester("ClassDeclaration", "class"),
+  continue: newKeywordTester("ContinueStatement", "continue"),
+  debugger: newKeywordTester("DebuggerStatement", "debugger"),
+  default: newKeywordTester(["SwitchCase", "ExportDefaultDeclaration"], "default"),
+  do: newKeywordTester("DoWhileStatement", "do"),
+  for: newKeywordTester([
+    "ForStatement",
+    "ForInStatement",
+    "ForOfStatement"
+  ], "for"),
+  if: newKeywordTester("IfStatement", "if"),
+  import: newKeywordTester("ImportDeclaration", "import"),
+  switch: newKeywordTester("SwitchStatement", "switch"),
+  throw: newKeywordTester("ThrowStatement", "throw"),
+  try: newKeywordTester("TryStatement", "try"),
+  while: newKeywordTester(["WhileStatement", "DoWhileStatement"], "while"),
+  with: newKeywordTester("WithStatement", "with"),
+  "cjs-export": {
+    test: (node, sourceCode) => node.type === "ExpressionStatement" && node.expression.type === "AssignmentExpression" && CJS_EXPORT.test(sourceCode.getText(node.expression.left))
+  },
+  "cjs-import": {
+    test: (node, sourceCode) => node.type === "VariableDeclaration" && node.declarations.length > 0 && node.declarations[0]?.init != null && CJS_IMPORT.test(sourceCode.getText(node.declarations[0].init))
+  },
+  enum: newKeywordTester("TSEnumDeclaration", "enum"),
+  interface: newKeywordTester("TSInterfaceDeclaration", "interface"),
+  "function-overload": newNodeTypeTester("TSDeclareFunction"),
+  ...Object.fromEntries(Object.entries(MaybeMultilineStatementType).flatMap(([key, value]) => [
+    [key, value],
+    [
+      `singleline-${key}`,
+      {
+        ...value,
+        test: (node, sourceCode) => value.test(node, sourceCode) && isSingleLine(node)
+      }
+    ],
+    [
+      `multiline-${key}`,
+      {
+        ...value,
+        test: (node, sourceCode) => value.test(node, sourceCode) && !isSingleLine(node)
+      }
+    ]
+  ]))
+};
+function createPaddingLineRule(options) {
+  return {
+    meta: {
+      type: "layout",
+      docs: {
+        description: "Require or disallow padding lines between statements"
+      },
+      fixable: "whitespace",
+      hasSuggestions: false,
+      schema: {
+        $defs: {
+          paddingType: {
+            type: "string",
+            enum: Object.keys(PaddingTypes)
+          },
+          statementType: {
+            type: "string",
+            enum: Object.keys(StatementTypes)
+          },
+          selectorOption: {
+            type: "object",
+            properties: {
+              selector: {
+                type: "string"
+              },
+              lineMode: {
+                type: "string",
+                enum: ["any", "singleline", "multiline"]
+              }
+            },
+            required: ["selector"],
+            additionalProperties: false
+          },
+          statementMatcher: {
+            anyOf: [
+              { $ref: "#/$defs/statementType" },
+              { $ref: "#/$defs/selectorOption" }
+            ]
+          },
+          statementOption: {
+            anyOf: [
+              { $ref: "#/$defs/statementMatcher" },
+              {
+                type: "array",
+                items: { $ref: "#/$defs/statementMatcher" },
+                minItems: 1,
+                uniqueItems: true,
+                additionalItems: false
+              }
+            ]
+          }
+        },
+        type: "array",
+        additionalItems: false,
+        items: {
+          type: "object",
+          properties: {
+            blankLine: { $ref: "#/$defs/paddingType" },
+            prev: { $ref: "#/$defs/statementOption" },
+            next: { $ref: "#/$defs/statementOption" }
+          },
+          additionalProperties: false,
+          required: ["blankLine", "prev", "next"]
+        }
+      },
+      messages: {
+        unexpectedBlankLine: "Unexpected blank line before this statement.",
+        expectedBlankLine: "Expected blank line before this statement."
+      }
+    },
+    create(context) {
+      const sourceCode = context.sourceCode;
+      const selectorMatchedNodes = new Map;
+      const pendingPairs = [];
+      function collectSelectorOption(option) {
+        if (Array.isArray(option)) {
+          for (const item of option)
+            collectSelectorOption(item);
+          return;
+        }
+        if (!isSelectorOption(option))
+          return;
+        selectorMatchedNodes.set(option.selector, new Set);
+      }
+      for (const configure of options) {
+        collectSelectorOption(configure.prev);
+        collectSelectorOption(configure.next);
+      }
+      let scopeInfo = null;
+      function enterScope() {
+        scopeInfo = {
+          upper: scopeInfo,
+          prevNode: null
+        };
+      }
+      function exitScope() {
+        if (scopeInfo)
+          scopeInfo = scopeInfo.upper;
+      }
+      function match(node, type) {
+        let innerStatementNode = node;
+        while (innerStatementNode.type === "LabeledStatement")
+          innerStatementNode = innerStatementNode.body;
+        if (Array.isArray(type))
+          return type.some(match.bind(null, innerStatementNode));
+        if (isSelectorOption(type)) {
+          const matchedNodes = selectorMatchedNodes.get(type.selector);
+          if (!matchedNodes?.has(innerStatementNode))
+            return false;
+          const lineMode = type.lineMode;
+          if (lineMode === "singleline")
+            return isSingleLine(innerStatementNode);
+          else if (lineMode === "multiline")
+            return !isSingleLine(innerStatementNode);
+          return true;
+        } else {
+          const statementType = StatementTypes[type];
+          if (statementType === undefined)
+            throw new Error(`Padding rule invariant: unsupported statement type ${type}`);
+          return statementType.test(innerStatementNode, sourceCode);
+        }
+      }
+      function getPaddingType(prevNode, nextNode) {
+        for (let i = options.length - 1;i >= 0; --i) {
+          const configure = options[i];
+          if (configure === undefined)
+            throw new Error("Padding rule invariant: configuration entry is missing");
+          if (match(prevNode, configure.prev) && match(nextNode, configure.next)) {
+            return PaddingTypes[configure.blankLine];
+          }
+        }
+        return PaddingTypes.any;
+      }
+      function getPaddingLineSequences(prevNode, nextNode) {
+        const pairs = [];
+        let prevToken = getActualLastToken(prevNode, sourceCode);
+        if (nextNode.loc.start.line - prevToken.loc.end.line >= 2) {
+          do {
+            const token = sourceCode.getTokenAfter(prevToken, {
+              includeComments: true
+            });
+            if (token.loc.start.line - prevToken.loc.end.line >= 2)
+              pairs.push([prevToken, token]);
+            prevToken = token;
+          } while (prevToken.range[0] < nextNode.range[0]);
+        }
+        return pairs;
+      }
+      function verify(node) {
+        if (!node.parent || ![
+          "BlockStatement",
+          "Program",
+          "StaticBlock",
+          "SwitchCase",
+          "SwitchStatement",
+          "TSInterfaceBody",
+          "TSModuleBlock",
+          "TSTypeLiteral"
+        ].includes(node.parent.type)) {
+          return;
+        }
+        const prevNode = scopeInfo.prevNode;
+        if (prevNode)
+          pendingPairs.push({ prevNode, nextNode: node });
+        scopeInfo.prevNode = node;
+      }
+      function verifyPendingPairs() {
+        for (const { prevNode, nextNode } of pendingPairs) {
+          const type = getPaddingType(prevNode, nextNode);
+          const paddingLines = getPaddingLineSequences(prevNode, nextNode);
+          type.verify(context, prevNode, nextNode, paddingLines);
+        }
+      }
+      function verifyThenEnterScope(node) {
+        verify(node);
+        enterScope();
+      }
+      const selectorMatchListeners = Object.fromEntries(Array.from(selectorMatchedNodes.keys(), (selector) => [
+        selector,
+        (node) => {
+          selectorMatchedNodes.get(selector)?.add(node);
+        }
+      ]));
+      return {
+        Program: enterScope,
+        "Program:exit": () => {
+          verifyPendingPairs();
+          exitScope();
+        },
+        BlockStatement: enterScope,
+        "BlockStatement:exit": exitScope,
+        SwitchStatement: enterScope,
+        "SwitchStatement:exit": exitScope,
+        SwitchCase: verifyThenEnterScope,
+        "SwitchCase:exit": exitScope,
+        StaticBlock: enterScope,
+        "StaticBlock:exit": exitScope,
+        TSInterfaceBody: enterScope,
+        "TSInterfaceBody:exit": exitScope,
+        TSModuleBlock: enterScope,
+        "TSModuleBlock:exit": exitScope,
+        TSTypeLiteral: enterScope,
+        "TSTypeLiteral:exit": exitScope,
+        TSDeclareFunction: verifyThenEnterScope,
+        "TSDeclareFunction:exit": exitScope,
+        TSMethodSignature: verifyThenEnterScope,
+        "TSMethodSignature:exit": exitScope,
+        ":statement": verify,
+        ...selectorMatchListeners
+      };
+    }
+  };
 }
-function widenedBinding(variable, scopes) {
-  const declarator = variableDeclarator2(variable);
-  if (declarator === null || declarator.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const" || declarator.id.type !== "Identifier" || declarator.init === null || variable.references.some((reference) => reference.isWrite() && !reference.init)) {
-    return null;
+
+// vendor/anti-slop/src/rules/require-readable-spacing.ts
+var paddingRule = createPaddingLineRule([
+  { blankLine: "always", prev: "import", next: "*" },
+  { blankLine: "always", prev: "*", next: { selector: "Program > :not(ImportDeclaration)" } },
+  { blankLine: "always", prev: { selector: "Program > :not(ImportDeclaration)" }, next: "*" },
+  { blankLine: "always", prev: "*", next: ["function", "class", "interface", "type"] },
+  { blankLine: "always", prev: ["function", "class", "interface", "type"], next: "*" },
+  {
+    blankLine: "always",
+    prev: "*",
+    next: ["multiline-const", "multiline-let", "multiline-var", "multiline-using"]
+  },
+  {
+    blankLine: "always",
+    prev: ["multiline-const", "multiline-let", "multiline-var", "multiline-using"],
+    next: "*"
+  },
+  { blankLine: "always", prev: "*", next: ["return", "if", "switch", "try", "for", "while", "do"] },
+  { blankLine: "always", prev: "block-like", next: "*" },
+  { blankLine: "any", prev: "import", next: "import" },
+  {
+    blankLine: "any",
+    prev: {
+      selector: ':matches(TSDeclareFunction, ExportNamedDeclaration[declaration.type="TSDeclareFunction"])'
+    },
+    next: {
+      selector: ':matches(TSDeclareFunction, FunctionDeclaration, ExportNamedDeclaration[declaration.type="TSDeclareFunction"], ExportNamedDeclaration[declaration.type="FunctionDeclaration"])'
+    }
   }
-  const boundary = functionBoundary(declarator);
-  const declaredType = declarator.id.typeAnnotation?.typeAnnotation;
-  const initializerAssertion = assertionFromExpression(declarator.init);
-  const initializerBroadKind = initializerAssertion === null ? null : broadTypeKind(initializerAssertion.typeAnnotation);
-  const declaredBroadKind = declaredType === undefined ? null : broadTypeKind(declaredType);
-  const broadKind = declaredBroadKind ?? initializerBroadKind;
-  if (broadKind === null)
-    return null;
-  const originalExpression = initializerAssertion !== null && initializerBroadKind !== null ? assertedExpression(initializerAssertion) : declarator.init;
-  const evidence = knownValueEvidence(originalExpression, scopes, boundary, new Set([variable]));
-  return evidence === null ? null : { broadKind, evidence, declaredAt: declarator.end, boundary };
-}
-function assertionIsNarrower(sourceText, broadKind, evidence, assertedType) {
-  if (broadTypeKind(assertedType) !== null)
-    return false;
-  if (broadKind === "top")
-    return true;
-  if (typesHaveSameSyntax(sourceText, evidence.type, assertedType))
-    return true;
-  if (broadKind === "object")
-    return isDefinitelyObjectType(assertedType);
-  return isDefinitelyNarrowerRecordType(assertedType);
-}
-var noWidenThenAssertRule = defineRule14({
+]);
+var requireReadableSpacingRule = {
+  ...paddingRule,
   meta: {
-    type: "problem",
+    ...paddingRule.meta,
     docs: {
-      description: "Disallow local const flows that explicitly widen a known value before asserting the widened binding to a narrower type."
+      description: "Require readable spacing between declarations and logical statement groups."
     },
-    messages: {
-      widenThenAssert: 'Binding "{{name}}" discards type evidence and later recreates it with an assertion. Keep the precise type from initialization through use; parse boundary input once.'
-    }
-  },
-  createOnce(context) {
-    let scopes = [];
-    const checkAssertion = (node) => {
-      const expression = assertedExpression(node);
-      if (expression.type !== "Identifier")
-        return;
-      const variable = resolvedVariableForIdentifier(scopes, expression);
-      if (variable === null)
-        return;
-      const widened = widenedBinding(variable, scopes);
-      if (widened === null || node.start <= widened.declaredAt || functionBoundary(node) !== widened.boundary || !assertionIsNarrower(context.sourceCode.text, widened.broadKind, widened.evidence, node.typeAnnotation)) {
-        return;
-      }
-      context.report({
-        node,
-        messageId: "widenThenAssert",
-        data: { name: expression.name }
-      });
-    };
-    return {
-      Program() {
-        scopes = context.sourceCode.scopeManager.scopes;
-      },
-      TSAsExpression: checkAssertion,
-      TSTypeAssertion: checkAssertion
-    };
+    schema: []
   }
-});
+};
 
 // vendor/anti-slop/src/rules/require-safety-comment-for-type-assertion.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
+import { defineRule as defineRule23 } from "@oxlint/plugins";
 var DEFAULT_SAFETY_MARKERS = ["SAFETY"];
 var commentOwnerKinds = new Set([
   "ExpressionStatement",
@@ -1762,7 +2824,7 @@ function hasSafetyComment(sourceCode, node, pattern) {
     current = current.parent;
   }
 }
-var requireSafetyCommentForTypeAssertionRule = defineRule15({
+var requireSafetyCommentForTypeAssertionRule = defineRule23({
   meta: {
     type: "problem",
     docs: {
@@ -1812,9 +2874,11 @@ var requireSafetyCommentForTypeAssertionRule = defineRule15({
 });
 
 // vendor/anti-slop/src/index.ts
-var antiSlopPlugin = eslintCompatPlugin({
+var antiSlopPlugin = eslintCompatPlugin3({
   meta: { name: "anti-slop" },
   rules: {
+    "no-array-filter-map": noArrayFilterMapRule,
+    "no-reduce-accumulator-copy": noReduceAccumulatorCopyRule,
     "no-chained-type-assertions": noChainedTypeAssertionsRule,
     "no-conditional-empty-object-spread": noConditionalEmptyObjectSpreadRule,
     "no-known-value-widening": noKnownValueWideningRule,
@@ -1829,16 +2893,17 @@ var antiSlopPlugin = eslintCompatPlugin({
     "no-unknown-returns": noUnknownReturnsRule,
     "no-unknown-type-aliases": noUnknownTypeAliasesRule,
     "no-widen-then-assert": noWidenThenAssertRule,
+    "require-readable-spacing": requireReadableSpacingRule,
     "require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule
   }
 });
 var src_default = antiSlopPlugin;
 // src/generic/index.ts
-import { eslintCompatPlugin as eslintCompatPlugin2 } from "@oxlint/plugins";
+import { eslintCompatPlugin as eslintCompatPlugin4 } from "@oxlint/plugins";
 
 // src/generic/rules/prefer-event-parameter-type.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
-function nearestEnclosingFunction(node) {
+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") {
@@ -1855,7 +2920,7 @@ function assertedEventParameter(node) {
   }
   const parameterName = expression.object.name;
   const property = expression.property.name;
-  const owner = nearestEnclosingFunction(node);
+  const owner = nearestEnclosingFunction2(node);
   if (!owner?.params.some((parameter) => parameter.type === "Identifier" && parameter.name === parameterName)) {
     return null;
   }
@@ -1864,7 +2929,7 @@ function assertedEventParameter(node) {
     property
   };
 }
-var preferEventParameterTypeRule = defineRule16({
+var preferEventParameterTypeRule = defineRule24({
   meta: {
     type: "suggestion",
     docs: {
@@ -1893,7 +2958,7 @@ var preferEventParameterTypeRule = defineRule16({
 });
 
 // src/generic/index.ts
-var timmoPlugin = eslintCompatPlugin2({
+var timmoPlugin = eslintCompatPlugin4({
   meta: { name: "timmo" },
   rules: {
     "prefer-event-parameter-type": preferEventParameterTypeRule
@@ -1901,16 +2966,6 @@ var timmoPlugin = eslintCompatPlugin2({
 });
 var generic_default = timmoPlugin;
 
-// node_modules/oxlint/dist/index.js
-function defineConfig(config) {
-  return config;
-}
-
-// src/configs/enable-plugin-rules.ts
-function enablePluginRules(namespace, plugin) {
-  return Object.fromEntries(Object.keys(plugin.rules).sort().map((rule) => [`${namespace}/${rule}`, "error"]));
-}
-
 // src/configs/recommended.ts
 var recommended = defineConfig({
   jsPlugins: [
@@ -1927,166 +2982,6 @@ var recommended = defineConfig({
 });
 var recommended_default = recommended;
 
-// src/effect/index.ts
-import { eslintCompatPlugin as eslintCompatPlugin3 } from "@oxlint/plugins";
-
-// src/effect/rules/no-try-catch-in-effect-generators.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
-function resolveVariable4(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;
-}
-function nearestEnclosingFunction2(node) {
-  let current = node.parent;
-  while (current) {
-    if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") {
-      return current;
-    }
-    current = current.parent;
-  }
-  return null;
-}
-function staticMemberName(node) {
-  if (node.type !== "MemberExpression" || node.computed)
-    return null;
-  return node.property.type === "Identifier" ? node.property.name : null;
-}
-function isEffectImport(sourceCode, identifier, namespace) {
-  const variable = resolveVariable4(sourceCode, identifier);
-  return variable?.defs.some((definition) => {
-    if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration" || definition.parent.source.value !== "effect") {
-      return false;
-    }
-    if (namespace)
-      return definition.node.type === "ImportNamespaceSpecifier";
-    if (definition.node.type !== "ImportSpecifier")
-      return false;
-    const imported = definition.node.imported;
-    return (imported.type === "Identifier" ? imported.name : imported.value) === "Effect";
-  }) ?? false;
-}
-function isEffectMethod(sourceCode, node, method) {
-  if (staticMemberName(node) !== method || node.type !== "MemberExpression") {
-    return false;
-  }
-  const object = node.object;
-  if (object.type === "Identifier") {
-    return isEffectImport(sourceCode, object, false);
-  }
-  if (staticMemberName(object) !== "Effect" || object.type !== "MemberExpression" || object.object.type !== "Identifier") {
-    return false;
-  }
-  return isEffectImport(sourceCode, object.object, true);
-}
-function isDirectArgument(owner, call) {
-  return call.arguments.some((argument) => argument === owner);
-}
-function isRecognisedEffectGenerator(sourceCode, owner) {
-  const parent = owner.parent;
-  if (parent.type !== "CallExpression" || !isDirectArgument(owner, parent)) {
-    return false;
-  }
-  if (isEffectMethod(sourceCode, parent.callee, "gen"))
-    return true;
-  const factoryCall = parent.callee;
-  return factoryCall.type === "CallExpression" && isEffectMethod(sourceCode, factoryCall.callee, "fn");
-}
-var noTryCatchInEffectGeneratorsRule = defineRule17({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow synchronous try/catch owned by recognised Effect generator callbacks."
-    },
-    messages: {
-      useEffectErrorChannel: "Keep expected failures in the Effect error channel. Use Effect.try for synchronous throwing work, Effect.tryPromise for asynchronous throwing work, Effect-returning schema APIs for decoding, and Effect recovery combinators for recovery."
-    }
-  },
-  create(context) {
-    return {
-      TryStatement(node) {
-        if (!node.handler)
-          return;
-        const owner = nearestEnclosingFunction2(node);
-        if (!owner?.generator || !isRecognisedEffectGenerator(context.sourceCode, owner)) {
-          return;
-        }
-        context.report({ node, messageId: "useEffectErrorChannel" });
-      }
-    };
-  }
-});
-
-// src/effect/index.ts
-var timmoEffectPlugin = eslintCompatPlugin3({
-  meta: { name: "timmo-effect" },
-  rules: {
-    "no-try-catch-in-effect-generators": noTryCatchInEffectGeneratorsRule
-  }
-});
-var effect_default = timmoEffectPlugin;
-
-// vendor/anti-slop/src/effect/index.ts
-import { eslintCompatPlugin as eslintCompatPlugin4 } from "@oxlint/plugins";
-
-// vendor/anti-slop/src/effect/rules/no-service-constructor-imports.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
-var SERVICE_CONSTRUCTOR_NAME = /^make[A-Z]/u;
-var TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$/u;
-function isProjectLocalImport(source) {
-  return source.startsWith("./") || source.startsWith("../");
-}
-function getImportedName(specifier) {
-  if (specifier.imported.type === "Identifier")
-    return specifier.imported.name;
-  return specifier.imported.value;
-}
-var noServiceConstructorImportsRule = defineRule18({
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow project-local make<CapabilityName> imports 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.'
-    }
-  },
-  create(context) {
-    const isTestFile = TEST_FILE.test(context.filename.replaceAll("\\", "/"));
-    return {
-      ImportDeclaration(node) {
-        if (isTestFile || !isProjectLocalImport(node.source.value))
-          return;
-        for (const specifier of node.specifiers) {
-          if (specifier.type !== "ImportSpecifier")
-            continue;
-          const importedName2 = getImportedName(specifier);
-          if (!SERVICE_CONSTRUCTOR_NAME.test(importedName2))
-            continue;
-          context.report({
-            node: specifier,
-            messageId: "serviceConstructorImport",
-            data: { name: importedName2 }
-          });
-        }
-      }
-    };
-  }
-});
-
-// vendor/anti-slop/src/effect/index.ts
-var antiSlopEffectPlugin = eslintCompatPlugin4({
-  meta: { name: "anti-slop-effect" },
-  rules: {
-    "no-service-constructor-imports": noServiceConstructorImportsRule
-  }
-});
-var effect_default2 = antiSlopEffectPlugin;
 // src/configs/recommended-effect.ts
 var recommendedEffect = defineConfig({
   extends: [recommended_default],