@effect/language-service 0.76.0 → 0.78.0

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/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:
@@ -44,7 +44,7 @@ var Class = /* @__PURE__ */ (function() {
   return PipeableBase;
 })();
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/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() {
@@ -92,7 +92,7 @@ function pipe(a, ...args3) {
   return pipeArguments(a, args3);
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Equivalence.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Equivalence.js
 var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
 function Array2(item) {
   return make((self, that) => {
@@ -104,7 +104,7 @@ function Array2(item) {
   });
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/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;
@@ -127,7 +127,7 @@ var getAllObjectKeys = (obj) => {
 };
 var byReferenceInstances = /* @__PURE__ */ new WeakSet();
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/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";
 }
@@ -148,7 +148,7 @@ function isObjectKeyword(input) {
 }
 var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObjectKeyword(self) && property in self);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/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) {
@@ -267,7 +267,7 @@ function withVisitedTracking(obj, fn2) {
   return result;
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/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) {
@@ -429,7 +429,7 @@ var compareSets = /* @__PURE__ */ makeCompareSet(compareBoth);
 var isEqual = (u) => hasProperty(u, symbol2);
 var asEquivalence = () => equals;
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Redactable.js
+// ../../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) {
@@ -448,7 +448,7 @@ var emptyServiceMap = {
   }
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/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();
@@ -527,7 +527,7 @@ function safeToString(input) {
   }
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/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 {
@@ -571,7 +571,7 @@ var Class2 = class {
   }
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/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;
@@ -639,7 +639,7 @@ var internalCall = isNotOptimizedAway ? standard[InternalTypeId] : forced[Intern
 var genConstructor = function* () {
 }.constructor;
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/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 = {
@@ -986,7 +986,7 @@ var DoneVoid = {
   value: void 0
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/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]: {
@@ -1051,7 +1051,7 @@ var some = (value) => {
   return a;
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/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]: {
@@ -1122,7 +1122,7 @@ var succeed = (success) => {
   return a;
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/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;
@@ -1130,7 +1130,10 @@ var isSuccess2 = isSuccess;
 var map = /* @__PURE__ */ dual(2, (self, f) => isSuccess2(self) ? succeed2(f(self.success)) : fail2(self.failure));
 var getOrElse = /* @__PURE__ */ dual(2, (self, onFailure) => isFailure2(self) ? onFailure(self.failure) : self.success);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Order.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/Order.js
 function make2(compare) {
   return (self, that) => self === that ? 0 : compare(self, that);
 }
@@ -1153,7 +1156,7 @@ var combine2 = /* @__PURE__ */ dual(2, (self, that) => make2((a1, a2) => {
 }));
 var mapInput = /* @__PURE__ */ dual(2, (self, f) => make2((b1, b2) => self(f(b1), f(b2))));
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/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;
@@ -1164,18 +1167,7 @@ var fromNullishOr = (a) => a == null ? none2() : some2(a);
 var getOrUndefined = /* @__PURE__ */ getOrElse2(constUndefined);
 var map2 = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/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.12/node_modules/effect/dist/internal/array.js
-var isArrayNonEmpty = (self) => self.length > 0;
-
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Record.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Record.js
 var map3 = /* @__PURE__ */ dual(2, (self, f) => {
   const out = {
     ...self
@@ -1187,7 +1179,7 @@ var map3 = /* @__PURE__ */ dual(2, (self, f) => {
 });
 var keys = (self) => Object.keys(self);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Array.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Array.js
 var Array3 = globalThis.Array;
 var fromIterable = (collection) => Array3.isArray(collection) ? collection : Array3.from(collection);
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
@@ -1250,30 +1242,16 @@ 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;
 });
-var partition = /* @__PURE__ */ dual(2, (self, f) => {
-  const excluded = [];
-  const satisfying = [];
-  const as = fromIterable(self);
-  for (let i = 0; i < as.length; i++) {
-    const result = f(as[i], i);
-    if (result === true) satisfying.push(as[i]);
-    else if (result === false) excluded.push(as[i]);
-    else if (isSuccess2(result)) satisfying.push(result.success);
-    else excluded.push(result.failure);
-  }
-  return [excluded, satisfying];
-});
 var every = /* @__PURE__ */ dual(2, (self, refinement) => self.every(refinement));
 var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
   const input = fromIterable(self);
@@ -1292,7 +1270,7 @@ var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
 var dedupe = (self) => dedupeWith(self, asEquivalence());
 var join = /* @__PURE__ */ dual(2, (self, sep) => fromIterable(self).join(sep));
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Data.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Data.js
 var Class3 = class extends Class {
   constructor(props) {
     super();
@@ -1303,7 +1281,7 @@ var Class3 = class extends Class {
 };
 var TaggedError2 = TaggedError;
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Encoding.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Encoding.js
 var EncodingErrorTypeId = "~effect/encoding/EncodingError";
 var EncodingError = class extends (/* @__PURE__ */ TaggedError2("EncodingError")) {
   /**
@@ -1339,7 +1317,7 @@ var base64EncodeUint8Array = (bytes) => {
 var base64abc = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/"];
 var base64UrlEncodeUint8Array = (data) => base64EncodeUint8Array(data).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.12/node_modules/effect/dist/Graph.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Graph.js
 var TypeId3 = "~effect/collections/Graph";
 var Edge = class extends Class3 {
 };
@@ -2263,7 +2241,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
   };
@@ -4043,6 +4023,14 @@ function make3(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
       );
@@ -4092,6 +4080,34 @@ function make3(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);
@@ -5270,6 +5286,73 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.extendsEffectSqlModelClass",
     (atLocation) => atLocation
   );
+  const isEffectSchemaModelTypeSourceFile = cachedBy(
+    fn("TypeParser.isEffectSchemaModelTypeSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const classSymbol = typeChecker.tryGetMemberInModuleExports("Class", moduleSymbol);
+      if (!classSymbol) return yield* typeParserIssue("Model's Class type not found", void 0, sourceFile);
+      const generatedSymbol = typeChecker.tryGetMemberInModuleExports("Generated", moduleSymbol);
+      if (!generatedSymbol) {
+        return yield* typeParserIssue("Model's Generated type not found", void 0, sourceFile);
+      }
+      const fieldOptionSymbol = typeChecker.tryGetMemberInModuleExports("FieldOption", moduleSymbol);
+      if (!fieldOptionSymbol) {
+        return yield* typeParserIssue("Model's FieldOption type not found", void 0, sourceFile);
+      }
+      return sourceFile;
+    }),
+    "TypeParser.isEffectSchemaModelTypeSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToEffectSchemaModelModuleApi = (memberName) => cachedBy(
+    fn("TypeParser.isNodeReferenceToEffectSchemaModelModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(
+        node,
+        "effect",
+        isEffectSchemaModelTypeSourceFile,
+        memberName
+      );
+    }),
+    `TypeParser.isNodeReferenceToEffectSchemaModelModuleApi(${memberName})`,
+    (node) => node
+  );
+  const extendsEffectSchemaModelClass = cachedBy(
+    fn("TypeParser.extendsEffectSchemaModelClass")(function* (atLocation) {
+      if (!atLocation.name) {
+        return yield* typeParserIssue("Class has no name", void 0, atLocation);
+      }
+      const heritageClauses = atLocation.heritageClauses;
+      if (!heritageClauses) {
+        return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
+      }
+      for (const heritageClause of heritageClauses) {
+        for (const typeX of heritageClause.types) {
+          if (ts.isExpressionWithTypeArguments(typeX)) {
+            const expression = typeX.expression;
+            if (ts.isCallExpression(expression)) {
+              const schemaCall = expression.expression;
+              if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
+                const isEffectSchemaModelModuleApi = yield* pipe(
+                  isNodeReferenceToEffectSchemaModelModuleApi("Class")(schemaCall.expression),
+                  orUndefined
+                );
+                if (isEffectSchemaModelModuleApi) {
+                  return {
+                    className: atLocation.name,
+                    selfTypeNode: schemaCall.typeArguments[0]
+                  };
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend effect's Model.Class", void 0, atLocation);
+    }),
+    "TypeParser.extendsEffectSchemaModelClass",
+    (atLocation) => atLocation
+  );
   const isEffectLayerTypeSourceFile = cachedBy(
     fn("TypeParser.isEffectLayerTypeSourceFile")(function* (sourceFile) {
       const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
@@ -5642,6 +5725,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     isNodeReferenceToEffectDataModuleApi,
     isNodeReferenceToEffectContextModuleApi,
     isNodeReferenceToEffectSqlModelModuleApi,
+    isNodeReferenceToEffectSchemaModelModuleApi,
     isNodeReferenceToEffectLayerModuleApi,
     isNodeReferenceToEffectSchemaParserModuleApi,
     isServiceMapTypeSourceFile,
@@ -5651,6 +5735,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     layerType,
     fiberType,
     effectSubtype,
+    effectYieldableType,
     importedEffectModule,
     effectGen,
     effectFnUntracedGen,
@@ -5679,6 +5764,7 @@ function make3(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     extendsSchemaTaggedRequest,
     extendsSchemaRequestClass,
     extendsEffectSqlModelClass,
+    extendsEffectSchemaModelClass,
     lazyExpression,
     emptyFunction,
     pipingFlows,
@@ -7200,6 +7286,7 @@ var classSelfMismatch = createDiagnostic({
             )
           ),
           orElse2(() => typeParser.extendsEffectSqlModelClass(node)),
+          orElse2(() => typeParser.extendsEffectSchemaModelClass(node)),
           orElse2(() => void_)
         );
         if (result) {
@@ -7526,16 +7613,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;
@@ -7543,6 +7630,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),
+      map5(() => "effect"),
+      orElse2(
+        () => pipe(
+          typeParser.isNodeReferenceToEffectLayerModuleApi("succeed")(node),
+          map5(() => "succeed"),
+          orElse2(
+            () => pipe(
+              typeParser.isNodeReferenceToEffectLayerModuleApi("sync")(node),
+              map5(() => "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, nodes2) => {
       if (fnNode.parameters.length === 0 || nodes2.length === 0) return false;
       const firstParam = fnNode.parameters[0];
@@ -7627,7 +7898,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;
         }
@@ -7636,11 +7910,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({
@@ -7655,7 +7929,8 @@ var effectFnOpportunity = createDiagnostic({
           node,
           nameIdentifier,
           effectModuleName: opportunity.effectModuleName,
-          inferredTraceName: traceName,
+          inferredTraceName,
+          suggestedTraceName,
           explicitTraceExpression: opportunity.explicitTraceExpression,
           pipeArguments: opportunity.pipeArguments,
           generatorFunction: opportunity.generatorFunction,
@@ -7665,27 +7940,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)) {
@@ -7759,18 +8033,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({
@@ -7790,7 +8067,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",
@@ -7812,22 +8089,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 = () => {
@@ -7840,7 +8136,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) {
@@ -7854,6 +8150,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})`;
         }
@@ -7906,6 +8204,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",
@@ -9274,6 +9636,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);
@@ -9283,50 +9646,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
+      });
     }
   })
 });
@@ -9592,6 +9937,761 @@ var nonObjectEffectServiceType = createDiagnostic({
   })
 });
 
+// src/diagnostics/outdatedApi.db.ts
+var asUnchanged = {
+  _tag: "Unchanged"
+};
+var asRenamedSameBehaviour = (newName) => ({
+  _tag: "RenamedSameBehaviour",
+  newName
+});
+var asRenamedAndNeedsOptions = (newName, optionsInstructions) => ({
+  _tag: "RenamedAndNeedsOptions",
+  newName,
+  optionsInstructions
+});
+var asRemoved = (alternativePattern) => ({
+  _tag: "Removed",
+  alternativePattern
+});
+var effectModuleMigrationDb = {
+  // Common APIs (in both v3 and v4, unchanged)
+  "acquireRelease": asUnchanged,
+  "acquireUseRelease": asUnchanged,
+  "addFinalizer": asUnchanged,
+  "all": asUnchanged,
+  "andThen": asUnchanged,
+  "annotateCurrentSpan": asUnchanged,
+  "annotateLogs": asUnchanged,
+  "annotateSpans": asUnchanged,
+  "as": asUnchanged,
+  "asSome": asUnchanged,
+  "asVoid": asUnchanged,
+  "cached": asUnchanged,
+  "cachedInvalidateWithTTL": asUnchanged,
+  "cachedWithTTL": asUnchanged,
+  "catch": asUnchanged,
+  "catchIf": asUnchanged,
+  "catchTag": asUnchanged,
+  "catchTags": asUnchanged,
+  "clockWith": asUnchanged,
+  "currentParentSpan": asUnchanged,
+  "currentSpan": asUnchanged,
+  "delay": asUnchanged,
+  "die": asUnchanged,
+  "ensuring": asUnchanged,
+  "eventually": asUnchanged,
+  "exit": asUnchanged,
+  "fail": asUnchanged,
+  "failCause": asUnchanged,
+  "failCauseSync": asUnchanged,
+  "failSync": asUnchanged,
+  "fiberId": asUnchanged,
+  "filter": asUnchanged,
+  "filterMap": asUnchanged,
+  "filterOrElse": asUnchanged,
+  "filterOrFail": asUnchanged,
+  "flatMap": asUnchanged,
+  "flatten": asUnchanged,
+  "flip": asUnchanged,
+  "fn": asUnchanged,
+  "fnUntraced": asUnchanged,
+  "forEach": asUnchanged,
+  "forever": asUnchanged,
+  "forkIn": asUnchanged,
+  "forkScoped": asUnchanged,
+  "gen": asUnchanged,
+  "ignore": asUnchanged,
+  "interrupt": asUnchanged,
+  "interruptible": asUnchanged,
+  "interruptibleMask": asUnchanged,
+  "isEffect": asUnchanged,
+  "isFailure": asUnchanged,
+  "isSuccess": asUnchanged,
+  "linkSpans": asUnchanged,
+  "log": asUnchanged,
+  "logDebug": asUnchanged,
+  "logError": asUnchanged,
+  "logFatal": asUnchanged,
+  "logInfo": asUnchanged,
+  "logTrace": asUnchanged,
+  "logWarning": asUnchanged,
+  "logWithLevel": asUnchanged,
+  "makeLatch": asRemoved(
+    "Use Latch.make instead of Effect.makeLatch."
+  ),
+  "makeSemaphore": asRemoved(
+    "Use Semaphore.make instead of Effect.makeSemaphore."
+  ),
+  "makeSpan": asUnchanged,
+  "makeSpanScoped": asUnchanged,
+  "map": asUnchanged,
+  "mapBoth": asUnchanged,
+  "mapError": asUnchanged,
+  "match": asUnchanged,
+  "matchCause": asUnchanged,
+  "matchCauseEffect": asUnchanged,
+  "matchEffect": asUnchanged,
+  "never": asUnchanged,
+  "onError": asUnchanged,
+  "onExit": asUnchanged,
+  "onInterrupt": asUnchanged,
+  "option": asUnchanged,
+  "orDie": asUnchanged,
+  "orElseSucceed": asUnchanged,
+  "promise": asUnchanged,
+  "provide": asUnchanged,
+  "provideService": asUnchanged,
+  "provideServiceEffect": asUnchanged,
+  "race": asUnchanged,
+  "raceAll": asUnchanged,
+  "raceFirst": asUnchanged,
+  "repeat": asUnchanged,
+  "repeatOrElse": asUnchanged,
+  "replicate": asUnchanged,
+  "replicateEffect": asUnchanged,
+  "request": asUnchanged,
+  "retry": asUnchanged,
+  "retryOrElse": asUnchanged,
+  "runCallback": asUnchanged,
+  "runFork": asUnchanged,
+  "runPromise": asUnchanged,
+  "runPromiseExit": asUnchanged,
+  "runSync": asUnchanged,
+  "runSyncExit": asUnchanged,
+  "sandbox": asUnchanged,
+  "schedule": asUnchanged,
+  "scheduleFrom": asUnchanged,
+  "scope": asUnchanged,
+  "scoped": asUnchanged,
+  "scopedWith": asUnchanged,
+  "serviceOption": asUnchanged,
+  "sleep": asUnchanged,
+  "spanAnnotations": asUnchanged,
+  "spanLinks": asUnchanged,
+  "succeed": asUnchanged,
+  "succeedNone": asUnchanged,
+  "succeedSome": asUnchanged,
+  "suspend": asUnchanged,
+  "sync": asUnchanged,
+  "tap": asUnchanged,
+  "tapDefect": asUnchanged,
+  "tapError": asUnchanged,
+  "tapErrorTag": asUnchanged,
+  "timed": asUnchanged,
+  "timeout": asUnchanged,
+  "timeoutOption": asUnchanged,
+  "tracer": asUnchanged,
+  "try": asUnchanged,
+  "tryPromise": asUnchanged,
+  "uninterruptible": asUnchanged,
+  "uninterruptibleMask": asUnchanged,
+  "updateService": asUnchanged,
+  "useSpan": asUnchanged,
+  "void": asUnchanged,
+  "when": asUnchanged,
+  "whileLoop": asUnchanged,
+  "withConcurrency": asUnchanged,
+  "withExecutionPlan": asUnchanged,
+  "withLogSpan": asUnchanged,
+  "withParentSpan": asUnchanged,
+  "withSpan": asUnchanged,
+  "withSpanScoped": asUnchanged,
+  "withTracer": asUnchanged,
+  "withTracerEnabled": asUnchanged,
+  "withTracerTiming": asUnchanged,
+  "yieldNow": asUnchanged,
+  "zip": asUnchanged,
+  "zipWith": asUnchanged,
+  // Renamed APIs (v3 name → v4 name)
+  "catchAll": asRenamedSameBehaviour("catch"),
+  "catchAllCause": asRenamedSameBehaviour("catchCause"),
+  "catchAllDefect": asRenamedSameBehaviour("catchDefect"),
+  "catchSome": asRemoved(
+    "Use Effect.catchIf instead. Note: the API shape changed from returning Option<Effect> to taking a predicate and handler separately."
+  ),
+  "catchSomeCause": asRemoved(
+    "Use Effect.catchCauseIf instead. Note: the API shape changed from returning Option<Effect> to taking a predicate and handler separately."
+  ),
+  "ensureErrorType": asRenamedSameBehaviour("satisfiesErrorType"),
+  "ensureRequirementsType": asRenamedSameBehaviour("satisfiesServicesType"),
+  "ensureSuccessType": asRenamedSameBehaviour("satisfiesSuccessType"),
+  "fork": asRenamedSameBehaviour("forkChild"),
+  "forkDaemon": asRenamedSameBehaviour("forkDetach"),
+  "scopeWith": asRenamedSameBehaviour("scopedWith"),
+  "serviceOptional": asRenamedSameBehaviour("serviceOption"),
+  "tapErrorCause": asRenamedSameBehaviour("tapCause"),
+  // Removed APIs
+  "annotateLogsScoped": asUnchanged,
+  "awaitAllChildren": asUnchanged,
+  "bind": asUnchanged,
+  "bindTo": asUnchanged,
+  "Do": asUnchanged,
+  "let": asUnchanged,
+  "partition": asUnchanged,
+  "validate": asUnchanged,
+  "catchSomeDefect": asRemoved(
+    "Use Effect.catchDefect or Effect.matchCause to handle specific defects."
+  ),
+  "forkAll": asRemoved(
+    "Fork effects individually with Effect.forEach and Effect.forkChild, or use Effect.all with concurrency options."
+  ),
+  "forkWithErrorHandler": asRemoved(
+    "Fork the effect with Effect.forkChild and observe the fiber result via Fiber.join or Fiber.await."
+  ),
+  "Tag": asRemoved(
+    "Use ServiceMap.Service instead of Effect.Tag."
+  ),
+  "Service": asRemoved(
+    "Use ServiceMap.Service instead of Effect.Service."
+  ),
+  "runtime": asRemoved(
+    "Runtime has been removed in Effect v4. Use Effect.services to grab services and then run using Effect.runPromiseWith."
+  ),
+  "bindAll": asRemoved(
+    "Use Effect.gen instead of Effect.bindAll."
+  ),
+  "EffectTypeId": asRemoved(
+    "EffectTypeId has been removed in Effect v4."
+  ),
+  "acquireReleaseInterruptible": asRemoved(
+    "Use Effect.acquireRelease instead."
+  ),
+  "allSuccesses": asRemoved(
+    "Use Effect.all with the { mode: 'either' } option and filter successes."
+  ),
+  "allWith": asRemoved(
+    "Use Effect.all with options instead."
+  ),
+  "allowInterrupt": asRemoved(
+    "Use Effect.yieldNow instead."
+  ),
+  "ap": asRemoved(
+    "Use Effect.map and Effect.flatMap to apply functions instead."
+  ),
+  "asSomeError": asRemoved(
+    "Use Effect.mapError(Option.some) instead."
+  ),
+  "async": asRenamedAndNeedsOptions("callback", "Note: in v4 the callback receives a Scheduler as 'this' context."),
+  "asyncEffect": asRemoved(
+    "Use Effect.suspend combined with Effect.promise instead."
+  ),
+  "blocked": asRemoved(
+    "The request batching API has been reworked in Effect v4."
+  ),
+  "cacheRequestResult": asRemoved(
+    "The request batching API has been reworked in Effect v4."
+  ),
+  "cachedFunction": asRemoved(
+    "Use Effect.cached or implement caching with a Ref instead."
+  ),
+  "cause": asRemoved(
+    "Use Effect.matchCause or Effect.sandbox to access the cause."
+  ),
+  "checkInterruptible": asRemoved(
+    "Interruption checking has been removed in Effect v4."
+  ),
+  "clock": asRemoved(
+    "Use Effect.clockWith instead."
+  ),
+  "configProviderWith": asRemoved(
+    "ConfigProvider access has been reworked in Effect v4."
+  ),
+  "console": asRemoved(
+    "Use Effect.consoleWith or the Console service directly."
+  ),
+  "consoleWith": asRemoved(
+    "Console access has been reworked in Effect v4."
+  ),
+  "context": asRemoved(
+    "Use Effect.context is removed. Access services directly via yield* or Effect.provideService."
+  ),
+  "contextWith": asRemoved(
+    "Use Effect.map with service access instead."
+  ),
+  "contextWithEffect": asRemoved(
+    "Use Effect.flatMap with service access instead."
+  ),
+  "custom": asRemoved(
+    "Use Effect.suspend or Effect.sync to create custom effects."
+  ),
+  "daemonChildren": asRemoved(
+    "Use Effect.forkDetach to fork detached fibers instead."
+  ),
+  "descriptor": asRemoved(
+    "Fiber descriptor access has been removed in Effect v4."
+  ),
+  "descriptorWith": asRemoved(
+    "Fiber descriptor access has been removed in Effect v4."
+  ),
+  "dieMessage": asRemoved(
+    "Use Effect.die(new Error(message)) instead."
+  ),
+  "dieSync": asRemoved(
+    "Use Effect.die with a lazily evaluated value instead."
+  ),
+  "diffFiberRefs": asRemoved(
+    "FiberRef has been replaced by ServiceMap.Reference in Effect v4."
+  ),
+  "disconnect": asRemoved(
+    "Fiber disconnect has been removed in Effect v4."
+  ),
+  "dropUntil": asRemoved(
+    "Use Array.dropUntil and Effect.forEach instead."
+  ),
+  "dropWhile": asRemoved(
+    "Use Array.dropWhile and Effect.forEach instead."
+  ),
+  "either": asRenamedAndNeedsOptions(
+    "result",
+    "Note: returns Result.Result<A, E> instead of Either<E, A>. Use the Result module to work with the result."
+  ),
+  "ensuringChild": asRemoved(
+    "Use Effect.onExit to manage child fiber cleanup instead."
+  ),
+  "ensuringChildren": asRemoved(
+    "Use Effect.onExit to manage child fiber cleanup instead."
+  ),
+  "every": asRemoved(
+    "Use Effect.forEach with a predicate check instead."
+  ),
+  "exists": asRemoved(
+    "Use Effect.forEach with a predicate check instead."
+  ),
+  "fiberIdWith": asRemoved(
+    "Use Effect.fiberId instead."
+  ),
+  "filterEffectOrElse": asRemoved(
+    "Use Effect.filterOrElse with an effectful predicate instead."
+  ),
+  "filterEffectOrFail": asRemoved(
+    "Use Effect.filterOrFail with an effectful predicate instead."
+  ),
+  "filterOrDie": asRemoved(
+    "Use Effect.filterOrFail and Effect.orDie instead."
+  ),
+  "filterOrDieMessage": asRemoved(
+    "Use Effect.filterOrFail and Effect.orDie instead."
+  ),
+  "finalizersMask": asRemoved(
+    "Finalizer masking has been removed in Effect v4."
+  ),
+  "findFirst": asUnchanged,
+  "firstSuccessOf": asRemoved(
+    "Use Effect.raceAll instead."
+  ),
+  "flipWith": asRemoved(
+    "Use Effect.flip combined with the desired transformation instead."
+  ),
+  "fromFiber": asRemoved(
+    "Use Fiber.join instead."
+  ),
+  "fromFiberEffect": asRemoved(
+    "Use Effect.flatMap with Fiber.join instead."
+  ),
+  "fromNullable": asRemoved(
+    "Use Effect.suspend with null checks instead."
+  ),
+  "functionWithSpan": asRemoved(
+    "Use Effect.withSpan instead."
+  ),
+  "getFiberRefs": asRemoved(
+    "FiberRef has been replaced by ServiceMap.Reference in Effect v4."
+  ),
+  "getRuntimeFlags": asRemoved(
+    "Runtime flags have been removed in Effect v4."
+  ),
+  "head": asRemoved(
+    "Use Array.head and Effect.flatMap instead."
+  ),
+  "if": asRemoved(
+    "Use Effect.when instead of Effect.if."
+  ),
+  "ignoreLogged": asRemoved(
+    "Logging configuration has been reworked in Effect v4."
+  ),
+  "inheritFiberRefs": asRemoved(
+    "FiberRef has been replaced by ServiceMap.Reference in Effect v4."
+  ),
+  "interruptWith": asRemoved(
+    "Use Effect.interrupt instead."
+  ),
+  "intoDeferred": asRemoved(
+    "Use Deferred.complete instead."
+  ),
+  "iterate": asRemoved(
+    "Use Effect.whileLoop or recursion with Effect.suspend instead."
+  ),
+  "labelMetrics": asRemoved(
+    "Metric labeling has been reworked in Effect v4."
+  ),
+  "labelMetricsScoped": asRemoved(
+    "Metric labeling has been reworked in Effect v4."
+  ),
+  "liftPredicate": asRemoved(
+    "Use Effect.filterOrFail instead."
+  ),
+  "linkSpanCurrent": asRemoved(
+    "Use Effect.linkSpans instead."
+  ),
+  "locally": asRemoved(
+    "FiberRef.locally has been removed. Use Effect.provideService with ServiceMap.Reference instead."
+  ),
+  "locallyScoped": asRemoved(
+    "FiberRef.locally has been removed. Use Effect.provideService with ServiceMap.Reference instead."
+  ),
+  "locallyScopedWith": asRemoved(
+    "FiberRef.locally has been removed. Use Effect.provideService with ServiceMap.Reference instead."
+  ),
+  "locallyWith": asRemoved(
+    "FiberRef.locally has been removed. Use Effect.provideService with ServiceMap.Reference instead."
+  ),
+  "logAnnotations": asRemoved(
+    "Use Effect.annotateLogs instead."
+  ),
+  "loop": asRemoved(
+    "Use Effect.whileLoop or recursion with Effect.suspend instead."
+  ),
+  "mapAccum": asRemoved(
+    "Use Effect.gen with a mutable accumulator instead."
+  ),
+  "mapErrorCause": asRemoved(
+    "Use Effect.sandbox and Effect.mapError instead."
+  ),
+  "mapInputContext": asRemoved(
+    "Use Effect.provide with a layer instead."
+  ),
+  "merge": asRemoved(
+    "Use Effect.match or Effect.exit instead."
+  ),
+  "mergeAll": asRemoved(
+    "Use Effect.forEach with a mutable accumulator instead."
+  ),
+  "metricLabels": asRemoved(
+    "Metric labeling has been reworked in Effect v4."
+  ),
+  "negate": asRemoved(
+    "Use Effect.map with boolean negation instead."
+  ),
+  "none": asRemoved(
+    "Use Effect.filterOrFail or Effect.option instead."
+  ),
+  "once": asRemoved(
+    "Use Effect.cached instead."
+  ),
+  "optionFromOptional": asRemoved(
+    "Use Effect.option instead."
+  ),
+  "orDieWith": asRemoved(
+    "Use Effect.orDie or Effect.mapError combined with Effect.orDie instead."
+  ),
+  "orElse": asRemoved(
+    "Use Effect.catch or Effect.matchEffect instead."
+  ),
+  "orElseFail": asRemoved(
+    "Use Effect.mapError instead."
+  ),
+  "parallelErrors": asRemoved(
+    "Use Effect.all with concurrency options instead."
+  ),
+  "parallelFinalizers": asRemoved(
+    "Finalizer ordering configuration has been removed in Effect v4."
+  ),
+  "patchFiberRefs": asRemoved(
+    "FiberRef has been replaced by ServiceMap.Reference in Effect v4."
+  ),
+  "patchRuntimeFlags": asRemoved(
+    "Runtime flags have been removed in Effect v4."
+  ),
+  "raceWith": asRemoved(
+    "Use Effect.race or Effect.raceFirst instead."
+  ),
+  "random": asRemoved(
+    "Use Effect.randomWith instead."
+  ),
+  "randomWith": asRemoved(
+    "Random access has been reworked in Effect v4."
+  ),
+  "reduce": asRemoved(
+    "Use Effect.forEach with a mutable accumulator or Effect.gen instead."
+  ),
+  "reduceEffect": asRemoved(
+    "Use Effect.forEach with a mutable accumulator or Effect.gen instead."
+  ),
+  "reduceRight": asRemoved(
+    "Use Effect.forEach with a mutable accumulator or Effect.gen instead."
+  ),
+  "reduceWhile": asRemoved(
+    "Use Effect.gen with early return instead."
+  ),
+  "repeatN": asRemoved(
+    "Use Effect.repeat with a schedule instead."
+  ),
+  "runRequestBlock": asRemoved(
+    "The request batching API has been reworked in Effect v4."
+  ),
+  "scheduleForked": asRemoved(
+    "Use Effect.schedule combined with Effect.forkChild instead."
+  ),
+  "sequentialFinalizers": asRemoved(
+    "Finalizer ordering configuration has been removed in Effect v4."
+  ),
+  "serviceConstants": asRemoved(
+    "Service helpers have been removed. Use ServiceMap.Service and yield* to access services."
+  ),
+  "serviceFunction": asRemoved(
+    "Service helpers have been removed. Use ServiceMap.Service and yield* to access services."
+  ),
+  "serviceFunctionEffect": asRemoved(
+    "Service helpers have been removed. Use ServiceMap.Service and yield* to access services."
+  ),
+  "serviceFunctions": asRemoved(
+    "Service helpers have been removed. Use ServiceMap.Service and yield* to access services."
+  ),
+  "serviceMembers": asRemoved(
+    "Service helpers have been removed. Use ServiceMap.Service and yield* to access services."
+  ),
+  "setFiberRefs": asRemoved(
+    "FiberRef has been replaced by ServiceMap.Reference in Effect v4."
+  ),
+  "step": asRemoved(
+    "The request batching API has been reworked in Effect v4."
+  ),
+  "summarized": asRemoved(
+    "Use Effect.gen to capture before/after state instead."
+  ),
+  "supervised": asRemoved(
+    "Supervision has been reworked in Effect v4."
+  ),
+  "tagMetrics": asRemoved(
+    "Metric labeling has been reworked in Effect v4."
+  ),
+  "tagMetricsScoped": asRemoved(
+    "Metric labeling has been reworked in Effect v4."
+  ),
+  "takeUntil": asRemoved(
+    "Use Array.takeUntil and Effect.forEach instead."
+  ),
+  "takeWhile": asRemoved(
+    "Use Array.takeWhile and Effect.forEach instead."
+  ),
+  "tapBoth": asRemoved(
+    "Use Effect.tap and Effect.tapError instead."
+  ),
+  "timedWith": asRemoved(
+    "Use Effect.timed instead."
+  ),
+  "timeoutFail": asRemoved(
+    "Use Effect.timeout combined with Effect.catchTag for TimeoutException instead."
+  ),
+  "timeoutFailCause": asRemoved(
+    "Use Effect.timeout combined with Effect.sandbox instead."
+  ),
+  "timeoutTo": asRemoved(
+    "Use Effect.timeoutOption and Effect.map instead."
+  ),
+  "tracerWith": asRemoved(
+    "Use Effect.tracer instead."
+  ),
+  "transplant": asRemoved(
+    "Fiber transplanting has been removed in Effect v4."
+  ),
+  "transposeMapOption": asRemoved(
+    "Use Effect.map with Option operations instead."
+  ),
+  "transposeOption": asRemoved(
+    "Use Effect.option instead."
+  ),
+  "tryMap": asRemoved(
+    "Use Effect.map inside Effect.try instead."
+  ),
+  "tryMapPromise": asRemoved(
+    "Use Effect.tryPromise instead."
+  ),
+  "unless": asRemoved(
+    "Use Effect.when with a negated condition instead."
+  ),
+  "unlessEffect": asRemoved(
+    "Use Effect.when with a negated effectful condition instead."
+  ),
+  "unsafeMakeLatch": asRemoved(
+    "Use Effect.makeLatch instead."
+  ),
+  "unsafeMakeSemaphore": asRemoved(
+    "Use Effect.makeSemaphore instead."
+  ),
+  "unsandbox": asRemoved(
+    "Use Effect.catchCause instead."
+  ),
+  "updateFiberRefs": asRemoved(
+    "FiberRef has been replaced by ServiceMap.Reference in Effect v4."
+  ),
+  "using": asRemoved(
+    "Use Effect.scoped instead."
+  ),
+  "validateAll": asRemoved(
+    "Use Effect.all with { mode: 'validate' } instead."
+  ),
+  "validateFirst": asRemoved(
+    "Use Effect.all with { mode: 'validate' } instead."
+  ),
+  "validateWith": asRemoved(
+    "Use Effect.all with { mode: 'validate' } instead."
+  ),
+  "whenEffect": asRemoved(
+    "Use Effect.when with an effectful condition via Effect.flatMap instead."
+  ),
+  "whenFiberRef": asRemoved(
+    "FiberRef has been replaced by ServiceMap.Reference in Effect v4."
+  ),
+  "whenLogLevel": asRemoved(
+    "Log level checking has been reworked in Effect v4."
+  ),
+  "whenRef": asRemoved(
+    "Use Ref.get and Effect.when instead."
+  ),
+  "withClock": asRemoved(
+    "Clock configuration has been reworked in Effect v4."
+  ),
+  "withClockScoped": asRemoved(
+    "Clock configuration has been reworked in Effect v4."
+  ),
+  "withConfigProvider": asRemoved(
+    "ConfigProvider configuration has been reworked in Effect v4."
+  ),
+  "withConfigProviderScoped": asRemoved(
+    "ConfigProvider configuration has been reworked in Effect v4."
+  ),
+  "withConsole": asRemoved(
+    "Console configuration has been reworked in Effect v4."
+  ),
+  "withConsoleScoped": asRemoved(
+    "Console configuration has been reworked in Effect v4."
+  ),
+  "withEarlyRelease": asRemoved(
+    "Use Effect.scoped with manual resource management instead."
+  ),
+  "withFiberRuntime": asRenamedAndNeedsOptions(
+    "withFiber",
+    "Note: in v4, only the Fiber is provided (not the full FiberRuntime with status). The callback receives (fiber: Fiber<unknown, unknown>) instead of (fiber: FiberRuntime<A, E>, status: FiberStatus)."
+  ),
+  "withMaxOpsBeforeYield": asRemoved(
+    "Use ServiceMap.Reference for MaxOpsBeforeYield configuration instead."
+  ),
+  "withMetric": asRemoved(
+    "Metric configuration has been reworked in Effect v4."
+  ),
+  "withRandom": asRemoved(
+    "Random configuration has been reworked in Effect v4."
+  ),
+  "withRandomFixed": asRemoved(
+    "Random configuration has been reworked in Effect v4."
+  ),
+  "withRandomScoped": asRemoved(
+    "Random configuration has been reworked in Effect v4."
+  ),
+  "withRequestBatching": asRemoved(
+    "Request batching configuration has been reworked in Effect v4."
+  ),
+  "withRequestCache": asRemoved(
+    "Request caching configuration has been reworked in Effect v4."
+  ),
+  "withRequestCaching": asRemoved(
+    "Request caching configuration has been reworked in Effect v4."
+  ),
+  "withRuntimeFlagsPatch": asRemoved(
+    "Runtime flags have been removed in Effect v4."
+  ),
+  "withRuntimeFlagsPatchScoped": asRemoved(
+    "Runtime flags have been removed in Effect v4."
+  ),
+  "withScheduler": asRemoved(
+    "Use ServiceMap.Reference for Scheduler configuration instead."
+  ),
+  "withSchedulingPriority": asRemoved(
+    "Scheduling priority configuration has been removed in Effect v4."
+  ),
+  "withTracerScoped": asRemoved(
+    "Use Effect.withTracer instead."
+  ),
+  "withUnhandledErrorLogLevel": asRemoved(
+    "Use ServiceMap.Reference for UnhandledLogLevel configuration instead."
+  ),
+  "zipLeft": asRemoved(
+    "Use Effect.tap instead of Effect.zipLeft."
+  ),
+  "zipRight": asRemoved(
+    "Use Effect.andThen instead of Effect.zipRight."
+  )
+};
+
+// src/diagnostics/outdatedApi.ts
+var outdatedApi = createDiagnostic({
+  name: "outdatedApi",
+  code: 48,
+  description: "Detects usage of APIs that have been removed or renamed in Effect v4",
+  severity: "warning",
+  apply: fn("outdatedApi.apply")(function* (sourceFile, report) {
+    const typeParser = yield* service(TypeParser);
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    if (typeParser.supportedEffect() === "v3") return;
+    let hasReported = false;
+    function reportMigration(propertyAccess, propertyName, _migration) {
+      hasReported = true;
+      report({
+        location: propertyAccess.name,
+        messageText: `${propertyName} is an Effect v3 API, but the project is using Effect v4.`,
+        fixes: []
+      });
+    }
+    const checkPropertyAccessMigration = (propertyAccess, checkRightNode, migrationDb) => {
+      if (!ts.isPropertyAccessExpression(propertyAccess)) return;
+      const identifier2 = propertyAccess.name;
+      if (!ts.isIdentifier(identifier2)) return;
+      const identifierName = ts.idText(identifier2);
+      const migration = migrationDb[identifierName];
+      if (!migration) return;
+      if (migration._tag === "Unchanged") return;
+      const targetType = typeCheckerUtils.getTypeAtLocation(propertyAccess.expression);
+      if (!targetType) return;
+      const targetPropertySymbol = typeChecker.getPropertyOfType(targetType, identifierName);
+      if (targetPropertySymbol) return;
+      return pipe(
+        checkRightNode(propertyAccess.expression),
+        map5(() => reportMigration(propertyAccess, identifierName, migration)),
+        ignore
+      );
+    };
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      const checkEffectMigration = checkPropertyAccessMigration(
+        node,
+        typeParser.importedEffectModule,
+        effectModuleMigrationDb
+      );
+      if (checkEffectMigration) {
+        yield* ignore(checkEffectMigration);
+      }
+    }
+    if (hasReported) {
+      report({
+        location: { pos: 0, end: 0 },
+        messageText: "This project targets Effect v4, but is using Effect v3 APIs. To find the correct API to use, clone and consult the github.com/effect-ts/effect-smol repository for the corresponding v4 replacement.",
+        fixes: []
+      });
+    }
+  })
+});
+
 // src/diagnostics/outdatedEffectCodegen.ts
 var outdatedEffectCodegen = createDiagnostic({
   name: "outdatedEffectCodegen",
@@ -10962,6 +12062,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 
 // src/diagnostics.ts
 var diagnostics = [
+  outdatedApi,
   anyUnknownInErrorContext,
   instanceOfSchema,
   catchAllToMapError,
@@ -10974,6 +12075,7 @@ var diagnostics = [
   missingEffectServiceDependency,
   missingLayerContext,
   floatingEffect,
+  effectInFailure,
   missingStarInYieldEffectGen,
   unnecessaryEffectGen,
   unnecessaryFailYieldableError,
@@ -11130,7 +12232,7 @@ var effectSchemaSelfInClasses = createCompletion({
       );
       if (hasTaggedErrorCompletion) {
         completions2.push({
-          name: `TaggedError<${name}>`,
+          name: `TaggedErrorClass<${name}>`,
           kind: ts.ScriptElementKind.constElement,
           insertText: isFullyQualified ? `${schemaIdentifier}.TaggedErrorClass<${name}>()("${errorTagKey}", {${"${0}"}}){}` : `TaggedErrorClass<${name}>()("${errorTagKey}", {${"${0}"}}){}`,
           replacementSpan,
@@ -11187,6 +12289,33 @@ var effectSchemaSelfInClasses = createCompletion({
         });
       }
     }
+    if (typeParser.supportedEffect() === "v4") {
+      const modelIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect/unstable/schema",
+        "Model"
+      ) || tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect/unstable",
+        "Model"
+      ) || "Model";
+      const isModelFullyQualified = modelIdentifier === ts.idText(accessedObject);
+      const hasModelClassCompletion = isModelFullyQualified || isSome2(
+        yield* pipe(
+          typeParser.isNodeReferenceToEffectSchemaModelModuleApi("Class")(accessedObject),
+          option
+        )
+      );
+      if (hasModelClassCompletion) {
+        completions2.push({
+          name: `Class<${name}>`,
+          kind: ts.ScriptElementKind.constElement,
+          insertText: isModelFullyQualified ? `${modelIdentifier}.Class<${name}>("${name}")({${"${0}"}}){}` : `Class<${name}>("${name}")({${"${0}"}}){}`,
+          replacementSpan,
+          isSnippet: true
+        });
+      }
+    }
     return completions2;
   })
 });
@@ -12443,7 +13572,7 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
       if (!(data && data.shouldTry)) return quickInfo2;
       const { atLocation, label, node, type } = data;
       const effectTypeArgsDocumentation = yield* pipe(
-        typeParser.effectType(
+        typeParser.effectYieldableType(
           type,
           atLocation
         ),
@@ -18203,13 +19332,19 @@ var layerMagic = createRefactor({
                 map5((_) => _.ROut),
                 option
               );
-              const [existingBefore, newlyIntroduced] = pipe(
+              const sorted = pipe(
                 fromIterable(layerOutputTypes),
-                sort(typeCheckerUtils.deterministicTypeOrder),
-                partition(
-                  (_) => isNone2(previouslyProvided) || typeChecker.isTypeAssignableTo(_, previouslyProvided.value)
-                )
+                sort(typeCheckerUtils.deterministicTypeOrder)
               );
+              const existingBefore = [];
+              const newlyIntroduced = [];
+              for (const t of sorted) {
+                if (isNone2(previouslyProvided) || typeChecker.isTypeAssignableTo(t, previouslyProvided.value)) {
+                  newlyIntroduced.push(t);
+                } else {
+                  existingBefore.push(t);
+                }
+              }
               const typeReferences = pipe(
                 newlyIntroduced,
                 map4((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),