npm - @effect/language-service - Versions diffs - 0.62.5 → 0.63.0 - Mend

@effect/language-service 0.62.5 → 0.63.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/README.md +5 -1
package/cli.js +2753 -675
package/cli.js.map +1 -1
package/effect-lsp-patch-utils.js +342 -147
package/effect-lsp-patch-utils.js.map +1 -1
package/index.js +459 -203
package/index.js.map +1 -1
package/package.json +1 -1
package/transform.js +342 -147
package/transform.js.map +1 -1

package/index.js CHANGED Viewed

@@ -1,6 +1,6 @@
 "use strict";
-// 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") {
@@ -98,7 +98,7 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   }
 }
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Equivalence.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Equivalence.js
 var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
 var array = (item) => make((self, that) => {
   if (self.length !== that.length) {
@@ -113,7 +113,7 @@ var array = (item) => make((self, that) => {
   return true;
 });
-// 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) => {
@@ -127,7 +127,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";
@@ -138,10 +138,10 @@ var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) &&
 var isTagged = /* @__PURE__ */ dual(2, (self, tag) => hasProperty(self, "_tag") && self["_tag"] === tag);
 var isRecord = (input) => isRecordOrArray(input) && !Array.isArray(input);
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/errors.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/errors.js
 var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;
-// 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;
@@ -263,7 +263,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) => {
@@ -288,6 +288,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);
@@ -369,7 +372,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) {
@@ -394,7 +397,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;
       }
