@timmo001/oxlint-rules 0.2.0 → 0.3.0

package/dist/configs/{effect.js → recommended-effect.js}

@@ -1,168 +1,8 @@
-// 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-service-constructor-imports.ts
-import { defineRule as defineRule2 } 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 = defineRule2({
-  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/index.ts
-var antiSlopEffectPlugin = eslintCompatPlugin2({
-  meta: { name: "anti-slop-effect" },
-  rules: {
-    "no-service-constructor-imports": noServiceConstructorImportsRule
-  }
-});
-var effect_default2 = antiSlopEffectPlugin;
 // vendor/anti-slop/src/index.ts
-import { eslintCompatPlugin as eslintCompatPlugin3 } from "@oxlint/plugins";
+import { eslintCompatPlugin } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/rules/no-chained-type-assertions.ts
-import { defineRule as defineRule3 } from "@oxlint/plugins";
+import { defineRule } from "@oxlint/plugins";
 function isTypeAssertionExpression(node) {
   return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
 }
@@ -197,7 +37,7 @@ function isForbiddenAssertionChain(node) {
   }
   return assertionCount > 1 && hasNonConstAssertion;
 }
-var noChainedTypeAssertionsRule = defineRule3({
+var noChainedTypeAssertionsRule = defineRule({
   meta: {
     type: "problem",
     docs: {
@@ -221,7 +61,7 @@ var noChainedTypeAssertionsRule = defineRule3({
 });
 
 // vendor/anti-slop/src/rules/no-conditional-empty-object-spread.ts
-import { defineRule as defineRule4 } from "@oxlint/plugins";
+import { defineRule as defineRule2 } from "@oxlint/plugins";
 function unwrapParentheses(node) {
   let current = node;
   while (current.type === "ParenthesizedExpression") {
@@ -236,7 +76,7 @@ function isConditionalEmptyObjectSpread(node) {
   const conditional = unwrapParentheses(node);
   return conditional.type === "ConditionalExpression" && (isEmptyObjectExpression(conditional.consequent) || isEmptyObjectExpression(conditional.alternate));
 }
-var noConditionalEmptyObjectSpreadRule = defineRule4({
+var noConditionalEmptyObjectSpreadRule = defineRule2({
   meta: {
     type: "suggestion",
     docs: {
@@ -260,7 +100,7 @@ var noConditionalEmptyObjectSpreadRule = defineRule4({
 });
 
 // vendor/anti-slop/src/rules/no-known-value-widening.ts
-import { defineRule as defineRule5 } from "@oxlint/plugins";
+import { defineRule as defineRule3 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/shared/lexical-type-parameters.ts
 function isNode(value) {
@@ -797,7 +637,7 @@ function unwrapExpression(expression) {
   }
   return current;
 }
-function resolveVariable2(sourceCode, identifier) {
+function resolveVariable(sourceCode, identifier) {
   let scope = sourceCode.getScope(identifier);
   while (scope !== null) {
     const variable = scope.set.get(identifier.name);
@@ -822,7 +662,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);
@@ -841,7 +681,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;
@@ -894,7 +734,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);
@@ -959,7 +799,7 @@ function isDictionaryAccumulatorTarget(destination) {
 function hasParentAssertion(node) {
   return node.parent?.type === "TSAsExpression" || node.parent?.type === "TSTypeAssertion";
 }
-var noKnownValueWideningRule = defineRule5({
+var noKnownValueWideningRule = defineRule3({
   meta: {
     type: "problem",
     docs: {
@@ -1008,7 +848,7 @@ var noKnownValueWideningRule = defineRule5({
       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);
@@ -1072,9 +912,9 @@ var noKnownValueWideningRule = defineRule5({
 });
 
 // vendor/anti-slop/src/rules/no-module-mocking.ts
-import { defineRule as defineRule6 } from "@oxlint/plugins";
+import { defineRule as defineRule4 } from "@oxlint/plugins";
 var moduleMockMethods = new Set(["doMock", "mock", "unstable_mockModule"]);
-function resolveVariable3(sourceCode, identifier) {
+function resolveVariable2(sourceCode, identifier) {
   let scope = sourceCode.getScope(identifier);
   while (scope !== null) {
     const variable = scope.set.get(identifier.name);
@@ -1095,7 +935,7 @@ function isTestFrameworkObject(sourceCode, expression) {
   if ((expression.name === "vi" || expression.name === "jest") && sourceCode.isGlobalReference(expression)) {
     return true;
   }
-  const variable = resolveVariable3(sourceCode, expression);
+  const variable = resolveVariable2(sourceCode, expression);
   if (variable === null || variable.defs.length === 0) {
     return expression.name === "vi" || expression.name === "jest";
   }
@@ -1117,7 +957,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 = defineRule6({
+var noModuleMockingRule = defineRule4({
   meta: {
     type: "problem",
     docs: {
@@ -1141,8 +981,8 @@ var noModuleMockingRule = defineRule6({
 });
 
 // vendor/anti-slop/src/rules/no-object-parameters.ts
-import { defineRule as defineRule7 } from "@oxlint/plugins";
-var noObjectParametersRule = defineRule7({
+import { defineRule as defineRule5 } from "@oxlint/plugins";
+var noObjectParametersRule = defineRule5({
   meta: {
     type: "problem",
     docs: {
@@ -1195,10 +1035,10 @@ var noObjectParametersRule = defineRule7({
 });
 
 // vendor/anti-slop/src/rules/no-reflect-apply.ts
-import { defineRule as defineRule8 } from "@oxlint/plugins";
+import { defineRule as defineRule6 } from "@oxlint/plugins";
 
 // vendor/anti-slop/src/shared/reflect-method.ts
-function resolveVariable4(sourceCode, identifier) {
+function resolveVariable3(sourceCode, identifier) {
   let scope = sourceCode.getScope(identifier);
   while (scope !== null) {
     const variable = scope.set.get(identifier.name);
@@ -1213,7 +1053,7 @@ function isGlobalReflect(sourceCode, expression) {
     return false;
   if (sourceCode.isGlobalReference(expression))
     return true;
-  const variable = resolveVariable4(sourceCode, expression);
+  const variable = resolveVariable3(sourceCode, expression);
   return variable === null || variable.defs.length === 0;
 }
 function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
@@ -1226,7 +1066,7 @@ function isGlobalReflectMethodCall(sourceCode, callee, methodName) {
 }
 
 // vendor/anti-slop/src/rules/no-reflect-apply.ts
-var noReflectApplyRule = defineRule8({
+var noReflectApplyRule = defineRule6({
   meta: {
     type: "problem",
     docs: {
@@ -1250,8 +1090,8 @@ var noReflectApplyRule = defineRule8({
 });
 
 // vendor/anti-slop/src/rules/no-reflect-get.ts
-import { defineRule as defineRule9 } from "@oxlint/plugins";
-var noReflectGetRule = defineRule9({
+import { defineRule as defineRule7 } from "@oxlint/plugins";
+var noReflectGetRule = defineRule7({
   meta: {
     type: "problem",
     docs: {
@@ -1275,7 +1115,7 @@ var noReflectGetRule = defineRule9({
 });
 
 // vendor/anti-slop/src/rules/no-runtime-typeof.ts
-import { defineRule as defineRule10 } from "@oxlint/plugins";
+import { defineRule as defineRule8 } from "@oxlint/plugins";
 function isRuntimeFunction(node) {
   return node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression";
 }
@@ -1298,7 +1138,7 @@ function isExistenceProbe(node) {
   const other = parent.left === node ? parent.right : parent.left;
   return other.type === "Literal" && other.value === "undefined";
 }
-var noRuntimeTypeofRule = defineRule10({
+var noRuntimeTypeofRule = defineRule8({
   meta: {
     type: "problem",
     docs: {
@@ -1332,7 +1172,7 @@ var noRuntimeTypeofRule = defineRule10({
 });
 
 // vendor/anti-slop/src/rules/no-shape-in-symbol-names.ts
-import { defineRule as defineRule11 } from "@oxlint/plugins";
+import { defineRule as defineRule9 } from "@oxlint/plugins";
 var FORBIDDEN_SYMBOL_NAME = "shape";
 function containsForbiddenSymbolName(name) {
   return name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME);
@@ -1343,7 +1183,7 @@ function isBorrowedMemberName(node) {
     return false;
   return parent.property === node && parent.computed === false;
 }
-var noForbiddenTermInSymbolNamesRule = defineRule11({
+var noForbiddenTermInSymbolNamesRule = defineRule9({
   meta: {
     type: "problem",
     docs: {
@@ -1372,12 +1212,12 @@ var noForbiddenTermInSymbolNamesRule = defineRule11({
 });
 
 // vendor/anti-slop/src/rules/no-unknown-parameters.ts
-import { defineRule as defineRule12 } from "@oxlint/plugins";
+import { defineRule as defineRule10 } 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 = defineRule12({
+var noUnknownParametersRule = defineRule10({
   meta: {
     type: "problem",
     docs: {
@@ -1421,8 +1261,8 @@ var noUnknownParametersRule = defineRule12({
 });
 
 // vendor/anti-slop/src/rules/no-unknown-returns.ts
-import { defineRule as defineRule13 } from "@oxlint/plugins";
-var noUnknownReturnsRule = defineRule13({
+import { defineRule as defineRule11 } from "@oxlint/plugins";
+var noUnknownReturnsRule = defineRule11({
   meta: {
     type: "problem",
     docs: {
@@ -1475,8 +1315,8 @@ var noUnknownReturnsRule = defineRule13({
 });
 
 // vendor/anti-slop/src/rules/no-unknown-type-aliases.ts
-import { defineRule as defineRule14 } from "@oxlint/plugins";
-var noUnknownTypeAliasesRule = defineRule14({
+import { defineRule as defineRule12 } from "@oxlint/plugins";
+var noUnknownTypeAliasesRule = defineRule12({
   meta: {
     type: "problem",
     docs: {
@@ -1514,7 +1354,7 @@ var noUnknownTypeAliasesRule = defineRule14({
 });
 
 // vendor/anti-slop/src/rules/no-unsafe-dictionary-type.ts
-import { defineRule as defineRule15 } from "@oxlint/plugins";
+import { defineRule as defineRule13 } from "@oxlint/plugins";
 var typeNodeKinds = new Set([
   "JSDocNonNullableType",
   "JSDocNullableType",
@@ -1601,7 +1441,7 @@ function shouldReportType(node, environment) {
   }
   return true;
 }
-var noUnsafeDictionaryTypeRule = defineRule15({
+var noUnsafeDictionaryTypeRule = defineRule13({
   meta: {
     type: "problem",
     docs: {
@@ -1643,7 +1483,7 @@ var noUnsafeDictionaryTypeRule = defineRule15({
 });
 
 // vendor/anti-slop/src/rules/no-widen-then-assert.ts
-import { defineRule as defineRule16 } from "@oxlint/plugins";
+import { defineRule as defineRule14 } from "@oxlint/plugins";
 var functionBoundaryTypes = new Set([
   "ArrowFunctionExpression",
   "FunctionDeclaration",
@@ -1839,7 +1679,7 @@ function assertionIsNarrower(sourceText, broadKind, evidence, assertedType) {
     return isDefinitelyObjectType(assertedType);
   return isDefinitelyNarrowerRecordType(assertedType);
 }
-var noWidenThenAssertRule = defineRule16({
+var noWidenThenAssertRule = defineRule14({
   meta: {
     type: "problem",
     docs: {
@@ -1879,7 +1719,7 @@ var noWidenThenAssertRule = defineRule16({
 });
 
 // vendor/anti-slop/src/rules/require-safety-comment-for-type-assertion.ts
-import { defineRule as defineRule17 } from "@oxlint/plugins";
+import { defineRule as defineRule15 } from "@oxlint/plugins";
 var DEFAULT_SAFETY_MARKERS = ["SAFETY"];
 var commentOwnerKinds = new Set([
   "ExpressionStatement",
@@ -1922,7 +1762,7 @@ function hasSafetyComment(sourceCode, node, pattern) {
     current = current.parent;
   }
 }
-var requireSafetyCommentForTypeAssertionRule = defineRule17({
+var requireSafetyCommentForTypeAssertionRule = defineRule15({
   meta: {
     type: "problem",
     docs: {
@@ -1972,7 +1812,7 @@ var requireSafetyCommentForTypeAssertionRule = defineRule17({
 });
 
 // vendor/anti-slop/src/index.ts
-var antiSlopPlugin = eslintCompatPlugin3({
+var antiSlopPlugin = eslintCompatPlugin({
   meta: { name: "anti-slop" },
   rules: {
     "no-chained-type-assertions": noChainedTypeAssertionsRule,
@@ -1994,11 +1834,11 @@ var antiSlopPlugin = eslintCompatPlugin3({
 });
 var src_default = antiSlopPlugin;
 // src/generic/index.ts
-import { eslintCompatPlugin as eslintCompatPlugin4 } from "@oxlint/plugins";
+import { eslintCompatPlugin as eslintCompatPlugin2 } from "@oxlint/plugins";
 
 // src/generic/rules/prefer-event-parameter-type.ts
-import { defineRule as defineRule18 } from "@oxlint/plugins";
-function nearestEnclosingFunction2(node) {
+import { defineRule as defineRule16 } from "@oxlint/plugins";
+function nearestEnclosingFunction(node) {
   let current = node.parent;
   while (current) {
     if (current.type === "FunctionDeclaration" || current.type === "FunctionExpression" || current.type === "ArrowFunctionExpression") {
@@ -2015,7 +1855,7 @@ function assertedEventParameter(node) {
   }
   const parameterName = expression.object.name;
   const property = expression.property.name;
-  const owner = nearestEnclosingFunction2(node);
+  const owner = nearestEnclosingFunction(node);
   if (!owner?.params.some((parameter) => parameter.type === "Identifier" && parameter.name === parameterName)) {
     return null;
   }
@@ -2024,7 +1864,7 @@ function assertedEventParameter(node) {
     property
   };
 }
-var preferEventParameterTypeRule = defineRule18({
+var preferEventParameterTypeRule = defineRule16({
   meta: {
     type: "suggestion",
     docs: {
@@ -2053,7 +1893,7 @@ var preferEventParameterTypeRule = defineRule18({
 });
 
 // src/generic/index.ts
-var timmoPlugin = eslintCompatPlugin4({
+var timmoPlugin = eslintCompatPlugin2({
   meta: { name: "timmo" },
   rules: {
     "prefer-event-parameter-type": preferEventParameterTypeRule
@@ -2087,8 +1927,168 @@ var recommended = defineConfig({
 });
 var recommended_default = recommended;
 
-// src/configs/effect.ts
-var effect = defineConfig({
+// 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],
   jsPlugins: [
     {
@@ -2102,7 +2102,7 @@ var effect = defineConfig({
     ...enablePluginRules("timmo-effect", effect_default)
   }
 });
-var effect_default3 = effect;
+var recommended_effect_default = recommendedEffect;
 export {
-  effect_default3 as default
+  recommended_effect_default as default
 };