@effect/language-service 0.51.1 → 0.52.1

package/cli.js

@@ -26990,6 +26990,7 @@ var getZshCompletions2 = (self, state = {
 
 // node_modules/.pnpm/@effect+cli@0.71.0_@effect+platform@0.92.1_@effect+printer-ansi@0.46.0_@effect+printer@0.46.0_effect@3.18.4/node_modules/@effect/cli/dist/esm/Options.js
 var all7 = all6;
+var boolean5 = boolean4;
 var choice3 = choice2;
 var directory2 = directory;
 var file3 = file2;
@@ -30956,7 +30957,8 @@ var getModuleFilePath = fn("getModuleFilePath")(
 var getTypeScriptApisUtils = fn("getTypeScriptApisFile")(
   function* (dirPath4) {
     const filePath = yield* getModuleFilePath(dirPath4, "typescript");
-    const sourceFile = yield* getUnpatchedSourceFile(filePath);
+    const sourceText = yield* getSourceFileText(filePath);
+    const sourceFile = yield* getUnpatchedSourceFile(filePath, sourceText);
     const bodyWithoutBundlerComment = yield* omitBundlerSourceFileComment(
       sourceFile.text.split("\n").map((line4) => `    ${line4}`).join("\n")
     );
@@ -31069,27 +31071,31 @@ var applyTextChanges = fn("applyTextChanges")(
     return newSourceText;
   }
 );
-var getUnpatchedSourceFile = fn("getUnpatchedSourceFile")(function* (filePath) {
+var getSourceFileText = fn("getSourceFileText")(function* (filePath) {
   const fs = yield* FileSystem;
-  const ts = yield* getTypeScript;
-  const sourceText = yield* fs.readFileString(filePath);
-  const sourceFile = ts.createSourceFile(
-    filePath,
-    sourceText,
-    ts.ScriptTarget.ES2022,
-    true
-  );
-  const { revertChanges } = yield* extractAppliedEffectLspPatches(sourceFile);
-  if (revertChanges.length === 0) return sourceFile;
-  const newSourceText = yield* applyTextChanges(sourceText, revertChanges);
-  const newSourceFile = ts.createSourceFile(
-    filePath,
-    newSourceText,
-    ts.ScriptTarget.ES2022,
-    true
-  );
-  return newSourceFile;
+  return yield* fs.readFileString(filePath);
 });
+var getUnpatchedSourceFile = fn("getUnpatchedSourceFile")(
+  function* (filePath, sourceText) {
+    const ts = yield* getTypeScript;
+    const sourceFile = ts.createSourceFile(
+      filePath,
+      sourceText,
+      ts.ScriptTarget.ES2022,
+      true
+    );
+    const { revertChanges } = yield* extractAppliedEffectLspPatches(sourceFile);
+    if (revertChanges.length === 0) return sourceFile;
+    const newSourceText = yield* applyTextChanges(sourceText, revertChanges);
+    const newSourceFile = ts.createSourceFile(
+      filePath,
+      newSourceText,
+      ts.ScriptTarget.ES2022,
+      true
+    );
+    return newSourceFile;
+  }
+);
 var omitBundlerSourceFileComment = fn("omitBundlerSourceFileComment")(
   function* (originalSourceText) {
     const ts = yield* getTypeScript;
@@ -31907,9 +31913,10 @@ var nanoLayer3 = (fa) => gen3(function* () {
   const tsUtils = yield* service2(TypeScriptUtils);
   const typeChecker = yield* service2(TypeCheckerApi);
   const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+  const program = yield* service2(TypeScriptProgram);
   return yield* pipe(
     fa,
-    provideService7(TypeParser, make64(ts, tsUtils, typeChecker, typeCheckerUtils))
+    provideService7(TypeParser, make64(ts, tsUtils, typeChecker, typeCheckerUtils, program))
   );
 });
 var TypeParserIssue = class _TypeParserIssue {
@@ -31919,7 +31926,92 @@ var TypeParserIssue = class _TypeParserIssue {
 function typeParserIssue(_message, _type, _node) {
   return TypeParserIssue.issue;
 }
-function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
+function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
+  const getSourceFilePackageInfo = cachedBy(
+    fn2("TypeParser.getSourceFilePackageInfo")(function* (sourceFile) {
+      return tsUtils.resolveModuleWithPackageInfoFromSourceFile(program, sourceFile);
+    }),
+    `TypeParser.getSourceFilePackageInfo`,
+    (sourceFile) => sourceFile
+  );
+  const getSourceFilesDeclaringSymbolModule = (packageName) => cachedBy(
+    fn2("TypeParser.getSourceFilesDeclaringSymbolModule")(function* (symbol3) {
+      const result = [];
+      if (!symbol3.declarations) return yield* typeParserIssue("Symbol has no declarations", void 0, void 0);
+      for (const sourceFile of symbol3.declarations) {
+        if (!ts.isSourceFile(sourceFile)) continue;
+        const packageInfo = yield* getSourceFilePackageInfo(sourceFile);
+        if (!packageInfo || packageInfo.name.toLowerCase() !== packageName.toLowerCase()) continue;
+        result.push(sourceFile);
+      }
+      if (result.length > 0) {
+        return result;
+      }
+      return yield* typeParserIssue(`Symbol has no source file declarations`, void 0, void 0);
+    }),
+    `TypeParser.getSourceFilesDeclaringSymbolModule(${packageName})`,
+    (symbol3) => symbol3
+  );
+  const isSymbolReferenceToPackageModule = (givenSymbol, packageName, checkSourceFile) => {
+    let symbol3 = givenSymbol;
+    while (symbol3.flags & ts.SymbolFlags.Alias) {
+      symbol3 = typeChecker.getAliasedSymbol(symbol3);
+    }
+    return pipe(
+      getSourceFilesDeclaringSymbolModule(packageName)(symbol3),
+      flatMap18(
+        (sourceFiles) => firstSuccessOf2(
+          sourceFiles.map((_) => checkSourceFile(_))
+        )
+      )
+    );
+  };
+  const isNodeReferenceToPackageModule = (givenNode, packageName, isCorrectSourceFile) => {
+    const symbol3 = typeChecker.getSymbolAtLocation(givenNode);
+    if (!symbol3) return typeParserIssue("Node has no symbol", void 0, givenNode);
+    return isSymbolReferenceToPackageModule(symbol3, packageName, isCorrectSourceFile);
+  };
+  const getSourceFilesDeclaringSymbolExportedUnderPackageModule = (packageName, memberName) => cachedBy(
+    fn2("TypeParser.getSourceFilesDeclaringSymbolUnderPackageExportedMember")(function* (symbol3) {
+      const result = [];
+      if (!symbol3.declarations) return yield* typeParserIssue("Symbol has no declarations", void 0, void 0);
+      for (const declaration of symbol3.declarations) {
+        const sourceFile = tsUtils.getSourceFileOfNode(declaration);
+        if (!sourceFile) continue;
+        const packageInfo = yield* getSourceFilePackageInfo(sourceFile);
+        if (!packageInfo || packageInfo.name.toLowerCase() !== packageName.toLowerCase()) continue;
+        const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+        if (!moduleSymbol) continue;
+        const memberSymbol = typeChecker.tryGetMemberInModuleExports(memberName, moduleSymbol);
+        if (memberSymbol && memberSymbol === symbol3) result.push({ memberSymbol, moduleSymbol, sourceFile });
+      }
+      if (result.length > 0) {
+        return result;
+      }
+      return yield* typeParserIssue(`Symbol has no declarations`, void 0, void 0);
+    }),
+    `TypeParser.getSourceFilesDeclaringSymbolUnderPackageExportedMember(${packageName}, ${memberName})`,
+    (sym) => sym
+  );
+  const isSymbolExportOfPackageModule = (givenSymbol, packageName, memberName, checkSourceFile) => {
+    let symbol3 = givenSymbol;
+    while (symbol3.flags & ts.SymbolFlags.Alias) {
+      symbol3 = typeChecker.getAliasedSymbol(symbol3);
+    }
+    return pipe(
+      getSourceFilesDeclaringSymbolExportedUnderPackageModule(packageName, memberName)(symbol3),
+      flatMap18(
+        (sourceFiles) => firstSuccessOf2(
+          sourceFiles.map((_) => checkSourceFile(_.sourceFile, _.moduleSymbol, _.memberSymbol))
+        )
+      )
+    );
+  };
+  const isNodeReferenceToExportOfPackageModule = (givenNode, packageName, isCorrectSourceFile, memberName) => {
+    const symbol3 = typeChecker.getSymbolAtLocation(givenNode);
+    if (!symbol3) return typeParserIssue("Node has no symbol", void 0, givenNode);
+    return isSymbolExportOfPackageModule(symbol3, packageName, memberName, isCorrectSourceFile);
+  };
   function covariantTypeArgument(type2) {
     const signatures = typeChecker.getSignaturesOfType(type2, ts.SignatureKind.Call);
     if (signatures.length !== 1) {
@@ -32025,6 +32117,26 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.strictEffectType",
     (type2) => type2
   );
+  const isEffectTypeSourceFile = cachedBy(
+    fn2("TypeParser.isEffectTypeSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const effectTypeSymbol = typeChecker.tryGetMemberInModuleExports("Effect", moduleSymbol);
+      if (!effectTypeSymbol) return yield* typeParserIssue("Effect type not found", void 0, sourceFile);
+      const type2 = typeChecker.getDeclaredTypeOfSymbol(effectTypeSymbol);
+      yield* effectType(type2, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isEffectTypeSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToEffectModuleApi = (memberName) => cachedBy(
+    fn2("TypeParser.isNodeReferenceToEffectModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(node, "effect", isEffectTypeSourceFile, memberName);
+    }),
+    `TypeParser.isNodeReferenceToEffectModuleApi(${memberName})`,
+    (node) => node
+  );
   const layerType = cachedBy(
     fn2("TypeParser.layerType")(function* (type2, atLocation) {
       yield* pipeableType(type2, atLocation);
@@ -32081,36 +32193,6 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.effectSubtype",
     (type2) => type2
   );
-  const importedSchemaModule = cachedBy(
-    fn2("TypeParser.importedSchemaModule")(function* (node) {
-      if (!ts.isIdentifier(node)) {
-        return yield* typeParserIssue("Node is not an expression", void 0, node);
-      }
-      const type2 = typeChecker.getTypeAtLocation(node);
-      const propertySymbol = typeChecker.getPropertyOfType(type2, "Class");
-      if (!propertySymbol) {
-        return yield* typeParserIssue("Type has no 'Class' property", type2, node);
-      }
-      const sourceFile = tsUtils.getSourceFileOfNode(node);
-      if (!sourceFile) {
-        return yield* typeParserIssue("Node is not in a source file", void 0, node);
-      }
-      const schemaIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
-        sourceFile,
-        "effect",
-        "Schema"
-      );
-      if (!schemaIdentifier) {
-        return yield* typeParserIssue("Schema module not found", void 0, node);
-      }
-      if (ts.idText(node) !== schemaIdentifier) {
-        return yield* typeParserIssue("Node is not a schema module reference", void 0, node);
-      }
-      return node;
-    }),
-    "TypeParser.importedSchemaModule",
-    (node) => node
-  );
   const importedContextModule = cachedBy(
     fn2("TypeParser.importedContextModule")(function* (node) {
       const type2 = typeChecker.getTypeAtLocation(node);
@@ -32141,22 +32223,9 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.importedContextModule",
     (node) => node
   );
-  const importedEffectModule = cachedBy(
-    fn2("TypeParser.importedEffectModule")(function* (node) {
-      const type2 = typeChecker.getTypeAtLocation(node);
-      const propertySymbol = typeChecker.getPropertyOfType(type2, "never");
-      if (!propertySymbol) {
-        return yield* typeParserIssue("Type has no 'never' property", type2, node);
-      }
-      if (!ts.isExpression(node)) {
-        return yield* typeParserIssue("Node is not an expression", type2, node);
-      }
-      const propertyType = typeChecker.getTypeOfSymbolAtLocation(propertySymbol, node);
-      yield* effectType(propertyType, node);
-      return node;
-    }),
-    "TypeParser.importedEffectModule",
-    (node) => node
+  const importedEffectModule = (node) => pipe(
+    isNodeReferenceToPackageModule(node, "effect", isEffectTypeSourceFile),
+    map34(() => node)
   );
   const importedDataModule = cachedBy(
     fn2("TypeParser.importedDataModule")(function* (node) {
@@ -32207,14 +32276,11 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
         return typeParserIssue("Node is not a property access expression", void 0, node);
       }
       const propertyAccess = node.expression;
-      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),
-        map34((effectModule) => ({
+        isNodeReferenceToEffectModuleApi("gen")(propertyAccess),
+        map34(() => ({
           node,
-          effectModule,
+          effectModule: propertyAccess.expression,
           generatorFunction,
           body: generatorFunction.body
         }))
@@ -32250,18 +32316,11 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
         );
       }
       const propertyAccess = node.expression;
-      if (!(ts.isIdentifier(propertyAccess.name) && ts.idText(propertyAccess.name) === "fnUntraced")) {
-        return typeParserIssue(
-          "Call expression name is not 'fnUntraced'",
-          void 0,
-          node
-        );
-      }
       return pipe(
-        importedEffectModule(propertyAccess.expression),
-        map34((effectModule) => ({
+        isNodeReferenceToEffectModuleApi("fnUntraced")(propertyAccess),
+        map34(() => ({
           node,
-          effectModule,
+          effectModule: propertyAccess.expression,
           generatorFunction,
           body: generatorFunction.body
         }))
@@ -32302,19 +32361,12 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
         );
       }
       const propertyAccess = expressionToTest;
-      if (!(ts.isIdentifier(propertyAccess.name) && ts.idText(propertyAccess.name) === "fn")) {
-        return typeParserIssue(
-          "Call expression name is not 'fn'",
-          void 0,
-          node
-        );
-      }
       return pipe(
-        importedEffectModule(propertyAccess.expression),
-        map34((effectModule) => ({
+        isNodeReferenceToEffectModuleApi("fn")(propertyAccess),
+        map34(() => ({
           node,
           generatorFunction,
-          effectModule,
+          effectModule: propertyAccess.expression,
           body: generatorFunction.body
         }))
       );
@@ -32416,6 +32468,26 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.effectSchemaType",
     (type2) => type2
   );
+  const isEffectSchemaTypeSourceFile = cachedBy(
+    fn2("TypeParser.isEffectSchemaTypeSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const typeSymbol = typeChecker.tryGetMemberInModuleExports("Schema", moduleSymbol);
+      if (!typeSymbol) return yield* typeParserIssue("Schema type not found", void 0, sourceFile);
+      const type2 = typeChecker.getDeclaredTypeOfSymbol(typeSymbol);
+      yield* effectSchemaType(type2, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isEffectSchemaTypeSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToEffectSchemaModuleApi = (memberName) => cachedBy(
+    fn2("TypeParser.isNodeReferenceToEffectSchemaModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(node, "effect", isEffectSchemaTypeSourceFile, memberName);
+    }),
+    `TypeParser.isNodeReferenceToEffectSchemaModuleApi(${memberName})`,
+    (node) => node
+  );
   const contextTagVarianceStruct = (type2, atLocation) => map34(
     all9(
       varianceStructInvariantType(type2, atLocation, "_Identifier"),
@@ -32542,22 +32614,15 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
             if (ts.isCallExpression(expression)) {
               const schemaCall = expression.expression;
               if (ts.isCallExpression(schemaCall) && schemaCall.typeArguments && schemaCall.typeArguments.length > 0) {
-                const selfTypeNode = schemaCall.typeArguments[0];
-                const schemaIdentifier = schemaCall.expression;
-                if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && ts.idText(schemaIdentifier.name) === "Class") {
-                  const expressionType = typeChecker.getTypeAtLocation(expression);
-                  const parsedSchemaModule = yield* pipe(
-                    effectSchemaType(expressionType, expression),
-                    flatMap18(() => importedSchemaModule(schemaIdentifier.expression)),
-                    option4
-                  );
-                  if (isSome2(parsedSchemaModule)) {
-                    return {
-                      className: atLocation.name,
-                      selfTypeNode,
-                      Schema: parsedSchemaModule.value
-                    };
-                  }
+                const isEffectSchemaModuleApi = yield* pipe(
+                  isNodeReferenceToEffectSchemaModuleApi("Class")(schemaCall.expression),
+                  option4
+                );
+                if (isSome2(isEffectSchemaModuleApi)) {
+                  return {
+                    className: atLocation.name,
+                    selfTypeNode: schemaCall.typeArguments[0]
+                  };
                 }
               }
             }
@@ -32586,23 +32651,17 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
               const schemaTaggedClassTCall = expression.expression;
               if (ts.isCallExpression(schemaTaggedClassTCall) && schemaTaggedClassTCall.typeArguments && schemaTaggedClassTCall.typeArguments.length > 0) {
                 const selfTypeNode = schemaTaggedClassTCall.typeArguments[0];
-                const schemaIdentifier = schemaTaggedClassTCall.expression;
-                if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && ts.idText(schemaIdentifier.name) === "TaggedClass") {
-                  const expressionType = typeChecker.getTypeAtLocation(expression);
-                  const parsedSchemaModule = yield* pipe(
-                    effectSchemaType(expressionType, expression),
-                    flatMap18(() => importedSchemaModule(schemaIdentifier.expression)),
-                    option4
-                  );
-                  if (isSome2(parsedSchemaModule)) {
-                    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
-                    };
-                  }
+                const isEffectSchemaModuleApi = yield* pipe(
+                  isNodeReferenceToEffectSchemaModuleApi("TaggedClass")(schemaTaggedClassTCall.expression),
+                  option4
+                );
+                if (isSome2(isEffectSchemaModuleApi)) {
+                  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
+                  };
                 }
               }
             }
@@ -32631,23 +32690,17 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
               const schemaTaggedErrorTCall = expression.expression;
               if (ts.isCallExpression(schemaTaggedErrorTCall) && schemaTaggedErrorTCall.typeArguments && schemaTaggedErrorTCall.typeArguments.length > 0) {
                 const selfTypeNode = schemaTaggedErrorTCall.typeArguments[0];
-                const schemaIdentifier = schemaTaggedErrorTCall.expression;
-                if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && ts.idText(schemaIdentifier.name) === "TaggedError") {
-                  const expressionType = typeChecker.getTypeAtLocation(expression);
-                  const parsedSchemaModule = yield* pipe(
-                    effectSchemaType(expressionType, expression),
-                    flatMap18(() => importedSchemaModule(schemaIdentifier.expression)),
-                    option4
-                  );
-                  if (isSome2(parsedSchemaModule)) {
-                    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
-                    };
-                  }
+                const isEffectSchemaModuleApi = yield* pipe(
+                  isNodeReferenceToEffectSchemaModuleApi("TaggedError")(schemaTaggedErrorTCall.expression),
+                  option4
+                );
+                if (isSome2(isEffectSchemaModuleApi)) {
+                  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
+                  };
                 }
               }
             }
@@ -32659,8 +32712,8 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
     "TypeParser.extendsSchemaTaggedError",
     (atLocation) => atLocation
   );
-  const extendsDataTaggedError = cachedBy(
-    fn2("TypeParser.extendsDataTaggedError")(function* (atLocation) {
+  const extendsSchemaTaggedRequest = cachedBy(
+    fn2("TypeParser.extendsSchemaTaggedRequest")(function* (atLocation) {
       if (!atLocation.name) {
         return yield* typeParserIssue("Class has no name", void 0, atLocation);
       }
@@ -32673,18 +32726,19 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
           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),
+              const schemaTaggedRequestTCall = expression.expression;
+              if (ts.isCallExpression(schemaTaggedRequestTCall) && schemaTaggedRequestTCall.typeArguments && schemaTaggedRequestTCall.typeArguments.length > 0) {
+                const selfTypeNode = schemaTaggedRequestTCall.typeArguments[0];
+                const isEffectSchemaModuleApi = yield* pipe(
+                  isNodeReferenceToEffectSchemaModuleApi("TaggedRequest")(schemaTaggedRequestTCall.expression),
                   option4
                 );
-                if (isSome2(parsedDataModule)) {
+                if (isSome2(isEffectSchemaModuleApi)) {
                   return {
                     className: atLocation.name,
-                    keyStringLiteral: dataTaggedErrorCall.arguments.length > 0 && ts.isStringLiteral(dataTaggedErrorCall.arguments[0]) ? dataTaggedErrorCall.arguments[0] : void 0,
-                    Data: parsedDataModule.value
+                    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
                   };
                 }
               }
@@ -32692,13 +32746,13 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
           }
         }
       }
-      return yield* typeParserIssue("Class does not extend Data.TaggedError", void 0, atLocation);
+      return yield* typeParserIssue("Class does not extend Schema.TaggedRequest", void 0, atLocation);
     }),
-    "TypeParser.extendsDataTaggedError",
+    "TypeParser.extendsSchemaTaggedRequest",
     (atLocation) => atLocation
   );
-  const extendsDataTaggedClass = cachedBy(
-    fn2("TypeParser.extendsDataTaggedClass")(function* (atLocation) {
+  const extendsDataTaggedError = cachedBy(
+    fn2("TypeParser.extendsDataTaggedError")(function* (atLocation) {
       if (!atLocation.name) {
         return yield* typeParserIssue("Class has no name", void 0, atLocation);
       }
@@ -32711,9 +32765,9 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
           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 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),
                   option4
@@ -32721,7 +32775,7 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
                 if (isSome2(parsedDataModule)) {
                   return {
                     className: atLocation.name,
-                    keyStringLiteral: dataTaggedClassCall.arguments.length > 0 && ts.isStringLiteral(dataTaggedClassCall.arguments[0]) ? dataTaggedClassCall.arguments[0] : void 0,
+                    keyStringLiteral: dataTaggedErrorCall.arguments.length > 0 && ts.isStringLiteral(dataTaggedErrorCall.arguments[0]) ? dataTaggedErrorCall.arguments[0] : void 0,
                     Data: parsedDataModule.value
                   };
                 }
@@ -32730,13 +32784,13 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
           }
         }
       }
-      return yield* typeParserIssue("Class does not extend Data.TaggedClass", void 0, atLocation);
+      return yield* typeParserIssue("Class does not extend Data.TaggedError", void 0, atLocation);
     }),
-    "TypeParser.extendsDataTaggedClass",
+    "TypeParser.extendsDataTaggedError",
     (atLocation) => atLocation
   );
-  const extendsSchemaTaggedRequest = cachedBy(
-    fn2("TypeParser.extendsSchemaTaggedRequest")(function* (atLocation) {
+  const extendsDataTaggedClass = cachedBy(
+    fn2("TypeParser.extendsDataTaggedClass")(function* (atLocation) {
       if (!atLocation.name) {
         return yield* typeParserIssue("Class has no name", void 0, atLocation);
       }
@@ -32749,35 +32803,28 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
           if (ts.isExpressionWithTypeArguments(typeX)) {
             const expression = typeX.expression;
             if (ts.isCallExpression(expression)) {
-              const schemaTaggedRequestTCall = expression.expression;
-              if (ts.isCallExpression(schemaTaggedRequestTCall) && schemaTaggedRequestTCall.typeArguments && schemaTaggedRequestTCall.typeArguments.length > 0) {
-                const selfTypeNode = schemaTaggedRequestTCall.typeArguments[0];
-                const schemaIdentifier = schemaTaggedRequestTCall.expression;
-                if (ts.isPropertyAccessExpression(schemaIdentifier) && ts.isIdentifier(schemaIdentifier.name) && ts.idText(schemaIdentifier.name) === "TaggedRequest") {
-                  const expressionType = typeChecker.getTypeAtLocation(expression);
-                  const parsedSchemaModule = yield* pipe(
-                    effectSchemaType(expressionType, expression),
-                    flatMap18(() => importedSchemaModule(schemaIdentifier.expression)),
-                    option4
-                  );
-                  if (isSome2(parsedSchemaModule)) {
-                    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
-                    };
-                  }
+              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),
+                  option4
+                );
+                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 Schema.TaggedRequest", void 0, atLocation);
+      return yield* typeParserIssue("Class does not extend Data.TaggedClass", void 0, atLocation);
     }),
-    "TypeParser.extendsSchemaTaggedRequest",
+    "TypeParser.extendsDataTaggedClass",
     (atLocation) => atLocation
   );
   const extendsContextTag = cachedBy(
@@ -32837,6 +32884,10 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
       if (!heritageClauses) {
         return yield* typeParserIssue("Class has no heritage clauses", void 0, atLocation);
       }
+      const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
+      if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
+      const type2 = typeChecker.getTypeOfSymbol(classSym);
+      const tagType = yield* contextTag(type2, atLocation);
       for (const heritageClause of heritageClauses) {
         for (const typeX of heritageClause.types) {
           if (ts.isExpressionWithTypeArguments(typeX)) {
@@ -32846,26 +32897,19 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
               if (ts.isCallExpression(effectTagCall) && wholeCall.typeArguments && wholeCall.typeArguments.length > 0) {
                 const effectTagIdentifier = effectTagCall.expression;
                 const selfTypeNode = wholeCall.typeArguments[0];
-                if (ts.isPropertyAccessExpression(effectTagIdentifier) && ts.isIdentifier(effectTagIdentifier.name) && ts.idText(effectTagIdentifier.name) === "Tag") {
-                  const parsedEffectModule = yield* pipe(
-                    importedEffectModule(effectTagIdentifier.expression),
-                    option4
-                  );
-                  if (isSome2(parsedEffectModule)) {
-                    const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
-                    if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
-                    const type2 = typeChecker.getTypeOfSymbol(classSym);
-                    const tagType = yield* contextTag(type2, atLocation);
-                    return {
-                      className: atLocation.name,
-                      selfTypeNode,
-                      keyStringLiteral: ts.isStringLiteral(effectTagCall.arguments[0]) ? effectTagCall.arguments[0] : void 0,
-                      args: effectTagCall.arguments,
-                      Identifier: tagType.Identifier,
-                      Service: tagType.Service,
-                      Tag: parsedEffectModule.value
-                    };
-                  }
+                const isEffectTag = yield* pipe(
+                  isNodeReferenceToEffectModuleApi("Tag")(effectTagIdentifier),
+                  option4
+                );
+                if (isSome2(isEffectTag)) {
+                  return {
+                    className: atLocation.name,
+                    selfTypeNode,
+                    keyStringLiteral: ts.isStringLiteral(effectTagCall.arguments[0]) ? effectTagCall.arguments[0] : void 0,
+                    args: effectTagCall.arguments,
+                    Identifier: tagType.Identifier,
+                    Service: tagType.Service
+                  };
                 }
               }
             }
@@ -32895,13 +32939,16 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
               if (ts.isCallExpression(effectServiceCall) && effectServiceCall.typeArguments && effectServiceCall.typeArguments.length > 0) {
                 const effectServiceIdentifier = effectServiceCall.expression;
                 const selfTypeNode = effectServiceCall.typeArguments[0];
-                if (ts.isPropertyAccessExpression(effectServiceIdentifier) && ts.isIdentifier(effectServiceIdentifier.name) && ts.idText(effectServiceIdentifier.name) === "Service") {
+                const isEffectService = yield* pipe(
+                  isNodeReferenceToEffectModuleApi("Service")(effectServiceIdentifier),
+                  option4
+                );
+                if (isSome2(isEffectService)) {
                   const classSym = typeChecker.getSymbolAtLocation(atLocation.name);
                   if (!classSym) return yield* typeParserIssue("Class has no symbol", void 0, atLocation);
                   const type2 = typeChecker.getTypeOfSymbol(classSym);
                   const parsedContextTag = yield* pipe(
-                    importedEffectModule(effectServiceIdentifier.expression),
-                    flatMap18(() => contextTag(type2, atLocation)),
+                    contextTag(type2, atLocation),
                     option4
                   );
                   if (isSome2(parsedContextTag)) {
@@ -32943,6 +32990,7 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
     (atLocation) => atLocation
   );
   return {
+    isNodeReferenceToEffectModuleApi,
     effectType,
     strictEffectType,
     layerType,
@@ -32971,6 +33019,80 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils) {
   };
 }
 
+// src/diagnostics/catchUnfailableEffect.ts
+var catchUnfailableEffect = createDiagnostic({
+  name: "catchUnfailableEffect",
+  code: 2,
+  severity: "suggestion",
+  apply: fn2("catchUnfailableEffect.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(TypeParser);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    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)) {
+        const catchFunctions = ["catchAll", "catch", "catchIf", "catchSome", "catchTag", "catchTags"];
+        const isCatchCall = yield* pipe(
+          firstSuccessOf2(
+            catchFunctions.map((catchFn) => typeParser.isNodeReferenceToEffectModuleApi(catchFn)(node.expression))
+          ),
+          option4
+        );
+        if (isSome2(isCatchCall)) {
+          const parent = node.parent;
+          if (parent && ts.isCallExpression(parent)) {
+            const pipeCallResult = yield* pipe(
+              typeParser.pipeCall(parent),
+              option4
+            );
+            if (isSome2(pipeCallResult)) {
+              const { args: args3, node: pipeCallNode, subject } = pipeCallResult.value;
+              const argIndex = args3.findIndex((arg) => arg === node);
+              if (argIndex !== -1) {
+                let effectTypeToCheck;
+                if (argIndex === 0) {
+                  effectTypeToCheck = typeChecker.getTypeAtLocation(subject);
+                } else {
+                  const signature = typeChecker.getResolvedSignature(pipeCallNode);
+                  if (signature) {
+                    const typeArguments = typeChecker.getTypeArgumentsForResolvedSignature(signature);
+                    if (typeArguments && typeArguments.length > argIndex) {
+                      effectTypeToCheck = typeArguments[argIndex];
+                    }
+                  }
+                }
+                if (effectTypeToCheck) {
+                  const effectType = yield* pipe(
+                    typeParser.effectType(effectTypeToCheck, node),
+                    option4
+                  );
+                  if (isSome2(effectType)) {
+                    const { E } = effectType.value;
+                    if (E.flags & ts.TypeFlags.Never) {
+                      report({
+                        location: node.expression,
+                        messageText: `Looks like the previous effect never fails, so probably this error handling will never be triggered.`,
+                        fixes: []
+                      });
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/classSelfMismatch.ts
 var classSelfMismatch = createDiagnostic({
   name: "classSelfMismatch",
@@ -34230,11 +34352,11 @@ var multipleEffectProvide = createDiagnostic({
       "Layer"
     ) || "Layer";
     const parseEffectProvideLayer = (node) => {
-      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && ts.idText(node.expression.name) === "provide" && node.arguments.length > 0) {
+      if (ts.isCallExpression(node) && node.arguments.length > 0) {
         const layer12 = node.arguments[0];
         const type2 = typeChecker.getTypeAtLocation(layer12);
         return pipe(
-          typeParser.importedEffectModule(node.expression.expression),
+          typeParser.isNodeReferenceToEffectModuleApi("provide")(node.expression),
           flatMap18(() => typeParser.layerType(type2, layer12)),
           map34(() => ({ layer: layer12, node })),
           orElse14(() => void_8)
@@ -35083,10 +35205,10 @@ var strictEffectProvide = createDiagnostic({
     const typeChecker = yield* service2(TypeCheckerApi);
     const typeParser = yield* service2(TypeParser);
     const parseEffectProvideWithLayer = (node) => gen3(function* () {
-      if (!ts.isCallExpression(node) || !ts.isPropertyAccessExpression(node.expression) || !ts.isIdentifier(node.expression.name) || ts.idText(node.expression.name) !== "provide" || node.arguments.length === 0) {
+      if (!ts.isCallExpression(node) || node.arguments.length === 0) {
         return yield* typeParserIssue("Not an Effect.provide call");
       }
-      yield* typeParser.importedEffectModule(node.expression.expression);
+      yield* typeParser.isNodeReferenceToEffectModuleApi("provide")(node.expression);
       return yield* firstSuccessOf2(
         node.arguments.map((arg) => {
           const argType = typeChecker.getTypeAtLocation(arg);
@@ -35381,6 +35503,7 @@ var unsupportedServiceAccessors = createDiagnostic({
 
 // src/diagnostics.ts
 var diagnostics = [
+  catchUnfailableEffect,
   classSelfMismatch,
   duplicatePackage,
   effectGenUsesAdapter,
@@ -35548,6 +35671,13 @@ var moduleNames = choice3("module", [
   repeated4,
   withDescription3("The name of the module to patch.")
 );
+var force = boolean5("force").pipe(
+  withDefault3(false),
+  withDescription3("Force patch even if already patched.")
+);
+var getPatchedMarker = (version) => {
+  return `"use effect-lsp-patch-version ${version}";`;
+};
 var getPatchesForModule = fn("getPatchesForModule")(
   function* (moduleName, dirPath4, version, sourceFile) {
     const ts = yield* getTypeScript;
@@ -35710,6 +35840,16 @@ var getPatchesForModule = fn("getPatchesForModule")(
         version
       )
     );
+    patches.push(
+      yield* makeEffectLspPatchChange(
+        sourceFile.text,
+        insertCheckSourceFilePosition.value.position,
+        insertCheckSourceFilePosition.value.position,
+        getPatchedMarker(version) + "\n",
+        "\n",
+        version
+      )
+    );
     return patches;
   }
 );
@@ -35733,8 +35873,8 @@ var printRememberPrepareScript = fn("printRememberPrepareScript")(function* () {
 }, ignore2);
 var patch9 = make58(
   "patch",
-  { dirPath: dirPath2, moduleNames },
-  fn("patch")(function* ({ dirPath: dirPath4, moduleNames: moduleNames3 }) {
+  { dirPath: dirPath2, moduleNames, force },
+  fn("patch")(function* ({ dirPath: dirPath4, force: force2, moduleNames: moduleNames3 }) {
     const fs = yield* FileSystem;
     const { version: effectLspVersion } = yield* getPackageJsonData(__dirname);
     yield* logDebug2(`Searching for typescript in ${dirPath4}...`);
@@ -35745,7 +35885,16 @@ var patch9 = make58(
       yield* logDebug2(`Searching ${moduleName}...`);
       const filePath = yield* getModuleFilePath(dirPath4, moduleName);
       yield* logDebug2(`Reading ${moduleName} from ${filePath}...`);
-      const sourceFile = yield* getUnpatchedSourceFile(filePath);
+      const sourceText = yield* getSourceFileText(filePath);
+      yield* logDebug2(
+        `Checking if ${filePath} is already patched with marker ${getPatchedMarker(effectLspVersion)}...`
+      );
+      if (!force2 && sourceText.indexOf(getPatchedMarker(effectLspVersion)) !== -1) {
+        yield* logInfo2(`${filePath} is already patched with version ${effectLspVersion}, skipped.`);
+        continue;
+      }
+      yield* logDebug2(`Parsing ${moduleName}...`);
+      const sourceFile = yield* getUnpatchedSourceFile(filePath, sourceText);
       yield* logDebug2(`Collecting patches for ${moduleName}...`);
       const patches = yield* getPatchesForModule(moduleName, dirPath4, effectLspVersion, sourceFile);
       const newSourceText = yield* applyTextChanges(sourceFile.text, patches);
@@ -35779,8 +35928,10 @@ var unpatch = make58(
     for (const moduleName of modulesToUnpatch) {
       yield* logDebug2(`Resolving ${moduleName}...`);
       const filePath = yield* getModuleFilePath(dirPath4, moduleName);
+      yield* logDebug2(`Reading ${moduleName} from ${filePath}...`);
+      const sourceText = yield* getSourceFileText(filePath);
       yield* logDebug2(`Unpatching ${filePath}...`);
-      const sourceFile = yield* getUnpatchedSourceFile(filePath);
+      const sourceFile = yield* getUnpatchedSourceFile(filePath, sourceText);
       yield* logDebug2(`Writing ${filePath}...`);
       yield* fs.writeFileString(filePath, sourceFile.text);
       yield* logInfo2(`${filePath} unpatched successfully.`);