@effect/language-service 0.77.0 → 0.79.0

package/effect-lsp-patch-utils.js

@@ -27,7 +27,7 @@ __export(effect_lsp_patch_utils_exports, {
 });
 module.exports = __toCommonJS(effect_lsp_patch_utils_exports);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Pipeable.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Pipeable.js
 var pipeArguments = (self, args3) => {
   switch (args3.length) {
     case 0:
@@ -60,7 +60,7 @@ var pipeArguments = (self, args3) => {
   }
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Function.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Function.js
 var dual = function(arity, body) {
   if (typeof arity === "function") {
     return function() {
@@ -108,7 +108,7 @@ function pipe(a, ...args3) {
   return pipeArguments(a, args3);
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/internal/equal.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/internal/equal.js
 var getAllObjectKeys = (obj) => {
   const keys2 = new Set(Reflect.ownKeys(obj));
   if (obj.constructor === Object) return keys2;
@@ -131,7 +131,7 @@ var getAllObjectKeys = (obj) => {
 };
 var byReferenceInstances = /* @__PURE__ */ new WeakSet();
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Predicate.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Predicate.js
 function isString(input) {
   return typeof input === "string";
 }
@@ -152,7 +152,7 @@ function isObjectKeyword(input) {
 }
 var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObjectKeyword(self) && property in self);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Hash.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Hash.js
 var symbol = "~effect/interfaces/Hash";
 var hash = (self) => {
   switch (typeof self) {
@@ -271,7 +271,7 @@ function withVisitedTracking(obj, fn2) {
   return result;
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Equal.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Equal.js
 var symbol2 = "~effect/interfaces/Equal";
 function equals() {
   if (arguments.length === 1) {
@@ -433,7 +433,10 @@ var compareSets = /* @__PURE__ */ makeCompareSet(compareBoth);
 var isEqual = (u) => hasProperty(u, symbol2);
 var asEquivalence = () => equals;
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Redactable.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/internal/array.js
+var isArrayNonEmpty = (self) => self.length > 0;
+
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Redactable.js
 var symbolRedactable = /* @__PURE__ */ Symbol.for("~effect/Inspectable/redactable");
 var isRedactable = (u) => hasProperty(u, symbolRedactable);
 function redact(u) {
@@ -452,7 +455,7 @@ var emptyServiceMap = {
   }
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Formatter.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Formatter.js
 function format(input, options) {
   const space = options?.space ?? 0;
   const seen = /* @__PURE__ */ new WeakSet();
@@ -531,7 +534,7 @@ function safeToString(input) {
   }
 }
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Inspectable.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJson = (input) => {
   try {
@@ -575,7 +578,7 @@ var Class = class {
   }
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Utils.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Utils.js
 var GenKindTypeId = "~effect/Utils/GenKind";
 var GenKindImpl = class {
   value;
@@ -643,7 +646,7 @@ var internalCall = isNotOptimizedAway ? standard[InternalTypeId] : forced[Intern
 var genConstructor = function* () {
 }.constructor;
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/internal/core.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/internal/core.js
 var EffectTypeId = `~effect/Effect`;
 var ExitTypeId = `~effect/Exit`;
 var effectVariance = {
@@ -990,7 +993,7 @@ var DoneVoid = {
   value: void 0
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/internal/option.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/internal/option.js
 var TypeId = "~effect/data/Option";
 var CommonProto = {
   [TypeId]: {
@@ -1055,7 +1058,7 @@ var some = (value) => {
   return a;
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/internal/result.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/internal/result.js
 var TypeId2 = "~effect/data/Result";
 var CommonProto2 = {
   [TypeId2]: {
@@ -1126,13 +1129,13 @@ var succeed = (success) => {
   return a;
 };
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Order.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Order.js
 function make(compare) {
   return (self, that) => self === that ? 0 : compare(self, that);
 }
 var String2 = /* @__PURE__ */ make((self, that) => self < that ? -1 : 1);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Option.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Option.js
 var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
@@ -1142,7 +1145,7 @@ var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : se
 var fromNullishOr = (a) => a == null ? none2() : some2(a);
 var getOrUndefined = /* @__PURE__ */ getOrElse(constUndefined);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Result.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Result.js
 var succeed2 = succeed;
 var fail2 = fail;
 var isFailure2 = isFailure;
@@ -1150,18 +1153,7 @@ var isSuccess2 = isSuccess;
 var map = /* @__PURE__ */ dual(2, (self, f) => isSuccess2(self) ? succeed2(f(self.success)) : fail2(self.failure));
 var getOrElse2 = /* @__PURE__ */ dual(2, (self, onFailure) => isFailure2(self) ? onFailure(self.failure) : self.success);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Filter.js
-var apply = (filter2, input, ...args3) => {
-  const result = filter2(input, ...args3);
-  if (result === true) return succeed2(input);
-  if (result === false) return fail2(input);
-  return result;
-};
-
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/internal/array.js
-var isArrayNonEmpty = (self) => self.length > 0;
-
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Record.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Record.js
 var map2 = /* @__PURE__ */ dual(2, (self, f) => {
   const out = {
     ...self
@@ -1173,7 +1165,7 @@ var map2 = /* @__PURE__ */ dual(2, (self, f) => {
 });
 var keys = (self) => Object.keys(self);
 
-// ../../node_modules/.pnpm/effect@4.0.0-beta.14/node_modules/effect/dist/Array.js
+// ../../node_modules/.pnpm/effect@4.0.0-beta.27/node_modules/effect/dist/Array.js
 var Array2 = globalThis.Array;
 var fromIterable = (collection) => Array2.isArray(collection) ? collection : Array2.from(collection);
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
@@ -1236,13 +1228,12 @@ var flatMap = /* @__PURE__ */ dual(2, (self, f) => {
   return out;
 });
 var flatten = /* @__PURE__ */ flatMap(identity);
-var filter = /* @__PURE__ */ dual(2, (self, f) => {
+var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
   const as = fromIterable(self);
   const out = [];
   for (let i = 0; i < as.length; i++) {
-    const result = apply(f, as[i], i);
-    if (!isFailure2(result)) {
-      out.push(result.success);
+    if (predicate(as[i], i)) {
+      out.push(as[i]);
     }
   }
   return out;
@@ -1646,10 +1637,12 @@ var defaults = {
   extendedKeyDetection: false,
   ignoreEffectWarningsInTscExitCode: false,
   ignoreEffectSuggestionsInTscExitCode: true,
+  ignoreEffectErrorsInTscExitCode: false,
   pipeableMinArgCount: 2,
   effectFn: ["span"],
   layerGraphFollowDepth: 0,
-  mermaidProvider: "mermaid.live"
+  mermaidProvider: "mermaid.live",
+  skipDisabledOptimization: false
 };
 function parseKeyPatterns(patterns) {
   const result = [];
@@ -1673,6 +1666,7 @@ function parse(config) {
     includeSuggestionsInTsc: isObject(config) && hasProperty(config, "includeSuggestionsInTsc") && isBoolean(config.includeSuggestionsInTsc) ? config.includeSuggestionsInTsc : defaults.includeSuggestionsInTsc,
     ignoreEffectWarningsInTscExitCode: isObject(config) && hasProperty(config, "ignoreEffectWarningsInTscExitCode") && isBoolean(config.ignoreEffectWarningsInTscExitCode) ? config.ignoreEffectWarningsInTscExitCode : defaults.ignoreEffectWarningsInTscExitCode,
     ignoreEffectSuggestionsInTscExitCode: isObject(config) && hasProperty(config, "ignoreEffectSuggestionsInTscExitCode") && isBoolean(config.ignoreEffectSuggestionsInTscExitCode) ? config.ignoreEffectSuggestionsInTscExitCode : defaults.ignoreEffectSuggestionsInTscExitCode,
+    ignoreEffectErrorsInTscExitCode: isObject(config) && hasProperty(config, "ignoreEffectErrorsInTscExitCode") && isBoolean(config.ignoreEffectErrorsInTscExitCode) ? config.ignoreEffectErrorsInTscExitCode : defaults.ignoreEffectErrorsInTscExitCode,
     quickinfo: isObject(config) && hasProperty(config, "quickinfo") && isBoolean(config.quickinfo) ? config.quickinfo : defaults.quickinfo,
     quickinfoEffectParameters: isObject(config) && hasProperty(config, "quickinfoEffectParameters") && isString(config.quickinfoEffectParameters) && ["always", "never", "whentruncated"].includes(config.quickinfoEffectParameters.toLowerCase()) ? config.quickinfoEffectParameters.toLowerCase() : defaults.quickinfoEffectParameters,
     quickinfoMaximumLength: isObject(config) && hasProperty(config, "quickinfoMaximumLength") && isNumber(config.quickinfoMaximumLength) ? config.quickinfoMaximumLength : defaults.quickinfoMaximumLength,
@@ -1689,9 +1683,12 @@ 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
+    mermaidProvider: isObject(config) && hasProperty(config, "mermaidProvider") && isString(config.mermaidProvider) ? config.mermaidProvider : defaults.mermaidProvider,
+    skipDisabledOptimization: isObject(config) && hasProperty(config, "skipDisabledOptimization") && isBoolean(config.skipDisabledOptimization) ? config.skipDisabledOptimization : defaults.skipDisabledOptimization
   };
 }
 
@@ -2461,7 +2458,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
       if (skippedRules.indexOf(ruleNameLowered) > -1 || skippedRules.indexOf("*") > -1) {
         return { diagnostics: diagnostics2, codeFixes };
       }
-      if (defaultLevel === "off" && (lineOverrides[ruleNameLowered] || sectionOverrides[ruleNameLowered] || lineOverrides["*"] || sectionOverrides["*"] || []).length === 0) {
+      if (!pluginOptions.skipDisabledOptimization && defaultLevel === "off" && (lineOverrides[ruleNameLowered] || sectionOverrides[ruleNameLowered] || lineOverrides["*"] || sectionOverrides["*"] || []).length === 0) {
         return { diagnostics: diagnostics2, codeFixes };
       }
       const fixByDisableNextLine = (node) => ({
@@ -3381,6 +3378,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 +3435,34 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.effectSubtype",
     (type) => type
   );
+  const effectYieldableType = cachedBy(
+    fn("TypeParser.effectYieldableType")(function* (type, atLocation) {
+      if (supportedEffect() === "v3") {
+        return yield* effectType(type, atLocation);
+      }
+      return yield* firstSuccessOf([
+        effectType(type, atLocation),
+        gen(function* () {
+          const asEffectSymbol = typeChecker.getPropertyOfType(type, "asEffect");
+          if (!asEffectSymbol) {
+            return yield* typeParserIssue("Type has no 'asEffect' property", type, atLocation);
+          }
+          const asEffectType = typeChecker.getTypeOfSymbolAtLocation(asEffectSymbol, atLocation);
+          const asEffectSignatures = typeChecker.getSignaturesOfType(asEffectType, ts.SignatureKind.Call);
+          if (asEffectSignatures.length === 0) {
+            return yield* typeParserIssue("'asEffect' property is not callable", type, atLocation);
+          }
+          return yield* firstSuccessOf(
+            asEffectSignatures.map(
+              (signature) => effectType(typeChecker.getReturnTypeOfSignature(signature), atLocation)
+            )
+          );
+        })
+      ]);
+    }),
+    "TypeParser.effectYieldableType",
+    (type) => type
+  );
   const isEffectContextSourceFile = cachedBy(
     fn("TypeParser.isEffectContextSourceFile")(function* (sourceFile) {
       const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
@@ -5057,6 +5090,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     layerType,
     fiberType,
     effectSubtype,
+    effectYieldableType,
     importedEffectModule,
     effectGen,
     effectFnUntracedGen,
@@ -5101,6 +5135,8 @@ var anyUnknownInErrorContext = createDiagnostic({
   code: 28,
   description: "Detects 'any' or 'unknown' types in Effect error or requirements channels",
   severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("anyUnknownInErrorContext.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -5204,6 +5240,8 @@ var catchAllToMapError = createDiagnostic({
   code: 39,
   description: "Suggests using Effect.mapError instead of Effect.catchAll when the callback only wraps the error with Effect.fail",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("catchAllToMapError.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -5301,6 +5339,8 @@ var catchUnfailableEffect = createDiagnostic({
   code: 2,
   description: "Warns when using error handling on Effects that never fail (error type is 'never')",
   severity: "suggestion",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("catchUnfailableEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -5350,6 +5390,8 @@ var classSelfMismatch = createDiagnostic({
   code: 20,
   description: "Ensures Self type parameter matches the class name in Service/Tag/Schema classes",
   severity: "error",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("classSelfMismatch.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -5488,6 +5530,8 @@ var deterministicKeys = createDiagnostic({
   code: 25,
   description: "Enforces deterministic naming for service/tag/error identifiers based on class names",
   severity: "off",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("deterministicKeys.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -5605,6 +5649,8 @@ var duplicatePackage = createDiagnostic({
   code: 6,
   description: "Detects when multiple versions of the same Effect package are loaded",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("duplicatePackage.apply")(function* (sourceFile, report) {
     const typeParser = yield* service(TypeParser);
     const options = yield* service(LanguageServicePluginOptions);
@@ -5634,6 +5680,8 @@ var effectFnIife = createDiagnostic({
   code: 46,
   description: "Effect.fn or Effect.fnUntraced is called as an IIFE (Immediately Invoked Function Expression). Use Effect.gen instead.",
   severity: "warning",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("effectFnIife.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -5736,6 +5784,8 @@ var effectFnOpportunity = createDiagnostic({
   code: 41,
   description: "Suggests using Effect.fn for functions that returns an Effect",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("effectFnOpportunity.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -5769,16 +5819,16 @@ var effectFnOpportunity = createDiagnostic({
       if (ts.isFunctionDeclaration(node) && node.name) {
         return node.name;
       }
-      if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+      if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name) && node.parent.initializer === node) {
         return node.parent.name;
       }
-      if (node.parent && ts.isPropertyAssignment(node.parent)) {
+      if (node.parent && ts.isPropertyAssignment(node.parent) && node.parent.initializer === node) {
         const name = node.parent.name;
         if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
           return name;
         }
       }
-      if (node.parent && ts.isPropertyDeclaration(node.parent)) {
+      if (node.parent && ts.isPropertyDeclaration(node.parent) && node.parent.initializer === node) {
         const name = node.parent.name;
         if (ts.isIdentifier(name)) {
           return name;
@@ -5786,6 +5836,190 @@ var effectFnOpportunity = createDiagnostic({
       }
       return void 0;
     };
+    const hasExportModifier = (node) => {
+      if (!ts.canHaveModifiers(node)) return false;
+      const modifiers = ts.getModifiers(node);
+      return modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+    };
+    const layerServiceNameFromExpression = (expression) => {
+      if (expression.kind === ts.SyntaxKind.ThisKeyword) {
+        const enclosingClass = ts.findAncestor(
+          expression,
+          (node) => ts.isClassDeclaration(node)
+        );
+        if (enclosingClass?.name) {
+          return ts.idText(enclosingClass.name);
+        }
+      }
+      if (ts.isIdentifier(expression)) return ts.idText(expression);
+      return sourceFile.text.slice(expression.pos, expression.end).trim();
+    };
+    const tryGetLayerApiMethod = (node) => pipe(
+      typeParser.isNodeReferenceToEffectLayerModuleApi("effect")(node),
+      map4(() => "effect"),
+      orElse2(
+        () => pipe(
+          typeParser.isNodeReferenceToEffectLayerModuleApi("succeed")(node),
+          map4(() => "succeed"),
+          orElse2(
+            () => pipe(
+              typeParser.isNodeReferenceToEffectLayerModuleApi("sync")(node),
+              map4(() => "sync"),
+              orElse2(() => succeed3(void 0))
+            )
+          )
+        )
+      )
+    );
+    const verifyLayerMethodAtCall = fn("effectFnOpportunity.verifyLayerMethodAtCall")(
+      function* (callExpression, method, implementationExpression) {
+        const directMethod = yield* tryGetLayerApiMethod(callExpression.expression);
+        if (directMethod === method && callExpression.arguments.length >= 2 && callExpression.arguments[1] === implementationExpression) {
+          return layerServiceNameFromExpression(callExpression.arguments[0]);
+        }
+        if (ts.isCallExpression(callExpression.expression)) {
+          const innerCall = callExpression.expression;
+          const innerMethod = yield* tryGetLayerApiMethod(innerCall.expression);
+          if (innerMethod === method && innerCall.arguments.length >= 1 && callExpression.arguments.length >= 1 && callExpression.arguments[0] === implementationExpression) {
+            return layerServiceNameFromExpression(innerCall.arguments[0]);
+          }
+        }
+        return void 0;
+      }
+    );
+    const tryMatchLayerSucceedInference = fn("effectFnOpportunity.tryMatchLayerSucceedInference")(
+      function* (objectLiteral) {
+        const callExpression = objectLiteral.parent;
+        if (!callExpression || !ts.isCallExpression(callExpression)) return void 0;
+        return yield* verifyLayerMethodAtCall(callExpression, "succeed", objectLiteral);
+      }
+    );
+    const tryMatchLayerSyncInference = fn("effectFnOpportunity.tryMatchLayerSyncInference")(
+      function* (objectLiteral) {
+        const returnStatement = objectLiteral.parent;
+        if (!returnStatement || !ts.isReturnStatement(returnStatement)) return void 0;
+        const functionBody = returnStatement.parent;
+        if (!functionBody || !ts.isBlock(functionBody)) return void 0;
+        const lazyFunction = functionBody.parent;
+        if (!lazyFunction || !ts.isArrowFunction(lazyFunction) && !ts.isFunctionExpression(lazyFunction)) {
+          return void 0;
+        }
+        const callExpression = lazyFunction.parent;
+        if (!callExpression || !ts.isCallExpression(callExpression)) return void 0;
+        return yield* verifyLayerMethodAtCall(callExpression, "sync", lazyFunction);
+      }
+    );
+    const tryMatchLayerEffectInference = fn("effectFnOpportunity.tryMatchLayerEffectInference")(
+      function* (objectLiteral) {
+        const returnStatement = objectLiteral.parent;
+        if (!returnStatement || !ts.isReturnStatement(returnStatement)) return void 0;
+        const generatorBody = returnStatement.parent;
+        if (!generatorBody || !ts.isBlock(generatorBody)) return void 0;
+        const generatorFunction = generatorBody.parent;
+        if (!generatorFunction || !ts.isFunctionExpression(generatorFunction) || !generatorFunction.asteriskToken) {
+          return void 0;
+        }
+        const genCall = generatorFunction.parent;
+        if (!genCall || !ts.isCallExpression(genCall)) return void 0;
+        const parsedEffectGen = yield* option(typeParser.effectGen(genCall));
+        if (parsedEffectGen._tag === "None" || parsedEffectGen.value.generatorFunction !== generatorFunction) {
+          return void 0;
+        }
+        const layerCall = genCall.parent;
+        if (!layerCall || !ts.isCallExpression(layerCall)) return void 0;
+        return yield* verifyLayerMethodAtCall(layerCall, "effect", genCall);
+      }
+    );
+    const tryMatchOfInference = fn("effectFnOpportunity.tryMatchOfInference")(
+      function* (objectLiteral) {
+        const callExpression = objectLiteral.parent;
+        if (!callExpression || !ts.isCallExpression(callExpression)) return void 0;
+        if (callExpression.arguments.length < 1 || callExpression.arguments[0] !== objectLiteral) return void 0;
+        if (!ts.isPropertyAccessExpression(callExpression.expression)) return void 0;
+        if (ts.idText(callExpression.expression.name) !== "of") return void 0;
+        const serviceTagExpression = callExpression.expression.expression;
+        const serviceTagType = typeCheckerUtils.getTypeAtLocation(serviceTagExpression);
+        if (!serviceTagType) return void 0;
+        const isTagLike = yield* pipe(
+          typeParser.contextTag(serviceTagType, serviceTagExpression),
+          orElse2(() => typeParser.serviceType(serviceTagType, serviceTagExpression)),
+          option
+        );
+        if (isTagLike._tag === "None") return void 0;
+        return layerServiceNameFromExpression(serviceTagExpression);
+      }
+    );
+    const tryMatchServiceMapMakeInference = fn("effectFnOpportunity.tryMatchServiceMapMakeInference")(
+      function* (objectLiteral) {
+        const returnStatement = objectLiteral.parent;
+        if (!returnStatement || !ts.isReturnStatement(returnStatement)) return void 0;
+        const generatorBody = returnStatement.parent;
+        if (!generatorBody || !ts.isBlock(generatorBody)) return void 0;
+        const generatorFunction = generatorBody.parent;
+        if (!generatorFunction || !ts.isFunctionExpression(generatorFunction) || !generatorFunction.asteriskToken) {
+          return void 0;
+        }
+        const genCall = generatorFunction.parent;
+        if (!genCall || !ts.isCallExpression(genCall)) return void 0;
+        const parsedEffectGen = yield* option(typeParser.effectGen(genCall));
+        if (parsedEffectGen._tag === "None" || parsedEffectGen.value.generatorFunction !== generatorFunction) {
+          return void 0;
+        }
+        const makeProperty = genCall.parent;
+        if (!makeProperty || !ts.isPropertyAssignment(makeProperty)) return void 0;
+        if (makeProperty.initializer !== genCall) return void 0;
+        if (!ts.isIdentifier(makeProperty.name) || ts.idText(makeProperty.name) !== "make") return void 0;
+        let currentNode = makeProperty.parent;
+        let classDeclaration = void 0;
+        while (currentNode) {
+          if (ts.isClassDeclaration(currentNode)) {
+            classDeclaration = currentNode;
+            break;
+          }
+          currentNode = currentNode.parent;
+        }
+        if (!classDeclaration || !classDeclaration.name) return void 0;
+        const parsedServiceMapService = yield* option(typeParser.extendsServiceMapService(classDeclaration));
+        if (parsedServiceMapService._tag === "None") return void 0;
+        return ts.idText(classDeclaration.name);
+      }
+    );
+    const tryGetLayerInferredTraceName = fn("effectFnOpportunity.tryGetLayerInferredTraceName")(
+      function* (node, suggestedTraceName) {
+        if (!suggestedTraceName) return void 0;
+        if (!(node.parent && ts.isPropertyAssignment(node.parent) && node.parent.initializer === node && node.parent.parent && ts.isObjectLiteralExpression(node.parent.parent))) {
+          return void 0;
+        }
+        const objectLiteral = node.parent.parent;
+        const succeedServiceName = yield* tryMatchLayerSucceedInference(objectLiteral);
+        if (succeedServiceName) return `${succeedServiceName}.${suggestedTraceName}`;
+        const syncServiceName = yield* tryMatchLayerSyncInference(objectLiteral);
+        if (syncServiceName) return `${syncServiceName}.${suggestedTraceName}`;
+        const effectServiceName = yield* tryMatchLayerEffectInference(objectLiteral);
+        if (effectServiceName) return `${effectServiceName}.${suggestedTraceName}`;
+        const ofServiceName = yield* tryMatchOfInference(objectLiteral);
+        if (ofServiceName) return `${ofServiceName}.${suggestedTraceName}`;
+        const serviceMapMakeServiceName = yield* tryMatchServiceMapMakeInference(objectLiteral);
+        return serviceMapMakeServiceName ? `${serviceMapMakeServiceName}.${suggestedTraceName}` : void 0;
+      }
+    );
+    const getInferredTraceName = fn("effectFnOpportunity.getInferredTraceName")(
+      function* (node, suggestedTraceName) {
+        const inferredFromLayer = yield* tryGetLayerInferredTraceName(node, suggestedTraceName);
+        if (inferredFromLayer) return inferredFromLayer;
+        if (ts.isFunctionDeclaration(node) && node.name && hasExportModifier(node)) {
+          return ts.idText(node.name);
+        }
+        if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name) && node.parent.initializer === node) {
+          const variableDeclarationList = node.parent.parent;
+          const variableStatement = variableDeclarationList?.parent;
+          if (variableDeclarationList && ts.isVariableDeclarationList(variableDeclarationList) && variableStatement && ts.isVariableStatement(variableStatement) && hasExportModifier(variableStatement) && (variableDeclarationList.flags & ts.NodeFlags.Const) !== 0) {
+            return ts.idText(node.parent.name);
+          }
+        }
+        return void 0;
+      }
+    );
     const areParametersReferencedIn = (fnNode, nodes) => {
       if (fnNode.parameters.length === 0 || nodes.length === 0) return false;
       const firstParam = fnNode.parameters[0];
@@ -5870,7 +6104,10 @@ var effectFnOpportunity = createDiagnostic({
       );
     };
     const parseEffectFnOpportunityTargetGen = fn("effectFnOpportunity.parseEffectFnOpportunityTarget")(
-      function* (node, returnType, traceName, nameIdentifier) {
+      function* (node, returnType, nameIdentifier) {
+        const suggestedTraceName = nameIdentifier ? ts.isIdentifier(nameIdentifier) ? ts.idText(nameIdentifier) : nameIdentifier.text : void 0;
+        const inferredTraceName = yield* getInferredTraceName(node, suggestedTraceName);
+        const hasStrictLayerInferredName = inferredTraceName !== void 0 && inferredTraceName !== suggestedTraceName;
         if (yield* isInsideEffectFn(node)) {
           return yield* TypeParserIssue.issue;
         }
@@ -5879,11 +6116,11 @@ var effectFnOpportunity = createDiagnostic({
         const opportunity = yield* pipe(
           tryParseGenOpportunity(node),
           orElse2(() => {
-            if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+            if (ts.isArrowFunction(node) && !ts.isBlock(node.body) && !hasStrictLayerInferredName) {
               return TypeParserIssue.issue;
             }
             const body = ts.isArrowFunction(node) ? node.body : node.body;
-            if (!body || !ts.isBlock(body) || body.statements.length <= 5) {
+            if ((!body || !ts.isBlock(body) || body.statements.length <= 5) && !hasStrictLayerInferredName) {
               return TypeParserIssue.issue;
             }
             return succeed3({
@@ -5898,7 +6135,8 @@ var effectFnOpportunity = createDiagnostic({
           node,
           nameIdentifier,
           effectModuleName: opportunity.effectModuleName,
-          inferredTraceName: traceName,
+          inferredTraceName,
+          suggestedTraceName,
           explicitTraceExpression: opportunity.explicitTraceExpression,
           pipeArguments: opportunity.pipeArguments,
           generatorFunction: opportunity.generatorFunction,
@@ -5908,27 +6146,26 @@ var effectFnOpportunity = createDiagnostic({
     );
     const parseEffectFnOpportunityTarget = (node) => {
       if (!ts.isFunctionExpression(node) && !ts.isArrowFunction(node) && !ts.isFunctionDeclaration(node)) {
-        return TypeParserIssue.issue;
+        return;
       }
       if ((ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) && node.asteriskToken) {
-        return TypeParserIssue.issue;
+        return;
       }
       if (ts.isFunctionExpression(node) && node.name) {
-        return TypeParserIssue.issue;
+        return;
       }
       if (node.type) {
-        return TypeParserIssue.issue;
+        return;
       }
       const functionType = typeChecker.getTypeAtLocation(node);
-      if (!functionType) return TypeParserIssue.issue;
+      if (!functionType) return;
       const callSignatures = typeChecker.getSignaturesOfType(functionType, ts.SignatureKind.Call);
-      if (callSignatures.length !== 1) return TypeParserIssue.issue;
+      if (callSignatures.length !== 1) return;
       const signature = callSignatures[0];
       const returnType = typeChecker.getReturnTypeOfSignature(signature);
       const nameIdentifier = getNameIdentifier(node);
-      const traceName = nameIdentifier ? ts.isIdentifier(nameIdentifier) ? ts.idText(nameIdentifier) : nameIdentifier.text : void 0;
-      if (!traceName) return TypeParserIssue.issue;
-      return parseEffectFnOpportunityTargetGen(node, returnType, traceName, nameIdentifier);
+      if (!nameIdentifier) return;
+      return parseEffectFnOpportunityTargetGen(node, returnType, nameIdentifier);
     };
     const getFunctionBodyBlock = (node) => {
       if (ts.isArrowFunction(node)) {
@@ -6002,18 +6239,21 @@ var effectFnOpportunity = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
-      const target = yield* pipe(parseEffectFnOpportunityTarget(node), option);
-      if (isNone2(target)) continue;
-      if (target.value.hasParamsInPipeArgs) continue;
+      const test = parseEffectFnOpportunityTarget(node);
+      if (!test) continue;
+      const target = yield* orUndefined(test);
+      if (!target) continue;
+      if (target.hasParamsInPipeArgs) continue;
       const {
         effectModuleName,
         explicitTraceExpression,
         inferredTraceName,
         nameIdentifier,
         node: targetNode,
-        pipeArguments: pipeArguments2
-      } = target.value;
-      const innerFunction = target.value.generatorFunction ?? targetNode;
+        pipeArguments: pipeArguments2,
+        suggestedTraceName
+      } = target;
+      const innerFunction = target.generatorFunction ?? targetNode;
       const fixes = [];
       if (pluginOptions.effectFn.includes("span") && explicitTraceExpression) {
         fixes.push({
@@ -6033,7 +6273,7 @@ var effectFnOpportunity = createDiagnostic({
           })
         });
       }
-      if (pluginOptions.effectFn.includes("untraced") && target.value.generatorFunction) {
+      if (pluginOptions.effectFn.includes("untraced") && target.generatorFunction) {
         fixes.push({
           fixName: "effectFnOpportunity_toEffectFnUntraced",
           description: "Convert to Effect.fnUntraced",
@@ -6055,22 +6295,41 @@ var effectFnOpportunity = createDiagnostic({
           })
         });
       }
-      if (pluginOptions.effectFn.includes("inferred-span") && inferredTraceName && !explicitTraceExpression) {
-        fixes.push({
-          fixName: "effectFnOpportunity_toEffectFnSpanInferred",
-          description: `Convert to Effect.fn("${inferredTraceName}")`,
-          apply: gen(function* () {
-            const changeTracker = yield* service(ChangeTracker);
-            const newNode = createEffectFnNode(
-              targetNode,
-              innerFunction,
-              effectModuleName,
-              inferredTraceName,
-              pipeArguments2
-            );
-            changeTracker.replaceNode(sourceFile, targetNode, newNode);
-          })
-        });
+      if (!explicitTraceExpression) {
+        if (pluginOptions.effectFn.includes("inferred-span") && inferredTraceName) {
+          fixes.push({
+            fixName: "effectFnOpportunity_toEffectFnSpanInferred",
+            description: `Convert to Effect.fn("${inferredTraceName}")`,
+            apply: gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              const newNode = createEffectFnNode(
+                targetNode,
+                innerFunction,
+                effectModuleName,
+                inferredTraceName,
+                pipeArguments2
+              );
+              changeTracker.replaceNode(sourceFile, targetNode, newNode);
+            })
+          });
+        }
+        if (pluginOptions.effectFn.includes("suggested-span") && suggestedTraceName && (!pluginOptions.effectFn.includes("inferred-span") || suggestedTraceName !== inferredTraceName)) {
+          fixes.push({
+            fixName: "effectFnOpportunity_toEffectFnSpanSuggested",
+            description: `Convert to Effect.fn("${suggestedTraceName}")`,
+            apply: gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              const newNode = createEffectFnNode(
+                targetNode,
+                innerFunction,
+                effectModuleName,
+                suggestedTraceName,
+                pipeArguments2
+              );
+              changeTracker.replaceNode(sourceFile, targetNode, newNode);
+            })
+          });
+        }
       }
       if (fixes.length === 0) continue;
       const generateExpectedSignature = () => {
@@ -6083,7 +6342,7 @@ var effectFnOpportunity = createDiagnostic({
           }
           return "_";
         }).join(", ");
-        const fnSignature = `function*${typeParamNames}(${paramNames}) { ... }`;
+        const fnSignature = ts.isArrowFunction(innerFunction) ? `${typeParamNames}(${paramNames}) => { ... }` : isGeneratorFunction(innerFunction) ? `function*${typeParamNames}(${paramNames}) { ... }` : `function${typeParamNames}(${paramNames}) { ... }`;
         const pipeArgsForWithSpan = pipeArguments2.slice(0, -1);
         const pipeArgsSuffix = (args3) => args3.length > 0 ? ", ...pipeTransformations" : "";
         switch (firstFix.fixName) {
@@ -6097,6 +6356,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})`;
         }
@@ -6117,6 +6378,8 @@ var effectGenUsesAdapter = createDiagnostic({
   code: 23,
   description: "Warns when using the deprecated adapter parameter in Effect.gen",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("effectGenUsesAdapter.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -6149,12 +6412,80 @@ 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",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  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",
   code: 14,
   description: "Detects nested Effects in void success channels that may cause unexecuted effects",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("effectInVoidSuccess.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -6204,6 +6535,8 @@ var effectMapVoid = createDiagnostic({
   code: 40,
   description: "Suggests using Effect.asVoid instead of Effect.map(() => void 0), Effect.map(() => undefined), or Effect.map(() => {})",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("effectMapVoid.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -6268,6 +6601,8 @@ var effectSucceedWithVoid = createDiagnostic({
   code: 47,
   description: "Suggests using Effect.void instead of Effect.succeed(undefined) or Effect.succeed(void 0)",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("effectSucceedWithVoid.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -6313,12 +6648,66 @@ var effectSucceedWithVoid = createDiagnostic({
   })
 });
 
+// src/diagnostics/extendsNativeError.ts
+var extendsNativeError = createDiagnostic({
+  name: "extendsNativeError",
+  code: 50,
+  description: "Warns when a class directly extends the native Error class",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: fn("extendsNativeError.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const errorSymbol = typeChecker.resolveName("Error", void 0, ts.SymbolFlags.Type, false);
+    if (!errorSymbol) return;
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isClassDeclaration(node) && node.heritageClauses) {
+        for (const clause of node.heritageClauses) {
+          if (clause.token === ts.SyntaxKind.ExtendsKeyword && clause.types.length > 0) {
+            const typeExpression = clause.types[0].expression;
+            const exprSymbol = typeChecker.getSymbolAtLocation(typeExpression);
+            const resolvedSymbol = exprSymbol && exprSymbol.flags & ts.SymbolFlags.Alias ? typeChecker.getAliasedSymbol(exprSymbol) : exprSymbol;
+            const isNativeError = resolvedSymbol === errorSymbol || (() => {
+              if (!resolvedSymbol || resolvedSymbol === errorSymbol) return false;
+              const exprType = typeChecker.getTypeAtLocation(typeExpression);
+              const constructSignatures = typeChecker.getSignaturesOfType(exprType, ts.SignatureKind.Construct);
+              if (constructSignatures.length > 0) {
+                const instanceType = typeChecker.getReturnTypeOfSignature(constructSignatures[0]);
+                return instanceType.symbol === errorSymbol;
+              }
+              return false;
+            })();
+            if (isNativeError) {
+              report({
+                location: node.name ?? typeExpression,
+                messageText: "Avoid extending the native 'Error' class directly. Consider using a tagged error (e.g. Data.TaggedError) to maintain type safety in the Effect failure channel.",
+                fixes: []
+              });
+            }
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/floatingEffect.ts
 var floatingEffect = createDiagnostic({
   name: "floatingEffect",
   code: 3,
   description: "Ensures Effects are yielded or assigned to variables, not left floating",
   severity: "error",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("floatingEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -6370,6 +6759,8 @@ var genericEffectServices = createDiagnostic({
   code: 10,
   description: "Prevents services with type parameters that cannot be discriminated at runtime",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("genericEffectServices.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -6417,6 +6808,8 @@ var globalErrorInEffectCatch = createDiagnostic({
   code: 36,
   description: "Warns when catch callbacks return global Error type instead of typed errors",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("globalErrorInEffectCatch.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -6477,6 +6870,8 @@ var globalErrorInEffectFailure = createDiagnostic({
   code: 35,
   description: "Warns when the global Error type is used in an Effect failure channel",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("globalErrorInEffectFailure.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -6530,6 +6925,8 @@ var importFromBarrel = createDiagnostic({
   code: 12,
   description: "Suggests importing from specific module paths instead of barrel exports",
   severity: "off",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("importFromBarrel.apply")(function* (sourceFile, report) {
     const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
     if (languageServicePluginOptions.namespaceImportPackages.length === 0) return;
@@ -6670,6 +7067,8 @@ var instanceOfSchema = createDiagnostic({
   code: 45,
   description: "Suggests using Schema.is instead of instanceof for Effect Schema types",
   severity: "off",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("instanceOfSchema.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -6733,6 +7132,8 @@ var layerMergeAllWithDependencies = createDiagnostic({
   code: 37,
   description: "Detects interdependencies in Layer.mergeAll calls where one layer provides a service that another layer requires",
   severity: "warning",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("layerMergeAllWithDependencies.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -6846,6 +7247,8 @@ var leakingRequirements = createDiagnostic({
   code: 8,
   description: "Detects implementation services leaked in service methods",
   severity: "suggestion",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("leakingRequirements.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -7000,6 +7403,8 @@ var missedPipeableOpportunity = createDiagnostic({
   code: 26,
   description: "Enforces the use of pipeable style for nested function calls",
   severity: "off",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("missedPipeableOpportunity.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -7180,6 +7585,8 @@ var missingEffectContext = createDiagnostic({
   code: 1,
   description: "Reports missing service requirements in Effect context channel",
   severity: "error",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("missingEffectContext.apply")(function* (sourceFile, report) {
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
@@ -7229,6 +7636,8 @@ var missingEffectError = createDiagnostic({
   code: 1,
   description: "Reports missing error types in Effect error channel",
   severity: "error",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("missingEffectError.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
@@ -7370,6 +7779,8 @@ var missingEffectServiceDependency = createDiagnostic({
   code: 22,
   description: "Checks that Effect.Service dependencies satisfy all required layer inputs",
   severity: "off",
+  fixable: false,
+  supportedEffect: ["v3"],
   apply: fn("missingEffectServiceDependency.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -7464,6 +7875,8 @@ var missingLayerContext = createDiagnostic({
   code: 38,
   description: "Reports missing service requirements in Layer context channel",
   severity: "error",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("missingLayerContext.apply")(function* (sourceFile, report) {
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
@@ -7513,10 +7926,13 @@ var missingReturnYieldStar = createDiagnostic({
   code: 7,
   description: "Suggests using 'return yield*' for Effects with never success for better type narrowing",
   severity: "error",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("missingReturnYieldStar.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
+    const tsUtils = yield* service(TypeScriptUtils);
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -7526,50 +7942,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
+      });
     }
   })
 });
@@ -7580,6 +7978,8 @@ var missingStarInYieldEffectGen = createDiagnostic({
   code: 4,
   description: "Enforces using 'yield*' instead of 'yield' when yielding Effects in generators",
   severity: "error",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -7655,6 +8055,8 @@ var multipleEffectProvide = createDiagnostic({
   code: 18,
   description: "Warns against chaining Effect.provide calls which can cause service lifecycle issues",
   severity: "warning",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("multipleEffectProvide.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
@@ -7741,12 +8143,85 @@ var multipleEffectProvide = createDiagnostic({
   })
 });
 
+// src/diagnostics/nodeBuiltinImport.ts
+var moduleAlternativesV3 = /* @__PURE__ */ new Map([
+  ["fs", { alternative: "FileSystem", module: "fs", package: "@effect/platform" }],
+  ["node:fs", { alternative: "FileSystem", module: "fs", package: "@effect/platform" }],
+  ["fs/promises", { alternative: "FileSystem", module: "fs", package: "@effect/platform" }],
+  ["node:fs/promises", { alternative: "FileSystem", module: "fs", package: "@effect/platform" }],
+  ["path", { alternative: "Path", module: "path", package: "@effect/platform" }],
+  ["node:path", { alternative: "Path", module: "path", package: "@effect/platform" }],
+  ["path/posix", { alternative: "Path", module: "path", package: "@effect/platform" }],
+  ["node:path/posix", { alternative: "Path", module: "path", package: "@effect/platform" }],
+  ["path/win32", { alternative: "Path", module: "path", package: "@effect/platform" }],
+  ["node:path/win32", { alternative: "Path", module: "path", package: "@effect/platform" }],
+  ["child_process", { alternative: "CommandExecutor", module: "child_process", package: "@effect/platform" }],
+  ["node:child_process", { alternative: "CommandExecutor", module: "child_process", package: "@effect/platform" }]
+]);
+var moduleAlternativesV4 = /* @__PURE__ */ new Map([
+  ["fs", { alternative: "FileSystem", module: "fs", package: "effect" }],
+  ["node:fs", { alternative: "FileSystem", module: "fs", package: "effect" }],
+  ["fs/promises", { alternative: "FileSystem", module: "fs", package: "effect" }],
+  ["node:fs/promises", { alternative: "FileSystem", module: "fs", package: "effect" }],
+  ["path", { alternative: "Path", module: "path", package: "effect" }],
+  ["node:path", { alternative: "Path", module: "path", package: "effect" }],
+  ["path/posix", { alternative: "Path", module: "path", package: "effect" }],
+  ["node:path/posix", { alternative: "Path", module: "path", package: "effect" }],
+  ["path/win32", { alternative: "Path", module: "path", package: "effect" }],
+  ["node:path/win32", { alternative: "Path", module: "path", package: "effect" }],
+  ["child_process", { alternative: "ChildProcess", module: "child_process", package: "effect" }],
+  ["node:child_process", { alternative: "ChildProcess", module: "child_process", package: "effect" }]
+]);
+var nodeBuiltinImport = createDiagnostic({
+  name: "nodeBuiltinImport",
+  code: 52,
+  description: "Warns when importing Node.js built-in modules that have Effect-native counterparts",
+  severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
+  apply: fn("nodeBuiltinImport.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const moduleAlternatives = typeParser.supportedEffect() === "v3" ? moduleAlternativesV3 : moduleAlternativesV4;
+    for (const statement of sourceFile.statements) {
+      if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
+        const specifier = statement.moduleSpecifier.text;
+        const match2 = moduleAlternatives.get(specifier);
+        if (match2) {
+          report({
+            location: statement.moduleSpecifier,
+            messageText: `Prefer using ${match2.alternative} from ${match2.package} instead of the Node.js '${match2.module}' module.`,
+            fixes: []
+          });
+        }
+      } else if (ts.isVariableStatement(statement)) {
+        for (const decl of statement.declarationList.declarations) {
+          if (decl.initializer && ts.isCallExpression(decl.initializer) && ts.isIdentifier(decl.initializer.expression) && ts.idText(decl.initializer.expression) === "require" && decl.initializer.arguments.length === 1 && ts.isStringLiteral(decl.initializer.arguments[0])) {
+            const arg = decl.initializer.arguments[0];
+            const specifier = arg.text;
+            const match2 = moduleAlternatives.get(specifier);
+            if (match2) {
+              report({
+                location: arg,
+                messageText: `Prefer using ${match2.alternative} from ${match2.package} instead of the Node.js '${match2.module}' module.`,
+                fixes: []
+              });
+            }
+          }
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/nonObjectEffectServiceType.ts
 var nonObjectEffectServiceType = createDiagnostic({
   name: "nonObjectEffectServiceType",
   code: 24,
   description: "Ensures Effect.Service types are objects, not primitives",
   severity: "error",
+  fixable: false,
+  supportedEffect: ["v3"],
   apply: fn("nonObjectEffectServiceType.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -7886,9 +8361,7 @@ var effectModuleMigrationDb = {
   "failSync": asUnchanged,
   "fiberId": asUnchanged,
   "filter": asUnchanged,
-  "filterMap": asRemoved(
-    "Use Effect.filter or Effect.map with Option instead."
-  ),
+  "filterMap": asUnchanged,
   "filterOrElse": asUnchanged,
   "filterOrFail": asUnchanged,
   "flatMap": asUnchanged,
@@ -8176,9 +8649,7 @@ var effectModuleMigrationDb = {
   "finalizersMask": asRemoved(
     "Finalizer masking has been removed in Effect v4."
   ),
-  "findFirst": asRemoved(
-    "Use Effect.forEach with early return instead."
-  ),
+  "findFirst": asUnchanged,
   "firstSuccessOf": asRemoved(
     "Use Effect.raceAll instead."
   ),
@@ -8533,6 +9004,8 @@ var outdatedApi = createDiagnostic({
   code: 48,
   description: "Detects usage of APIs that have been removed or renamed in Effect v4",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v4"],
   apply: fn("outdatedApi.apply")(function* (sourceFile, report) {
     const typeParser = yield* service(TypeParser);
     const ts = yield* service(TypeScriptApi);
@@ -9669,6 +10142,8 @@ var outdatedEffectCodegen = createDiagnostic({
   code: 19,
   description: "Detects when generated code is outdated and needs to be regenerated",
   severity: "warning",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("outdatedEffectCodegen.apply")(function* (sourceFile, _report) {
     const codegensWithRanges = yield* getCodegensForSourceFile(codegens, sourceFile);
     for (const { codegen, hash: hash2, range } of codegensWithRanges) {
@@ -9715,6 +10190,8 @@ var overriddenSchemaConstructor = createDiagnostic({
   code: 30,
   description: "Prevents overriding constructors in Schema classes which breaks decoding behavior",
   severity: "error",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("overriddenSchemaConstructor.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -9852,6 +10329,8 @@ var preferSchemaOverJson = createDiagnostic({
   code: 44,
   description: "Suggests using Effect Schema for JSON operations instead of JSON.parse/JSON.stringify which may throw",
   severity: "suggestion",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("preferSchemaOverJson.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -9962,6 +10441,8 @@ var redundantSchemaTagIdentifier = createDiagnostic({
   code: 42,
   description: "Suggests removing redundant identifier argument when it equals the tag value in Schema.TaggedClass/TaggedError/TaggedRequest",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("redundantSchemaTagIdentifier.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -10012,6 +10493,8 @@ var returnEffectInGen = createDiagnostic({
   code: 11,
   description: "Warns when returning an Effect in a generator causes nested Effect<Effect<...>>",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("returnEffectInGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
@@ -10081,6 +10564,8 @@ var runEffectInsideEffect = createDiagnostic({
   code: 32,
   description: "Suggests using Runtime methods instead of Effect.run* inside Effect contexts",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3"],
   apply: fn("runEffectInsideEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -10205,6 +10690,8 @@ var schemaStructWithTag = createDiagnostic({
   code: 34,
   description: "Suggests using Schema.TaggedStruct instead of Schema.Struct with _tag field",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("schemaStructWithTag.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -10297,6 +10784,8 @@ var schemaSyncInEffect = createDiagnostic({
   code: 43,
   description: "Suggests using Effect-based Schema methods instead of sync methods inside Effect generators",
   severity: "suggestion",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("schemaSyncInEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -10346,6 +10835,8 @@ var schemaUnionOfLiterals = createDiagnostic({
   code: 33,
   description: "Simplifies Schema.Union of multiple Schema.Literal calls into single Schema.Literal",
   severity: "off",
+  fixable: true,
+  supportedEffect: ["v3"],
   apply: fn("schemaUnionOfLiterals.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -10421,6 +10912,8 @@ var scopeInLayerEffect = createDiagnostic({
   code: 13,
   description: "Suggests using Layer.scoped instead of Layer.effect when Scope is in requirements",
   severity: "warning",
+  fixable: true,
+  supportedEffect: ["v3"],
   apply: fn("scopeInLayerEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
@@ -10510,12 +11003,91 @@ Consider using "scoped" instead to get rid of the scope in the requirements.`,
   })
 });
 
+// src/diagnostics/serviceNotAsClass.ts
+var serviceNotAsClass = createDiagnostic({
+  name: "serviceNotAsClass",
+  code: 51,
+  description: "Warns when ServiceMap.Service is used as a variable instead of a class declaration",
+  severity: "off",
+  fixable: true,
+  supportedEffect: ["v4"],
+  apply: fn("serviceNotAsClass.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    if (typeParser.supportedEffect() === "v3") return;
+    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);
+      if (!ts.isVariableDeclaration(node)) continue;
+      if (!node.initializer || !ts.isCallExpression(node.initializer)) continue;
+      const callExpr = node.initializer;
+      if (!callExpr.typeArguments || callExpr.typeArguments.length === 0) continue;
+      const typeArgs = callExpr.typeArguments;
+      const declList = node.parent;
+      if (!ts.isVariableDeclarationList(declList)) continue;
+      if (!(declList.flags & ts.NodeFlags.Const)) continue;
+      const isServiceMapService = yield* pipe(
+        typeParser.isNodeReferenceToServiceMapModuleApi("Service")(callExpr.expression),
+        orUndefined
+      );
+      if (!isServiceMapService) continue;
+      const variableName = ts.isIdentifier(node.name) ? ts.idText(node.name) : sourceFile.text.substring(ts.getTokenPosOfNode(node.name, sourceFile), node.name.end);
+      const variableStatement = declList.parent;
+      const argsText = callExpr.arguments.length > 0 ? callExpr.arguments.map((a) => sourceFile.text.substring(ts.getTokenPosOfNode(a, sourceFile), a.end)).join(", ") : "";
+      const shapeText = typeArgs.length > 0 ? typeArgs.map((t) => sourceFile.text.substring(ts.getTokenPosOfNode(t, sourceFile), t.end)).join(", ") : "Shape";
+      report({
+        location: callExpr,
+        messageText: `ServiceMap.Service should be used in a class declaration instead of as a variable. Use: class ${variableName} extends ServiceMap.Service<${variableName}, ${shapeText}>()("${argsText.replace(/['"]/g, "")}") {}`,
+        fixes: [{
+          fixName: "serviceNotAsClass",
+          description: `Convert to class declaration`,
+          apply: gen(function* () {
+            const changeTracker = yield* service(ChangeTracker);
+            const targetNode = ts.isVariableStatement(variableStatement) ? variableStatement : declList;
+            const innerCall = ts.factory.createCallExpression(
+              callExpr.expression,
+              [ts.factory.createTypeReferenceNode(variableName), ...typeArgs],
+              []
+            );
+            const outerCall = ts.factory.createCallExpression(
+              innerCall,
+              void 0,
+              [...callExpr.arguments]
+            );
+            const heritageClause = ts.factory.createHeritageClause(
+              ts.SyntaxKind.ExtendsKeyword,
+              [ts.factory.createExpressionWithTypeArguments(outerCall, void 0)]
+            );
+            const modifiers = ts.isVariableStatement(variableStatement) ? variableStatement.modifiers : void 0;
+            const classDeclaration = ts.factory.createClassDeclaration(
+              modifiers,
+              ts.isIdentifier(node.name) ? node.name : ts.factory.createIdentifier(variableName),
+              void 0,
+              [heritageClause],
+              []
+            );
+            changeTracker.replaceNode(sourceFile, targetNode, classDeclaration);
+          })
+        }]
+      });
+    }
+  })
+});
+
 // src/diagnostics/strictBooleanExpressions.ts
 var strictBooleanExpressions = createDiagnostic({
   name: "strictBooleanExpressions",
   code: 17,
   description: "Enforces boolean types in conditional expressions for type safety",
   severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("strictBooleanExpressions.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
@@ -10587,6 +11159,8 @@ var strictEffectProvide = createDiagnostic({
   code: 27,
   description: "Warns when using Effect.provide with layers outside of application entry points",
   severity: "off",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("strictEffectProvide.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
@@ -10638,6 +11212,8 @@ var tryCatchInEffectGen = createDiagnostic({
   code: 15,
   description: "Discourages try/catch in Effect generators in favor of Effect error handling",
   severity: "suggestion",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("tryCatchInEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -10695,6 +11271,8 @@ var unknownInEffectCatch = createDiagnostic({
   code: 31,
   description: "Warns when catch callbacks return unknown instead of typed errors",
   severity: "warning",
+  fixable: false,
+  supportedEffect: ["v3", "v4"],
   apply: fn("unknownInEffectCatch.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -10756,6 +11334,8 @@ var unnecessaryEffectGen = createDiagnostic({
   code: 5,
   description: "Suggests removing Effect.gen when it contains only a single return statement",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("unnecessaryEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -10800,6 +11380,8 @@ var unnecessaryFailYieldableError = createDiagnostic({
   code: 29,
   description: "Suggests yielding yieldable errors directly instead of wrapping with Effect.fail",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("unnecessaryFailYieldableError.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -10859,6 +11441,8 @@ var unnecessaryPipe = createDiagnostic({
   code: 9,
   description: "Removes pipe calls with no arguments",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("unnecessaryPipe.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -10905,6 +11489,8 @@ var unnecessaryPipeChain = createDiagnostic({
   code: 16,
   description: "Simplifies chained pipe calls into a single pipe call",
   severity: "suggestion",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("unnecessaryPipeChain.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
@@ -10980,6 +11566,8 @@ var unsupportedServiceAccessors = createDiagnostic({
   code: 21,
   description: "Warns about service accessors that need codegen due to generic/complex signatures",
   severity: "warning",
+  fixable: true,
+  supportedEffect: ["v3", "v4"],
   apply: fn("unsupportedServiceAccessors.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const nodeToVisit = [];
@@ -11046,6 +11634,7 @@ var diagnostics = [
   missingEffectServiceDependency,
   missingLayerContext,
   floatingEffect,
+  effectInFailure,
   missingStarInYieldEffectGen,
   unnecessaryEffectGen,
   unnecessaryFailYieldableError,
@@ -11081,7 +11670,10 @@ var diagnostics = [
   effectFnOpportunity,
   redundantSchemaTagIdentifier,
   schemaSyncInEffect,
-  preferSchemaOverJson
+  preferSchemaOverJson,
+  extendsNativeError,
+  serviceNotAsClass,
+  nodeBuiltinImport
 ];
 
 // src/effect-lsp-patch-utils.ts
@@ -11162,6 +11754,12 @@ function extractDiagnosticsForExitStatus(tsInstance, program, diagnostics2, _mod
       (_) => !(_.source === "effect" && _.category === tsInstance.DiagnosticCategory.Warning)
     );
   }
+  if (parsedOptions.ignoreEffectErrorsInTscExitCode) {
+    newDiagnostics = filter(
+      newDiagnostics,
+      (_) => !(_.source === "effect" && _.category === tsInstance.DiagnosticCategory.Error)
+    );
+  }
   return newDiagnostics;
 }
 // Annotate the CommonJS export names for ESM import in node: