@effect/language-service 0.76.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.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:
@@ -60,7 +60,7 @@ var pipeArguments = (self, args3) => {
   }
 };
 
-// ../../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() {
@@ -108,7 +108,7 @@ function pipe(a, ...args3) {
   return pipeArguments(a, args3);
 }
 
-// ../../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;
@@ -131,7 +131,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";
 }
@@ -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.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) {
@@ -271,7 +271,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) {
@@ -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.12/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.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();
@@ -531,7 +534,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 {
@@ -575,7 +578,7 @@ var Class = 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;
@@ -643,7 +646,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 = {
@@ -990,7 +993,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]: {
@@ -1055,7 +1058,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]: {
@@ -1126,13 +1129,13 @@ var succeed = (success) => {
   return a;
 };
 
-// ../../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/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.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;
@@ -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.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;
@@ -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.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 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.12/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);
@@ -4608,6 +4637,73 @@ function make2(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);
@@ -4980,6 +5076,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     isNodeReferenceToEffectDataModuleApi,
     isNodeReferenceToEffectContextModuleApi,
     isNodeReferenceToEffectSqlModelModuleApi,
+    isNodeReferenceToEffectSchemaModelModuleApi,
     isNodeReferenceToEffectLayerModuleApi,
     isNodeReferenceToEffectSchemaParserModuleApi,
     isServiceMapTypeSourceFile,
@@ -4989,6 +5086,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     layerType,
     fiberType,
     effectSubtype,
+    effectYieldableType,
     importedEffectModule,
     effectGen,
     effectFnUntracedGen,
@@ -5017,6 +5115,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     extendsSchemaTaggedRequest,
     extendsSchemaRequestClass,
     extendsEffectSqlModelClass,
+    extendsEffectSchemaModelClass,
     lazyExpression,
     emptyFunction,
     pipingFlows,
@@ -5307,6 +5406,7 @@ var classSelfMismatch = createDiagnostic({
             )
           ),
           orElse2(() => typeParser.extendsEffectSqlModelClass(node)),
+          orElse2(() => typeParser.extendsEffectSchemaModelClass(node)),
           orElse2(() => void_)
         );
         if (result) {
@@ -5699,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;
@@ -5716,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];
@@ -5800,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;
         }
@@ -5809,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({
@@ -5828,7 +6115,8 @@ var effectFnOpportunity = createDiagnostic({
           node,
           nameIdentifier,
           effectModuleName: opportunity.effectModuleName,
-          inferredTraceName: traceName,
+          inferredTraceName,
+          suggestedTraceName,
           explicitTraceExpression: opportunity.explicitTraceExpression,
           pipeArguments: opportunity.pipeArguments,
           generatorFunction: opportunity.generatorFunction,
@@ -5838,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)) {
@@ -5932,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({
@@ -5963,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",
@@ -5985,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 = () => {
@@ -6013,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) {
@@ -6027,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})`;
         }
@@ -6079,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",
@@ -7447,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);
@@ -7456,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
+      });
     }
   })
 });
@@ -7765,6 +8123,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),
+        map4(() => 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/refactors/writeTagClassAccessors.ts
 var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, service2, className, atLocation, involvedMembers) {
   const ts = yield* service(TypeScriptApi);
@@ -10204,6 +11317,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 
 // src/diagnostics.ts
 var diagnostics = [
+  outdatedApi,
   anyUnknownInErrorContext,
   instanceOfSchema,
   catchAllToMapError,
@@ -10216,6 +11330,7 @@ var diagnostics = [
   missingEffectServiceDependency,
   missingLayerContext,
   floatingEffect,
+  effectInFailure,
   missingStarInYieldEffectGen,
   unnecessaryEffectGen,
   unnecessaryFailYieldableError,