@@ -423,7 +428,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 {
@@ -481,7 +486,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:
@@ -514,16 +519,16 @@ 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";
 var OP_FAILURE = "Failure";
 var OP_WITH_RUNTIME = "WithRuntime";
-// 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");
@@ -610,7 +615,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,
@@ -668,7 +673,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,
@@ -730,7 +735,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;
@@ -738,17 +743,17 @@ 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 make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
 var string2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
 var number2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
 var reverse = (O) => make2((self, that) => O(that, self));
 var mapInput = /* @__PURE__ */ dual(2, (self, f) => make2((b1, b2) => self(f(b1), f(b2))));
-// 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;
@@ -759,7 +764,7 @@ var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nu
 var getOrUndefined = /* @__PURE__ */ getOrElse2(constUndefined);
 var map2 = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
-// 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 map3 = /* @__PURE__ */ dual(2, (self, f) => {
   const out = {
     ...self
@@ -771,7 +776,7 @@ var map3 = /* @__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)));
@@ -811,7 +816,10 @@ var containsWith = (isEquivalent) => dual(2, (self, a) => {
 var _equivalence = /* @__PURE__ */ equivalence();
 var intersectionWith = (isEquivalent) => {
   const has3 = containsWith(isEquivalent);
-  return dual(2, (self, that) => fromIterable(self).filter((a) => has3(that, a)));
+  return dual(2, (self, that) => {
+    const bs = fromIterable(that);
+    return fromIterable(self).filter((a) => has3(bs, a));
+  });
 };
 var intersection = /* @__PURE__ */ intersectionWith(_equivalence);
 var empty = () => [];
@@ -872,7 +880,7 @@ var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
 var dedupe = (self) => dedupeWith(self, equivalence());
 var join = /* @__PURE__ */ dual(2, (self, sep) => fromIterable(self).join(sep));
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Chunk.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Chunk.js
 var TypeId3 = /* @__PURE__ */ Symbol.for("effect/Chunk");
 function copy(src, srcPos, dest, destPos, len) {
   for (let i = srcPos; i < Math.min(src.length, srcPos + len); i++) {
@@ -1168,14 +1176,14 @@ var isNonEmpty = (self) => self.length > 0;
 var unsafeHead = (self) => unsafeGet2(self, 0);
 var headNonEmpty2 = unsafeHead;
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/hashMap/config.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/hashMap/config.js
 var SIZE = 5;
 var BUCKET_SIZE = /* @__PURE__ */ Math.pow(2, SIZE);
 var MASK = BUCKET_SIZE - 1;
 var MAX_INDEX_NODE = BUCKET_SIZE / 2;
 var MIN_ARRAY_NODE = BUCKET_SIZE / 4;
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/hashMap/bitwise.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/hashMap/bitwise.js
 function popcount(x) {
   x -= x >> 1 & 1431655765;
   x = (x & 858993459) + (x >> 2 & 858993459);
@@ -1194,13 +1202,13 @@ function fromBitmap(bitmap, bit) {
   return popcount(bitmap & bit - 1);
 }
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/stack.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/stack.js
 var make4 = (value, previous) => ({
   value,
   previous
 });
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/hashMap/array.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/hashMap/array.js
 function arrayUpdate(mutate3, at, v, arr) {
   let out = arr;
   if (!mutate3) {
@@ -1245,7 +1253,7 @@ function arraySpliceIn(mutate3, at, v, arr) {
   return out;
 }
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/hashMap/node.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/hashMap/node.js
 var EmptyNode = class _EmptyNode {
   _tag = "EmptyNode";
   modify(edit, _shift, f, hash2, key, size4) {
@@ -1480,7 +1488,7 @@ function mergeLeaves(edit, shift, h1, n1, h2, n2) {
   }
 }
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/hashMap.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/hashMap.js
 var HashMapSymbolKey = "effect/HashMap";
 var HashMapTypeId = /* @__PURE__ */ Symbol.for(HashMapSymbolKey);
 var HashMapProto = {
@@ -1692,7 +1700,7 @@ var reduce2 = /* @__PURE__ */ dual(3, (self, zero2, f) => {
   return zero2;
 });
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/hashSet.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/hashSet.js
 var HashSetSymbolKey = "effect/HashSet";
 var HashSetTypeId = /* @__PURE__ */ Symbol.for(HashSetSymbolKey);
 var HashSetProto = {
@@ -1754,13 +1762,13 @@ var union2 = /* @__PURE__ */ dual(2, (self, that) => mutate(empty4(), (set2) =>
 }));
 var forEach2 = /* @__PURE__ */ dual(2, (self, f) => forEach(self._keyMap, (_, k) => f(k)));
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/HashSet.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/HashSet.js
 var empty5 = empty4;
 var size3 = size2;
 var add2 = add;
 var union3 = union2;
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/data.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/data.js
 var ArrayProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(Array.prototype), {
   [symbol]() {
     return cached(this, array2(this));
@@ -1783,7 +1791,7 @@ var Structural = /* @__PURE__ */ (function() {
   return Structural2;
 })();
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/opCodes/cause.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/opCodes/cause.js
 var OP_DIE = "Die";
 var OP_EMPTY = "Empty";
 var OP_FAIL = "Fail";
@@ -1791,7 +1799,7 @@ var OP_INTERRUPT = "Interrupt";
 var OP_PARALLEL = "Parallel";
 var OP_SEQUENTIAL = "Sequential";
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/cause.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/cause.js
 var CauseSymbolKey = "effect/Cause";
 var CauseTypeId = /* @__PURE__ */ Symbol.for(CauseSymbolKey);
 var variance = {
@@ -2223,7 +2231,7 @@ var prettyErrors = (cause) => reduceWithContext(cause, void 0, {
   sequentialCase: (_, l, r) => [...l, ...r]
 });
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/singleShotGen.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/singleShotGen.js
 var SingleShotGen2 = class _SingleShotGen {
   self;
   called = false;
@@ -2253,7 +2261,7 @@ var SingleShotGen2 = class _SingleShotGen {
   }
 };
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/core.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/core.js
 var EffectTypeId2 = /* @__PURE__ */ Symbol.for("effect/Effect");
 var EffectPrimitive = class {
   _op;
@@ -2537,7 +2545,7 @@ var currentSpanFromFiber = (fiber) => {
   return span !== void 0 && span._tag === "Span" ? some2(span) : none2();
 };
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Data.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Data.js
 var Class2 = Structural;
 var Error2 = /* @__PURE__ */ (function() {
   const plainArgsSymbol = /* @__PURE__ */ Symbol.for("effect/Data/Error/plainArgs");
@@ -2575,10 +2583,10 @@ var TaggedError = (tag) => {
   return O.BaseEffectError;
 };
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/encoding/common.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/encoding/common.js
 var encoder = /* @__PURE__ */ new TextEncoder();
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/encoding/base64.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/encoding/base64.js
 var encode = (bytes) => {
   const length = bytes.length;
   let result = "";
@@ -2604,13 +2612,13 @@ var encode = (bytes) => {
 };
 var base64abc = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/"];
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/internal/encoding/base64Url.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/encoding/base64Url.js
 var encode2 = (data) => encode(data).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Encoding.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Encoding.js
 var encodeBase64Url = (input) => typeof input === "string" ? encode2(encoder.encode(input)) : encode2(input);
-// node_modules/.pnpm/effect@3.19.0/node_modules/effect/dist/esm/Graph.js
+// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Graph.js
 var TypeId4 = "~effect/Graph";
 var Edge = class extends Class2 {
 };
@@ -3118,12 +3126,12 @@ var SingleShotGen3 = 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;
@@ -4527,6 +4535,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);
   }
@@ -4775,6 +4785,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);
@@ -4844,6 +4858,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,
@@ -4855,7 +4878,9 @@ function makeTypeCheckerUtils(ts, typeChecker, tsUtils) {
     deterministicTypeOrder,
     getInferredReturnType,
     expectedAndRealType,
-    typeToSimplifiedTypeNode
+    typeToSimplifiedTypeNode,
+    isGlobalErrorType,
+    getTypeAtLocation
   };
 }
@@ -4977,7 +5002,7 @@ function make7(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);
@@ -4991,7 +5016,7 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
       return result;
     }),
     `TypeParser.findSymbolsMatchingPackageAndExportedName(${packageName}, ${exportedSymbolName})`,
-    (sourceFile) => sourceFile
+    () => program
   );
   const isCauseTypeSourceFile = cachedBy(
     fn("TypeParser.isCauseTypeSourceFile")(function* (sourceFile) {
@@ -5006,20 +5031,22 @@ function make7(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);
@@ -5409,7 +5436,8 @@ function make7(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)) {
@@ -6000,11 +6028,79 @@ function make7(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,
@@ -6014,7 +6110,7 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     effectGen,
     effectFnUntracedGen,
     effectFnGen,
-    effectCauseYieldableErrorTypes,
+    extendsCauseYieldableError,
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
     contextTag,
@@ -6030,7 +6126,8 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     extendsSchemaTaggedError,
     extendsDataTaggedError,
     extendsDataTaggedClass,
-    extendsSchemaTaggedRequest
+    extendsSchemaTaggedRequest,
+    extendsEffectSqlModelClass
   };
 }
@@ -6429,7 +6526,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,
@@ -6881,7 +6979,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)),
@@ -6890,7 +6988,7 @@ var findNodeToProcess = fn("StructuralSchemaGen.findNodeToProcess")(
       map4((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),
@@ -7068,7 +7166,7 @@ var typeToSchema = createCodegen({
           )
         );
       }
-      const type = typeChecker.getTypeAtLocation(node.name);
+      const type = typeCheckerUtils.getTypeAtLocation(node.name);
       if (!type) {
         return yield* fail3(
           new CodegenNotApplicableError(
@@ -7229,10 +7327,12 @@ var effectDataClasses = createCompletion({
 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 = [];
@@ -7252,7 +7352,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)),
@@ -7263,11 +7364,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) {
@@ -7333,11 +7430,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);
@@ -7368,7 +7467,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) {
@@ -7407,6 +7506,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);
@@ -7428,6 +7528,7 @@ var classSelfMismatch = createDiagnostic({
           orElse2(() => typeParser.extendsSchemaTaggedClass(node)),
           orElse2(() => typeParser.extendsSchemaTaggedError(node)),
           orElse2(() => typeParser.extendsSchemaTaggedRequest(node)),
+          orElse2(() => typeParser.extendsEffectSqlModelClass(node)),
           orElse2(() => void_)
         );
         if (result) {
@@ -7471,6 +7572,7 @@ var classSelfMismatch = createDiagnostic({
 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);
@@ -7591,6 +7693,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);
@@ -7638,6 +7741,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);
@@ -7675,6 +7779,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);
@@ -7723,10 +7828,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;
@@ -7745,7 +7852,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(
@@ -7771,6 +7879,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);
@@ -7813,10 +7922,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),
+          flatMap4(() => {
+            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);
@@ -7956,6 +8111,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);
@@ -8063,7 +8219,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) {
@@ -8097,10 +8254,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];
@@ -8131,7 +8290,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({
@@ -8176,6 +8336,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);
@@ -8224,6 +8385,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);
@@ -8363,6 +8525,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);
@@ -8404,13 +8567,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(
@@ -8453,10 +8618,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) => {
@@ -8468,42 +8634,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
+                  });
+                }
               }
             }
           }
@@ -8517,6 +8685,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);
@@ -8591,11 +8760,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,
@@ -8610,7 +8780,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),
           flatMap4(() => typeParser.layerType(type, layer)),
@@ -8688,6 +8859,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);
@@ -8726,12 +8898,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);
@@ -8741,7 +8914,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_)
@@ -8778,6 +8952,7 @@ var nonObjectEffectServiceType = createDiagnostic({
 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);
@@ -8823,11 +8998,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];
@@ -8861,7 +9037,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),
                 map8(() => true),
