@effect/language-service 0.62.4 → 0.63.0

package/effect-lsp-patch-utils.js

@@ -26,7 +26,7 @@ __export(effect_lsp_patch_utils_exports, {
 });
 module.exports = __toCommonJS(effect_lsp_patch_utils_exports);
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Function.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
 var dual = function(arity, body) {
   if (typeof arity === "function") {
@@ -122,7 +122,7 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   }
 }
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/GlobalValue.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/GlobalValue.js
 var globalStoreId = `effect/GlobalValue`;
 var globalStore;
 var globalValue = (id, compute) => {
@@ -136,7 +136,7 @@ var globalValue = (id, compute) => {
   return globalStore.get(id);
 };
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Predicate.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Predicate.js
 var isString = (input) => typeof input === "string";
 var isNumber = (input) => typeof input === "number";
 var isBoolean = (input) => typeof input === "boolean";
@@ -146,7 +146,7 @@ var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
 var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) && property in self);
 var isRecord = (input) => isRecordOrArray(input) && !Array.isArray(input);
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Utils.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Utils.js
 var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
 var GenKindImpl = class {
   value;
@@ -268,7 +268,7 @@ var internalCall = isNotOptimizedAway ? standard.effect_internal_function : forc
 var genConstructor = function* () {
 }.constructor;
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Hash.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Hash.js
 var randomHashCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/randomHashCache"), () => /* @__PURE__ */ new WeakMap());
 var symbol = /* @__PURE__ */ Symbol.for("effect/Hash");
 var hash = (self) => {
@@ -293,6 +293,9 @@ var hash = (self) => {
       if (self === null) {
         return string("null");
       } else if (self instanceof Date) {
+        if (Number.isNaN(self.getTime())) {
+          return string("Invalid Date");
+        }
         return hash(self.toISOString());
       } else if (self instanceof URL) {
         return hash(self.href);
@@ -367,7 +370,7 @@ var cached = function() {
   return hash2;
 };
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Equal.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Equal.js
 var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
 function equals() {
   if (arguments.length === 1) {
@@ -392,7 +395,9 @@ function compareBoth(self, that) {
           return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
         }
       } else if (self instanceof Date && that instanceof Date) {
-        return self.toISOString() === that.toISOString();
+        const t1 = self.getTime();
+        const t2 = that.getTime();
+        return t1 === t2 || Number.isNaN(t1) && Number.isNaN(t2);
       } else if (self instanceof URL && that instanceof URL) {
         return self.href === that.href;
       }
@@ -421,7 +426,7 @@ function compareBoth(self, that) {
 var isEqual = (u) => hasProperty(u, symbol2);
 var equivalence = () => equals;
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Inspectable.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJSON = (x) => {
   try {
@@ -473,7 +478,7 @@ var redact = (u) => {
   return u;
 };
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Pipeable.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Pipeable.js
 var pipeArguments = (self, args2) => {
   switch (args2.length) {
     case 0:
@@ -506,14 +511,14 @@ var pipeArguments = (self, args2) => {
   }
 };
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/opCodes/effect.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/opCodes/effect.js
 var OP_COMMIT = "Commit";
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/version.js
-var moduleVersion = "3.19.0";
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/version.js
+var moduleVersion = "3.19.13";
 var getCurrentVersion = () => moduleVersion;
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/effectable.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/effectable.js
 var EffectTypeId = /* @__PURE__ */ Symbol.for("effect/Effect");
 var StreamTypeId = /* @__PURE__ */ Symbol.for("effect/Stream");
 var SinkTypeId = /* @__PURE__ */ Symbol.for("effect/Sink");
@@ -600,7 +605,7 @@ var StructuralCommitPrototype = {
   ...StructuralPrototype
 };
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/option.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/option.js
 var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
 var CommonProto = {
   ...EffectPrototype,
@@ -658,7 +663,7 @@ var some = (value) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/either.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/either.js
 var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
 var CommonProto2 = {
   ...EffectPrototype,
@@ -720,7 +725,7 @@ var right = (right3) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Either.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Either.js
 var right2 = right;
 var left2 = left;
 var isLeft2 = isLeft;
@@ -728,14 +733,14 @@ var isRight2 = isRight;
 var map = /* @__PURE__ */ dual(2, (self, f) => isRight2(self) ? right2(f(self.right)) : left2(self.left));
 var getOrElse = /* @__PURE__ */ dual(2, (self, onLeft) => isLeft2(self) ? onLeft(self.left) : self.right);
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/array.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/array.js
 var isNonEmptyArray = (self) => self.length > 0;
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Order.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Order.js
 var make = (compare) => (self, that) => self === that ? 0 : compare(self, that);
 var string2 = /* @__PURE__ */ make((self, that) => self < that ? -1 : 1);
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Option.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Option.js
 var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
@@ -745,7 +750,7 @@ var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : se
 var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
 var getOrUndefined = /* @__PURE__ */ getOrElse2(constUndefined);
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Record.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Record.js
 var map2 = /* @__PURE__ */ dual(2, (self, f) => {
   const out = {
     ...self
@@ -757,7 +762,7 @@ var map2 = /* @__PURE__ */ dual(2, (self, f) => {
 });
 var keys = (self) => Object.keys(self);
 
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Array.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Array.js
 var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
 var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
@@ -797,7 +802,10 @@ var containsWith = (isEquivalent) => dual(2, (self, a) => {
 var _equivalence = /* @__PURE__ */ equivalence();
 var intersectionWith = (isEquivalent) => {
   const has = containsWith(isEquivalent);
-  return dual(2, (self, that) => fromIterable(self).filter((a) => has(that, a)));
+  return dual(2, (self, that) => {
+    const bs = fromIterable(that);
+    return fromIterable(self).filter((a) => has(bs, a));
+  });
 };
 var intersection = /* @__PURE__ */ intersectionWith(_equivalence);
 var empty = () => [];
@@ -875,12 +883,12 @@ var SingleShotGen2 = class _SingleShotGen {
     return new _SingleShotGen(this.self);
   }
 };
-var evaluate = Symbol.for("Nano.evaluate");
-var contA = Symbol.for("Nano.contA");
-var contE = Symbol.for("Nano.contE");
-var contAll = Symbol.for("Nano.contAll");
-var NanoYield = Symbol.for("Nano.yield");
-var args = Symbol.for("Nano.args");
+var evaluate = /* @__PURE__ */ Symbol.for("Nano.evaluate");
+var contA = /* @__PURE__ */ Symbol.for("Nano.contA");
+var contE = /* @__PURE__ */ Symbol.for("Nano.contE");
+var contAll = /* @__PURE__ */ Symbol.for("Nano.contAll");
+var NanoYield = /* @__PURE__ */ Symbol.for("Nano.yield");
+var args = /* @__PURE__ */ Symbol.for("Nano.args");
 var NanoDefectException = class {
   constructor(message, lastSpan) {
     this.message = message;
@@ -1687,7 +1695,9 @@ function makeTypeScriptUtils(ts) {
     } else {
       return;
     }
-    return { accessedObject, outerNode, replacementSpan };
+    const importDeclaration = ts.findAncestor(accessedObject, ts.isImportDeclaration);
+    if (importDeclaration) return;
+    return { accessedObject, outerNode, replacementSpan, insideImportDeclaration: !!importDeclaration };
   }
   function parseDataForExtendsClassCompletion(sourceFile, position) {
     const maybeInfos = parseAccessedExpressionForCompletion(sourceFile, position);
@@ -2191,6 +2201,8 @@ var nanoLayer2 = (fa) => pipe(
 function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
   const readonlyArraySymbol = typeChecker.resolveName("ReadonlyArray", void 0, ts.SymbolFlags.Type, false);
   const globalReadonlyArrayType = readonlyArraySymbol ? typeChecker.getDeclaredTypeOfSymbol(readonlyArraySymbol) : void 0;
+  const errorSymbol = typeChecker.resolveName("Error", void 0, ts.SymbolFlags.Type, false);
+  const globalErrorType = errorSymbol ? typeChecker.getDeclaredTypeOfSymbol(errorSymbol) : void 0;
   function isUnion(type) {
     return !!(type.flags & ts.TypeFlags.Union);
   }
@@ -2439,6 +2451,10 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
   function typeToSimplifiedTypeNode(type, enclosingNode, flags) {
     return typeToSimplifiedTypeNodeWorker(type, enclosingNode, flags, 0);
   }
+  function isGlobalErrorType(type) {
+    if (!globalErrorType) return false;
+    return typeChecker.isTypeAssignableTo(type, globalErrorType) && typeChecker.isTypeAssignableTo(globalErrorType, type);
+  }
   function typeToSimplifiedTypeNodeWorker(type, enclosingNode, flags, depth) {
     const fallbackStandard = () => {
       const typeNode = typeChecker.typeToTypeNode(type, enclosingNode, flags);
@@ -2508,6 +2524,15 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
     }
     return fallbackStandard();
   }
+  function getTypeAtLocation(node) {
+    if (node.parent && ts.isJsxSelfClosingElement(node.parent) && node.parent.tagName === node) return;
+    if (node.parent && ts.isJsxOpeningElement(node.parent) && node.parent.tagName === node) return;
+    if (node.parent && ts.isJsxClosingElement(node.parent) && node.parent.tagName === node) return;
+    if (node.parent && ts.isJsxAttribute(node.parent) && node.parent.name === node) return;
+    if (ts.isExpression(node) || ts.isTypeNode(node)) {
+      return typeChecker.getTypeAtLocation(node);
+    }
+  }
   return {
     isUnion,
     isReadonlyArrayType,
@@ -2519,7 +2544,9 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
     deterministicTypeOrder,
     getInferredReturnType,
     expectedAndRealType,
-    typeToSimplifiedTypeNode
+    typeToSimplifiedTypeNode,
+    isGlobalErrorType,
+    getTypeAtLocation
   };
 }
 
@@ -2641,7 +2668,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     return isSymbolExportOfPackageModule(symbol3, packageName, memberName, isCorrectSourceFile);
   };
   const findSymbolsMatchingPackageAndExportedName = (packageName, exportedSymbolName) => cachedBy(
-    fn("TypeParser.findSymbolsMatchingPackageAndExportedName")(function* (_fromSourceFile) {
+    fn("TypeParser.findSymbolsMatchingPackageAndExportedName")(function* () {
       const result = [];
       for (const sourceFile of program.getSourceFiles()) {
         const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
@@ -2655,7 +2682,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
       return result;
     }),
     `TypeParser.findSymbolsMatchingPackageAndExportedName(${packageName}, ${exportedSymbolName})`,
-    (sourceFile) => sourceFile
+    () => program
   );
   const isCauseTypeSourceFile = cachedBy(
     fn("TypeParser.isCauseTypeSourceFile")(function* (sourceFile) {
@@ -2670,20 +2697,22 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.isCauseTypeSourceFile",
     (sourceFile) => sourceFile
   );
-  const effectCauseYieldableErrorTypes = cachedBy(
-    fn("TypeParser.effectCauseYieldableErrorTypes")(function* (fromSourceFile) {
-      const symbols = yield* findSymbolsMatchingPackageAndExportedName("effect", "YieldableError")(fromSourceFile);
-      const result = [];
+  const extendsCauseYieldableError = cachedBy(
+    fn("TypeParser.extendsCauseYieldableError")(function* (givenType) {
+      const symbols = yield* findSymbolsMatchingPackageAndExportedName("effect", "YieldableError")();
       for (const [symbol3, sourceFile] of symbols) {
-        const causeFile = yield* isCauseTypeSourceFile(sourceFile);
+        const causeFile = yield* pipe(isCauseTypeSourceFile(sourceFile), orElse2(() => void_));
         if (!causeFile) continue;
         const type = typeChecker.getDeclaredTypeOfSymbol(symbol3);
-        result.push(type);
+        if (!type) continue;
+        if (typeChecker.isTypeAssignableTo(givenType, type)) {
+          return type;
+        }
       }
-      return result;
+      return yield* typeParserIssue("Type does not extend Cause.YieldableError", givenType);
     }),
-    "TypeParser.effectCauseYieldableErrorTypes",
-    (fromSourceFile) => fromSourceFile
+    "TypeParser.extendsCauseYieldableError",
+    (type) => type
   );
   function covariantTypeArgument(type) {
     const signatures = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call);
@@ -3073,7 +3102,8 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
         }
         if (ts.isYieldExpression(nodeToCheck) && nodeToCheck.asteriskToken && nodeToCheck.expression) {
           const yieldedExpression = nodeToCheck.expression;
-          const type = typeChecker.getTypeAtLocation(yieldedExpression);
+          const type = typeCheckerUtils.getTypeAtLocation(yieldedExpression);
+          if (!type) continue;
           const { A: successType } = yield* effectType(type, yieldedExpression);
           let replacementNode = succeed(yieldedExpression);
           if (!explicitReturn && !(successType.flags & ts.TypeFlags.VoidLike)) {
@@ -3664,11 +3694,79 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.extendsEffectService",
     (atLocation) => atLocation
   );
+  const isEffectSqlModelTypeSourceFile = cachedBy(
+    fn("TypeParser.isEffectSqlModelTypeSourceFile")(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 makeRepositorySymbol = typeChecker.tryGetMemberInModuleExports("makeRepository", moduleSymbol);
+      if (!makeRepositorySymbol) {
+        return yield* typeParserIssue("Model's makeRepository type not found", void 0, sourceFile);
+      }
+      const makeDataLoadersSymbol = typeChecker.tryGetMemberInModuleExports("makeDataLoaders", moduleSymbol);
+      if (!makeDataLoadersSymbol) {
+        return yield* typeParserIssue("Model's makeDataLoaders type not found", void 0, sourceFile);
+      }
+      return sourceFile;
+    }),
+    "TypeParser.isEffectSqlModelTypeSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToEffectSqlModelModuleApi = (memberName) => cachedBy(
+    fn("TypeParser.isNodeReferenceToEffectSqlModelModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(
+        node,
+        "@effect/sql",
+        isEffectSqlModelTypeSourceFile,
+        memberName
+      );
+    }),
+    `TypeParser.isNodeReferenceToEffectSqlModelModuleApi(${memberName})`,
+    (node) => node
+  );
+  const extendsEffectSqlModelClass = cachedBy(
+    fn("TypeParser.extendsEffectSqlModelClass")(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 isEffectSchemaModuleApi = yield* pipe(
+                  isNodeReferenceToEffectSqlModelModuleApi("Class")(schemaCall.expression),
+                  option
+                );
+                if (isSome2(isEffectSchemaModuleApi)) {
+                  return {
+                    className: atLocation.name,
+                    selfTypeNode: schemaCall.typeArguments[0]
+                  };
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend @effect/sql's Model.Class", void 0, atLocation);
+    }),
+    "TypeParser.extendsEffectSqlModelClass",
+    (atLocation) => atLocation
+  );
   return {
     isNodeReferenceToEffectModuleApi,
     isNodeReferenceToEffectSchemaModuleApi,
     isNodeReferenceToEffectDataModuleApi,
     isNodeReferenceToEffectContextModuleApi,
+    isNodeReferenceToEffectSqlModelModuleApi,
     effectType,
     strictEffectType,
     layerType,
@@ -3678,7 +3776,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     effectGen,
     effectFnUntracedGen,
     effectFnGen,
-    effectCauseYieldableErrorTypes,
+    extendsCauseYieldableError,
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
     contextTag,
@@ -3694,7 +3792,8 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     extendsSchemaTaggedError,
     extendsDataTaggedError,
     extendsDataTaggedClass,
-    extendsSchemaTaggedRequest
+    extendsSchemaTaggedRequest,
+    extendsEffectSqlModelClass
   };
 }
 
@@ -3702,10 +3801,12 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
 var anyUnknownInErrorContext = createDiagnostic({
   name: "anyUnknownInErrorContext",
   code: 28,
+  description: "Detects 'any' or 'unknown' types in Effect error or requirements channels",
   severity: "off",
   apply: fn("anyUnknownInErrorContext.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
     const isAnyOrUnknown = (type) => (type.flags & ts.TypeFlags.Any) > 0 || (type.flags & ts.TypeFlags.Unknown) > 0;
     const matchingNodes = [];
@@ -3725,7 +3826,8 @@ var anyUnknownInErrorContext = createDiagnostic({
       if (ts.isParameter(node) || ts.isPropertyDeclaration(node) || ts.isVariableDeclaration(node)) {
         if (node.type) {
           const typeNode = node.type;
-          const type2 = typeChecker.getTypeAtLocation(node.type);
+          const type2 = typeCheckerUtils.getTypeAtLocation(node.type);
+          if (!type2) continue;
           const expectedEffect = yield* pipe(
             typeParser.strictEffectType(type2, node.type),
             orElse2(() => typeParser.layerType(type2, typeNode)),
@@ -3736,11 +3838,7 @@ var anyUnknownInErrorContext = createDiagnostic({
       }
       ts.forEachChild(node, appendNodeToVisit);
       if (!ts.isExpression(node)) continue;
-      if (node.parent && ts.isJsxSelfClosingElement(node.parent) && node.parent.tagName === node) continue;
-      if (node.parent && ts.isJsxOpeningElement(node.parent) && node.parent.tagName === node) continue;
-      if (node.parent && ts.isJsxClosingElement(node.parent) && node.parent.tagName === node) continue;
-      if (node.parent && ts.isJsxAttribute(node.parent) && node.parent.name === node) continue;
-      let type = typeChecker.getTypeAtLocation(node);
+      let type = typeCheckerUtils.getTypeAtLocation(node);
       if (ts.isCallExpression(node)) {
         const resolvedSignature = typeChecker.getResolvedSignature(node);
         if (resolvedSignature) {
@@ -3806,11 +3904,13 @@ var anyUnknownInErrorContext = createDiagnostic({
 var catchUnfailableEffect = createDiagnostic({
   name: "catchUnfailableEffect",
   code: 2,
+  description: "Warns when using error handling on Effects that never fail (error type is 'never')",
   severity: "suggestion",
   apply: fn("catchUnfailableEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -3841,7 +3941,7 @@ var catchUnfailableEffect = createDiagnostic({
               if (argIndex !== -1) {
                 let effectTypeToCheck;
                 if (argIndex === 0) {
-                  effectTypeToCheck = typeChecker.getTypeAtLocation(subject);
+                  effectTypeToCheck = typeCheckerUtils.getTypeAtLocation(subject);
                 } else {
                   const signature = typeChecker.getResolvedSignature(pipeCallNode);
                   if (signature) {
@@ -3880,6 +3980,7 @@ var catchUnfailableEffect = createDiagnostic({
 var classSelfMismatch = createDiagnostic({
   name: "classSelfMismatch",
   code: 20,
+  description: "Ensures Self type parameter matches the class name in Service/Tag/Schema classes",
   severity: "error",
   apply: fn("classSelfMismatch.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -3901,6 +4002,7 @@ var classSelfMismatch = createDiagnostic({
           orElse2(() => typeParser.extendsSchemaTaggedClass(node)),
           orElse2(() => typeParser.extendsSchemaTaggedError(node)),
           orElse2(() => typeParser.extendsSchemaTaggedRequest(node)),
+          orElse2(() => typeParser.extendsEffectSqlModelClass(node)),
           orElse2(() => void_)
         );
         if (result) {
@@ -4010,6 +4112,7 @@ function createString(sourceFile, identifier, kind) {
 var deterministicKeys = createDiagnostic({
   name: "deterministicKeys",
   code: 25,
+  description: "Enforces deterministic naming for service/tag/error identifiers based on class names",
   severity: "off",
   apply: fn("deterministicKeys.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -4130,6 +4233,7 @@ var programResolvedCacheSize = /* @__PURE__ */ new Map();
 var duplicatePackage = createDiagnostic({
   name: "duplicatePackage",
   code: 6,
+  description: "Detects when multiple versions of the same Effect package are loaded",
   severity: "warning",
   apply: fn("duplicatePackage.apply")(function* (sourceFile, report) {
     const program = yield* service(TypeScriptProgram);
@@ -4177,6 +4281,7 @@ ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageNam
 var effectGenUsesAdapter = createDiagnostic({
   name: "effectGenUsesAdapter",
   code: 23,
+  description: "Warns when using the deprecated adapter parameter in Effect.gen",
   severity: "warning",
   apply: fn("effectGenUsesAdapter.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -4214,6 +4319,7 @@ var effectGenUsesAdapter = createDiagnostic({
 var effectInVoidSuccess = createDiagnostic({
   name: "effectInVoidSuccess",
   code: 14,
+  description: "Detects nested Effects in void success channels that may cause unexecuted effects",
   severity: "warning",
   apply: fn("effectInVoidSuccess.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -4262,10 +4368,12 @@ var effectInVoidSuccess = createDiagnostic({
 var floatingEffect = createDiagnostic({
   name: "floatingEffect",
   code: 3,
+  description: "Ensures Effects are yielded or assigned to variables, not left floating",
   severity: "error",
   apply: fn("floatingEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
     function isFloatingExpression(node) {
       if (!ts.isExpressionStatement(node)) return false;
@@ -4284,7 +4392,8 @@ var floatingEffect = createDiagnostic({
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
       if (!isFloatingExpression(node)) continue;
-      const type = typeChecker.getTypeAtLocation(node.expression);
+      const type = typeCheckerUtils.getTypeAtLocation(node.expression);
+      if (!type) continue;
       const effect = yield* option(typeParser.effectType(type, node.expression));
       if (isSome2(effect)) {
         const allowedFloatingEffects = yield* pipe(
@@ -4310,6 +4419,7 @@ var floatingEffect = createDiagnostic({
 var genericEffectServices = createDiagnostic({
   name: "genericEffectServices",
   code: 10,
+  description: "Prevents services with type parameters that cannot be discriminated at runtime",
   severity: "warning",
   apply: fn("genericEffectServices.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -4352,10 +4462,56 @@ var genericEffectServices = createDiagnostic({
   })
 });
 
+// src/diagnostics/globalErrorInEffectFailure.ts
+var globalErrorInEffectFailure = createDiagnostic({
+  name: "globalErrorInEffectFailure",
+  code: 35,
+  description: "Warns when Effect.fail is called with the global Error type",
+  severity: "warning",
+  apply: fn("globalErrorInEffectFailure.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    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.isCallExpression(node)) {
+        yield* pipe(
+          typeParser.isNodeReferenceToEffectModuleApi("fail")(node.expression),
+          flatMap2(() => {
+            if (node.arguments.length > 0) {
+              const failArgument = node.arguments[0];
+              const argumentType = typeCheckerUtils.getTypeAtLocation(failArgument);
+              if (argumentType && typeCheckerUtils.isGlobalErrorType(argumentType)) {
+                return sync(
+                  () => report({
+                    location: node,
+                    messageText: `Effect.fail is called with the global Error type. It's not recommended to use the global Error type in Effect failures as they can get merged together. Instead, use tagged errors (Data.TaggedError) or custom errors with a discriminator property to get properly type-checked errors.`,
+                    fixes: []
+                  })
+                );
+              }
+            }
+            return void_;
+          }),
+          ignore
+        );
+      }
+    }
+  })
+});
+
 // src/diagnostics/importFromBarrel.ts
 var importFromBarrel = createDiagnostic({
   name: "importFromBarrel",
   code: 12,
+  description: "Suggests importing from specific module paths instead of barrel exports",
   severity: "off",
   apply: fn("importFromBarrel.apply")(function* (sourceFile, report) {
     const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
@@ -4495,6 +4651,7 @@ var importFromBarrel = createDiagnostic({
 var leakingRequirements = createDiagnostic({
   name: "leakingRequirements",
   code: 8,
+  description: "Detects implementation services leaked in service methods",
   severity: "suggestion",
   apply: fn("leakingRequirements.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -4602,7 +4759,8 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
       const node = nodeToVisit.shift();
       const typesToCheck = [];
       if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && ts.idText(node.expression.name) === "GenericTag") {
-        typesToCheck.push([typeChecker.getTypeAtLocation(node), node]);
+        const nodeType = typeCheckerUtils.getTypeAtLocation(node);
+        if (nodeType) typesToCheck.push([nodeType, node]);
       } else if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
         const classSym = typeChecker.getSymbolAtLocation(node.name);
         if (classSym) {
@@ -4636,10 +4794,12 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
 var missedPipeableOpportunity = createDiagnostic({
   name: "missedPipeableOpportunity",
   code: 26,
+  description: "Enforces the use of pipeable style for nested function calls",
   severity: "off",
   apply: fn("missedPipeableOpportunity.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
     const options = yield* service(LanguageServicePluginOptions);
     const nodeToVisit = [sourceFile];
@@ -4670,7 +4830,8 @@ var missedPipeableOpportunity = createDiagnostic({
         const originalParentChain = parentChain.slice();
         while (parentChain.length > options.pipeableMinArgCount) {
           const subject = parentChain.pop();
-          const resultType = typeChecker.getTypeAtLocation(subject);
+          const resultType = typeCheckerUtils.getTypeAtLocation(subject);
+          if (!resultType) continue;
           const pipeableType = yield* pipe(typeParser.pipeableType(resultType, subject), orElse2(() => void_));
           if (pipeableType) {
             report({
@@ -4715,6 +4876,7 @@ var missedPipeableOpportunity = createDiagnostic({
 var missingEffectContext = createDiagnostic({
   name: "missingEffectContext",
   code: 1,
+  description: "Reports missing service requirements in Effect context channel",
   severity: "error",
   apply: fn("missingEffectContext.apply")(function* (sourceFile, report) {
     const typeChecker = yield* service(TypeCheckerApi);
@@ -4763,6 +4925,7 @@ var missingEffectContext = createDiagnostic({
 var missingEffectError = createDiagnostic({
   name: "missingEffectError",
   code: 1,
+  description: "Reports missing error types in Effect error channel",
   severity: "error",
   apply: fn("missingEffectError.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -4902,6 +5065,7 @@ var missingEffectError = createDiagnostic({
 var missingEffectServiceDependency = createDiagnostic({
   name: "missingEffectServiceDependency",
   code: 22,
+  description: "Checks that Effect.Service dependencies satisfy all required layer inputs",
   severity: "off",
   apply: fn("missingEffectServiceDependency.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -4943,13 +5107,15 @@ var missingEffectServiceDependency = createDiagnostic({
                   excludeNever
                 );
                 const providedIndexes = /* @__PURE__ */ new Set();
-                const optionsType = typeChecker.getTypeAtLocation(options);
-                const dependenciesProperty = typeChecker.getPropertyOfType(optionsType, "dependencies");
                 let types = [];
-                if (dependenciesProperty) {
-                  const dependenciesTypes = typeChecker.getTypeOfSymbolAtLocation(dependenciesProperty, options);
-                  const numberIndexType = typeChecker.getIndexTypeOfType(dependenciesTypes, ts.IndexKind.Number);
-                  types = numberIndexType ? typeCheckerUtils.unrollUnionMembers(numberIndexType) : [];
+                const optionsType = typeCheckerUtils.getTypeAtLocation(options);
+                if (optionsType) {
+                  const dependenciesProperty = typeChecker.getPropertyOfType(optionsType, "dependencies");
+                  if (dependenciesProperty) {
+                    const dependenciesTypes = typeChecker.getTypeOfSymbolAtLocation(dependenciesProperty, options);
+                    const numberIndexType = typeChecker.getIndexTypeOfType(dependenciesTypes, ts.IndexKind.Number);
+                    types = numberIndexType ? typeCheckerUtils.unrollUnionMembers(numberIndexType) : [];
+                  }
                 }
                 for (const depType of types) {
                   const depLayerResult = yield* pipe(
@@ -4992,10 +5158,11 @@ var missingEffectServiceDependency = createDiagnostic({
 var missingReturnYieldStar = createDiagnostic({
   name: "missingReturnYieldStar",
   code: 7,
+  description: "Suggests using 'return yield*' for Effects with never success for better type narrowing",
   severity: "error",
   apply: fn("missingReturnYieldStar.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
@@ -5007,42 +5174,44 @@ var missingReturnYieldStar = createDiagnostic({
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
       if (ts.isYieldExpression(node) && node.expression && node.asteriskToken) {
-        const type = typeChecker.getTypeAtLocation(node.expression);
-        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
-                });
+        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
+                  });
+                }
               }
             }
           }
@@ -5056,6 +5225,7 @@ var missingReturnYieldStar = createDiagnostic({
 var missingStarInYieldEffectGen = createDiagnostic({
   name: "missingStarInYieldEffectGen",
   code: 4,
+  description: "Enforces using 'yield*' instead of 'yield' when yielding Effects in generators",
   severity: "error",
   apply: fn("missingStarInYieldEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -5130,11 +5300,12 @@ var missingStarInYieldEffectGen = createDiagnostic({
 var multipleEffectProvide = createDiagnostic({
   name: "multipleEffectProvide",
   code: 18,
+  description: "Warns against chaining Effect.provide calls which can cause service lifecycle issues",
   severity: "warning",
   apply: fn("multipleEffectProvide.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
-    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
     const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
       sourceFile,
@@ -5149,7 +5320,8 @@ var multipleEffectProvide = createDiagnostic({
     const parseEffectProvideLayer = (node) => {
       if (ts.isCallExpression(node) && node.arguments.length > 0) {
         const layer = node.arguments[0];
-        const type = typeChecker.getTypeAtLocation(layer);
+        const type = typeCheckerUtils.getTypeAtLocation(layer);
+        if (!type) return void_;
         return pipe(
           typeParser.isNodeReferenceToEffectModuleApi("provide")(node.expression),
           flatMap2(() => typeParser.layerType(type, layer)),
@@ -5227,6 +5399,7 @@ var multipleEffectProvide = createDiagnostic({
 var nonObjectEffectServiceType = createDiagnostic({
   name: "nonObjectEffectServiceType",
   code: 24,
+  description: "Ensures Effect.Service types are objects, not primitives",
   severity: "error",
   apply: fn("nonObjectEffectServiceType.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -5265,12 +5438,13 @@ var nonObjectEffectServiceType = createDiagnostic({
               fixes: []
             };
             if (propertyName === "succeed") {
-              const valueType = typeChecker.getTypeAtLocation(propertyValue);
-              if (isPrimitiveType(valueType)) {
+              const valueType = typeCheckerUtils.getTypeAtLocation(propertyValue);
+              if (valueType && isPrimitiveType(valueType)) {
                 report(errorToReport);
               }
             } else if (propertyName === "sync") {
-              const valueType = typeChecker.getTypeAtLocation(propertyValue);
+              const valueType = typeCheckerUtils.getTypeAtLocation(propertyValue);
+              if (!valueType) continue;
               const signatures = typeChecker.getSignaturesOfType(valueType, ts.SignatureKind.Call);
               for (const signature of signatures) {
                 const returnType = typeChecker.getReturnTypeOfSignature(signature);
@@ -5280,7 +5454,8 @@ var nonObjectEffectServiceType = createDiagnostic({
                 }
               }
             } else if (propertyName === "effect" || propertyName === "scoped") {
-              const valueType = typeChecker.getTypeAtLocation(propertyValue);
+              const valueType = typeCheckerUtils.getTypeAtLocation(propertyValue);
+              if (!valueType) continue;
               const effectResult = yield* pipe(
                 typeParser.effectType(valueType, propertyValue),
                 orElse2(() => void_)
@@ -5627,7 +5802,8 @@ var annotate = createCodegen({
       }
       for (const variableDeclaration of variableDeclarations) {
         if (!variableDeclaration.initializer) continue;
-        const initializerType = typeChecker.getTypeAtLocation(variableDeclaration.initializer);
+        const initializerType = typeCheckerUtils.getTypeAtLocation(variableDeclaration.initializer);
+        if (!initializerType) continue;
         const enclosingNode = ts.findAncestor(variableDeclaration, (_) => tsUtils.isDeclarationKind(_.kind)) || sourceFile;
         const initializerTypeNode = fromNullable(typeCheckerUtils.typeToSimplifiedTypeNode(
           initializerType,
@@ -6079,7 +6255,7 @@ var findNodeToProcess = fn("StructuralSchemaGen.findNodeToProcess")(
   function* (sourceFile, textRange) {
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
-    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     return pipe(
       tsUtils.getAncestorNodesInRange(sourceFile, textRange),
       filter((node) => ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)),
@@ -6088,7 +6264,7 @@ var findNodeToProcess = fn("StructuralSchemaGen.findNodeToProcess")(
       map3((node) => ({
         node,
         identifier: node.name,
-        type: typeChecker.getTypeAtLocation(node.name),
+        type: typeCheckerUtils.getTypeAtLocation(node.name),
         isExported: node.modifiers ? (ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export) !== 0 : false
       })),
       filter(({ type }) => !!type),
@@ -6266,7 +6442,7 @@ var typeToSchema = createCodegen({
           )
         );
       }
-      const type = typeChecker.getTypeAtLocation(node.name);
+      const type = typeCheckerUtils.getTypeAtLocation(node.name);
       if (!type) {
         return yield* fail(
           new CodegenNotApplicableError(
@@ -6347,6 +6523,7 @@ var codegens = [accessors, annotate, typeToSchema];
 var outdatedEffectCodegen = createDiagnostic({
   name: "outdatedEffectCodegen",
   code: 19,
+  description: "Detects when generated code is outdated and needs to be regenerated",
   severity: "warning",
   apply: fn("outdatedEffectCodegen.apply")(function* (sourceFile, _report) {
     const codegensWithRanges = yield* getCodegensForSourceFile(codegens, sourceFile);
@@ -6392,11 +6569,12 @@ var outdatedEffectCodegen = createDiagnostic({
 var overriddenSchemaConstructor = createDiagnostic({
   name: "overriddenSchemaConstructor",
   code: 30,
+  description: "Prevents overriding constructors in Schema classes which breaks decoding behavior",
   severity: "error",
   apply: fn("overriddenSchemaConstructor.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
-    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     function isAllowedConstructor(node) {
       if (node.body && node.body.statements.length === 1) {
         const expressionStatement = node.body.statements[0];
@@ -6430,7 +6608,8 @@ var overriddenSchemaConstructor = createDiagnostic({
         for (const heritageClause of node.heritageClauses) {
           if (heritageClause.token === ts.SyntaxKind.ExtendsKeyword) {
             for (const type of heritageClause.types) {
-              const typeAtLocation = typeChecker.getTypeAtLocation(type.expression);
+              const typeAtLocation = typeCheckerUtils.getTypeAtLocation(type.expression);
+              if (!typeAtLocation) continue;
               const isSchema = yield* pipe(
                 typeParser.effectSchemaType(typeAtLocation, type.expression),
                 map4(() => true),
@@ -6527,10 +6706,11 @@ var overriddenSchemaConstructor = createDiagnostic({
 var returnEffectInGen = createDiagnostic({
   name: "returnEffectInGen",
   code: 11,
+  description: "Warns when returning an Effect in a generator causes nested Effect<Effect<...>>",
   severity: "suggestion",
   apply: fn("returnEffectInGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
@@ -6548,7 +6728,8 @@ var returnEffectInGen = createDiagnostic({
           (_) => ts.isFunctionExpression(_) || ts.isFunctionDeclaration(_) || ts.isMethodDeclaration(_) || ts.isArrowFunction(_) || ts.isGetAccessor(_)
         );
         if (!(generatorOrRegularFunction && "asteriskToken" in generatorOrRegularFunction && generatorOrRegularFunction.asteriskToken)) continue;
-        const type = typeChecker.getTypeAtLocation(node.expression);
+        const type = typeCheckerUtils.getTypeAtLocation(node.expression);
+        if (!type) continue;
         const maybeEffect = yield* option(typeParser.strictEffectType(type, node.expression));
         if (isSome2(maybeEffect)) {
           if (generatorOrRegularFunction && generatorOrRegularFunction.parent) {
@@ -6594,6 +6775,7 @@ Nested Effect-able types may be intended if you plan to later manually flatten o
 var runEffectInsideEffect = createDiagnostic({
   name: "runEffectInsideEffect",
   code: 32,
+  description: "Suggests using Runtime methods instead of Effect.run* inside Effect contexts",
   severity: "suggestion",
   apply: fn("runEffectInsideEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -6733,6 +6915,7 @@ Consider extracting the Runtime by using for example Effect.runtime and then use
 var schemaStructWithTag = createDiagnostic({
   name: "schemaStructWithTag",
   code: 34,
+  description: "Suggests using Schema.TaggedStruct instead of Schema.Struct with _tag field",
   severity: "suggestion",
   apply: fn("schemaStructWithTag.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -6812,6 +6995,7 @@ var schemaStructWithTag = createDiagnostic({
 var schemaUnionOfLiterals = createDiagnostic({
   name: "schemaUnionOfLiterals",
   code: 33,
+  description: "Simplifies Schema.Union of multiple Schema.Literal calls into single Schema.Literal",
   severity: "off",
   apply: fn("schemaUnionOfLiterals.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -6885,6 +7069,7 @@ var schemaUnionOfLiterals = createDiagnostic({
 var scopeInLayerEffect = createDiagnostic({
   name: "scopeInLayerEffect",
   code: 13,
+  description: "Suggests using Layer.scoped instead of Layer.effect when Scope is in requirements",
   severity: "warning",
   apply: fn("scopeInLayerEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -6943,12 +7128,14 @@ Consider using "scoped" instead to get rid of the scope in the requirements.`,
       const node = nodeToVisit.shift();
       const layerEffectApiCall = parseLayerEffectApiCall(node);
       if (layerEffectApiCall) {
-        const type = typeChecker.getTypeAtLocation(node);
-        yield* pipe(
-          typeParser.layerType(type, node),
-          flatMap2(({ RIn }) => reportIfLayerRequireScope(RIn, node, layerEffectApiCall.methodIdentifier)),
-          ignore
-        );
+        const type = typeCheckerUtils.getTypeAtLocation(node);
+        if (type) {
+          yield* pipe(
+            typeParser.layerType(type, node),
+            flatMap2(({ RIn }) => reportIfLayerRequireScope(RIn, node, layerEffectApiCall.methodIdentifier)),
+            ignore
+          );
+        }
         continue;
       }
       if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
@@ -6976,6 +7163,7 @@ Consider using "scoped" instead to get rid of the scope in the requirements.`,
 var strictBooleanExpressions = createDiagnostic({
   name: "strictBooleanExpressions",
   code: 17,
+  description: "Enforces boolean types in conditional expressions for type safety",
   severity: "off",
   apply: fn("strictBooleanExpressions.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -7017,7 +7205,8 @@ var strictBooleanExpressions = createDiagnostic({
         if (!nodeToCheck) continue;
         if (!conditionChecks.has(nodeToCheck.parent)) continue;
         if (!ts.isExpression(nodeToCheck)) continue;
-        const nodeType = typeChecker.getTypeAtLocation(nodeToCheck);
+        const nodeType = typeCheckerUtils.getTypeAtLocation(nodeToCheck);
+        if (!nodeType) continue;
         const constrainedType = typeChecker.getBaseConstraintOfType(nodeType);
         let typesToCheck = [constrainedType || nodeType];
         while (typesToCheck.length > 0) {
@@ -7045,10 +7234,11 @@ var strictBooleanExpressions = createDiagnostic({
 var strictEffectProvide = createDiagnostic({
   name: "strictEffectProvide",
   code: 27,
+  description: "Warns when using Effect.provide with layers outside of application entry points",
   severity: "off",
   apply: fn("strictEffectProvide.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
     const parseEffectProvideWithLayer = (node) => gen(function* () {
       if (!ts.isCallExpression(node) || node.arguments.length === 0) {
@@ -7057,7 +7247,8 @@ var strictEffectProvide = createDiagnostic({
       yield* typeParser.isNodeReferenceToEffectModuleApi("provide")(node.expression);
       return yield* firstSuccessOf(
         node.arguments.map((arg) => {
-          const argType = typeChecker.getTypeAtLocation(arg);
+          const argType = typeCheckerUtils.getTypeAtLocation(arg);
+          if (!argType) return typeParserIssue("Could not get argument type");
           return typeParser.layerType(argType, arg);
         })
       );
@@ -7089,6 +7280,7 @@ var strictEffectProvide = createDiagnostic({
 var tryCatchInEffectGen = createDiagnostic({
   name: "tryCatchInEffectGen",
   code: 15,
+  description: "Discourages try/catch in Effect generators in favor of Effect error handling",
   severity: "suggestion",
   apply: fn("tryCatchInEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -7134,6 +7326,7 @@ var tryCatchInEffectGen = createDiagnostic({
 var unknownInEffectCatch = createDiagnostic({
   name: "unknownInEffectCatch",
   code: 31,
+  description: "Warns when catch callbacks return unknown instead of typed errors",
   severity: "warning",
   apply: fn("unknownInEffectCatch.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -7191,6 +7384,7 @@ Consider wrapping unknown errors into Effect's Data.TaggedError for example, or
 var unnecessaryEffectGen = createDiagnostic({
   name: "unnecessaryEffectGen",
   code: 5,
+  description: "Suggests removing Effect.gen when it contains only a single return statement",
   severity: "suggestion",
   apply: fn("unnecessaryEffectGen.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -7234,15 +7428,12 @@ var unnecessaryEffectGen = createDiagnostic({
 var unnecessaryFailYieldableError = createDiagnostic({
   name: "unnecessaryFailYieldableError",
   code: 29,
+  description: "Suggests yielding yieldable errors directly instead of wrapping with Effect.fail",
   severity: "suggestion",
   apply: fn("unnecessaryFailYieldableError.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
-    const typeChecker = yield* service(TypeCheckerApi);
-    const yieldableErrorTypes = yield* pipe(
-      typeParser.effectCauseYieldableErrorTypes(sourceFile),
-      orElse2(() => succeed([]))
-    );
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const nodeToVisit = [];
     const appendNodeToVisit = (node) => {
       nodeToVisit.push(node);
@@ -7256,32 +7447,34 @@ var unnecessaryFailYieldableError = createDiagnostic({
         const callExpression = node.expression;
         yield* pipe(
           typeParser.isNodeReferenceToEffectModuleApi("fail")(callExpression.expression),
-          map4(() => {
+          flatMap2(() => {
             if (callExpression.arguments.length > 0) {
               const failArgument = callExpression.arguments[0];
-              const argumentType = typeChecker.getTypeAtLocation(failArgument);
-              const isYieldableError = yieldableErrorTypes.some(
-                (yieldableType) => typeChecker.isTypeAssignableTo(argumentType, yieldableType)
+              const argumentType = typeCheckerUtils.getTypeAtLocation(failArgument);
+              if (!argumentType) return void_;
+              return pipe(
+                typeParser.extendsCauseYieldableError(argumentType),
+                map4(
+                  () => report({
+                    location: node,
+                    messageText: `This Effect.fail call uses a yieldable error type as argument. You can yield* the error directly instead.`,
+                    fixes: [{
+                      fixName: "unnecessaryFailYieldableError_fix",
+                      description: "Replace yield* Effect.fail with yield*",
+                      apply: gen(function* () {
+                        const changeTracker = yield* service(ChangeTracker);
+                        changeTracker.replaceNode(
+                          sourceFile,
+                          callExpression,
+                          failArgument
+                        );
+                      })
+                    }]
+                  })
+                )
               );
-              if (isYieldableError) {
-                report({
-                  location: node,
-                  messageText: `This Effect.fail call uses a yieldable error type as argument. You can yield* the error directly instead.`,
-                  fixes: [{
-                    fixName: "unnecessaryFailYieldableError_fix",
-                    description: "Replace yield* Effect.fail with yield*",
-                    apply: gen(function* () {
-                      const changeTracker = yield* service(ChangeTracker);
-                      changeTracker.replaceNode(
-                        sourceFile,
-                        callExpression,
-                        failArgument
-                      );
-                    })
-                  }]
-                });
-              }
             }
+            return void_;
           }),
           ignore
         );
@@ -7294,6 +7487,7 @@ var unnecessaryFailYieldableError = createDiagnostic({
 var unnecessaryPipe = createDiagnostic({
   name: "unnecessaryPipe",
   code: 9,
+  description: "Removes pipe calls with no arguments",
   severity: "suggestion",
   apply: fn("unnecessaryPipe.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -7339,6 +7533,7 @@ var unnecessaryPipe = createDiagnostic({
 var unnecessaryPipeChain = createDiagnostic({
   name: "unnecessaryPipeChain",
   code: 16,
+  description: "Simplifies chained pipe calls into a single pipe call",
   severity: "suggestion",
   apply: fn("unnecessaryPipeChain.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -7413,6 +7608,7 @@ var unnecessaryPipeChain = createDiagnostic({
 var unsupportedServiceAccessors = createDiagnostic({
   name: "unsupportedServiceAccessors",
   code: 21,
+  description: "Warns about service accessors that need codegen due to generic/complex signatures",
   severity: "warning",
   apply: fn("unsupportedServiceAccessors.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
@@ -7500,7 +7696,8 @@ var diagnostics = [
   unknownInEffectCatch,
   runEffectInsideEffect,
   schemaUnionOfLiterals,
-  schemaStructWithTag
+  schemaStructWithTag,
+  globalErrorInEffectFailure
 ];
 
 // src/effect-lsp-patch-utils.ts