@effect/language-service 0.55.5 → 0.57.0

package/cli.js

@@ -867,7 +867,7 @@ var require_getParsedConfigFile = __commonJS({
           throw new Error(formatDiagnostics([diag]));
         },
         readDirectory: tsserver.sys.readDirectory,
-        readFile: (file5) => fs.readFileSync(path2.isAbsolute(file5) ? file5 : path2.join(getCurrentDirectory(), file5), "utf-8"),
+        readFile: (file6) => fs.readFileSync(path2.isAbsolute(file6) ? file6 : path2.join(getCurrentDirectory(), file6), "utf-8"),
         useCaseSensitiveFileNames: tsserver.sys.useCaseSensitiveFileNames
       });
       if (parsed?.errors.length) {
@@ -942,7 +942,7 @@ var require_createProjectService = __commonJS({
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.createProjectService = createProjectService2;
+    exports2.createProjectService = createProjectService3;
     var debug_1 = __importDefault(require_src());
     var getParsedConfigFileFromTSServer_js_1 = require_getParsedConfigFileFromTSServer();
     var DEFAULT_PROJECT_MATCHED_FILES_THRESHOLD = 8;
@@ -956,7 +956,7 @@ var require_createProjectService = __commonJS({
     var createStubFileWatcher = () => ({
       close: doNothing
     });
-    function createProjectService2({ jsDocParsingMode, options: optionsRaw = {}, tsconfigRootDir } = {}) {
+    function createProjectService3({ jsDocParsingMode, options: optionsRaw = {}, tsconfigRootDir } = {}) {
       const options3 = {
         defaultProject: "tsconfig.json",
         ...optionsRaw
@@ -22834,11 +22834,11 @@ var make53 = (impl) => {
     }),
     stream: (path2, options3) => pipe(impl.open(path2, {
       flag: "r"
-    }), options3?.offset ? tap2((file5) => file5.seek(options3.offset, "start")) : identity, map17((file5) => stream(file5, options3)), unwrapScoped6),
+    }), options3?.offset ? tap2((file6) => file6.seek(options3.offset, "start")) : identity, map17((file6) => stream(file6, options3)), unwrapScoped6),
     sink: (path2, options3) => pipe(impl.open(path2, {
       flag: "w",
       ...options3
-    }), map17((file5) => forEach10((_) => file5.writeAll(_))), unwrapScoped5),
+    }), map17((file6) => forEach10((_) => file6.writeAll(_))), unwrapScoped5),
     writeFileString: (path2, data, options3) => flatMap9(try_3({
       try: () => new TextEncoder().encode(data),
       catch: (cause2) => new BadArgument({
@@ -22850,7 +22850,7 @@ var make53 = (impl) => {
     }), (_) => impl.writeFile(path2, _, options3))
   });
 };
-var stream = (file5, {
+var stream = (file6, {
   bufferSize = 16,
   bytesToRead: bytesToRead_,
   chunkSize: chunkSize_ = Size(64 * 1024)
@@ -22862,7 +22862,7 @@ var stream = (file5, {
       return void_6;
     }
     const toRead = bytesToRead !== void 0 && bytesToRead - totalBytesRead < chunkSize ? bytesToRead - totalBytesRead : chunkSize;
-    return flatMap15(file5.readAlloc(toRead), match2({
+    return flatMap15(file6.readAlloc(toRead), match2({
       onNone: () => void_6,
       onSome: (buf) => flatMap15(write2(of2(buf)), (_) => loop2(totalBytesRead + BigInt(buf.length)))
     }));
@@ -24168,10 +24168,10 @@ function getFileList(directory3, options3) {
       // to be filtered out if the user so desires
       map17((files2) => ["..", ...files2])
     );
-    return yield* filter8(files, (file5) => {
-      const result = options3.filter(file5);
+    return yield* filter8(files, (file6) => {
+      const result = options3.filter(file6);
       const userDefinedFilter = isEffect2(result) ? result : succeed7(result);
-      const directoryFilter = options3.type === "directory" ? map17(orDie2(fs.stat(path2.join(directory3, file5))), (info2) => info2.type === "Directory") : succeed7(true);
+      const directoryFilter = options3.type === "directory" ? map17(orDie2(fs.stat(path2.join(directory3, file6))), (info2) => info2.type === "Directory") : succeed7(true);
       return zipWith4(userDefinedFilter, directoryFilter, (a, b) => a && b);
     }, {
       concurrency: files.length
@@ -24220,8 +24220,8 @@ function renderPrefix(state, toDisplay, currentIndex, length3, figures2) {
   }
   return state.cursor === currentIndex ? figures2.pointer.pipe(annotate2(cyanBright2), cat2(prefix)) : prefix.pipe(cat2(space2));
 }
-function renderFileName(file5, isSelected) {
-  return isSelected ? annotate2(text3(file5), combine10(underlined2, cyanBright2)) : text3(file5);
+function renderFileName(file6, isSelected) {
+  return isSelected ? annotate2(text3(file6), combine10(underlined2, cyanBright2)) : text3(file6);
 }
 function renderFiles(state, files, figures2, options3) {
   const length3 = files.length;
@@ -24325,7 +24325,7 @@ function processSelection(state, options3) {
     const info2 = yield* orDie2(fs.stat(resolvedPath));
     if (info2.type === "Directory") {
       const files = yield* getFileList(resolvedPath, options3);
-      const filesWithoutParent = files.filter((file5) => file5 !== "..");
+      const filesWithoutParent = files.filter((file6) => file6 !== "..");
       if (options3.type === "directory" || options3.type === "either") {
         return filesWithoutParent.length === 0 ? Action.Submit({
           value: resolvedPath
@@ -28899,7 +28899,7 @@ var makeTempFile = /* @__PURE__ */ makeTempFileFactory("makeTempFile");
 var makeTempFileScoped = /* @__PURE__ */ (() => {
   const makeFile2 = /* @__PURE__ */ makeTempFileFactory("makeTempFileScoped");
   const removeDirectory = /* @__PURE__ */ removeFactory("makeTempFileScoped");
-  return (options3) => acquireRelease2(makeFile2(options3), (file5) => orDie2(removeDirectory(Path3.dirname(file5), {
+  return (options3) => acquireRelease2(makeFile2(options3), (file6) => orDie2(removeDirectory(Path3.dirname(file6), {
     recursive: true
   })));
 })();
@@ -31150,6 +31150,34 @@ var omitBundlerSourceFileComment = fn("omitBundlerSourceFileComment")(
     return yield* applyTextChanges(sourceFile.text, deleteChanges);
   }
 );
+var extractEffectLspOptions = (compilerOptions) => {
+  return (hasProperty(compilerOptions, "plugins") && Array.isArray(compilerOptions.plugins) ? compilerOptions.plugins : []).find((_) => hasProperty(_, "name") && _.name === "@effect/language-service");
+};
+var getFileNamesInTsConfig = fn("getFileNamesInTsConfig")(function* (tsconfigPath) {
+  const path2 = yield* Path2;
+  const tsInstance = yield* getTypeScript;
+  const filesToCheck = /* @__PURE__ */ new Set();
+  let tsconfigToHandle = [tsconfigPath];
+  while (tsconfigToHandle.length > 0) {
+    const tsconfigPath2 = tsconfigToHandle.shift();
+    const tsconfigAbsolutePath = path2.resolve(tsconfigPath2);
+    const configFile = tsInstance.readConfigFile(tsconfigAbsolutePath, tsInstance.sys.readFile);
+    if (configFile.error) {
+      if (!tsconfigAbsolutePath.endsWith("tsconfig.json")) {
+        tsconfigToHandle = [...tsconfigToHandle, path2.resolve(tsconfigPath2, "tsconfig.json")];
+      }
+      continue;
+    }
+    const parsedConfig = tsInstance.parseJsonConfigFileContent(
+      configFile.config,
+      tsInstance.sys,
+      path2.dirname(tsconfigAbsolutePath)
+    );
+    tsconfigToHandle = [...tsconfigToHandle, ...parsedConfig.projectReferences?.map((_) => _.path) ?? []];
+    parsedConfig.fileNames.forEach((_) => filesToCheck.add(_));
+  }
+  return filesToCheck;
+});
 
 // src/cli/check.ts
 var LOCAL_TYPESCRIPT_DIR = "./node_modules/typescript";
@@ -31186,7 +31214,7 @@ var check2 = make58(
   })
 );
 
-// src/cli/diagnostics.ts
+// src/cli/codegen.ts
 var import_project_service = __toESM(require_dist2());
 
 // src/core/LanguageServicePluginOptions.ts
@@ -31565,9 +31593,9 @@ var getCodegensForSourceFile = fn2("LSP.getApplicableCodegens")(function* (codeg
         pos: codegenMatch.index + pos + whitespace.length,
         end: codegenMatch.index + pos + codegenMatch[0].length
       };
-      const codegen = codegens2.find((codegen2) => codegen2.name === codegenName);
-      if (!codegen) continue;
-      result.push({ codegen, hash: codegenHash, range: range3 });
+      const codegen2 = codegens2.find((codegen3) => codegen3.name === codegenName);
+      if (!codegen2) continue;
+      result.push({ codegen: codegen2, hash: codegenHash, range: range3 });
     }
   }
   return result;
@@ -31575,18 +31603,18 @@ var getCodegensForSourceFile = fn2("LSP.getApplicableCodegens")(function* (codeg
 var getEditsForCodegen = fn2("LSP.getEditsForCodegen")(function* (codegens2, sourceFile, textRange) {
   const applicableCodegens = yield* getCodegensForSourceFile(codegens2, sourceFile);
   const inRangeCodegens = applicableCodegens.filter(
-    (codegen2) => codegen2.range.pos <= textRange.pos && codegen2.range.end >= textRange.end
+    (codegen3) => codegen3.range.pos <= textRange.pos && codegen3.range.end >= textRange.end
   );
   if (inRangeCodegens.length !== 1) {
     return yield* fail18(new CodegenNotApplicableError("zero or multiple codegens in range"));
   }
-  const { codegen, range: range3 } = inRangeCodegens[0];
-  const edit = yield* codegen.apply(sourceFile, range3);
+  const { codegen: codegen2, range: range3 } = inRangeCodegens[0];
+  const edit = yield* codegen2.apply(sourceFile, range3);
   const updateHashComment = pipe(
     service2(ChangeTracker),
     map34((changeTracker) => {
       changeTracker.deleteRange(sourceFile, range3);
-      changeTracker.insertText(sourceFile, range3.pos, `${codegen.name}:${edit.hash}`);
+      changeTracker.insertText(sourceFile, range3.pos, `${codegen2.name}:${edit.hash}`);
     })
   );
   return {
@@ -32055,6 +32083,51 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     if (!symbol3) return typeParserIssue("Node has no symbol", void 0, givenNode);
     return isSymbolExportOfPackageModule(symbol3, packageName, memberName, isCorrectSourceFile);
   };
+  const findSymbolsMatchingPackageAndExportedName = (packageName, exportedSymbolName) => cachedBy(
+    fn2("TypeParser.findSymbolsMatchingPackageAndExportedName")(function* (_fromSourceFile) {
+      const result = [];
+      for (const sourceFile of program.getSourceFiles()) {
+        const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+        if (!moduleSymbol) continue;
+        const symbol3 = typeChecker.tryGetMemberInModuleExports(exportedSymbolName, moduleSymbol);
+        if (!symbol3) continue;
+        const packageInfo = yield* getSourceFilePackageInfo(sourceFile);
+        if (!packageInfo || packageInfo.name.toLowerCase() !== packageName.toLowerCase()) continue;
+        result.push([symbol3, sourceFile]);
+      }
+      return result;
+    }),
+    `TypeParser.findSymbolsMatchingPackageAndExportedName(${packageName}, ${exportedSymbolName})`,
+    (sourceFile) => sourceFile
+  );
+  const isCauseTypeSourceFile = cachedBy(
+    fn2("TypeParser.isCauseTypeSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const causeTypeSymbol = typeChecker.tryGetMemberInModuleExports("Cause", moduleSymbol);
+      if (!causeTypeSymbol) return yield* typeParserIssue("Cause type not found", void 0, sourceFile);
+      const type2 = typeChecker.getDeclaredTypeOfSymbol(causeTypeSymbol);
+      yield* pipeableType(type2, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isCauseTypeSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const effectCauseYieldableErrorTypes = cachedBy(
+    fn2("TypeParser.effectCauseYieldableErrorTypes")(function* (fromSourceFile) {
+      const symbols = yield* findSymbolsMatchingPackageAndExportedName("effect", "YieldableError")(fromSourceFile);
+      const result = [];
+      for (const [symbol3, sourceFile] of symbols) {
+        const causeFile = yield* isCauseTypeSourceFile(sourceFile);
+        if (!causeFile) continue;
+        const type2 = typeChecker.getDeclaredTypeOfSymbol(symbol3);
+        result.push(type2);
+      }
+      return result;
+    }),
+    "TypeParser.effectCauseYieldableErrorTypes",
+    (fromSourceFile) => fromSourceFile
+  );
   function covariantTypeArgument(type2) {
     const signatures = typeChecker.getSignaturesOfType(type2, ts.SignatureKind.Call);
     if (signatures.length !== 1) {
@@ -33044,6 +33117,7 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     effectGen,
     effectFnUntracedGen,
     effectFnGen,
+    effectCauseYieldableErrorTypes,
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
     contextTag,
@@ -33063,6 +33137,534 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   };
 }
 
+// src/refactors/writeTagClassAccessors.ts
+var generate = fn2("writeTagClassAccessors.generate")(function* (sourceFile, service3, className, atLocation, involvedMembers) {
+  const ts = yield* service2(TypeScriptApi);
+  const tsUtils = yield* service2(TypeScriptUtils);
+  const typeChecker = yield* service2(TypeCheckerApi);
+  const typeParser = yield* service2(TypeParser);
+  const changeTracker = yield* service2(ChangeTracker);
+  const insertLocation = atLocation.members.length > 0 ? atLocation.members[0].pos : atLocation.end - 1;
+  const effectIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+    sourceFile,
+    "effect",
+    "Effect"
+  ) || "Effect";
+  const createFunctionProperty = (className2, propertyName, type2, forceAny) => {
+    const arrowBody = ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectIdentifier),
+        "andThen"
+      ),
+      void 0,
+      [
+        ts.factory.createIdentifier(ts.idText(className2)),
+        ts.factory.createArrowFunction(
+          void 0,
+          void 0,
+          [ts.factory.createParameterDeclaration(
+            void 0,
+            void 0,
+            "_",
+            void 0,
+            forceAny ? ts.factory.createTypeReferenceNode("any") : void 0
+          )],
+          void 0,
+          void 0,
+          ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier("_"),
+              propertyName
+            ),
+            void 0,
+            [
+              ts.factory.createSpreadElement(ts.factory.createIdentifier("args"))
+            ]
+          )
+        )
+      ]
+    );
+    return ts.factory.createPropertyDeclaration(
+      [
+        ts.factory.createModifier(ts.SyntaxKind.StaticKeyword),
+        ts.factory.createModifier(ts.SyntaxKind.OverrideKeyword)
+      ],
+      propertyName,
+      void 0,
+      type2,
+      ts.factory.createArrowFunction(
+        void 0,
+        void 0,
+        [ts.factory.createParameterDeclaration(
+          void 0,
+          ts.factory.createToken(ts.SyntaxKind.DotDotDotToken),
+          "args",
+          void 0,
+          forceAny ? ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode("any")) : void 0
+        )],
+        void 0,
+        void 0,
+        forceAny ? ts.factory.createAsExpression(arrowBody, ts.factory.createTypeReferenceNode("any")) : arrowBody
+      )
+    );
+  };
+  const generateReturnType = (type2, atLocation2, className2) => pipe(
+    typeParser.effectType(type2, atLocation2),
+    flatMap18((returnedEffect) => {
+      const contextType = returnedEffect.R.flags & ts.TypeFlags.Never ? ts.factory.createTypeReferenceNode(ts.idText(className2)) : ts.factory.createUnionTypeNode(
+        [
+          ts.factory.createTypeReferenceNode(ts.idText(className2)),
+          typeChecker.typeToTypeNode(returnedEffect.R, atLocation2, ts.NodeBuilderFlags.NoTruncation)
+        ]
+      );
+      const successType = typeChecker.typeToTypeNode(
+        returnedEffect.A,
+        atLocation2,
+        ts.NodeBuilderFlags.NoTruncation
+      );
+      if (!successType) return fail18("error generating success type");
+      const failureType = typeChecker.typeToTypeNode(
+        returnedEffect.E,
+        atLocation2,
+        ts.NodeBuilderFlags.NoTruncation
+      );
+      if (!failureType) return fail18("error generating failure type");
+      const typeNode = ts.factory.createTypeReferenceNode(
+        ts.factory.createQualifiedName(
+          ts.factory.createIdentifier(effectIdentifier),
+          ts.factory.createIdentifier("Effect")
+        ),
+        [successType, failureType, contextType]
+      );
+      return succeed17(typeNode);
+    }),
+    orElse14(
+      () => pipe(
+        typeParser.promiseLike(type2, atLocation2),
+        flatMap18(({ type: type3 }) => {
+          const successType = typeChecker.typeToTypeNode(
+            type3,
+            atLocation2,
+            ts.NodeBuilderFlags.NoTruncation
+          );
+          if (!successType) return fail18("error generating success type");
+          return succeed17(ts.factory.createTypeReferenceNode(
+            ts.factory.createQualifiedName(
+              ts.factory.createIdentifier(effectIdentifier),
+              ts.factory.createIdentifier("Effect")
+            ),
+            [
+              successType,
+              ts.factory.createTypeReferenceNode(
+                ts.factory.createQualifiedName(
+                  ts.factory.createIdentifier("Cause"),
+                  ts.factory.createIdentifier("UnknownException")
+                )
+              ),
+              ts.factory.createTypeReferenceNode(ts.idText(className2))
+            ]
+          ));
+        })
+      )
+    ),
+    orElse14(() => {
+      const successType = typeChecker.typeToTypeNode(type2, atLocation2, ts.NodeBuilderFlags.NoTruncation);
+      if (!successType) return fail18("error generating success type");
+      const typeNode = ts.factory.createTypeReferenceNode(
+        ts.factory.createQualifiedName(
+          ts.factory.createIdentifier(effectIdentifier),
+          ts.factory.createIdentifier("Effect")
+        ),
+        [
+          successType,
+          ts.factory.createTypeReferenceNode("never"),
+          ts.factory.createTypeReferenceNode(ts.idText(className2))
+        ]
+      );
+      return succeed17(typeNode);
+    })
+  );
+  const proxySignature = (signature, atLocation2, className2) => gen3(function* () {
+    const signatureDeclaration = typeChecker.signatureToSignatureDeclaration(
+      signature,
+      ts.SyntaxKind.FunctionType,
+      atLocation2,
+      ts.NodeBuilderFlags.NoTruncation
+    );
+    if (!signatureDeclaration) return yield* fail18("error generating signature");
+    const returnType = yield* generateReturnType(
+      typeChecker.getReturnTypeOfSignature(signature),
+      atLocation2,
+      className2
+    );
+    return ts.factory.createFunctionTypeNode(
+      signatureDeclaration.typeParameters,
+      signatureDeclaration.parameters,
+      returnType
+    );
+  });
+  for (const { property, propertyType } of involvedMembers) {
+    const callSignatures = [];
+    let propertyDeclaration = void 0;
+    for (const signature of typeChecker.getSignaturesOfType(propertyType, ts.SignatureKind.Call)) {
+      yield* pipe(
+        proxySignature(signature, atLocation, className),
+        map34((sig) => {
+          callSignatures.push(sig);
+        }),
+        ignore3
+      );
+    }
+    const allSignatures = ts.factory.createIntersectionTypeNode(callSignatures);
+    const type2 = tsUtils.simplifyTypeNode(allSignatures);
+    propertyDeclaration = createFunctionProperty(className, ts.symbolName(property), type2, callSignatures.length > 1);
+    const oldProperty = atLocation.members.filter(ts.isPropertyDeclaration).find((p2) => {
+      const symbol3 = typeChecker.getSymbolAtLocation(p2.name);
+      return symbol3 && ts.symbolName(symbol3) === ts.symbolName(property);
+    });
+    if (oldProperty) {
+      const start4 = ts.getTokenPosOfNode(oldProperty, sourceFile);
+      changeTracker.deleteRange(sourceFile, {
+        pos: start4,
+        end: oldProperty.end
+      });
+      changeTracker.insertNodeAt(sourceFile, start4, propertyDeclaration);
+    } else {
+      changeTracker.insertNodeAt(sourceFile, insertLocation, propertyDeclaration, { suffix: "\n" });
+    }
+  }
+});
+var parse5 = fn2("writeTagClassAccessors.parse")(function* (node) {
+  const ts = yield* service2(TypeScriptApi);
+  const typeChecker = yield* service2(TypeCheckerApi);
+  const typeParser = yield* service2(TypeParser);
+  const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+  if (!ts.isClassDeclaration(node)) return yield* fail18("not a class declaration");
+  const { Service, accessors: accessors2, className } = yield* pipe(
+    typeParser.extendsEffectService(node),
+    orElse14(() => map34(typeParser.extendsEffectTag(node), (_) => ({ accessors: true, ..._ }))),
+    orElse14(() => fail18("not a class extending Effect.Service call"))
+  );
+  if (accessors2 !== true) return yield* fail18("accessors are not enabled in the Effect.Service call");
+  const involvedMembers = [];
+  const nonPrimitiveServices = typeCheckerUtils.unrollUnionMembers(Service).filter(
+    (_) => !(_.flags & ts.TypeFlags.Number || _.flags & ts.TypeFlags.String || _.flags & ts.TypeFlags.Boolean || _.flags & ts.TypeFlags.Literal)
+  );
+  if (nonPrimitiveServices.length === 0) return yield* fail18("Service type is a primitive type");
+  for (const serviceShape of nonPrimitiveServices) {
+    for (const property of typeChecker.getPropertiesOfType(serviceShape)) {
+      const propertyType = typeChecker.getTypeOfSymbolAtLocation(property, node);
+      const callSignatures = typeChecker.getSignaturesOfType(propertyType, ts.SignatureKind.Call);
+      if (callSignatures.length > 0) {
+        const withTypeParameters = callSignatures.filter((_) => _.typeParameters && _.typeParameters.length > 0);
+        if (callSignatures.length > 1 || withTypeParameters.length > 0) involvedMembers.push({ property, propertyType });
+      }
+    }
+  }
+  const hash2 = involvedMembers.map(({ property, propertyType }) => {
+    return ts.symbolName(property) + ": " + typeChecker.typeToString(propertyType);
+  }).concat([ts.idText(className)]).join("\n");
+  return { Service, className, atLocation: node, hash: cyrb53(hash2), involvedMembers };
+});
+var writeTagClassAccessors = createRefactor({
+  name: "writeTagClassAccessors",
+  description: "Implement accessors methods with generics or multiple signatures",
+  apply: fn2("writeTagClassAccessors.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service2(TypeScriptApi);
+    const tsUtils = yield* service2(TypeScriptUtils);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeParser = yield* service2(TypeParser);
+    const parseNode = (node) => pipe(
+      parse5(node),
+      map34(({ Service, atLocation, className, involvedMembers }) => ({
+        kind: "refactor.rewrite.effect.writeTagClassAccessors",
+        description: "Implement Service accessors",
+        apply: pipe(
+          generate(sourceFile, Service, className, atLocation, involvedMembers),
+          provideService7(TypeScriptUtils, tsUtils),
+          provideService7(TypeParser, typeParser),
+          provideService7(TypeCheckerApi, typeChecker),
+          provideService7(TypeScriptApi, ts)
+        )
+      }))
+    );
+    const parentNodes = tsUtils.getAncestorNodesInRange(sourceFile, textRange);
+    return yield* pipe(
+      firstSuccessOf2(parentNodes.map(parseNode)),
+      orElse14(() => fail18(new RefactorNotApplicableError()))
+    );
+  })
+});
+
+// src/codegens/accessors.ts
+var accessors = createCodegen({
+  name: "accessors",
+  apply: fn2("accessors.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service2(TypeScriptApi);
+    const tsUtils = yield* service2(TypeScriptUtils);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeParser = yield* service2(TypeParser);
+    const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+    const nodeAndCommentRange = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, textRange.pos);
+    if (!nodeAndCommentRange) return yield* fail18(new CodegenNotApplicableError("no node and comment range"));
+    return yield* pipe(
+      parse5(nodeAndCommentRange.node),
+      map34(
+        (_) => ({
+          hash: _.hash,
+          description: "Generate accessors for the service",
+          apply: pipe(
+            generate(sourceFile, _.Service, _.className, _.atLocation, _.involvedMembers),
+            provideService7(TypeScriptApi, ts),
+            provideService7(TypeScriptUtils, tsUtils),
+            provideService7(TypeCheckerApi, typeChecker),
+            provideService7(TypeParser, typeParser),
+            provideService7(TypeCheckerUtils, typeCheckerUtils)
+          )
+        })
+      ),
+      orElse14((cause2) => fail18(new CodegenNotApplicableError(cause2)))
+    );
+  })
+});
+
+// src/codegens/annotate.ts
+var annotate3 = createCodegen({
+  name: "annotate",
+  apply: fn2("annotate.apply")(function* (sourceFile, textRange) {
+    const ts = yield* service2(TypeScriptApi);
+    const tsUtils = yield* service2(TypeScriptUtils);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+    const parse6 = (node) => gen3(function* () {
+      let variableDeclarations = [];
+      const result = [];
+      if (ts.isVariableStatement(node)) {
+        variableDeclarations = [...variableDeclarations, ...node.declarationList.declarations];
+      } else if (ts.isVariableDeclarationList(node)) {
+        variableDeclarations = [...variableDeclarations, ...node.declarations];
+      } else if (ts.isVariableDeclaration(node)) {
+        variableDeclarations = [...variableDeclarations, node];
+      }
+      if (variableDeclarations.length === 0) {
+        return yield* fail18(new CodegenNotApplicableError("not a variable declaration"));
+      }
+      for (const variableDeclaration of variableDeclarations) {
+        if (!variableDeclaration.initializer) continue;
+        const initializerType = typeChecker.getTypeAtLocation(variableDeclaration.initializer);
+        const initializerTypeNode = fromNullable(typeCheckerUtils.typeToSimplifiedTypeNode(
+          initializerType,
+          node,
+          ts.NodeBuilderFlags.NoTruncation
+        )).pipe(
+          orElse(
+            () => fromNullable(typeCheckerUtils.typeToSimplifiedTypeNode(
+              initializerType,
+              void 0,
+              ts.NodeBuilderFlags.NoTruncation
+            ))
+          ),
+          getOrUndefined
+        );
+        if (!initializerTypeNode) continue;
+        const typeNodeString = typeChecker.typeToString(initializerType, void 0, ts.TypeFormatFlags.NoTruncation);
+        const hash3 = cyrb53(typeNodeString);
+        result.push({ variableDeclaration, initializerTypeNode, hash: hash3 });
+      }
+      if (result.length === 0) {
+        return yield* fail18(new CodegenNotApplicableError("no variable declarations with initializers"));
+      }
+      const hash2 = cyrb53(result.map((_) => _.hash).join("/"));
+      return {
+        hash: hash2,
+        result
+      };
+    });
+    const nodeAndCommentRange = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, textRange.pos);
+    if (!nodeAndCommentRange) return yield* fail18(new CodegenNotApplicableError("no node and comment range"));
+    return yield* pipe(
+      parse6(nodeAndCommentRange.node),
+      map34(
+        (_) => ({
+          hash: _.hash,
+          description: "Annotate with type",
+          apply: gen3(function* () {
+            const changeTracker = yield* service2(ChangeTracker);
+            for (const { initializerTypeNode, variableDeclaration } of _.result) {
+              if (variableDeclaration.type) {
+                changeTracker.deleteRange(sourceFile, {
+                  pos: variableDeclaration.name.end,
+                  end: variableDeclaration.type.end
+                });
+              }
+              changeTracker.insertNodeAt(
+                sourceFile,
+                variableDeclaration.name.end,
+                initializerTypeNode,
+                {
+                  prefix: ": "
+                }
+              );
+            }
+          })
+        })
+      )
+    );
+  })
+});
+
+// src/codegens.ts
+var codegens = [accessors, annotate3];
+
+// src/cli/codegen.ts
+var NoFilesToCodegenError = class extends TaggedError("NoFilesToCodegenError") {
+  get message() {
+    return "No files to codegen. Please provide an existing .ts file or a project tsconfig.json";
+  }
+};
+var file4 = file3("file").pipe(
+  optional4,
+  withDescription3("The full path of the file to codegen.")
+);
+var project2 = file3("project").pipe(
+  optional4,
+  withDescription3("The full path of the project tsconfig.json file to codegen.")
+);
+var verbose = boolean5("verbose").pipe(
+  withDefault3(false),
+  withDescription3("Verbose output.")
+);
+var BATCH_SIZE = 50;
+var codegen = make58(
+  "codegen",
+  { file: file4, project: project2, verbose },
+  fn("codegen")(function* ({ file: file6, project: project4, verbose: verbose2 }) {
+    const path2 = yield* Path2;
+    const fs = yield* FileSystem;
+    const tsInstance = yield* getTypeScript;
+    let filesToCodegen = /* @__PURE__ */ new Set();
+    let checkedFilesCount = 0;
+    let updatedFilesCount = 0;
+    if (isSome2(project4)) {
+      filesToCodegen = yield* getFileNamesInTsConfig(project4.value);
+    }
+    if (isSome2(file6)) {
+      filesToCodegen.add(path2.resolve(file6.value));
+    }
+    if (filesToCodegen.size === 0) {
+      return yield* new NoFilesToCodegenError();
+    }
+    const filesWithCodegenDirective = /* @__PURE__ */ new Set();
+    for (const filePath of filesToCodegen) {
+      const sourceText = yield* fs.readFileString(filePath);
+      if (sourceText.toLowerCase().indexOf("@effect-codegens") !== -1) {
+        filesWithCodegenDirective.add(filePath);
+      }
+    }
+    if (filesWithCodegenDirective.size === 0) {
+      return yield* new NoFilesToCodegenError();
+    }
+    const filesToCodegenArray = fromIterable(filesWithCodegenDirective);
+    const batches = chunksOf(filesToCodegenArray, BATCH_SIZE);
+    let lastLanguageService;
+    const disposeIfLanguageServiceChanged = (languageService) => {
+      if (lastLanguageService !== languageService) {
+        lastLanguageService?.dispose();
+        lastLanguageService = languageService;
+      }
+    };
+    for (const batch of batches) {
+      const { service: service3 } = (0, import_project_service.createProjectService)({ options: { loadTypeScriptPlugins: false } });
+      for (const filePath of batch) {
+        service3.openClientFile(filePath);
+        try {
+          const scriptInfo = service3.getScriptInfo(filePath);
+          if (!scriptInfo) continue;
+          const project5 = scriptInfo.getDefaultProject();
+          const languageService = project5.getLanguageService(true);
+          disposeIfLanguageServiceChanged(languageService);
+          const program = languageService.getProgram();
+          if (!program) continue;
+          const sourceFile = program.getSourceFile(filePath);
+          if (!sourceFile) continue;
+          const pluginConfig = extractEffectLspOptions(program.getCompilerOptions());
+          if (!pluginConfig) continue;
+          const formatContext = tsInstance.formatting.getFormatContext(
+            tsInstance.getDefaultFormatCodeSettings(project5.getNewLine()),
+            project5
+          );
+          const allFileChanges = pipe(
+            gen3(function* () {
+              let allChanges = [];
+              const codegensWithRanges = yield* getCodegensForSourceFile(codegens, sourceFile);
+              for (const { codegen: codegen2, hash: hash2, range: range3 } of codegensWithRanges) {
+                const applicable = yield* pipe(
+                  getEditsForCodegen([codegen2], sourceFile, range3),
+                  orElse14(() => void_8)
+                );
+                if (applicable && applicable.hash !== hash2) {
+                  const changes2 = tsInstance.textChanges.ChangeTracker.with(
+                    {
+                      formatContext,
+                      host: project5,
+                      preferences: {}
+                    },
+                    (changeTracker) => pipe(
+                      applicable.apply,
+                      provideService7(ChangeTracker, changeTracker),
+                      run9
+                    )
+                  );
+                  allChanges = [...allChanges, ...changes2];
+                }
+              }
+              return allChanges;
+            }),
+            nanoLayer3,
+            nanoLayer2,
+            nanoLayer,
+            provideService7(TypeCheckerApi, program.getTypeChecker()),
+            provideService7(TypeScriptProgram, program),
+            provideService7(TypeScriptApi, tsInstance),
+            provideService7(
+              LanguageServicePluginOptions,
+              { ...parse4(pluginConfig), diagnosticsName: false }
+            ),
+            run9,
+            getOrElse(() => [])
+          );
+          checkedFilesCount++;
+          const thisFileChanges = allFileChanges.filter((change) => change.fileName === sourceFile.fileName);
+          const flattenedChanges = flatten(thisFileChanges.map((change) => change.textChanges));
+          if (verbose2) {
+            if (flattenedChanges.length > 0) {
+              console.log(`${filePath}: with ${flattenedChanges.length} changes`);
+            } else {
+              console.log(`${filePath}: no changes`);
+            }
+          }
+          if (flattenedChanges.length === 0) continue;
+          const sourceText = yield* fs.readFileString(filePath);
+          const newSourceText = yield* applyTextChanges(sourceText, flattenedChanges);
+          yield* fs.writeFileString(filePath, newSourceText);
+          updatedFilesCount++;
+        } finally {
+          service3.closeClientFile(filePath);
+        }
+      }
+      yield* yieldNow4();
+    }
+    disposeIfLanguageServiceChanged(void 0);
+    console.log(
+      `${filesToCodegen.size} involved files, of which ${filesWithCodegenDirective.size} with codegens.
+${checkedFilesCount} checked and ${updatedFilesCount} updated.`
+    );
+  })
+);
+
+// src/cli/diagnostics.ts
+var import_project_service2 = __toESM(require_dist2());
+
 // src/diagnostics/anyUnknownInErrorContext.ts
 var anyUnknownInErrorContext = createDiagnostic({
   name: "anyUnknownInErrorContext",
@@ -34671,300 +35273,6 @@ var nonObjectEffectServiceType = createDiagnostic({
   })
 });
 
-// src/refactors/writeTagClassAccessors.ts
-var generate = fn2("writeTagClassAccessors.generate")(function* (sourceFile, service3, className, atLocation, involvedMembers) {
-  const ts = yield* service2(TypeScriptApi);
-  const tsUtils = yield* service2(TypeScriptUtils);
-  const typeChecker = yield* service2(TypeCheckerApi);
-  const typeParser = yield* service2(TypeParser);
-  const changeTracker = yield* service2(ChangeTracker);
-  const insertLocation = atLocation.members.length > 0 ? atLocation.members[0].pos : atLocation.end - 1;
-  const effectIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
-    sourceFile,
-    "effect",
-    "Effect"
-  ) || "Effect";
-  const createFunctionProperty = (className2, propertyName, type2, forceAny) => {
-    const arrowBody = ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(
-        ts.factory.createIdentifier(effectIdentifier),
-        "andThen"
-      ),
-      void 0,
-      [
-        ts.factory.createIdentifier(ts.idText(className2)),
-        ts.factory.createArrowFunction(
-          void 0,
-          void 0,
-          [ts.factory.createParameterDeclaration(
-            void 0,
-            void 0,
-            "_",
-            void 0,
-            forceAny ? ts.factory.createTypeReferenceNode("any") : void 0
-          )],
-          void 0,
-          void 0,
-          ts.factory.createCallExpression(
-            ts.factory.createPropertyAccessExpression(
-              ts.factory.createIdentifier("_"),
-              propertyName
-            ),
-            void 0,
-            [
-              ts.factory.createSpreadElement(ts.factory.createIdentifier("args"))
-            ]
-          )
-        )
-      ]
-    );
-    return ts.factory.createPropertyDeclaration(
-      [
-        ts.factory.createModifier(ts.SyntaxKind.StaticKeyword),
-        ts.factory.createModifier(ts.SyntaxKind.OverrideKeyword)
-      ],
-      propertyName,
-      void 0,
-      type2,
-      ts.factory.createArrowFunction(
-        void 0,
-        void 0,
-        [ts.factory.createParameterDeclaration(
-          void 0,
-          ts.factory.createToken(ts.SyntaxKind.DotDotDotToken),
-          "args",
-          void 0,
-          forceAny ? ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode("any")) : void 0
-        )],
-        void 0,
-        void 0,
-        forceAny ? ts.factory.createAsExpression(arrowBody, ts.factory.createTypeReferenceNode("any")) : arrowBody
-      )
-    );
-  };
-  const generateReturnType = (type2, atLocation2, className2) => pipe(
-    typeParser.effectType(type2, atLocation2),
-    flatMap18((returnedEffect) => {
-      const contextType = returnedEffect.R.flags & ts.TypeFlags.Never ? ts.factory.createTypeReferenceNode(ts.idText(className2)) : ts.factory.createUnionTypeNode(
-        [
-          ts.factory.createTypeReferenceNode(ts.idText(className2)),
-          typeChecker.typeToTypeNode(returnedEffect.R, atLocation2, ts.NodeBuilderFlags.NoTruncation)
-        ]
-      );
-      const successType = typeChecker.typeToTypeNode(
-        returnedEffect.A,
-        atLocation2,
-        ts.NodeBuilderFlags.NoTruncation
-      );
-      if (!successType) return fail18("error generating success type");
-      const failureType = typeChecker.typeToTypeNode(
-        returnedEffect.E,
-        atLocation2,
-        ts.NodeBuilderFlags.NoTruncation
-      );
-      if (!failureType) return fail18("error generating failure type");
-      const typeNode = ts.factory.createTypeReferenceNode(
-        ts.factory.createQualifiedName(
-          ts.factory.createIdentifier(effectIdentifier),
-          ts.factory.createIdentifier("Effect")
-        ),
-        [successType, failureType, contextType]
-      );
-      return succeed17(typeNode);
-    }),
-    orElse14(
-      () => pipe(
-        typeParser.promiseLike(type2, atLocation2),
-        flatMap18(({ type: type3 }) => {
-          const successType = typeChecker.typeToTypeNode(
-            type3,
-            atLocation2,
-            ts.NodeBuilderFlags.NoTruncation
-          );
-          if (!successType) return fail18("error generating success type");
-          return succeed17(ts.factory.createTypeReferenceNode(
-            ts.factory.createQualifiedName(
-              ts.factory.createIdentifier(effectIdentifier),
-              ts.factory.createIdentifier("Effect")
-            ),
-            [
-              successType,
-              ts.factory.createTypeReferenceNode(
-                ts.factory.createQualifiedName(
-                  ts.factory.createIdentifier("Cause"),
-                  ts.factory.createIdentifier("UnknownException")
-                )
-              ),
-              ts.factory.createTypeReferenceNode(ts.idText(className2))
-            ]
-          ));
-        })
-      )
-    ),
-    orElse14(() => {
-      const successType = typeChecker.typeToTypeNode(type2, atLocation2, ts.NodeBuilderFlags.NoTruncation);
-      if (!successType) return fail18("error generating success type");
-      const typeNode = ts.factory.createTypeReferenceNode(
-        ts.factory.createQualifiedName(
-          ts.factory.createIdentifier(effectIdentifier),
-          ts.factory.createIdentifier("Effect")
-        ),
-        [
-          successType,
-          ts.factory.createTypeReferenceNode("never"),
-          ts.factory.createTypeReferenceNode(ts.idText(className2))
-        ]
-      );
-      return succeed17(typeNode);
-    })
-  );
-  const proxySignature = (signature, atLocation2, className2) => gen3(function* () {
-    const signatureDeclaration = typeChecker.signatureToSignatureDeclaration(
-      signature,
-      ts.SyntaxKind.FunctionType,
-      atLocation2,
-      ts.NodeBuilderFlags.NoTruncation
-    );
-    if (!signatureDeclaration) return yield* fail18("error generating signature");
-    const returnType = yield* generateReturnType(
-      typeChecker.getReturnTypeOfSignature(signature),
-      atLocation2,
-      className2
-    );
-    return ts.factory.createFunctionTypeNode(
-      signatureDeclaration.typeParameters,
-      signatureDeclaration.parameters,
-      returnType
-    );
-  });
-  for (const { property, propertyType } of involvedMembers) {
-    const callSignatures = [];
-    let propertyDeclaration = void 0;
-    for (const signature of typeChecker.getSignaturesOfType(propertyType, ts.SignatureKind.Call)) {
-      yield* pipe(
-        proxySignature(signature, atLocation, className),
-        map34((sig) => {
-          callSignatures.push(sig);
-        }),
-        ignore3
-      );
-    }
-    const allSignatures = ts.factory.createIntersectionTypeNode(callSignatures);
-    const type2 = tsUtils.simplifyTypeNode(allSignatures);
-    propertyDeclaration = createFunctionProperty(className, ts.symbolName(property), type2, callSignatures.length > 1);
-    const oldProperty = atLocation.members.filter(ts.isPropertyDeclaration).find((p2) => {
-      const symbol3 = typeChecker.getSymbolAtLocation(p2.name);
-      return symbol3 && ts.symbolName(symbol3) === ts.symbolName(property);
-    });
-    if (oldProperty) {
-      const start4 = ts.getTokenPosOfNode(oldProperty, sourceFile);
-      changeTracker.deleteRange(sourceFile, {
-        pos: start4,
-        end: oldProperty.end
-      });
-      changeTracker.insertNodeAt(sourceFile, start4, propertyDeclaration);
-    } else {
-      changeTracker.insertNodeAt(sourceFile, insertLocation, propertyDeclaration, { suffix: "\n" });
-    }
-  }
-});
-var parse5 = fn2("writeTagClassAccessors.parse")(function* (node) {
-  const ts = yield* service2(TypeScriptApi);
-  const typeChecker = yield* service2(TypeCheckerApi);
-  const typeParser = yield* service2(TypeParser);
-  const typeCheckerUtils = yield* service2(TypeCheckerUtils);
-  if (!ts.isClassDeclaration(node)) return yield* fail18("not a class declaration");
-  const { Service, accessors: accessors2, className } = yield* pipe(
-    typeParser.extendsEffectService(node),
-    orElse14(() => map34(typeParser.extendsEffectTag(node), (_) => ({ accessors: true, ..._ }))),
-    orElse14(() => fail18("not a class extending Effect.Service call"))
-  );
-  if (accessors2 !== true) return yield* fail18("accessors are not enabled in the Effect.Service call");
-  const involvedMembers = [];
-  const nonPrimitiveServices = typeCheckerUtils.unrollUnionMembers(Service).filter(
-    (_) => !(_.flags & ts.TypeFlags.Number || _.flags & ts.TypeFlags.String || _.flags & ts.TypeFlags.Boolean || _.flags & ts.TypeFlags.Literal)
-  );
-  if (nonPrimitiveServices.length === 0) return yield* fail18("Service type is a primitive type");
-  for (const serviceShape of nonPrimitiveServices) {
-    for (const property of typeChecker.getPropertiesOfType(serviceShape)) {
-      const propertyType = typeChecker.getTypeOfSymbolAtLocation(property, node);
-      const callSignatures = typeChecker.getSignaturesOfType(propertyType, ts.SignatureKind.Call);
-      if (callSignatures.length > 0) {
-        const withTypeParameters = callSignatures.filter((_) => _.typeParameters && _.typeParameters.length > 0);
-        if (callSignatures.length > 1 || withTypeParameters.length > 0) involvedMembers.push({ property, propertyType });
-      }
-    }
-  }
-  const hash2 = involvedMembers.map(({ property, propertyType }) => {
-    return ts.symbolName(property) + ": " + typeChecker.typeToString(propertyType);
-  }).concat([ts.idText(className)]).join("\n");
-  return { Service, className, atLocation: node, hash: cyrb53(hash2), involvedMembers };
-});
-var writeTagClassAccessors = createRefactor({
-  name: "writeTagClassAccessors",
-  description: "Implement accessors methods with generics or multiple signatures",
-  apply: fn2("writeTagClassAccessors.apply")(function* (sourceFile, textRange) {
-    const ts = yield* service2(TypeScriptApi);
-    const tsUtils = yield* service2(TypeScriptUtils);
-    const typeChecker = yield* service2(TypeCheckerApi);
-    const typeParser = yield* service2(TypeParser);
-    const parseNode = (node) => pipe(
-      parse5(node),
-      map34(({ Service, atLocation, className, involvedMembers }) => ({
-        kind: "refactor.rewrite.effect.writeTagClassAccessors",
-        description: "Implement Service accessors",
-        apply: pipe(
-          generate(sourceFile, Service, className, atLocation, involvedMembers),
-          provideService7(TypeScriptUtils, tsUtils),
-          provideService7(TypeParser, typeParser),
-          provideService7(TypeCheckerApi, typeChecker),
-          provideService7(TypeScriptApi, ts)
-        )
-      }))
-    );
-    const parentNodes = tsUtils.getAncestorNodesInRange(sourceFile, textRange);
-    return yield* pipe(
-      firstSuccessOf2(parentNodes.map(parseNode)),
-      orElse14(() => fail18(new RefactorNotApplicableError()))
-    );
-  })
-});
-
-// src/codegens/accessors.ts
-var accessors = createCodegen({
-  name: "accessors",
-  apply: fn2("accessors.apply")(function* (sourceFile, textRange) {
-    const ts = yield* service2(TypeScriptApi);
-    const tsUtils = yield* service2(TypeScriptUtils);
-    const typeChecker = yield* service2(TypeCheckerApi);
-    const typeParser = yield* service2(TypeParser);
-    const typeCheckerUtils = yield* service2(TypeCheckerUtils);
-    const nodeAndCommentRange = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, textRange.pos);
-    if (!nodeAndCommentRange) return yield* fail18(new CodegenNotApplicableError("no node and comment range"));
-    return yield* pipe(
-      parse5(nodeAndCommentRange.node),
-      map34(
-        (_) => ({
-          hash: _.hash,
-          description: "Generate accessors for the service",
-          apply: pipe(
-            generate(sourceFile, _.Service, _.className, _.atLocation, _.involvedMembers),
-            provideService7(TypeScriptApi, ts),
-            provideService7(TypeScriptUtils, tsUtils),
-            provideService7(TypeCheckerApi, typeChecker),
-            provideService7(TypeParser, typeParser),
-            provideService7(TypeCheckerUtils, typeCheckerUtils)
-          )
-        })
-      ),
-      orElse14((cause2) => fail18(new CodegenNotApplicableError(cause2)))
-    );
-  })
-});
-
-// src/codegens.ts
-var codegens = [accessors];
-
 // src/diagnostics/outdatedEffectCodegen.ts
 var outdatedEffectCodegen = createDiagnostic({
   name: "outdatedEffectCodegen",
@@ -34972,23 +35280,23 @@ var outdatedEffectCodegen = createDiagnostic({
   severity: "warning",
   apply: fn2("outdatedEffectCodegen.apply")(function* (sourceFile, _report) {
     const codegensWithRanges = yield* getCodegensForSourceFile(codegens, sourceFile);
-    for (const { codegen, hash: hash2, range: range3 } of codegensWithRanges) {
+    for (const { codegen: codegen2, hash: hash2, range: range3 } of codegensWithRanges) {
       yield* pipe(
-        getEditsForCodegen([codegen], sourceFile, range3),
+        getEditsForCodegen([codegen2], sourceFile, range3),
         map34((applicable) => {
           if (applicable.hash !== hash2) {
             _report({
               location: range3,
-              messageText: `Codegen ${codegen.name} result is outdated`,
+              messageText: `Codegen ${codegen2.name} result is outdated`,
               fixes: [
                 {
                   fixName: "outdatedEffectCodegen_fix",
-                  description: `Re-run ${codegen.name}`,
+                  description: `Re-run ${codegen2.name}`,
                   apply: applicable.apply
                 },
                 {
                   fixName: "outdatedEffectCodegen_ignore",
-                  description: `Ignore this ${codegen.name} update`,
+                  description: `Ignore this ${codegen2.name} update`,
                   apply: applicable.ignore
                 }
               ]
@@ -34999,7 +35307,7 @@ var outdatedEffectCodegen = createDiagnostic({
           (e) => sync11(() => {
             _report({
               location: range3,
-              messageText: `Codegen ${codegen.name} is not applicable here: ${e.cause}`,
+              messageText: `Codegen ${codegen2.name} is not applicable here: ${e.cause}`,
               fixes: []
             });
           })
@@ -35695,6 +36003,66 @@ var unnecessaryEffectGen = createDiagnostic({
   })
 });
 
+// src/diagnostics/unnecessaryFailYieldableError.ts
+var unnecessaryFailYieldableError = createDiagnostic({
+  name: "unnecessaryFailYieldableError",
+  code: 29,
+  severity: "suggestion",
+  apply: fn2("unnecessaryFailYieldableError.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(TypeParser);
+    const typeChecker = yield* service2(TypeCheckerApi);
+    const yieldableErrorTypes = yield* pipe(
+      typeParser.effectCauseYieldableErrorTypes(sourceFile),
+      orElse14(() => succeed17([]))
+    );
+    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.isYieldExpression(node) && node.asteriskToken && node.expression && ts.isCallExpression(node.expression)) {
+        const callExpression = node.expression;
+        yield* pipe(
+          typeParser.isNodeReferenceToEffectModuleApi("fail")(callExpression.expression),
+          map34(() => {
+            if (callExpression.arguments.length > 0) {
+              const failArgument = callExpression.arguments[0];
+              const argumentType = typeChecker.getTypeAtLocation(failArgument);
+              const isYieldableError = yieldableErrorTypes.some(
+                (yieldableType) => typeChecker.isTypeAssignableTo(argumentType, yieldableType)
+              );
+              if (isYieldableError) {
+                report({
+                  location: node,
+                  messageText: `This Effect.fail call uses a yieldable error type as argument. You can yield* the error directly instead.`,
+                  fixes: [{
+                    fixName: "unnecessaryFailYieldableError_fix",
+                    description: "Replace yield* Effect.fail with yield*",
+                    apply: gen3(function* () {
+                      const changeTracker = yield* service2(ChangeTracker);
+                      changeTracker.replaceNode(
+                        sourceFile,
+                        callExpression,
+                        failArgument
+                      );
+                    })
+                  }]
+                });
+              }
+            }
+          }),
+          ignore3
+        );
+      }
+    }
+  })
+});
+
 // src/diagnostics/unnecessaryPipe.ts
 var unnecessaryPipe = createDiagnostic({
   name: "unnecessaryPipe",
@@ -35882,6 +36250,7 @@ var diagnostics = [
   floatingEffect,
   missingStarInYieldEffectGen,
   unnecessaryEffectGen,
+  unnecessaryFailYieldableError,
   missingReturnYieldStar,
   leakingRequirements,
   unnecessaryPipe,
@@ -35912,58 +36281,37 @@ var NoFilesToCheckError = class extends TaggedError("NoFilesToCheckError") {
     return "No files to check. Please provide an existing .ts file or a project tsconfig.json";
   }
 };
-var file4 = file3("file").pipe(
+var file5 = file3("file").pipe(
   optional4,
   withDescription3("The full path of the file to check for diagnostics.")
 );
-var project2 = file3("project").pipe(
+var project3 = file3("project").pipe(
   optional4,
   withDescription3("The full path of the project tsconfig.json file to check for diagnostics.")
 );
-var extractEffectLspOptions = (compilerOptions) => {
-  return (hasProperty(compilerOptions, "plugins") && isArray(compilerOptions.plugins) ? compilerOptions.plugins : []).find((_) => hasProperty(_, "name") && _.name === "@effect/language-service");
-};
-var BATCH_SIZE = 50;
+var BATCH_SIZE2 = 50;
 var diagnostics2 = make58(
   "diagnostics",
-  { file: file4, project: project2 },
-  fn("diagnostics")(function* ({ file: file5, project: project3 }) {
+  { file: file5, project: project3 },
+  fn("diagnostics")(function* ({ file: file6, project: project4 }) {
     const path2 = yield* Path2;
     const tsInstance = yield* getTypeScript;
-    const filesToCheck = /* @__PURE__ */ new Set();
+    let filesToCheck = /* @__PURE__ */ new Set();
     let checkedFilesCount = 0;
     let errorsCount = 0;
     let warningsCount = 0;
     let messagesCount = 0;
-    if (isSome2(file5)) {
-      filesToCheck.add(path2.resolve(file5.value));
-    }
-    if (isSome2(project3)) {
-      let tsconfigToHandle = [project3.value ?? ""];
-      while (tsconfigToHandle.length > 0) {
-        const tsconfigPath = tsconfigToHandle.shift();
-        const tsconfigAbsolutePath = path2.resolve(tsconfigPath);
-        const configFile = tsInstance.readConfigFile(tsconfigAbsolutePath, tsInstance.sys.readFile);
-        if (configFile.error) {
-          if (!tsconfigAbsolutePath.endsWith("tsconfig.json")) {
-            tsconfigToHandle = [...tsconfigToHandle, path2.resolve(tsconfigPath, "tsconfig.json")];
-          }
-          continue;
-        }
-        const parsedConfig = tsInstance.parseJsonConfigFileContent(
-          configFile.config,
-          tsInstance.sys,
-          path2.dirname(tsconfigAbsolutePath)
-        );
-        tsconfigToHandle = [...tsconfigToHandle, ...parsedConfig.projectReferences?.map((_) => _.path) ?? []];
-        parsedConfig.fileNames.forEach((_) => filesToCheck.add(_));
-      }
+    if (isSome2(project4)) {
+      filesToCheck = yield* getFileNamesInTsConfig(project4.value);
+    }
+    if (isSome2(file6)) {
+      filesToCheck.add(path2.resolve(file6.value));
     }
     if (filesToCheck.size === 0) {
       return yield* new NoFilesToCheckError();
     }
     const filesToCheckArray = fromIterable(filesToCheck);
-    const batches = chunksOf(filesToCheckArray, BATCH_SIZE);
+    const batches = chunksOf(filesToCheckArray, BATCH_SIZE2);
     let lastLanguageService;
     const disposeIfLanguageServiceChanged = (languageService) => {
       if (lastLanguageService !== languageService) {
@@ -35972,14 +36320,14 @@ var diagnostics2 = make58(
       }
     };
     for (const batch of batches) {
-      const { service: service3 } = (0, import_project_service.createProjectService)({ options: { loadTypeScriptPlugins: false } });
+      const { service: service3 } = (0, import_project_service2.createProjectService)({ options: { loadTypeScriptPlugins: false } });
       for (const filePath of batch) {
         service3.openClientFile(filePath);
         try {
           const scriptInfo = service3.getScriptInfo(filePath);
           if (!scriptInfo) continue;
-          const project4 = scriptInfo.getDefaultProject();
-          const languageService = project4.getLanguageService(true);
+          const project5 = scriptInfo.getDefaultProject();
+          const languageService = project5.getLanguageService(true);
           disposeIfLanguageServiceChanged(languageService);
           const program = languageService.getProgram();
           if (!program) continue;
@@ -36070,7 +36418,7 @@ var getPatchesForModule = fn("getPatchesForModule")(
     let insertCheckSourceFilePosition = none2();
     let insertSkipPrecedingCommentDirectivePosition = none2();
     let insertAppendMetadataRelationErrorPosition = none2();
-    const nodesToCheck = [];
+    let nodesToCheck = [];
     function findNodeAtPositionIncludingTrivia(sourceFile2, position) {
       function find3(node) {
         if (position >= node.pos && position < node.end) {
@@ -36098,7 +36446,7 @@ var getPatchesForModule = fn("getPatchesForModule")(
     if (!pushFunctionDeclarationNode("checkSourceFileWorker")) requiresFullScan = true;
     if (!pushFunctionDeclarationNode("markPrecedingCommentDirectiveLine")) requiresFullScan = true;
     if (!pushFunctionDeclarationNode("reportRelationError")) requiresFullScan = true;
-    if (requiresFullScan) nodesToCheck.push(sourceFile);
+    if (requiresFullScan) nodesToCheck = [sourceFile];
     while (nodesToCheck.length > 0) {
       const node = nodesToCheck.shift();
       if (!node) continue;
@@ -36328,7 +36676,7 @@ var cliCommand = make58(
   "effect-language-service",
   {},
   () => log3("Please select a command or run --help.")
-).pipe(withSubcommands3([patch9, unpatch, check2, diagnostics2]));
+).pipe(withSubcommands3([patch9, unpatch, check2, diagnostics2, codegen]));
 var main = run8(cliCommand, {
   name: "effect-language-service",
   version: "0.0.2"