@effect/language-service 0.77.0 → 0.78.0

package/effect-lsp-patch-utils.js

@@ -27,7 +27,7 @@ __export(effect_lsp_patch_utils_exports, {
 });
 module.exports = __toCommonJS(effect_lsp_patch_utils_exports);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Pipeable.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Pipeable.js
 var pipeArguments = (self, args3) => {
   switch (args3.length) {
     case 0:
@@ -60,7 +60,7 @@ var pipeArguments = (self, args3) => {
   }
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Function.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Function.js
 var dual = function(arity, body) {
   if (typeof arity === "function") {
     return function() {
@@ -108,7 +108,7 @@ function pipe(a, ...args3) {
   return pipeArguments(a, args3);
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/internal/equal.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/internal/equal.js
 var getAllObjectKeys = (obj) => {
   const keys2 = new Set(Reflect.ownKeys(obj));
   if (obj.constructor === Object) return keys2;
@@ -131,7 +131,7 @@ var getAllObjectKeys = (obj) => {
 };
 var byReferenceInstances = /* @__PURE__ */ new WeakSet();
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Predicate.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Predicate.js
 function isString(input) {
   return typeof input === "string";
 }
@@ -152,7 +152,7 @@ function isObjectKeyword(input) {
 }
 var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObjectKeyword(self) && property in self);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Hash.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Hash.js
 var symbol = "~effect/interfaces/Hash";
 var hash = (self) => {
   switch (typeof self) {
@@ -271,7 +271,7 @@ function withVisitedTracking(obj, fn2) {
   return result;
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Equal.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Equal.js
 var symbol2 = "~effect/interfaces/Equal";
 function equals() {
   if (arguments.length === 1) {
@@ -433,7 +433,10 @@ var compareSets = /* @__PURE__ */ makeCompareSet(compareBoth);
 var isEqual = (u) => hasProperty(u, symbol2);
 var asEquivalence = () => equals;
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Redactable.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/internal/array.js
+var isArrayNonEmpty = (self) => self.length > 0;
+
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Redactable.js
 var symbolRedactable = /* @__PURE__ */ Symbol.for("~effect/Inspectable/redactable");
 var isRedactable = (u) => hasProperty(u, symbolRedactable);
 function redact(u) {
@@ -452,7 +455,7 @@ var emptyServiceMap = {
   }
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Formatter.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Formatter.js
 function format(input, options) {
   const space = options?.space ?? 0;
   const seen = /* @__PURE__ */ new WeakSet();
@@ -531,7 +534,7 @@ function safeToString(input) {
   }
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Inspectable.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJson = (input) => {
   try {
@@ -575,7 +578,7 @@ var Class = class {
   }
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Utils.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Utils.js
 var GenKindTypeId = "~effect/Utils/GenKind";
 var GenKindImpl = class {
   value;
@@ -643,7 +646,7 @@ var internalCall = isNotOptimizedAway ? standard[InternalTypeId] : forced[Intern
 var genConstructor = function* () {
 }.constructor;
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/internal/core.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/internal/core.js
 var EffectTypeId = `~effect/Effect`;
 var ExitTypeId = `~effect/Exit`;
 var effectVariance = {
@@ -990,7 +993,7 @@ var DoneVoid = {
   value: void 0
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/internal/option.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/internal/option.js
 var TypeId = "~effect/data/Option";
 var CommonProto = {
   [TypeId]: {
@@ -1055,7 +1058,7 @@ var some = (value) => {
   return a;
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/internal/result.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/internal/result.js
 var TypeId2 = "~effect/data/Result";
 var CommonProto2 = {
   [TypeId2]: {
@@ -1126,13 +1129,13 @@ var succeed = (success) => {
   return a;
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Order.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Order.js
 function make(compare) {
   return (self, that) => self === that ? 0 : compare(self, that);
 }
 var String2 = /* @__PURE__ */ make((self, that) => self < that ? -1 : 1);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Option.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Option.js
 var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
@@ -1142,7 +1145,7 @@ var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : se
 var fromNullishOr = (a) => a == null ? none2() : some2(a);
 var getOrUndefined = /* @__PURE__ */ getOrElse(constUndefined);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Result.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Result.js
 var succeed2 = succeed;
 var fail2 = fail;
 var isFailure2 = isFailure;
@@ -1150,18 +1153,7 @@ var isSuccess2 = isSuccess;
 var map = /* @__PURE__ */ dual(2, (self, f) => isSuccess2(self) ? succeed2(f(self.success)) : fail2(self.failure));
 var getOrElse2 = /* @__PURE__ */ dual(2, (self, onFailure) => isFailure2(self) ? onFailure(self.failure) : self.success);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Filter.js
-var apply = (filter2, input, ...args3) => {
-  const result = filter2(input, ...args3);
-  if (result === true) return succeed2(input);
-  if (result === false) return fail2(input);
-  return result;
-};
-
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/internal/array.js
-var isArrayNonEmpty = (self) => self.length > 0;
-
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Record.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Record.js
 var map2 = /* @__PURE__ */ dual(2, (self, f) => {
   const out = {
     ...self
@@ -1173,7 +1165,7 @@ var map2 = /* @__PURE__ */ dual(2, (self, f) => {
 });
 var keys = (self) => Object.keys(self);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Array.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Array.js
 var Array2 = globalThis.Array;
 var fromIterable = (collection) => Array2.isArray(collection) ? collection : Array2.from(collection);
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
@@ -1236,13 +1228,12 @@ var flatMap = /* @__PURE__ */ dual(2, (self, f) => {
   return out;
 });
 var flatten = /* @__PURE__ */ flatMap(identity);
-var filter = /* @__PURE__ */ dual(2, (self, f) => {
+var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
   const as = fromIterable(self);
   const out = [];
   for (let i = 0; i < as.length; i++) {
-    const result = apply(f, as[i], i);
-    if (!isFailure2(result)) {
-      out.push(result.success);
+    if (predicate(as[i], i)) {
+      out.push(as[i]);
     }
   }
   return out;
@@ -1689,7 +1680,9 @@ function parse(config) {
     keyPatterns: isObject(config) && hasProperty(config, "keyPatterns") && isArray(config.keyPatterns) ? parseKeyPatterns(config.keyPatterns) : defaults.keyPatterns,
     extendedKeyDetection: isObject(config) && hasProperty(config, "extendedKeyDetection") && isBoolean(config.extendedKeyDetection) ? config.extendedKeyDetection : defaults.extendedKeyDetection,
     pipeableMinArgCount: isObject(config) && hasProperty(config, "pipeableMinArgCount") && isNumber(config.pipeableMinArgCount) ? config.pipeableMinArgCount : defaults.pipeableMinArgCount,
-    effectFn: isObject(config) && hasProperty(config, "effectFn") && isArray(config.effectFn) && config.effectFn.every(isString) ? config.effectFn.map((_) => _.toLowerCase()) : defaults.effectFn,
+    effectFn: isObject(config) && hasProperty(config, "effectFn") && isArray(config.effectFn) && config.effectFn.every(isString) ? config.effectFn.map(
+      (_) => _.toLowerCase()
+    ) : defaults.effectFn,
     layerGraphFollowDepth: isObject(config) && hasProperty(config, "layerGraphFollowDepth") && isNumber(config.layerGraphFollowDepth) ? config.layerGraphFollowDepth : defaults.layerGraphFollowDepth,
     mermaidProvider: isObject(config) && hasProperty(config, "mermaidProvider") && isString(config.mermaidProvider) ? config.mermaidProvider : defaults.mermaidProvider
   };
@@ -3381,6 +3374,14 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   const layerType = cachedBy(
     fn("TypeParser.layerType")(function* (type, atLocation) {
       yield* pipeableType(type, atLocation);
+      if (supportedEffect() === "v4") {
+        const typeIdSymbol = typeChecker.getPropertyOfType(type, "~effect/Layer");
+        if (typeIdSymbol) {
+          const typeIdType = typeChecker.getTypeOfSymbolAtLocation(typeIdSymbol, atLocation);
+          return yield* layerVarianceStruct(typeIdType, atLocation);
+        }
+        return yield* typeParserIssue("Type is not a layer", type, atLocation);
+      }
       const propertiesSymbols = typeChecker.getPropertiesOfType(type).filter(
         (_) => _.flags & ts.SymbolFlags.Property && !(_.flags & ts.SymbolFlags.Optional) && _.valueDeclaration
       );
@@ -3430,6 +3431,34 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.effectSubtype",
     (type) => type
   );
+  const effectYieldableType = cachedBy(
+    fn("TypeParser.effectYieldableType")(function* (type, atLocation) {
+      if (supportedEffect() === "v3") {
+        return yield* effectType(type, atLocation);
+      }
+      return yield* firstSuccessOf([
+        effectType(type, atLocation),
+        gen(function* () {
+          const asEffectSymbol = typeChecker.getPropertyOfType(type, "asEffect");
+          if (!asEffectSymbol) {
+            return yield* typeParserIssue("Type has no 'asEffect' property", type, atLocation);
+          }
+          const asEffectType = typeChecker.getTypeOfSymbolAtLocation(asEffectSymbol, atLocation);
+          const asEffectSignatures = typeChecker.getSignaturesOfType(asEffectType, ts.SignatureKind.Call);
+          if (asEffectSignatures.length === 0) {
+            return yield* typeParserIssue("'asEffect' property is not callable", type, atLocation);
+          }
+          return yield* firstSuccessOf(
+            asEffectSignatures.map(
+              (signature) => effectType(typeChecker.getReturnTypeOfSignature(signature), atLocation)
+            )
+          );
+        })
+      ]);
+    }),
+    "TypeParser.effectYieldableType",
+    (type) => type
+  );
   const isEffectContextSourceFile = cachedBy(
     fn("TypeParser.isEffectContextSourceFile")(function* (sourceFile) {
       const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
@@ -5057,6 +5086,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     layerType,
     fiberType,
     effectSubtype,
+    effectYieldableType,
     importedEffectModule,
     effectGen,
     effectFnUntracedGen,
@@ -5769,16 +5799,16 @@ var effectFnOpportunity = createDiagnostic({
       if (ts.isFunctionDeclaration(node) && node.name) {
         return node.name;
       }
-      if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+      if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name) && node.parent.initializer === node) {
         return node.parent.name;
       }
-      if (node.parent && ts.isPropertyAssignment(node.parent)) {
+      if (node.parent && ts.isPropertyAssignment(node.parent) && node.parent.initializer === node) {
         const name = node.parent.name;
         if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
           return name;
         }
       }
-      if (node.parent && ts.isPropertyDeclaration(node.parent)) {
+      if (node.parent && ts.isPropertyDeclaration(node.parent) && node.parent.initializer === node) {
         const name = node.parent.name;
         if (ts.isIdentifier(name)) {
           return name;
@@ -5786,6 +5816,190 @@ var effectFnOpportunity = createDiagnostic({
       }
       return void 0;
     };
+    const hasExportModifier = (node) => {
+      if (!ts.canHaveModifiers(node)) return false;
+      const modifiers = ts.getModifiers(node);
+      return modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+    };
+    const layerServiceNameFromExpression = (expression) => {
+      if (expression.kind === ts.SyntaxKind.ThisKeyword) {
+        const enclosingClass = ts.findAncestor(
+          expression,
+          (node) => ts.isClassDeclaration(node)
+        );
+        if (enclosingClass?.name) {
+          return ts.idText(enclosingClass.name);
+        }
+      }
+      if (ts.isIdentifier(expression)) return ts.idText(expression);
+      return sourceFile.text.slice(expression.pos, expression.end).trim();
+    };
+    const tryGetLayerApiMethod = (node) => pipe(
+      typeParser.isNodeReferenceToEffectLayerModuleApi("effect")(node),
+      map4(() => "effect"),
+      orElse2(
+        () => pipe(
+          typeParser.isNodeReferenceToEffectLayerModuleApi("succeed")(node),
+          map4(() => "succeed"),
+          orElse2(
+            () => pipe(
+              typeParser.isNodeReferenceToEffectLayerModuleApi("sync")(node),
+              map4(() => "sync"),
+              orElse2(() => succeed3(void 0))
+            )
+          )
+        )
+      )
+    );
+    const verifyLayerMethodAtCall = fn("effectFnOpportunity.verifyLayerMethodAtCall")(
+      function* (callExpression, method, implementationExpression) {
+        const directMethod = yield* tryGetLayerApiMethod(callExpression.expression);
+        if (directMethod === method && callExpression.arguments.length >= 2 && callExpression.arguments[1] === implementationExpression) {
+          return layerServiceNameFromExpression(callExpression.arguments[0]);
+        }
+        if (ts.isCallExpression(callExpression.expression)) {
+          const innerCall = callExpression.expression;
+          const innerMethod = yield* tryGetLayerApiMethod(innerCall.expression);
+          if (innerMethod === method && innerCall.arguments.length >= 1 && callExpression.arguments.length >= 1 && callExpression.arguments[0] === implementationExpression) {
+            return layerServiceNameFromExpression(innerCall.arguments[0]);
+          }
+        }
+        return void 0;
+      }
+    );
+    const tryMatchLayerSucceedInference = fn("effectFnOpportunity.tryMatchLayerSucceedInference")(
+      function* (objectLiteral) {
+        const callExpression = objectLiteral.parent;
+        if (!callExpression || !ts.isCallExpression(callExpression)) return void 0;
+        return yield* verifyLayerMethodAtCall(callExpression, "succeed", objectLiteral);
+      }
+    );
+    const tryMatchLayerSyncInference = fn("effectFnOpportunity.tryMatchLayerSyncInference")(
+      function* (objectLiteral) {
+        const returnStatement = objectLiteral.parent;
+        if (!returnStatement || !ts.isReturnStatement(returnStatement)) return void 0;
+        const functionBody = returnStatement.parent;
+        if (!functionBody || !ts.isBlock(functionBody)) return void 0;
+        const lazyFunction = functionBody.parent;
+        if (!lazyFunction || !ts.isArrowFunction(lazyFunction) && !ts.isFunctionExpression(lazyFunction)) {
+          return void 0;
+        }
+        const callExpression = lazyFunction.parent;
+        if (!callExpression || !ts.isCallExpression(callExpression)) return void 0;
+        return yield* verifyLayerMethodAtCall(callExpression, "sync", lazyFunction);
+      }
+    );
+    const tryMatchLayerEffectInference = fn("effectFnOpportunity.tryMatchLayerEffectInference")(
+      function* (objectLiteral) {
+        const returnStatement = objectLiteral.parent;
+        if (!returnStatement || !ts.isReturnStatement(returnStatement)) return void 0;
+        const generatorBody = returnStatement.parent;
+        if (!generatorBody || !ts.isBlock(generatorBody)) return void 0;
+        const generatorFunction = generatorBody.parent;
+        if (!generatorFunction || !ts.isFunctionExpression(generatorFunction) || !generatorFunction.asteriskToken) {
+          return void 0;
+        }
+        const genCall = generatorFunction.parent;
+        if (!genCall || !ts.isCallExpression(genCall)) return void 0;
+        const parsedEffectGen = yield* option(typeParser.effectGen(genCall));
+        if (parsedEffectGen._tag === "None" || parsedEffectGen.value.generatorFunction !== generatorFunction) {
+          return void 0;
+        }
+        const layerCall = genCall.parent;
+        if (!layerCall || !ts.isCallExpression(layerCall)) return void 0;
+        return yield* verifyLayerMethodAtCall(layerCall, "effect", genCall);
+      }
+    );
+    const tryMatchOfInference = fn("effectFnOpportunity.tryMatchOfInference")(
+      function* (objectLiteral) {
+        const callExpression = objectLiteral.parent;
+        if (!callExpression || !ts.isCallExpression(callExpression)) return void 0;
+        if (callExpression.arguments.length < 1 || callExpression.arguments[0] !== objectLiteral) return void 0;
+        if (!ts.isPropertyAccessExpression(callExpression.expression)) return void 0;
+        if (ts.idText(callExpression.expression.name) !== "of") return void 0;
+        const serviceTagExpression = callExpression.expression.expression;
+        const serviceTagType = typeCheckerUtils.getTypeAtLocation(serviceTagExpression);
+        if (!serviceTagType) return void 0;
+        const isTagLike = yield* pipe(
+          typeParser.contextTag(serviceTagType, serviceTagExpression),
+          orElse2(() => typeParser.serviceType(serviceTagType, serviceTagExpression)),
+          option
+        );
+        if (isTagLike._tag === "None") return void 0;
+        return layerServiceNameFromExpression(serviceTagExpression);
+      }
+    );
+    const tryMatchServiceMapMakeInference = fn("effectFnOpportunity.tryMatchServiceMapMakeInference")(
+      function* (objectLiteral) {
+        const returnStatement = objectLiteral.parent;
+        if (!returnStatement || !ts.isReturnStatement(returnStatement)) return void 0;
+        const generatorBody = returnStatement.parent;
+        if (!generatorBody || !ts.isBlock(generatorBody)) return void 0;
+        const generatorFunction = generatorBody.parent;
+        if (!generatorFunction || !ts.isFunctionExpression(generatorFunction) || !generatorFunction.asteriskToken) {
+          return void 0;
+        }
+        const genCall = generatorFunction.parent;
+        if (!genCall || !ts.isCallExpression(genCall)) return void 0;
+        const parsedEffectGen = yield* option(typeParser.effectGen(genCall));
+        if (parsedEffectGen._tag === "None" || parsedEffectGen.value.generatorFunction !== generatorFunction) {
+          return void 0;
+        }
+        const makeProperty = genCall.parent;
+        if (!makeProperty || !ts.isPropertyAssignment(makeProperty)) return void 0;
+        if (makeProperty.initializer !== genCall) return void 0;
+        if (!ts.isIdentifier(makeProperty.name) || ts.idText(makeProperty.name) !== "make") return void 0;
+        let currentNode = makeProperty.parent;
+        let classDeclaration = void 0;
+        while (currentNode) {
+          if (ts.isClassDeclaration(currentNode)) {
+            classDeclaration = currentNode;
+            break;
+          }
+          currentNode = currentNode.parent;
+        }
+        if (!classDeclaration || !classDeclaration.name) return void 0;
+        const parsedServiceMapService = yield* option(typeParser.extendsServiceMapService(classDeclaration));
+        if (parsedServiceMapService._tag === "None") return void 0;
+        return ts.idText(classDeclaration.name);
+      }
+    );
+    const tryGetLayerInferredTraceName = fn("effectFnOpportunity.tryGetLayerInferredTraceName")(
+      function* (node, suggestedTraceName) {
+        if (!suggestedTraceName) return void 0;
+        if (!(node.parent && ts.isPropertyAssignment(node.parent) && node.parent.initializer === node && node.parent.parent && ts.isObjectLiteralExpression(node.parent.parent))) {
+          return void 0;
+        }
+        const objectLiteral = node.parent.parent;
+        const succeedServiceName = yield* tryMatchLayerSucceedInference(objectLiteral);
+        if (succeedServiceName) return `${succeedServiceName}.${suggestedTraceName}`;
+        const syncServiceName = yield* tryMatchLayerSyncInference(objectLiteral);
+        if (syncServiceName) return `${syncServiceName}.${suggestedTraceName}`;
+        const effectServiceName = yield* tryMatchLayerEffectInference(objectLiteral);
+        if (effectServiceName) return `${effectServiceName}.${suggestedTraceName}`;
+        const ofServiceName = yield* tryMatchOfInference(objectLiteral);
+        if (ofServiceName) return `${ofServiceName}.${suggestedTraceName}`;
+        const serviceMapMakeServiceName = yield* tryMatchServiceMapMakeInference(objectLiteral);
+        return serviceMapMakeServiceName ? `${serviceMapMakeServiceName}.${suggestedTraceName}` : void 0;
+      }
+    );
+    const getInferredTraceName = fn("effectFnOpportunity.getInferredTraceName")(
+      function* (node, suggestedTraceName) {
+        const inferredFromLayer = yield* tryGetLayerInferredTraceName(node, suggestedTraceName);
+        if (inferredFromLayer) return inferredFromLayer;
+        if (ts.isFunctionDeclaration(node) && node.name && hasExportModifier(node)) {
+          return ts.idText(node.name);
+        }
+        if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name) && node.parent.initializer === node) {
+          const variableDeclarationList = node.parent.parent;
+          const variableStatement = variableDeclarationList?.parent;
+          if (variableDeclarationList && ts.isVariableDeclarationList(variableDeclarationList) && variableStatement && ts.isVariableStatement(variableStatement) && hasExportModifier(variableStatement) && (variableDeclarationList.flags & ts.NodeFlags.Const) !== 0) {
+            return ts.idText(node.parent.name);
+          }
+        }
+        return void 0;
+      }
+    );
     const areParametersReferencedIn = (fnNode, nodes) => {
       if (fnNode.parameters.length === 0 || nodes.length === 0) return false;
       const firstParam = fnNode.parameters[0];
@@ -5870,7 +6084,10 @@ var effectFnOpportunity = createDiagnostic({
       );
     };
     const parseEffectFnOpportunityTargetGen = fn("effectFnOpportunity.parseEffectFnOpportunityTarget")(
-      function* (node, returnType, traceName, nameIdentifier) {
+      function* (node, returnType, nameIdentifier) {
+        const suggestedTraceName = nameIdentifier ? ts.isIdentifier(nameIdentifier) ? ts.idText(nameIdentifier) : nameIdentifier.text : void 0;
+        const inferredTraceName = yield* getInferredTraceName(node, suggestedTraceName);
+        const hasStrictLayerInferredName = inferredTraceName !== void 0 && inferredTraceName !== suggestedTraceName;
         if (yield* isInsideEffectFn(node)) {
           return yield* TypeParserIssue.issue;
         }
@@ -5879,11 +6096,11 @@ var effectFnOpportunity = createDiagnostic({
         const opportunity = yield* pipe(
           tryParseGenOpportunity(node),
           orElse2(() => {
-            if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+            if (ts.isArrowFunction(node) && !ts.isBlock(node.body) && !hasStrictLayerInferredName) {
               return TypeParserIssue.issue;
             }
             const body = ts.isArrowFunction(node) ? node.body : node.body;
-            if (!body || !ts.isBlock(body) || body.statements.length <= 5) {
+            if ((!body || !ts.isBlock(body) || body.statements.length <= 5) && !hasStrictLayerInferredName) {
               return TypeParserIssue.issue;
             }
             return succeed3({
@@ -5898,7 +6115,8 @@ var effectFnOpportunity = createDiagnostic({
           node,
           nameIdentifier,
           effectModuleName: opportunity.effectModuleName,
-          inferredTraceName: traceName,
+          inferredTraceName,
+          suggestedTraceName,
           explicitTraceExpression: opportunity.explicitTraceExpression,
           pipeArguments: opportunity.pipeArguments,
           generatorFunction: opportunity.generatorFunction,
@@ -5908,27 +6126,26 @@ var effectFnOpportunity = createDiagnostic({
     );
     const parseEffectFnOpportunityTarget = (node) => {
       if (!ts.isFunctionExpression(node) && !ts.isArrowFunction(node) && !ts.isFunctionDeclaration(node)) {
-        return TypeParserIssue.issue;
+        return;
       }
       if ((ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) && node.asteriskToken) {
-        return TypeParserIssue.issue;
+        return;
       }
       if (ts.isFunctionExpression(node) && node.name) {
-        return TypeParserIssue.issue;
+        return;
       }
       if (node.type) {
-        return TypeParserIssue.issue;
+        return;
       }
       const functionType = typeChecker.getTypeAtLocation(node);
-      if (!functionType) return TypeParserIssue.issue;
+      if (!functionType) return;
       const callSignatures = typeChecker.getSignaturesOfType(functionType, ts.SignatureKind.Call);
-      if (callSignatures.length !== 1) return TypeParserIssue.issue;
+      if (callSignatures.length !== 1) return;
       const signature = callSignatures[0];
       const returnType = typeChecker.getReturnTypeOfSignature(signature);
       const nameIdentifier = getNameIdentifier(node);
-      const traceName = nameIdentifier ? ts.isIdentifier(nameIdentifier) ? ts.idText(nameIdentifier) : nameIdentifier.text : void 0;
-      if (!traceName) return TypeParserIssue.issue;
-      return parseEffectFnOpportunityTargetGen(node, returnType, traceName, nameIdentifier);
+      if (!nameIdentifier) return;
+      return parseEffectFnOpportunityTargetGen(node, returnType, nameIdentifier);
     };
     const getFunctionBodyBlock = (node) => {
       if (ts.isArrowFunction(node)) {
@@ -6002,18 +6219,21 @@ var effectFnOpportunity = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
-      const target = yield* pipe(parseEffectFnOpportunityTarget(node), option);
-      if (isNone2(target)) continue;
-      if (target.value.hasParamsInPipeArgs) continue;
+      const test = parseEffectFnOpportunityTarget(node);
+      if (!test) continue;
+      const target = yield* orUndefined(test);
+      if (!target) continue;
+      if (target.hasParamsInPipeArgs) continue;
       const {
         effectModuleName,
         explicitTraceExpression,
         inferredTraceName,
         nameIdentifier,
         node: targetNode,
-        pipeArguments: pipeArguments2
-      } = target.value;
-      const innerFunction = target.value.generatorFunction ?? targetNode;
+        pipeArguments: pipeArguments2,
+        suggestedTraceName
+      } = target;
+      const innerFunction = target.generatorFunction ?? targetNode;
       const fixes = [];
       if (pluginOptions.effectFn.includes("span") && explicitTraceExpression) {
         fixes.push({
@@ -6033,7 +6253,7 @@ var effectFnOpportunity = createDiagnostic({
           })
         });
       }
-      if (pluginOptions.effectFn.includes("untraced") && target.value.generatorFunction) {
+      if (pluginOptions.effectFn.includes("untraced") && target.generatorFunction) {
         fixes.push({
           fixName: "effectFnOpportunity_toEffectFnUntraced",
           description: "Convert to Effect.fnUntraced",
@@ -6055,22 +6275,41 @@ var effectFnOpportunity = createDiagnostic({
           })
         });
       }
-      if (pluginOptions.effectFn.includes("inferred-span") && inferredTraceName && !explicitTraceExpression) {
-        fixes.push({
-          fixName: "effectFnOpportunity_toEffectFnSpanInferred",
-          description: `Convert to Effect.fn("${inferredTraceName}")`,
-          apply: gen(function* () {
-            const changeTracker = yield* service(ChangeTracker);
-            const newNode = createEffectFnNode(
-              targetNode,
-              innerFunction,
-              effectModuleName,
-              inferredTraceName,
-              pipeArguments2
-            );
-            changeTracker.replaceNode(sourceFile, targetNode, newNode);
-          })
-        });
+      if (!explicitTraceExpression) {
+        if (pluginOptions.effectFn.includes("inferred-span") && inferredTraceName) {
+          fixes.push({
+            fixName: "effectFnOpportunity_toEffectFnSpanInferred",
+            description: `Convert to Effect.fn("${inferredTraceName}")`,
+            apply: gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              const newNode = createEffectFnNode(
+                targetNode,
+                innerFunction,
+                effectModuleName,
+                inferredTraceName,
+                pipeArguments2
+              );
+              changeTracker.replaceNode(sourceFile, targetNode, newNode);
+            })
+          });
+        }
+        if (pluginOptions.effectFn.includes("suggested-span") && suggestedTraceName && (!pluginOptions.effectFn.includes("inferred-span") || suggestedTraceName !== inferredTraceName)) {
+          fixes.push({
+            fixName: "effectFnOpportunity_toEffectFnSpanSuggested",
+            description: `Convert to Effect.fn("${suggestedTraceName}")`,
+            apply: gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              const newNode = createEffectFnNode(
+                targetNode,
+                innerFunction,
+                effectModuleName,
+                suggestedTraceName,
+                pipeArguments2
+              );
+              changeTracker.replaceNode(sourceFile, targetNode, newNode);
+            })
+          });
+        }
       }
       if (fixes.length === 0) continue;
       const generateExpectedSignature = () => {
@@ -6083,7 +6322,7 @@ var effectFnOpportunity = createDiagnostic({
           }
           return "_";
         }).join(", ");
-        const fnSignature = `function*${typeParamNames}(${paramNames}) { ... }`;
+        const fnSignature = ts.isArrowFunction(innerFunction) ? `${typeParamNames}(${paramNames}) => { ... }` : isGeneratorFunction(innerFunction) ? `function*${typeParamNames}(${paramNames}) { ... }` : `function${typeParamNames}(${paramNames}) { ... }`;
         const pipeArgsForWithSpan = pipeArguments2.slice(0, -1);
         const pipeArgsSuffix = (args3) => args3.length > 0 ? ", ...pipeTransformations" : "";
         switch (firstFix.fixName) {
@@ -6097,6 +6336,8 @@ var effectFnOpportunity = createDiagnostic({
             return `${effectModuleName}.fn(${fnSignature}${pipeArgsSuffix(pipeArguments2)})`;
           case "effectFnOpportunity_toEffectFnSpanInferred":
             return `${effectModuleName}.fn("${inferredTraceName}")(${fnSignature}${pipeArgsSuffix(pipeArguments2)})`;
+          case "effectFnOpportunity_toEffectFnSpanSuggested":
+            return `${effectModuleName}.fn("${suggestedTraceName}")(${fnSignature}${pipeArgsSuffix(pipeArguments2)})`;
           default:
             return `${effectModuleName}.fn(${fnSignature})`;
         }
@@ -6149,6 +6390,70 @@ var effectGenUsesAdapter = createDiagnostic({
   })
 });
 
+// src/diagnostics/effectInFailure.ts
+var effectInFailure = createDiagnostic({
+  name: "effectInFailure",
+  code: 49,
+  description: "Warns when an Effect is used inside an Effect failure channel",
+  severity: "warning",
+  apply: fn("effectInFailure.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const isStrictEffectType = cachedBy(
+      fn("effectInFailure.isStrictEffectType")(function* (type, atLocation) {
+        yield* typeParser.strictEffectType(type, atLocation);
+        return true;
+      }),
+      "effectInFailure.isStrictEffectType",
+      (type) => type
+    );
+    const visited = /* @__PURE__ */ new WeakSet();
+    const stack = [sourceFile];
+    const shouldSkipBecauseChildMatched = /* @__PURE__ */ new WeakSet();
+    while (stack.length > 0) {
+      const node = stack.pop();
+      if (!visited.has(node)) {
+        visited.add(node);
+        stack.push(node);
+        ts.forEachChild(node, (child) => {
+          stack.push(child);
+          return void 0;
+        });
+        continue;
+      }
+      if (shouldSkipBecauseChildMatched.has(node)) {
+        if (node.parent) shouldSkipBecauseChildMatched.add(node.parent);
+        continue;
+      }
+      const type = typeCheckerUtils.getTypeAtLocation(node);
+      if (!type) continue;
+      const effect = yield* orUndefined(typeParser.strictEffectType(type, node));
+      if (!effect) continue;
+      const failureMembers = typeCheckerUtils.unrollUnionMembers(effect.E);
+      let memberWithEffect = void 0;
+      for (const member of failureMembers) {
+        const isMemberEffect = yield* orUndefined(isStrictEffectType(member, node));
+        if (isMemberEffect) {
+          memberWithEffect = member;
+          break;
+        }
+      }
+      if (!memberWithEffect) continue;
+      const messageText = `The error channel contains an Effect (${typeChecker.typeToString(memberWithEffect)}). Putting Effect computations in the failure channel is not intended; keep only failure types there.`;
+      report({
+        location: node,
+        messageText,
+        fixes: []
+      });
+      if (node.parent) {
+        shouldSkipBecauseChildMatched.add(node.parent);
+      }
+    }
+  })
+});
+
 // src/diagnostics/effectInVoidSuccess.ts
 var effectInVoidSuccess = createDiagnostic({
   name: "effectInVoidSuccess",
@@ -7517,6 +7822,7 @@ var missingReturnYieldStar = createDiagnostic({
     const ts = yield* service(TypeScriptApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
+    const tsUtils = yield* service(TypeScriptUtils);
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -7526,50 +7832,32 @@ var missingReturnYieldStar = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
-      if (ts.isYieldExpression(node) && node.expression && node.asteriskToken) {
-        const type = typeCheckerUtils.getTypeAtLocation(node.expression);
-        if (type) {
-          const maybeEffect = yield* option(typeParser.effectType(type, node.expression));
-          if (isSome2(maybeEffect) && maybeEffect.value.A.flags & ts.TypeFlags.Never) {
-            const generatorFunctionOrReturnStatement = ts.findAncestor(
-              node,
-              (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_) || ts.isReturnStatement(_) || ts.isThrowStatement(_)
-            );
-            if (generatorFunctionOrReturnStatement && !ts.isReturnStatement(generatorFunctionOrReturnStatement) && !ts.isThrowStatement(generatorFunctionOrReturnStatement)) {
-              if (generatorFunctionOrReturnStatement && generatorFunctionOrReturnStatement.parent) {
-                const effectGenNode = generatorFunctionOrReturnStatement.parent;
-                const effectGenLike = yield* pipe(
-                  typeParser.effectGen(effectGenNode),
-                  orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
-                  orElse2(() => typeParser.effectFnGen(effectGenNode)),
-                  option
-                );
-                if (isSome2(effectGenLike)) {
-                  const fix = node.expression ? [{
-                    fixName: "missingReturnYieldStar_fix",
-                    description: "Add return statement",
-                    apply: gen(function* () {
-                      const changeTracker = yield* service(ChangeTracker);
-                      changeTracker.replaceNode(
-                        sourceFile,
-                        node,
-                        ts.factory.createReturnStatement(
-                          node
-                        )
-                      );
-                    })
-                  }] : [];
-                  report({
-                    location: node,
-                    messageText: `It is recommended to use return yield* for Effects that never succeed to signal a definitive exit point for type narrowing and tooling support.`,
-                    fixes: fix
-                  });
-                }
-              }
-            }
-          }
-        }
-      }
+      if (!ts.isExpressionStatement(node)) continue;
+      const unwrapped = tsUtils.skipOuterExpressions(node.expression);
+      if (!ts.isYieldExpression(unwrapped) || !unwrapped.expression || !unwrapped.asteriskToken) continue;
+      const type = typeCheckerUtils.getTypeAtLocation(unwrapped.expression);
+      if (!type) continue;
+      const maybeEffect = yield* option(typeParser.effectYieldableType(type, unwrapped.expression));
+      if (!(isSome2(maybeEffect) && maybeEffect.value.A.flags & ts.TypeFlags.Never)) continue;
+      const { effectGen, scopeNode } = yield* typeParser.findEnclosingScopes(node);
+      if (!effectGen || scopeNode && scopeNode !== effectGen.generatorFunction) continue;
+      const fix = [{
+        fixName: "missingReturnYieldStar_fix",
+        description: "Add return statement",
+        apply: gen(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          changeTracker.replaceNode(
+            sourceFile,
+            node,
+            ts.factory.createReturnStatement(node.expression)
+          );
+        })
+      }];
+      report({
+        location: unwrapped,
+        messageText: `It is recommended to use return yield* for Effects that never succeed to signal a definitive exit point for type narrowing and tooling support.`,
+        fixes: fix
+      });
     }
   })
 });
@@ -7886,9 +8174,7 @@ var effectModuleMigrationDb = {
   "failSync": asUnchanged,
   "fiberId": asUnchanged,
   "filter": asUnchanged,
-  "filterMap": asRemoved(
-    "Use Effect.filter or Effect.map with Option instead."
-  ),
+  "filterMap": asUnchanged,
   "filterOrElse": asUnchanged,
   "filterOrFail": asUnchanged,
   "flatMap": asUnchanged,
@@ -8176,9 +8462,7 @@ var effectModuleMigrationDb = {
   "finalizersMask": asRemoved(
     "Finalizer masking has been removed in Effect v4."
   ),
-  "findFirst": asRemoved(
-    "Use Effect.forEach with early return instead."
-  ),
+  "findFirst": asUnchanged,
   "firstSuccessOf": asRemoved(
     "Use Effect.raceAll instead."
   ),
@@ -11046,6 +11330,7 @@ var diagnostics = [
   missingEffectServiceDependency,
   missingLayerContext,
   floatingEffect,
+  effectInFailure,
   missingStarInYieldEffectGen,
   unnecessaryEffectGen,
   unnecessaryFailYieldableError,