@effect/language-service 0.36.0 → 0.37.0

package/effect-lsp-patch-utils.js

@@ -20,7 +20,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/effect-lsp-patch-utils.ts
 var effect_lsp_patch_utils_exports = {};
 __export(effect_lsp_patch_utils_exports, {
-  checkSourceFileWorker: () => checkSourceFileWorker
+  appendMetadataRelationError: () => appendMetadataRelationError,
+  checkSourceFileWorker: () => checkSourceFileWorker,
+  clearSourceFileEffectMetadata: () => clearSourceFileEffectMetadata
 });
 module.exports = __toCommonJS(effect_lsp_patch_utils_exports);
 
@@ -331,10 +333,10 @@ var string = (str) => {
   }
   return optimize(h);
 };
-var structureKeys = (o, keys) => {
+var structureKeys = (o, keys2) => {
   let h = 12289;
-  for (let i = 0; i < keys.length; i++) {
-    h ^= pipe(string(keys[i]), combine(hash(o[keys[i]])));
+  for (let i = 0; i < keys2.length; i++) {
+    h ^= pipe(string(keys2[i]), combine(hash(o[keys2[i]])));
   }
   return optimize(h);
 };
@@ -739,24 +741,17 @@ var isSome2 = isSome;
 var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : self);
 var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
 
-// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Iterable.js
-var findFirst = /* @__PURE__ */ dual(2, (self, f) => {
-  let i = 0;
-  for (const a of self) {
-    const o = f(a, i);
-    if (isBoolean(o)) {
-      if (o) {
-        return some2(a);
-      }
-    } else {
-      if (isSome2(o)) {
-        return o;
-      }
-    }
-    i++;
+// node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Record.js
+var map2 = /* @__PURE__ */ dual(2, (self, f) => {
+  const out = {
+    ...self
+  };
+  for (const key of keys(self)) {
+    out[key] = f(self[key], key);
   }
-  return none2();
+  return out;
 });
+var keys = (self) => Object.keys(self);
 
 // node_modules/.pnpm/effect@3.17.8/node_modules/effect/dist/esm/Array.js
 var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
@@ -776,7 +771,6 @@ var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
 });
 var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
 var tailNonEmpty = (self) => self.slice(1);
-var findFirst2 = findFirst;
 var sort = /* @__PURE__ */ dual(2, (self, O) => {
   const out = Array.from(self);
   out.sort(O);
@@ -797,7 +791,7 @@ var intersectionWith = (isEquivalent) => {
 };
 var intersection = /* @__PURE__ */ intersectionWith(_equivalence);
 var empty = () => [];
-var map2 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
+var map3 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
 var flatMap = /* @__PURE__ */ dual(2, (self, f) => {
   if (isEmptyReadonlyArray(self)) {
     return [];
@@ -935,6 +929,7 @@ var NanoFiber = class {
   _yielded = void 0;
   _services = {};
   _cache = {};
+  _perf = false;
   runLoop(nano) {
     let current = nano;
     while (true) {
@@ -958,6 +953,34 @@ var NanoFiber = class {
     return NanoYield;
   }
 };
+var timings = {};
+var timingsCount = {};
+var WithSpanProto = {
+  ...PrimitiveProto,
+  [evaluate](fiber) {
+    const [fa, name] = this[args];
+    if (!fiber._perf) return fa;
+    const start = performance.now();
+    timingsCount[name] = (timingsCount[name] || 0) + 1;
+    return match(fa, {
+      onSuccess: (_) => {
+        const end = performance.now();
+        timings[name] = (timings[name] || 0) + (end - start);
+        return succeed(_);
+      },
+      onFailure: (_) => {
+        const end = performance.now();
+        timings[name] = (timings[name] || 0) + (end - start);
+        return fail(_);
+      }
+    });
+  }
+};
+var withSpan = (name) => (fa) => {
+  const nano = Object.create(WithSpanProto);
+  nano[args] = [fa, name];
+  return nano;
+};
 var unsafeRun = (nano) => {
   const fiber = new NanoFiber();
   const result = fiber.runLoop(nano);
@@ -979,7 +1002,7 @@ var flatMap2 = dual(2, (fa, f) => {
   nano[contA] = f;
   return nano;
 });
-var map3 = dual(2, (fa, f) => flatMap2(fa, (_) => succeed(f(_))));
+var map4 = dual(2, (fa, f) => flatMap2(fa, (_) => succeed(f(_))));
 var SyncProto = {
   ...PrimitiveProto,
   [evaluate](fiber) {
@@ -1012,7 +1035,7 @@ var unsafeFromIterator = (iterator, initial) => {
   return nano;
 };
 var gen = (...args2) => suspend(() => unsafeFromIterator(args2[0]()));
-var fn = (_) => (body) => (...args2) => suspend(() => unsafeFromIterator(body(...args2)));
+var fn = (_) => (body) => (...args2) => withSpan(_)(suspend(() => unsafeFromIterator(body(...args2))));
 var MatchProto = {
   ...PrimitiveProto,
   [evaluate](fiber) {
@@ -1138,7 +1161,7 @@ function parseDiagnosticSeverity(config) {
     pipe(
       Object.entries(config),
       filter(([key, value]) => isString(key) && isString(value)),
-      map2(([key, value]) => [String(key).toLowerCase(), String(value).toLowerCase()]),
+      map3(([key, value]) => [String(key).toLowerCase(), String(value).toLowerCase()]),
       filter(
         ([_, value]) => value === "off" || value === "error" || value === "warning" || value === "message" || value === "suggestion"
       )
@@ -1156,8 +1179,10 @@ var defaults = {
   inlays: true,
   allowedDuplicatedPackages: [],
   namespaceImportPackages: [],
+  topLevelNamedReexports: "ignore",
   barrelImportPackages: [],
-  topLevelNamedReexports: "ignore"
+  importAliases: {},
+  renames: true
 };
 function parse(config) {
   return {
@@ -1172,7 +1197,9 @@ function parse(config) {
     allowedDuplicatedPackages: isObject(config) && hasProperty(config, "allowedDuplicatedPackages") && isArray(config.allowedDuplicatedPackages) && config.allowedDuplicatedPackages.every(isString) ? config.allowedDuplicatedPackages.map((_) => _.toLowerCase()) : defaults.allowedDuplicatedPackages,
     namespaceImportPackages: isObject(config) && hasProperty(config, "namespaceImportPackages") && isArray(config.namespaceImportPackages) && config.namespaceImportPackages.every(isString) ? config.namespaceImportPackages.map((_) => _.toLowerCase()) : defaults.namespaceImportPackages,
     barrelImportPackages: isObject(config) && hasProperty(config, "barrelImportPackages") && isArray(config.barrelImportPackages) && config.barrelImportPackages.every(isString) ? config.barrelImportPackages.map((_) => _.toLowerCase()) : defaults.barrelImportPackages,
-    topLevelNamedReexports: isObject(config) && hasProperty(config, "topLevelNamedReexports") && isString(config.topLevelNamedReexports) && ["ignore", "follow"].includes(config.topLevelNamedReexports.toLowerCase()) ? config.topLevelNamedReexports.toLowerCase() : defaults.topLevelNamedReexports
+    importAliases: isObject(config) && hasProperty(config, "importAliases") && isRecord(config.importAliases) ? map2(config.importAliases, (value) => String(value)) : defaults.importAliases,
+    topLevelNamedReexports: isObject(config) && hasProperty(config, "topLevelNamedReexports") && isString(config.topLevelNamedReexports) && ["ignore", "follow"].includes(config.topLevelNamedReexports.toLowerCase()) ? config.topLevelNamedReexports.toLowerCase() : defaults.topLevelNamedReexports,
+    renames: isObject(config) && hasProperty(config, "renames") && isBoolean(config.renames) ? config.renames : defaults.renames
   };
 }
 
@@ -1236,7 +1263,7 @@ function makeTypeScriptUtils(ts) {
     return pipe(
       referencedPackages.concat(packageJsonScope?.referencedPackages || []),
       dedupe,
-      map2((packageName) => packageName.toLowerCase()),
+      map3((packageName) => packageName.toLowerCase()),
       filter(
         (packageName) => pattern.endsWith("*") && packageName.startsWith(pattern.toLowerCase().substring(0, pattern.length - 1))
       )
@@ -1352,7 +1379,7 @@ function makeTypeScriptUtils(ts) {
       fnCall = ts.factory.createCallExpression(
         fnCall,
         void 0,
-        [ts.factory.createStringLiteral(fnName.text)]
+        [ts.factory.createStringLiteral(ts.idText(fnName))]
       );
     }
     return tryPreserveDeclarationSemantics(
@@ -1424,7 +1451,7 @@ function makeTypeScriptUtils(ts) {
       if (!namedBindings) continue;
       if (ts.isNamespaceImport(namedBindings)) {
         if (test(namedBindings.name, statement.moduleSpecifier, none2())) {
-          return namedBindings.name.text;
+          return ts.idText(namedBindings.name);
         }
       } else if (ts.isNamedImports(namedBindings)) {
         for (const importSpecifier of namedBindings.elements) {
@@ -1432,7 +1459,7 @@ function makeTypeScriptUtils(ts) {
             orElse(() => some2(importSpecifier.name))
           );
           if (test(importSpecifier.name, statement.moduleSpecifier, importProperty)) {
-            return importSpecifier.name.text;
+            return ts.idText(importSpecifier.name);
           }
         }
       }
@@ -1445,7 +1472,7 @@ function makeTypeScriptUtils(ts) {
         if (isNone2(importProperty) && ts.isStringLiteral(fromModule) && fromModule.text === packageName + "/" + moduleName) {
           return true;
         }
-        if (isSome2(importProperty) && ts.isIdentifier(importProperty.value) && importProperty.value.text === moduleName && ts.isStringLiteral(fromModule) && fromModule.text === packageName) {
+        if (isSome2(importProperty) && ts.isIdentifier(importProperty.value) && ts.idText(importProperty.value) === moduleName && ts.isStringLiteral(fromModule) && fromModule.text === packageName) {
           return true;
         }
         return false;
@@ -1943,7 +1970,7 @@ var getEditsForCodegen = fn("LSP.getEditsForCodegen")(function* (codegens2, sour
   const edit = yield* codegen.apply(sourceFile, range);
   const updateHashComment = pipe(
     service(ChangeTracker),
-    map3((changeTracker) => {
+    map4((changeTracker) => {
       changeTracker.deleteRange(sourceFile, range);
       changeTracker.insertText(sourceFile, range.pos, `${codegen.name}:${edit.hash}`);
     })
@@ -1957,191 +1984,17 @@ var getEditsForCodegen = fn("LSP.getEditsForCodegen")(function* (codegens2, sour
     ignore: updateHashComment
   };
 });
+var getEffectLspPatchSourceFileMetadata = (sourceFile) => {
+  return sourceFile["@effect-lsp-patch/metadata"];
+};
+var getOrDefaultEffectLspPatchSourceFileMetadata = (sourceFile) => {
+  return getEffectLspPatchSourceFileMetadata(sourceFile) || (sourceFile["@effect-lsp-patch/metadata"] = {
+    relationErrors: []
+  });
+};
 
 // src/core/TypeCheckerApi.ts
 var TypeCheckerApi = Tag("TypeChecker");
-var deterministicTypeOrder = gen(function* () {
-  const typeChecker = yield* service(TypeCheckerApi);
-  return make((a, b) => {
-    const aName = typeChecker.typeToString(a);
-    const bName = typeChecker.typeToString(b);
-    if (aName < bName) return -1;
-    if (aName > bName) return 1;
-    return 0;
-  });
-});
-var CannotFindAncestorConvertibleDeclarationError = class {
-  constructor(node) {
-    this.node = node;
-  }
-  _tag = "@effect/language-service/CannotFindAncestorConvertibleDeclarationError";
-};
-var getAncestorConvertibleDeclaration = fn(
-  "TypeCheckerApi.getAncestorConvertibleDeclaration"
-)(function* (node) {
-  const ts = yield* service(TypeScriptApi);
-  let current = node;
-  while (current) {
-    if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current)) {
-      return current;
-    }
-    current = current.parent;
-  }
-  return yield* fail(new CannotFindAncestorConvertibleDeclarationError(node));
-});
-var CannotInferReturnTypeFromEmptyBody = class {
-  constructor(declaration) {
-    this.declaration = declaration;
-  }
-  _tag = "@effect/language-service/CannotInferReturnTypeFromEmptyBody";
-};
-var CannotInferReturnType = class {
-  constructor(declaration) {
-    this.declaration = declaration;
-  }
-  _tag = "@effect/language-service/CannotInferReturnType";
-};
-var getInferredReturnType = fn("TypeCheckerApi.getInferredReturnType")(function* (declaration) {
-  const typeChecker = yield* service(TypeCheckerApi);
-  const ts = yield* service(TypeScriptApi);
-  if (!declaration.body) {
-    return yield* fail(
-      new CannotInferReturnTypeFromEmptyBody(declaration)
-    );
-  }
-  let returnType;
-  if (typeChecker.isImplementationOfOverload(declaration)) {
-    const signatures = typeChecker.getSignaturesOfType(
-      typeChecker.getTypeAtLocation(declaration),
-      ts.SignatureKind.Call
-    );
-    if (signatures.length > 1) {
-      returnType = typeChecker.getUnionType(
-        signatures.map((s) => typeChecker.getReturnTypeOfSignature(s)).filter((_) => !!_)
-      );
-    }
-  }
-  if (!returnType) {
-    const signature = typeChecker.getSignatureFromDeclaration(declaration);
-    if (signature) {
-      const typePredicate = typeChecker.getTypePredicateOfSignature(signature);
-      if (typePredicate && typePredicate.type) {
-        return typePredicate.type;
-      } else {
-        returnType = typeChecker.getReturnTypeOfSignature(signature);
-      }
-    }
-  }
-  if (!returnType) {
-    return yield* fail(
-      new CannotInferReturnType(declaration)
-    );
-  }
-  return returnType;
-});
-var expectedAndRealType = cachedBy(
-  fn("TypeCheckerApi.expectedAndRealType")(function* (sourceFile) {
-    const typeChecker = yield* service(TypeCheckerApi);
-    const ts = yield* service(TypeScriptApi);
-    const result = [];
-    const nodeToVisit = [sourceFile];
-    const appendNodeToVisit = (node) => {
-      nodeToVisit.push(node);
-      return void 0;
-    };
-    while (nodeToVisit.length > 0) {
-      const node = nodeToVisit.shift();
-      if (ts.isVariableDeclaration(node) && node.initializer) {
-        const expectedType = typeChecker.getTypeAtLocation(node.name);
-        const realType = typeChecker.getTypeAtLocation(node.initializer);
-        result.push([node.name, expectedType, node.initializer, realType]);
-        appendNodeToVisit(node.initializer);
-        continue;
-      } else if (ts.isCallExpression(node)) {
-        const resolvedSignature = typeChecker.getResolvedSignature(node);
-        if (resolvedSignature) {
-          resolvedSignature.parameters.map((parameter, index) => {
-            const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
-            const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
-            result.push([
-              node.arguments[index],
-              expectedType,
-              node.arguments[index],
-              realType
-            ]);
-          });
-        }
-        ts.forEachChild(node, appendNodeToVisit);
-        continue;
-      } else if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
-        const parent = node.parent;
-        if (ts.isObjectLiteralElement(parent)) {
-          if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) {
-            const type = typeChecker.getContextualType(parent.parent);
-            if (type) {
-              const name = ts.isIdentifier(node) ? ts.idText(node) : ts.isStringLiteral(node) ? node.text : void 0;
-              if (name) {
-                const symbol3 = typeChecker.getPropertyOfType(type, name);
-                if (symbol3) {
-                  const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
-                  const realType = typeChecker.getTypeAtLocation(node);
-                  result.push([node, expectedType, node, realType]);
-                }
-              }
-            }
-          }
-        }
-        ts.forEachChild(node, appendNodeToVisit);
-        continue;
-      } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
-        const expectedType = typeChecker.getTypeAtLocation(node.left);
-        const realType = typeChecker.getTypeAtLocation(node.right);
-        result.push([node.left, expectedType, node.right, realType]);
-        appendNodeToVisit(node.right);
-        continue;
-      } else if (ts.isReturnStatement(node) && node.expression) {
-        const parentDeclaration = yield* option(getAncestorConvertibleDeclaration(node));
-        if (isSome2(parentDeclaration)) {
-          const expectedType = yield* option(getInferredReturnType(parentDeclaration.value));
-          const realType = typeChecker.getTypeAtLocation(node.expression);
-          if (isSome2(expectedType)) {
-            result.push([node, expectedType.value, node, realType]);
-          }
-        }
-        ts.forEachChild(node, appendNodeToVisit);
-        continue;
-      } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length === 0 && ts.isExpression(node.body)) {
-        const body = node.body;
-        const expectedType = typeChecker.getContextualType(body);
-        const realType = typeChecker.getTypeAtLocation(body);
-        if (expectedType) {
-          result.push([body, expectedType, body, realType]);
-        }
-        ts.forEachChild(body, appendNodeToVisit);
-        continue;
-      } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length > 0 && ts.isExpression(node.body)) {
-        const body = node.body;
-        const expectedType = yield* option(getInferredReturnType(node));
-        const realType = typeChecker.getTypeAtLocation(body);
-        if (isSome2(expectedType)) {
-          result.push([body, expectedType.value, body, realType]);
-        }
-        ts.forEachChild(body, appendNodeToVisit);
-        continue;
-      } else if (ts.isSatisfiesExpression(node)) {
-        const expectedType = typeChecker.getTypeAtLocation(node.type);
-        const realType = typeChecker.getTypeAtLocation(node.expression);
-        result.push([node.expression, expectedType, node.expression, realType]);
-        appendNodeToVisit(node.expression);
-        continue;
-      }
-      ts.forEachChild(node, appendNodeToVisit);
-    }
-    return result;
-  }),
-  "TypeCheckerApi.expectedAndRealType",
-  (sourceFile) => sourceFile
-);
 function makeResolveExternalModuleName(typeChecker) {
   if (!(hasProperty(typeChecker, "resolveExternalModuleName") && isFunction(typeChecker.resolveExternalModuleName))) {
     return;
@@ -2254,12 +2107,161 @@ function makeTypeCheckerUtils(ts, typeChecker) {
       };
     }
   );
+  const deterministicTypeOrder = make((a, b) => {
+    const aName = typeChecker.typeToString(a);
+    const bName = typeChecker.typeToString(b);
+    if (aName < bName) return -1;
+    if (aName > bName) return 1;
+    return 0;
+  });
+  const getAncestorConvertibleDeclaration = (node) => {
+    let current = node;
+    while (current) {
+      if (ts.isFunctionDeclaration(current) || ts.isFunctionExpression(current) || ts.isArrowFunction(current) || ts.isMethodDeclaration(current)) {
+        return current;
+      }
+      current = current.parent;
+    }
+  };
+  const getInferredReturnType = (declaration) => {
+    if (!declaration.body) {
+      return;
+    }
+    let returnType;
+    if (typeChecker.isImplementationOfOverload(declaration)) {
+      const signatures = typeChecker.getSignaturesOfType(
+        typeChecker.getTypeAtLocation(declaration),
+        ts.SignatureKind.Call
+      );
+      if (signatures.length > 1) {
+        returnType = typeChecker.getUnionType(
+          signatures.map((s) => typeChecker.getReturnTypeOfSignature(s)).filter((_) => !!_)
+        );
+      }
+    }
+    if (!returnType) {
+      const signature = typeChecker.getSignatureFromDeclaration(declaration);
+      if (signature) {
+        const typePredicate = typeChecker.getTypePredicateOfSignature(signature);
+        if (typePredicate && typePredicate.type) {
+          return typePredicate.type;
+        } else {
+          returnType = typeChecker.getReturnTypeOfSignature(signature);
+        }
+      }
+    }
+    return returnType;
+  };
+  const expectedAndRealTypeCache = /* @__PURE__ */ new WeakMap();
+  const expectedAndRealType = (sourceFile) => {
+    const cached2 = expectedAndRealTypeCache.get(sourceFile);
+    if (cached2) return cached2;
+    const result = [];
+    const nodeToVisit = [sourceFile];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isVariableDeclaration(node) && node.initializer) {
+        const expectedType = typeChecker.getTypeAtLocation(node.name);
+        const realType = typeChecker.getTypeAtLocation(node.initializer);
+        result.push([node.name, expectedType, node.initializer, realType]);
+        appendNodeToVisit(node.initializer);
+        continue;
+      } else if (ts.isCallExpression(node)) {
+        const resolvedSignature = typeChecker.getResolvedSignature(node);
+        if (resolvedSignature) {
+          resolvedSignature.parameters.map((parameter, index) => {
+            const expectedType = typeChecker.getTypeOfSymbolAtLocation(parameter, node);
+            const realType = typeChecker.getTypeAtLocation(node.arguments[index]);
+            result.push([
+              node.arguments[index],
+              expectedType,
+              node.arguments[index],
+              realType
+            ]);
+          });
+        }
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      } else if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+        const parent = node.parent;
+        if (ts.isObjectLiteralElement(parent)) {
+          if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) {
+            const type = typeChecker.getContextualType(parent.parent);
+            if (type) {
+              const name = ts.isIdentifier(node) ? ts.idText(node) : ts.isStringLiteral(node) ? node.text : void 0;
+              if (name) {
+                const symbol3 = typeChecker.getPropertyOfType(type, name);
+                if (symbol3) {
+                  const expectedType = typeChecker.getTypeOfSymbolAtLocation(symbol3, node);
+                  const realType = typeChecker.getTypeAtLocation(node);
+                  result.push([node, expectedType, node, realType]);
+                }
+              }
+            }
+          }
+        }
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
+        const expectedType = typeChecker.getTypeAtLocation(node.left);
+        const realType = typeChecker.getTypeAtLocation(node.right);
+        result.push([node.left, expectedType, node.right, realType]);
+        appendNodeToVisit(node.right);
+        continue;
+      } else if (ts.isReturnStatement(node) && node.expression) {
+        const parentDeclaration = getAncestorConvertibleDeclaration(node);
+        if (parentDeclaration) {
+          const expectedType = getInferredReturnType(parentDeclaration);
+          const realType = typeChecker.getTypeAtLocation(node.expression);
+          if (expectedType) {
+            result.push([node, expectedType, node, realType]);
+          }
+        }
+        ts.forEachChild(node, appendNodeToVisit);
+        continue;
+      } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length === 0 && ts.isExpression(node.body)) {
+        const body = node.body;
+        const expectedType = typeChecker.getContextualType(body);
+        const realType = typeChecker.getTypeAtLocation(body);
+        if (expectedType) {
+          result.push([body, expectedType, body, realType]);
+        }
+        ts.forEachChild(body, appendNodeToVisit);
+        continue;
+      } else if (ts.isArrowFunction(node) && (node.typeParameters || []).length > 0 && ts.isExpression(node.body)) {
+        const body = node.body;
+        const expectedType = getInferredReturnType(node);
+        const realType = typeChecker.getTypeAtLocation(body);
+        if (expectedType) {
+          result.push([body, expectedType, body, realType]);
+        }
+        ts.forEachChild(body, appendNodeToVisit);
+        continue;
+      } else if (ts.isSatisfiesExpression(node)) {
+        const expectedType = typeChecker.getTypeAtLocation(node.type);
+        const realType = typeChecker.getTypeAtLocation(node.expression);
+        result.push([node.expression, expectedType, node.expression, realType]);
+        appendNodeToVisit(node.expression);
+        continue;
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+    expectedAndRealTypeCache.set(sourceFile, result);
+    return result;
+  };
   return {
     isUnion,
     getTypeParameterAtPosition,
     getMissingTypeEntriesInTargetType,
     unrollUnionMembers,
-    appendToUniqueTypesMap
+    appendToUniqueTypesMap,
+    deterministicTypeOrder,
+    getInferredReturnType,
+    expectedAndRealType
   };
 }
 
@@ -2344,7 +2346,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
     const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, atLocation);
     return invariantTypeArgument(propertyType);
   };
-  const effectVarianceStruct = (type, atLocation) => map3(
+  const effectVarianceStruct = (type, atLocation) => map4(
     all(
       varianceStructCovariantType(type, atLocation, "_A"),
       varianceStructCovariantType(type, atLocation, "_E"),
@@ -2352,7 +2354,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
     ),
     ([A, E, R]) => ({ A, E, R })
   );
-  const layerVarianceStruct = (type, atLocation) => map3(
+  const layerVarianceStruct = (type, atLocation) => map4(
     all(
       varianceStructContravariantType(type, atLocation, "_ROut"),
       varianceStructCovariantType(type, atLocation, "_E"),
@@ -2491,6 +2493,21 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.importedEffectModule",
     (node) => node
   );
+  const importedDataModule = cachedBy(
+    fn("TypeParser.importedDataModule")(function* (node) {
+      const type = typeChecker.getTypeAtLocation(node);
+      const propertySymbol = typeChecker.getPropertyOfType(type, "TaggedError");
+      if (!propertySymbol) {
+        return yield* typeParserIssue("Type has no 'TaggedError' property", type, node);
+      }
+      if (!ts.isExpression(node)) {
+        return yield* typeParserIssue("Node is not an expression", type, node);
+      }
+      return node;
+    }),
+    "TypeParser.importedDataModule",
+    (node) => node
+  );
   const effectGen = cachedBy(
     function(node) {
       if (!ts.isCallExpression(node)) {
@@ -2510,12 +2527,12 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
         return typeParserIssue("Node is not a property access expression", void 0, node);
       }
       const propertyAccess = node.expression;
-      if (propertyAccess.name.text !== "gen") {
+      if (!(ts.isIdentifier(propertyAccess.name) && ts.idText(propertyAccess.name) === "gen")) {
         return typeParserIssue("Call expression name is not 'gen'", void 0, node);
       }
       return pipe(
         importedEffectModule(propertyAccess.expression),
-        map3((effectModule) => ({
+        map4((effectModule) => ({
           node,
           effectModule,
           generatorFunction,
@@ -2554,7 +2571,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
         );
       }
       const propertyAccess = node.expression;
-      if (propertyAccess.name.text !== "fnUntraced") {
+      if (!(ts.isIdentifier(propertyAccess.name) && ts.idText(propertyAccess.name) === "fnUntraced")) {
         return typeParserIssue(
           "Call expression name is not 'fnUntraced'",
           void 0,
@@ -2563,7 +2580,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
       }
       return pipe(
         importedEffectModule(propertyAccess.expression),
-        map3((effectModule) => ({
+        map4((effectModule) => ({
           node,
           effectModule,
           generatorFunction,
@@ -2607,7 +2624,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
         );
       }
       const propertyAccess = expressionToTest;
-      if (propertyAccess.name.text !== "fn") {
+      if (!(ts.isIdentifier(propertyAccess.name) && ts.idText(propertyAccess.name) === "fn")) {
         return typeParserIssue(
           "Call expression name is not 'fn'",
           void 0,
@@ -2616,7 +2633,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
       }
       return pipe(
         importedEffectModule(propertyAccess.expression),
-        map3((effectModule) => ({
+        map4((effectModule) => ({
           node,
           generatorFunction,
           effectModule,
@@ -2690,7 +2707,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.unnecessaryEffectGen",
     (node) => node
   );
-  const effectSchemaVarianceStruct = (type, atLocation) => map3(
+  const effectSchemaVarianceStruct = (type, atLocation) => map4(
     all(
       varianceStructInvariantType(type, atLocation, "_A"),
       varianceStructInvariantType(type, atLocation, "_I"),
@@ -2722,7 +2739,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.effectSchemaType",
     (type) => type
   );
-  const contextTagVarianceStruct = (type, atLocation) => map3(
+  const contextTagVarianceStruct = (type, atLocation) => map4(
     all(
       varianceStructInvariantType(type, atLocation, "_Identifier"),
       varianceStructInvariantType(type, atLocation, "_Service")
@@ -2761,7 +2778,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
           kind: "pipeable"
         });
       }
-      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "pipe" && node.arguments.length > 0) {
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && ts.idText(node.expression) === "pipe" && node.arguments.length > 0) {
         const [subject, ...args2] = node.arguments;
         return succeed({ node, subject, args: args2, kind: "pipe" });
       }
@@ -2886,7 +2903,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
         for (const typeX of heritageClause.types) {
           if (ts.isExpressionWithTypeArguments(typeX)) {
             const expression = typeX.expression;
-            if (ts.isCallExpression(expression)) {
+            if (ts.isCallExpression(expression) && expression.arguments.length > 0) {
               const schemaTaggedClassTCall = expression.expression;
               if (ts.isCallExpression(schemaTaggedClassTCall) && schemaTaggedClassTCall.typeArguments && schemaTaggedClassTCall.typeArguments.length > 0) {
                 const selfTypeNode = schemaTaggedClassTCall.typeArguments[0];
@@ -2900,6 +2917,8 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
                     return {
                       className: atLocation.name,
                       selfTypeNode,
+                      keyStringLiteral: schemaTaggedClassTCall.arguments.length > 0 && ts.isStringLiteral(schemaTaggedClassTCall.arguments[0]) ? schemaTaggedClassTCall.arguments[0] : void 0,
+                      tagStringLiteral: expression.arguments.length > 0 && ts.isStringLiteral(expression.arguments[0]) ? expression.arguments[0] : void 0,
                       Schema: parsedSchemaModule.value
                     };
                   }
@@ -2941,6 +2960,8 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
                     return {
                       className: atLocation.name,
                       selfTypeNode,
+                      keyStringLiteral: schemaTaggedErrorTCall.arguments.length > 0 && ts.isStringLiteral(schemaTaggedErrorTCall.arguments[0]) ? schemaTaggedErrorTCall.arguments[0] : void 0,
+                      tagStringLiteral: expression.arguments.length > 0 && ts.isStringLiteral(expression.arguments[0]) ? expression.arguments[0] : void 0,
                       Schema: parsedSchemaModule.value
                     };
                   }
@@ -2955,6 +2976,82 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.extendsSchemaTaggedError",
     (atLocation) => atLocation
   );
+  const extendsDataTaggedError = cachedBy(
+    fn("TypeParser.extendsDataTaggedError")(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 dataTaggedErrorCall = expression;
+              const dataIdentifier = dataTaggedErrorCall.expression;
+              if (ts.isPropertyAccessExpression(dataIdentifier) && ts.isIdentifier(dataIdentifier.name) && ts.idText(dataIdentifier.name) === "TaggedError") {
+                const parsedDataModule = yield* pipe(
+                  importedDataModule(dataIdentifier.expression),
+                  option
+                );
+                if (isSome2(parsedDataModule)) {
+                  return {
+                    className: atLocation.name,
+                    keyStringLiteral: dataTaggedErrorCall.arguments.length > 0 && ts.isStringLiteral(dataTaggedErrorCall.arguments[0]) ? dataTaggedErrorCall.arguments[0] : void 0,
+                    Data: parsedDataModule.value
+                  };
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Data.TaggedError", void 0, atLocation);
+    }),
+    "TypeParser.extendsDataTaggedError",
+    (atLocation) => atLocation
+  );
+  const extendsDataTaggedClass = cachedBy(
+    fn("TypeParser.extendsDataTaggedClass")(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 dataTaggedClassCall = expression;
+              const dataIdentifier = dataTaggedClassCall.expression;
+              if (ts.isPropertyAccessExpression(dataIdentifier) && ts.isIdentifier(dataIdentifier.name) && ts.idText(dataIdentifier.name) === "TaggedClass") {
+                const parsedDataModule = yield* pipe(
+                  importedDataModule(dataIdentifier.expression),
+                  option
+                );
+                if (isSome2(parsedDataModule)) {
+                  return {
+                    className: atLocation.name,
+                    keyStringLiteral: dataTaggedClassCall.arguments.length > 0 && ts.isStringLiteral(dataTaggedClassCall.arguments[0]) ? dataTaggedClassCall.arguments[0] : void 0,
+                    Data: parsedDataModule.value
+                  };
+                }
+              }
+            }
+          }
+        }
+      }
+      return yield* typeParserIssue("Class does not extend Data.TaggedClass", void 0, atLocation);
+    }),
+    "TypeParser.extendsDataTaggedClass",
+    (atLocation) => atLocation
+  );
   const extendsSchemaTaggedRequest = cachedBy(
     fn("TypeParser.extendsSchemaTaggedRequest")(function* (atLocation) {
       if (!atLocation.name) {
@@ -2982,6 +3079,8 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
                     return {
                       className: atLocation.name,
                       selfTypeNode,
+                      tagStringLiteral: expression.arguments.length > 0 && ts.isStringLiteral(expression.arguments[0]) ? expression.arguments[0] : void 0,
+                      keyStringLiteral: schemaTaggedRequestTCall.arguments.length > 0 && ts.isStringLiteral(schemaTaggedRequestTCall.arguments[0]) ? schemaTaggedRequestTCall.arguments[0] : void 0,
                       Schema: parsedSchemaModule.value
                     };
                   }
@@ -3001,9 +3100,6 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
       if (!atLocation.name) {
         return yield* typeParserIssue("Class has no name", void 0, atLocation);
       }
-      const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
-      if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
-      const type = typeChecker.getTypeOfSymbol(classSym);
       const heritageClauses = atLocation.heritageClauses;
       if (!heritageClauses) {
         return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
@@ -3023,10 +3119,14 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
                     option
                   );
                   if (isSome2(parsedContextModule)) {
+                    const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
+                    if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
+                    const type = typeChecker.getTypeOfSymbol(classSym);
                     const tagType = yield* contextTag(type, atLocation);
                     return {
                       className: atLocation.name,
                       selfTypeNode,
+                      keyStringLiteral: ts.isStringLiteral(contextTagCall.arguments[0]) ? contextTagCall.arguments[0] : void 0,
                       args: contextTagCall.arguments,
                       Identifier: tagType.Identifier,
                       Tag: parsedContextModule.value
@@ -3048,9 +3148,6 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
       if (!atLocation.name) {
         return yield* typeParserIssue("Class has no name", void 0, atLocation);
       }
-      const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
-      if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
-      const type = typeChecker.getTypeOfSymbol(classSym);
       const heritageClauses = atLocation.heritageClauses;
       if (!heritageClauses) {
         return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
@@ -3065,6 +3162,9 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
                 const effectServiceIdentifier = effectServiceCall.expression;
                 const selfTypeNode = effectServiceCall.typeArguments[0];
                 if (ts.isPropertyAccessExpression(effectServiceIdentifier) && ts.isIdentifier(effectServiceIdentifier.name) && ts.idText(effectServiceIdentifier.name) === "Service") {
+                  const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
+                  if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
+                  const type = typeChecker.getTypeOfSymbol(classSym);
                   const parsedContextTag = yield* pipe(
                     importedEffectModule(effectServiceIdentifier.expression),
                     flatMap2(() => contextTag(type, atLocation)),
@@ -3091,6 +3191,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
                       className: atLocation.name,
                       selfTypeNode,
                       args: wholeCall.arguments,
+                      keyStringLiteral: ts.isStringLiteral(wholeCall.arguments[0]) ? wholeCall.arguments[0] : void 0,
                       options: wholeCall.arguments[1],
                       accessors: accessors2,
                       dependencies
@@ -3129,6 +3230,8 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils) {
     extendsSchemaClass,
     extendsSchemaTaggedClass,
     extendsSchemaTaggedError,
+    extendsDataTaggedError,
+    extendsDataTaggedClass,
     extendsSchemaTaggedRequest
   };
 }
@@ -3261,13 +3364,13 @@ var effectInVoidSuccess = createDiagnostic({
       if (expectedEffect.A.flags & ts.TypeFlags.Void) {
         const voidValueTypes = typeCheckerUtils.unrollUnionMembers(realEffect.A);
         const voidedEffect = yield* firstSuccessOf(
-          voidValueTypes.map((_) => map3(typeParser.strictEffectType(_, node), () => _))
+          voidValueTypes.map((_) => map4(typeParser.strictEffectType(_, node), () => _))
         );
         return { voidedEffect };
       }
       return yield* fail(typeParserIssue("expectedEffect success is not void"));
     });
-    const entries = yield* expectedAndRealType(sourceFile);
+    const entries = typeCheckerUtils.expectedAndRealType(sourceFile);
     for (const [node, expectedType, valueNode, realType] of entries) {
       if (expectedType !== realType) {
         yield* pipe(
@@ -3277,7 +3380,7 @@ var effectInVoidSuccess = createDiagnostic({
             valueNode,
             realType
           ),
-          map3(({ voidedEffect }) => {
+          map4(({ voidedEffect }) => {
             report(
               {
                 location: node,
@@ -3372,7 +3475,7 @@ var genericEffectServices = createDiagnostic({
       for (const [type, reportAt] of typesToCheck) {
         yield* pipe(
           typeParser.contextTag(type, node),
-          map3(() => {
+          map4(() => {
             report({
               location: reportAt,
               messageText: `Effect Services with type parameters are not supported because they cannot be properly discriminated at runtime, which may cause unexpected behavior.`,
@@ -3536,7 +3639,6 @@ var leakingRequirements = createDiagnostic({
     const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
-    const typeOrder = yield* deterministicTypeOrder;
     const parseLeakedRequirements = cachedBy(
       fn("leakingServices.checkServiceLeaking")(
         function* (service2, atLocation) {
@@ -3550,7 +3652,7 @@ var leakingRequirements = createDiagnostic({
             let effectContextType = void 0;
             yield* pipe(
               typeParser.effectType(servicePropertyType, atLocation),
-              map3((_) => effectContextType = _.R),
+              map4((_) => effectContextType = _.R),
               orElse2(() => {
                 const servicePropertyCallSignatures = typeChecker.getSignaturesOfType(
                   servicePropertyType,
@@ -3562,7 +3664,7 @@ var leakingRequirements = createDiagnostic({
                       typeChecker.getReturnTypeOfSignature(servicePropertyCallSignatures[0]),
                       atLocation
                     ),
-                    map3((_) => {
+                    map4((_) => {
                       effectContextType = _.R;
                     })
                   );
@@ -3580,7 +3682,7 @@ var leakingRequirements = createDiagnostic({
                   if (type.flags & ts.TypeFlags.Never) return succeed(true);
                   return pipe(
                     typeParser.scopeType(type, atLocation),
-                    map3(() => true),
+                    map4(() => true),
                     orElse2(() => succeed(false))
                   );
                 }
@@ -3639,7 +3741,9 @@ More info at https://effect.website/docs/requirements-management/layers/#avoidin
           flatMap2(
             ({ Service }) => pipe(
               parseLeakedRequirements(Service, node),
-              map3((requirements) => reportLeakingRequirements(reportAt, sort(requirements, typeOrder)))
+              map4(
+                (requirements) => reportLeakingRequirements(reportAt, sort(requirements, typeCheckerUtils.deterministicTypeOrder))
+              )
             )
           ),
           orElse2(() => sync(() => ts.forEachChild(node, appendNodeToVisit))),
@@ -3658,22 +3762,21 @@ var missingEffectContext = createDiagnostic({
   apply: fn("missingEffectContext.apply")(function* (sourceFile, report) {
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
-    const typeOrder = yield* deterministicTypeOrder;
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const checkForMissingContextTypes = (node, expectedType, valueNode, realType) => pipe(
       all(
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
-      map3(
+      map4(
         ([expectedEffect, realEffect]) => typeCheckerUtils.getMissingTypeEntriesInTargetType(
           realEffect.R,
           expectedEffect.R
         )
       )
     );
-    const sortTypes = sort(typeOrder);
-    const entries = yield* expectedAndRealType(sourceFile);
+    const sortTypes = sort(typeCheckerUtils.deterministicTypeOrder);
+    const entries = getEffectLspPatchSourceFileMetadata(sourceFile)?.relationErrors || typeCheckerUtils.expectedAndRealType(sourceFile);
     for (const [node, expectedType, valueNode, realType] of entries) {
       if (expectedType !== realType) {
         yield* pipe(
@@ -3683,7 +3786,7 @@ var missingEffectContext = createDiagnostic({
             valueNode,
             realType
           ),
-          map3(
+          map4(
             (missingTypes) => missingTypes.length > 0 ? report(
               {
                 location: node,
@@ -3710,7 +3813,6 @@ var missingEffectError = createDiagnostic({
     const typeChecker = yield* service(TypeCheckerApi);
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
-    const typeOrder = yield* deterministicTypeOrder;
     const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
       sourceFile,
       "effect",
@@ -3729,7 +3831,7 @@ var missingEffectError = createDiagnostic({
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
-      map3(
+      map4(
         ([expectedEffect, realEffect]) => pipe(
           typeCheckerUtils.getMissingTypeEntriesInTargetType(
             realEffect.E,
@@ -3739,8 +3841,8 @@ var missingEffectError = createDiagnostic({
         )
       )
     );
-    const sortTypes = sort(typeOrder);
-    const entries = yield* expectedAndRealType(sourceFile);
+    const sortTypes = sort(typeCheckerUtils.deterministicTypeOrder);
+    const entries = getEffectLspPatchSourceFileMetadata(sourceFile)?.relationErrors || typeCheckerUtils.expectedAndRealType(sourceFile);
     for (const [node, expectedType, valueNode, realType] of entries) {
       if (expectedType !== realType) {
         yield* pipe(
@@ -3750,7 +3852,7 @@ var missingEffectError = createDiagnostic({
             valueNode,
             realType
           ),
-          map3((result) => {
+          map4((result) => {
             if (result.missingErrorTypes.length === 0) return;
             const fixes = [];
             if (ts.isExpression(valueNode) && result.expectedErrorType.flags & ts.TypeFlags.Never) {
@@ -3777,17 +3879,17 @@ var missingEffectError = createDiagnostic({
             if (ts.isExpression(valueNode)) {
               const propertyAssignments = pipe(
                 result.missingErrorTypes,
-                map2((_) => typeChecker.getPropertyOfType(_, "_tag")),
+                map3((_) => typeChecker.getPropertyOfType(_, "_tag")),
                 filter((_) => !!_),
-                map2((_) => typeChecker.getTypeOfSymbolAtLocation(_, valueNode)),
+                map3((_) => typeChecker.getTypeOfSymbolAtLocation(_, valueNode)),
                 filter((_) => !!(_.flags & ts.TypeFlags.Literal)),
-                map2((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),
+                map3((_) => typeChecker.typeToTypeNode(_, void 0, ts.NodeBuilderFlags.NoTruncation)),
                 filter((_) => !!_ && ts.isLiteralTypeNode(_)),
-                map2((_) => _.literal),
+                map3((_) => _.literal),
                 filter((_) => ts.isLiteralExpression(_)),
-                map2((_) => _.text),
+                map3((_) => _.text),
                 sort(string2),
-                map2(
+                map3(
                   (_) => ts.factory.createPropertyAssignment(
                     ts.factory.createIdentifier(_),
                     ts.factory.createArrowFunction(
@@ -4023,7 +4125,7 @@ var missingStarInYieldEffectGen = createDiagnostic({
             typeParser.effectGen(effectGenNode),
             orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
             orElse2(() => typeParser.effectFnGen(effectGenNode)),
-            map3(({ functionStar }) => {
+            map4(({ functionStar }) => {
               if (functionStar) {
                 brokenGenerators.add(functionStar);
               }
@@ -4093,7 +4195,7 @@ var multipleEffectProvide = createDiagnostic({
         return pipe(
           typeParser.importedEffectModule(node.expression.expression),
           flatMap2(() => typeParser.layerType(type, layer)),
-          map3(() => ({ layer, node })),
+          map4(() => ({ layer, node })),
           orElse2(() => void_)
         );
       }
@@ -4184,7 +4286,7 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
       ),
       void 0,
       [
-        ts.factory.createIdentifier(className2.text),
+        ts.factory.createIdentifier(ts.idText(className2)),
         ts.factory.createArrowFunction(
           void 0,
           void 0,
@@ -4234,9 +4336,9 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
   const generateReturnType = (type, atLocation2, className2) => pipe(
     typeParser.effectType(type, atLocation2),
     flatMap2((returnedEffect) => {
-      const contextType = returnedEffect.R.flags & ts.TypeFlags.Never ? ts.factory.createTypeReferenceNode(className2.text) : ts.factory.createUnionTypeNode(
+      const contextType = returnedEffect.R.flags & ts.TypeFlags.Never ? ts.factory.createTypeReferenceNode(ts.idText(className2)) : ts.factory.createUnionTypeNode(
         [
-          ts.factory.createTypeReferenceNode(className2.text),
+          ts.factory.createTypeReferenceNode(ts.idText(className2)),
           typeChecker.typeToTypeNode(returnedEffect.R, atLocation2, ts.NodeBuilderFlags.NoTruncation)
         ]
       );
@@ -4284,7 +4386,7 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
                   ts.factory.createIdentifier("UnknownException")
                 )
               ),
-              ts.factory.createTypeReferenceNode(className2.text)
+              ts.factory.createTypeReferenceNode(ts.idText(className2))
             ]
           ));
         })
@@ -4301,7 +4403,7 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
         [
           successType,
           ts.factory.createTypeReferenceNode("never"),
-          ts.factory.createTypeReferenceNode(className2.text)
+          ts.factory.createTypeReferenceNode(ts.idText(className2))
         ]
       );
       return succeed(typeNode);
@@ -4332,7 +4434,7 @@ var generate = fn("writeTagClassAccessors.generate")(function* (sourceFile, serv
     for (const signature of typeChecker.getSignaturesOfType(propertyType, ts.SignatureKind.Call)) {
       yield* pipe(
         proxySignature(signature, atLocation, className),
-        map3((sig) => {
+        map4((sig) => {
           callSignatures.push(sig);
         }),
         ignore
@@ -4378,7 +4480,7 @@ var parse2 = fn("writeTagClassAccessors.parse")(function* (node) {
   }
   const hash2 = involvedMembers.map(({ property, propertyType }) => {
     return ts.symbolName(property) + ": " + typeChecker.typeToString(propertyType);
-  }).concat([className.text]).join("\n");
+  }).concat([ts.idText(className)]).join("\n");
   return { Service, className, atLocation: node, hash: cyrb53(hash2), involvedMembers };
 });
 var writeTagClassAccessors = createRefactor({
@@ -4391,7 +4493,7 @@ var writeTagClassAccessors = createRefactor({
     const typeParser = yield* service(TypeParser);
     const parseNode = (node) => pipe(
       parse2(node),
-      map3(({ Service, atLocation, className, involvedMembers }) => ({
+      map4(({ Service, atLocation, className, involvedMembers }) => ({
         kind: "refactor.rewrite.effect.writeTagClassAccessors",
         description: "Implement Service accessors",
         apply: pipe(
@@ -4423,7 +4525,7 @@ var accessors = createCodegen({
     if (!nodeAndCommentRange) return yield* fail(new CodegenNotApplicableError("no node and comment range"));
     return yield* pipe(
       parse2(nodeAndCommentRange.node),
-      map3(
+      map4(
         (_) => ({
           hash: _.hash,
           description: "Generate accessors for the service",
@@ -4454,7 +4556,7 @@ var outdatedEffectCodegen = createDiagnostic({
     for (const { codegen, hash: hash2, range } of codegensWithRanges) {
       yield* pipe(
         getEditsForCodegen([codegen], sourceFile, range),
-        map3((applicable) => {
+        map4((applicable) => {
           if (applicable.hash !== hash2) {
             _report({
               location: range,
@@ -4514,7 +4616,7 @@ var overriddenSchemaConstructor = createDiagnostic({
               const typeAtLocation = typeChecker.getTypeAtLocation(type.expression);
               const isSchema = yield* pipe(
                 typeParser.effectSchemaType(typeAtLocation, type.expression),
-                map3(() => true),
+                map4(() => true),
                 orElse2(() => succeed(false))
               );
               if (isSchema) {
@@ -4585,7 +4687,7 @@ var returnEffectInGen = createDiagnostic({
               typeParser.effectGen(effectGenNode),
               orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
               orElse2(() => typeParser.effectFnGen(effectGenNode)),
-              map3(() => {
+              map4(() => {
                 const fix = node.expression ? [{
                   fixName: "returnEffectInGen_fix",
                   description: "Add yield* statement",
@@ -4648,7 +4750,7 @@ var scopeInLayerEffect = createDiagnostic({
       const entries = typeCheckerUtils.unrollUnionMembers(type);
       return pipe(
         firstSuccessOf(entries.map((type2) => typeParser.scopeType(type2, node))),
-        map3(
+        map4(
           () => report({
             location: node,
             messageText: `Seems like you are constructing a layer with a scope in the requirements.
@@ -4807,7 +4909,7 @@ var tryCatchInEffectGen = createDiagnostic({
             typeParser.effectGen(effectGenNode),
             orElse2(() => typeParser.effectFnUntracedGen(effectGenNode)),
             orElse2(() => typeParser.effectFnGen(effectGenNode)),
-            map3(() => {
+            map4(() => {
               report({
                 location: node,
                 messageText: "Avoid using try/catch inside Effect generators. Use Effect's error handling mechanisms instead (e.g., Effect.try, Effect.tryPromise, Effect.catchAll, Effect.catchTag).",
@@ -4842,7 +4944,7 @@ var unnecessaryEffectGen = createDiagnostic({
       if (ts.isCallExpression(node)) {
         yield* pipe(
           typeParser.unnecessaryEffectGen(node),
-          map3(
+          map4(
             ({ replacementNode }) => report({
               location: node,
               messageText: `This Effect.gen contains a single return statement.`,
@@ -4885,7 +4987,7 @@ var unnecessaryPipe = createDiagnostic({
       if (ts.isCallExpression(node)) {
         yield* pipe(
           typeParser.pipeCall(node),
-          map3(({ args: args2, subject }) => {
+          map4(({ args: args2, subject }) => {
             if (args2.length === 0) {
               report({
                 location: node,
@@ -4931,9 +5033,9 @@ var unnecessaryPipeChain = createDiagnostic({
         yield* pipe(
           typeParser.pipeCall(node),
           flatMap2(
-            (pipeCall) => map3(typeParser.pipeCall(pipeCall.subject), (innerCall) => ({ pipeCall, innerCall }))
+            (pipeCall) => map4(typeParser.pipeCall(pipeCall.subject), (innerCall) => ({ pipeCall, innerCall }))
           ),
-          map3(({ innerCall, pipeCall }) => {
+          map4(({ innerCall, pipeCall }) => {
             report({
               location: node,
               messageText: `Chained pipe calls can be simplified to a single pipe call`,
@@ -5067,14 +5169,29 @@ var diagnostics = [
 ];
 
 // src/effect-lsp-patch-utils.ts
-function checkSourceFileWorker(tsInstance, program, sourceFile, compilerOptions, addDiagnostic) {
-  const pluginOptions = pipe(
-    compilerOptions.plugins || [],
-    findFirst2((_) => hasProperty(_, "name") && _.name === "@effect/language-service")
-  );
-  if (isNone2(pluginOptions)) {
-    return;
+var extractEffectLspOptions = (compilerOptions) => {
+  return (hasProperty(compilerOptions, "plugins") && isArray(compilerOptions.plugins) ? compilerOptions.plugins : []).find((_) => hasProperty(_, "name") && _.name === "@effect/language-service");
+};
+function clearSourceFileEffectMetadata(sourceFile) {
+  getOrDefaultEffectLspPatchSourceFileMetadata(sourceFile).relationErrors = [];
+}
+function appendMetadataRelationError(tsInstance, errorNode, source, target) {
+  let sourceFile = errorNode;
+  while (sourceFile.parent && !tsInstance.isSourceFile(sourceFile)) {
+    sourceFile = sourceFile.parent;
+  }
+  if (tsInstance.isSourceFile(sourceFile)) {
+    getOrDefaultEffectLspPatchSourceFileMetadata(sourceFile).relationErrors.push([
+      errorNode,
+      target,
+      errorNode,
+      source
+    ]);
   }
+}
+function checkSourceFileWorker(tsInstance, program, sourceFile, compilerOptions, addDiagnostic) {
+  const pluginOptions = extractEffectLspOptions(compilerOptions);
+  if (!pluginOptions) return;
   pipe(
     getSemanticDiagnosticsWithCodeFixes(diagnostics, sourceFile),
     nanoLayer3,
@@ -5098,11 +5215,13 @@ function checkSourceFileWorker(tsInstance, program, sourceFile, compilerOptions,
       console.error(e);
       return [];
     }),
-    map2(addDiagnostic)
+    map3(addDiagnostic)
   );
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  checkSourceFileWorker
+  appendMetadataRelationError,
+  checkSourceFileWorker,
+  clearSourceFileEffectMetadata
 });
 //# sourceMappingURL=effect-lsp-patch-utils.js.map