@@ -8958,10 +9135,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) => {
@@ -8979,7 +9157,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) {
@@ -9025,6 +9204,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);
@@ -9164,6 +9344,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);
@@ -9243,6 +9424,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);
@@ -9316,6 +9498,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);
@@ -9374,12 +9557,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),
-          flatMap4(({ RIn }) => reportIfLayerRequireScope(RIn, node, layerEffectApiCall.methodIdentifier)),
-          ignore
-        );
+        const type = typeCheckerUtils.getTypeAtLocation(node);
+        if (type) {
+          yield* pipe(
+            typeParser.layerType(type, node),
+            flatMap4(({ RIn }) => reportIfLayerRequireScope(RIn, node, layerEffectApiCall.methodIdentifier)),
+            ignore
+          );
+        }
         continue;
       }
       if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
@@ -9407,6 +9592,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);
@@ -9448,7 +9634,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) {
@@ -9476,10 +9663,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) {
@@ -9488,7 +9676,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);
         })
       );
@@ -9520,6 +9709,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);
@@ -9565,6 +9755,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);
@@ -9622,6 +9813,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);
@@ -9665,15 +9857,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);
@@ -9687,32 +9876,34 @@ var unnecessaryFailYieldableError = createDiagnostic({
         const callExpression = node.expression;
         yield* pipe(
           typeParser.isNodeReferenceToEffectModuleApi("fail")(callExpression.expression),
-          map8(() => {
+          flatMap4(() => {
             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),
+                map8(
+                  () => 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
         );
@@ -9725,6 +9916,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);
@@ -9770,6 +9962,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);
@@ -9844,6 +10037,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);
@@ -9931,7 +10125,8 @@ var diagnostics = [
   unknownInEffectCatch,
   runEffectInsideEffect,
   schemaUnionOfLiterals,
-  schemaStructWithTag
+  schemaStructWithTag,
+  globalErrorInEffectFailure
 ];
 // src/completions/effectDiagnosticsComment.ts
@@ -10128,6 +10323,43 @@ var effectSelfInClasses = createCompletion({
   })
 });
+// src/completions/effectSqlModelSelfInClasses.ts
+var effectSqlModelSelfInClasses = createCompletion({
+  name: "effectSqlModelSelfInClasses",
+  apply: fn("effectSqlModelSelfInClasses")(function* (sourceFile, position) {
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const typeParser = yield* service(TypeParser);
+    const maybeInfos = tsUtils.parseDataForExtendsClassCompletion(sourceFile, position);
+    if (!maybeInfos) return [];
+    const { accessedObject, className, replacementSpan } = maybeInfos;
+    const schemaIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "@effect/sql",
+      "Model"
+    ) || "Model";
+    const isFullyQualified = schemaIdentifier === ts.idText(accessedObject);
+    const name = ts.idText(className);
+    const completions2 = [];
+    const hasClassCompletion = isFullyQualified || isSome2(
+      yield* pipe(
+        typeParser.isNodeReferenceToEffectSqlModelModuleApi("Class")(accessedObject),
+        option
+      )
+    );
+    if (hasClassCompletion) {
+      completions2.push({
+        name: `Class<${name}>`,
+        kind: ts.ScriptElementKind.constElement,
+        insertText: isFullyQualified ? `${schemaIdentifier}.Class<${name}>("${name}")({${"${0}"}}){}` : `Class<${name}>("${name}")({${"${0}"}}){}`,
+        replacementSpan,
+        isSnippet: true
+      });
+    }
+    return completions2;
+  })
+});
 // src/completions/fnFunctionStar.ts
 var fnFunctionStar = createCompletion({
   name: "fnFunctionStar",
@@ -10184,10 +10416,12 @@ var genFunctionStar = createCompletion({
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const maybeInfos = tsUtils.parseAccessedExpressionForCompletion(sourceFile, position);
     if (!maybeInfos) return [];
     const { accessedObject } = maybeInfos;
-    const type = typeChecker.getTypeAtLocation(accessedObject);
+    const type = typeCheckerUtils.getTypeAtLocation(accessedObject);
+    if (!type) return [];
     const genMemberSymbol = type.getProperty("gen");
     if (!genMemberSymbol) return [];
     const genType = typeChecker.getTypeOfSymbolAtLocation(genMemberSymbol, accessedObject);
@@ -10274,6 +10508,7 @@ var schemaBrand = createCompletion({
 // src/completions.ts
 var completions = [
+  effectSqlModelSelfInClasses,
   effectSchemaSelfInClasses,
   effectSelfInClasses,
   contextSelfInClasses,
@@ -10909,6 +11144,7 @@ function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
     const tsUtils = yield* service(TypeScriptUtils);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const textRange = tsUtils.toTextRange(position);
     function isSymbolFromEffectRpcModule(symbol3) {
       if (symbol3.valueDeclaration) {
@@ -10940,7 +11176,8 @@ function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {
     let callNode = null;
     for (const node of tsUtils.getAncestorNodesInRange(sourceFile, textRange)) {
       if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name) && tsUtils.isNodeInRange(textRange)(node.name)) {
-        const type = typeChecker.getTypeAtLocation(node);
+        const type = typeCheckerUtils.getTypeAtLocation(node);
+        if (!type) return void 0;
         for (const callSig of typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call)) {
           if (callSig.parameters.length >= 2 && isSymbolFromEffectRpcClientModule(callSig.parameters[1])) {
             rpcName = ts.idText(node.name);
@@ -10974,11 +11211,13 @@ function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {
         if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && (ts.idText(node.expression.name) === "make" || ts.idText(node.expression.name) === "fromTaggedRequest")) {
           const symbol3 = typeChecker.getSymbolAtLocation(node.expression.name);
           if (symbol3 && isSymbolFromEffectRpcModule(symbol3)) {
-            const type = typeChecker.getTypeAtLocation(node);
-            const _tag = type.getProperty("_tag");
-            if (_tag) {
-              const tagValue = typeChecker.getTypeOfSymbolAtLocation(_tag, node);
-              if ("value" in tagValue && tagValue.value === rpcName) result.push([node, symbol3]);
+            const type = typeCheckerUtils.getTypeAtLocation(node);
+            if (type) {
+              const _tag = type.getProperty("_tag");
+              if (_tag) {
+                const tagValue = typeChecker.getTypeOfSymbolAtLocation(_tag, node);
+                if ("value" in tagValue && tagValue.value === rpcName) result.push([node, symbol3]);
+              }
             }
           }
         }
@@ -11072,6 +11311,7 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
     gen(function* () {
       const ts = yield* service(TypeScriptApi);
       const typeChecker = yield* service(TypeCheckerApi);
+      const typeCheckerUtils = yield* service(TypeCheckerUtils);
       const typeParser = yield* service(TypeParser);
       const tsUtils = yield* service(TypeScriptUtils);
       const options = yield* service(LanguageServicePluginOptions);
@@ -11187,13 +11427,16 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
         const adjustedNode = getNodeForQuickInfo(touchingNode);
         if (ts.isToken(adjustedNode) && adjustedNode.kind === ts.SyntaxKind.YieldKeyword) {
           if (ts.isYieldExpression(adjustedNode.parent) && adjustedNode.parent.asteriskToken && adjustedNode.parent.expression) {
-            return {
-              label: "Effect Type Parameters",
-              type: typeChecker.getTypeAtLocation(adjustedNode.parent.expression),
-              atLocation: adjustedNode.parent.expression,
-              node: adjustedNode.parent,
-              shouldTry: true
-            };
+            const type3 = typeCheckerUtils.getTypeAtLocation(adjustedNode.parent.expression);
+            if (type3) {
+              return {
+                label: "Effect Type Parameters",
+                type: type3,
+                atLocation: adjustedNode.parent.expression,
+                node: adjustedNode.parent,
+                shouldTry: true
+              };
+            }
           }
         }
         const nodeSignature = getSignatureForQuickInfo(adjustedNode);
@@ -11206,13 +11449,16 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
             shouldTry: options.quickinfoEffectParameters === "always" && quickInfo2 ? true : quickInfo2 && ts.displayPartsToString(quickInfo2.displayParts).indexOf("...") > -1
           };
         }
-        return {
-          label: "Effect Type Parameters",
-          type: typeChecker.getTypeAtLocation(adjustedNode),
-          atLocation: adjustedNode,
-          node: adjustedNode,
-          shouldTry: options.quickinfoEffectParameters === "always" && quickInfo2 ? true : quickInfo2 && ts.displayPartsToString(quickInfo2.displayParts).indexOf("...") > -1
-        };
+        const type2 = typeCheckerUtils.getTypeAtLocation(adjustedNode);
+        if (type2) {
+          return {
+            label: "Effect Type Parameters",
+            type: type2,
+            atLocation: adjustedNode,
+            node: adjustedNode,
+            shouldTry: options.quickinfoEffectParameters === "always" && quickInfo2 ? true : quickInfo2 && ts.displayPartsToString(quickInfo2.displayParts).indexOf("...") > -1
+          };
+        }
       }
       const data = getDataForQuickInfo();
       if (!(data && data.shouldTry)) return quickInfo2;
@@ -15481,7 +15727,7 @@ var extractLayerGraph = fn("extractLayerGraph")(function* (node, opts) {
         }
       }
     } else if (ts.isExpression(node2)) {
-      layerType = typeChecker.getTypeAtLocation(node2);
+      layerType = typeCheckerUtils.getTypeAtLocation(node2);
     }
     if (layerType) {
       layerTypes = yield* pipe(typeParser.layerType(layerType, node2), orElse2(() => void_));
@@ -15997,7 +16243,7 @@ function getAdjustedNode(sourceFile, position) {
   return gen(function* () {
     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 range = tsUtils.toTextRange(position);
     const maybeNode = pipe(
@@ -16009,10 +16255,12 @@ function getAdjustedNode(sourceFile, position) {
     if (isNone2(maybeNode)) return void 0;
     const node = maybeNode.value;
     const layerNode = node.initializer ? node.initializer : node;
-    const layerType = typeChecker.getTypeAtLocation(layerNode);
-    const maybeLayer = yield* option(typeParser.layerType(layerType, layerNode));
-    if (isNone2(maybeLayer)) return void 0;
-    return { node, layerNode };
+    const layerType = typeCheckerUtils.getTypeAtLocation(layerNode);
+    if (layerType) {
+      const maybeLayer = yield* option(typeParser.layerType(layerType, layerNode));
+      if (isNone2(maybeLayer)) return void 0;
+      return { node, layerNode };
+    }
   });
 }
 function parseLayerGraph(layerNode) {
@@ -17647,15 +17895,21 @@ var processNode = (node, isVirtualTypeNode) => gen(function* () {
   }
   if (ts.isTypeQueryNode(node)) {
     const typeChecker = yield* service(TypeCheckerApi);
-    const type = typeChecker.getTypeAtLocation(node.exprName);
-    const typeNode = typeChecker.typeToTypeNode(type, void 0, ts.NodeBuilderFlags.NoTruncation);
-    if (typeNode) return yield* processNode(typeNode, true);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const type = typeCheckerUtils.getTypeAtLocation(node.exprName);
+    if (type) {
+      const typeNode = typeChecker.typeToTypeNode(type, void 0, ts.NodeBuilderFlags.NoTruncation);
+      if (typeNode) return yield* processNode(typeNode, true);
+    }
   }
   if (!isVirtualTypeNode && ts.isIndexedAccessTypeNode(node) && ts.isParenthesizedTypeNode(node.objectType) && ts.isTypeQueryNode(node.objectType.type) && ts.isTypeOperatorNode(node.indexType) && node.indexType.operator === ts.SyntaxKind.KeyOfKeyword && ts.isTypeQueryNode(node.indexType.type) && node.indexType.type.exprName.getText().trim() === node.objectType.type.exprName.getText().trim()) {
     const typeChecker = yield* service(TypeCheckerApi);
-    const type = typeChecker.getTypeAtLocation(node);
-    const typeNode = typeChecker.typeToTypeNode(type, void 0, ts.NodeBuilderFlags.NoTruncation);
-    if (typeNode) return yield* processNode(typeNode, true);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const type = typeCheckerUtils.getTypeAtLocation(node);
+    if (type) {
+      const typeNode = typeChecker.typeToTypeNode(type, void 0, ts.NodeBuilderFlags.NoTruncation);
+      if (typeNode) return yield* processNode(typeNode, true);
+    }
   }
   if (ts.isTypeReferenceNode(node)) {
     const parsedName = entityNameToDataTypeName(node.typeName);
@@ -17962,6 +18216,7 @@ var wrapWithEffectGen = createRefactor({
     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 findEffectToWrap = fn("wrapWithEffectGen.apply.findEffectToWrap")(
       function* (node) {
@@ -17969,7 +18224,8 @@ var wrapWithEffectGen = createRefactor({
         if (node.parent && ts.isHeritageClause(node.parent)) return yield* fail3("is in a heritage clause");
         const parent = node.parent;
         if (parent != null && ts.isVariableDeclaration(parent) && parent.initializer !== node) return yield* fail3("is LHS of variable declaration");
-        const type = typeChecker.getTypeAtLocation(node);
+        const type = typeCheckerUtils.getTypeAtLocation(node);
+        if (!type) return yield* fail3("cannot get type");
         yield* typeParser.strictEffectType(type, node);
         return node;
       }