@effect/language-service 0.65.0 → 0.67.0

package/cli.js

@@ -945,7 +945,7 @@ var require_createProjectService = __commonJS({
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.createProjectService = createProjectService5;
+    exports2.createProjectService = createProjectService6;
     var debug_1 = __importDefault(require_src());
     var getParsedConfigFileFromTSServer_js_1 = require_getParsedConfigFileFromTSServer();
     var DEFAULT_PROJECT_MATCHED_FILES_THRESHOLD = 8;
@@ -959,7 +959,7 @@ var require_createProjectService = __commonJS({
     var createStubFileWatcher = () => ({
       close: doNothing
     });
-    function createProjectService5({ jsDocParsingMode, options: optionsRaw = {}, tsconfigRootDir } = {}) {
+    function createProjectService6({ jsDocParsingMode, options: optionsRaw = {}, tsconfigRootDir } = {}) {
       const options3 = {
         defaultProject: "tsconfig.json",
         ...optionsRaw
@@ -30211,7 +30211,7 @@ var runMain3 = runMain2;
 // package.json
 var package_default = {
   name: "@effect/language-service",
-  version: "0.65.0",
+  version: "0.67.0",
   packageManager: "pnpm@8.11.0",
   publishConfig: {
     access: "public",
@@ -33315,6 +33315,97 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.effectFnGen",
     (node) => node
   );
+  const findEnclosingScopes = fn2("TypeParser.findEnclosingScopes")(function* (startNode) {
+    let currentParent = startNode.parent;
+    let scopeNode = void 0;
+    let effectGenResult = void 0;
+    while (currentParent) {
+      const nodeToCheck = currentParent;
+      if (!scopeNode) {
+        if (ts.isFunctionExpression(nodeToCheck) || ts.isFunctionDeclaration(nodeToCheck) || ts.isMethodDeclaration(nodeToCheck) || ts.isArrowFunction(nodeToCheck) || ts.isGetAccessorDeclaration(nodeToCheck) || ts.isSetAccessorDeclaration(nodeToCheck)) {
+          scopeNode = nodeToCheck;
+        }
+      }
+      if (!effectGenResult) {
+        const isEffectGen = yield* pipe(
+          effectGen(nodeToCheck),
+          map34((result) => ({
+            node: result.node,
+            effectModule: result.effectModule,
+            generatorFunction: result.generatorFunction,
+            body: result.body
+          })),
+          orElse15(
+            () => pipe(
+              effectFnUntracedGen(nodeToCheck),
+              map34((result) => ({
+                node: result.node,
+                effectModule: result.effectModule,
+                generatorFunction: result.generatorFunction,
+                body: result.body,
+                pipeArguments: result.pipeArguments
+              }))
+            )
+          ),
+          orElse15(
+            () => pipe(
+              effectFnGen(nodeToCheck),
+              map34((result) => ({
+                node: result.node,
+                effectModule: result.effectModule,
+                generatorFunction: result.generatorFunction,
+                body: result.body,
+                pipeArguments: result.pipeArguments
+              }))
+            )
+          ),
+          option5
+        );
+        if (isSome2(isEffectGen)) {
+          effectGenResult = isEffectGen.value;
+        }
+      }
+      if (scopeNode && effectGenResult) {
+        break;
+      }
+      currentParent = nodeToCheck.parent;
+    }
+    return { scopeNode, effectGen: effectGenResult };
+  });
+  const effectFn = cachedBy(
+    function(node) {
+      if (!ts.isCallExpression(node)) {
+        return typeParserIssue("Node is not a call expression", void 0, node);
+      }
+      if (node.arguments.length === 0) {
+        return typeParserIssue("Node has no arguments", void 0, node);
+      }
+      const regularFunction = node.arguments[0];
+      if (!ts.isFunctionExpression(regularFunction) && !ts.isArrowFunction(regularFunction)) {
+        return typeParserIssue("Node is not a function expression or arrow function", void 0, node);
+      }
+      if (ts.isFunctionExpression(regularFunction) && regularFunction.asteriskToken !== void 0) {
+        return typeParserIssue("Node is a generator function, not a regular function", void 0, node);
+      }
+      const expressionToTest = ts.isCallExpression(node.expression) ? node.expression.expression : node.expression;
+      if (!ts.isPropertyAccessExpression(expressionToTest)) {
+        return typeParserIssue("Node is not a property access expression", void 0, node);
+      }
+      const propertyAccess = expressionToTest;
+      const pipeArguments2 = node.arguments.slice(1);
+      return pipe(
+        isNodeReferenceToEffectModuleApi("fn")(propertyAccess),
+        map34(() => ({
+          node,
+          effectModule: propertyAccess.expression,
+          regularFunction,
+          pipeArguments: pipeArguments2
+        }))
+      );
+    },
+    "TypeParser.effectFn",
+    (node) => node
+  );
   const unnecessaryEffectGen2 = cachedBy(
     fn2("TypeParser.unnecessaryEffectGen")(function* (node) {
       const { body } = yield* effectGen(node);
@@ -33426,6 +33517,28 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     `TypeParser.isNodeReferenceToEffectSchemaModuleApi(${memberName})`,
     (node) => node
   );
+  const isEffectParseResultSourceFile = cachedBy(
+    fn2("TypeParser.isEffectParseResultSourceFile")(function* (sourceFile) {
+      const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
+      if (!moduleSymbol) return yield* typeParserIssue("Node has no symbol", void 0, sourceFile);
+      const parseIssueSymbol = typeChecker.tryGetMemberInModuleExports("ParseIssue", moduleSymbol);
+      if (!parseIssueSymbol) return yield* typeParserIssue("ParseIssue type not found", void 0, sourceFile);
+      const decodeSyncSymbol = typeChecker.tryGetMemberInModuleExports("decodeSync", moduleSymbol);
+      if (!decodeSyncSymbol) return yield* typeParserIssue("decodeSync not found", void 0, sourceFile);
+      const encodeSyncSymbol = typeChecker.tryGetMemberInModuleExports("encodeSync", moduleSymbol);
+      if (!encodeSyncSymbol) return yield* typeParserIssue("encodeSync not found", void 0, sourceFile);
+      return sourceFile;
+    }),
+    "TypeParser.isEffectParseResultSourceFile",
+    (sourceFile) => sourceFile
+  );
+  const isNodeReferenceToEffectParseResultModuleApi = (memberName) => cachedBy(
+    fn2("TypeParser.isNodeReferenceToEffectParseResultModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(node, "effect", isEffectParseResultSourceFile, memberName);
+    }),
+    `TypeParser.isNodeReferenceToEffectParseResultModuleApi(${memberName})`,
+    (node) => node
+  );
   const contextTagVarianceStruct = (type2, atLocation) => map34(
     all9(
       varianceStructInvariantType(type2, atLocation, "_Identifier"),
@@ -34206,11 +34319,65 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
           if (includeEffectFn) {
             const effectFnGenParsed = yield* pipe(effectFnGen(node), option5);
             const effectFnUntracedGenParsed = isNone2(effectFnGenParsed) ? yield* pipe(effectFnUntracedGen(node), option5) : none2();
-            const isEffectFn = isSome2(effectFnGenParsed);
-            const effectFnParsed = isEffectFn ? effectFnGenParsed : effectFnUntracedGenParsed;
-            const transformationKind = isEffectFn ? "effectFn" : "effectFnUntraced";
-            if (isSome2(effectFnParsed) && effectFnParsed.value.pipeArguments.length > 0) {
-              const fnResult = effectFnParsed.value;
+            const effectFnNonGenParsed = isNone2(effectFnGenParsed) && isNone2(effectFnUntracedGenParsed) ? yield* pipe(effectFn(node), option5) : none2();
+            const isEffectFnGen = isSome2(effectFnGenParsed);
+            const isEffectFnUntracedGen = isSome2(effectFnUntracedGenParsed);
+            const isEffectFnNonGen = isSome2(effectFnNonGenParsed);
+            const transformationKind = isEffectFnUntracedGen ? "effectFnUntraced" : "effectFn";
+            if (isEffectFnGen || isEffectFnUntracedGen) {
+              const effectFnParsed = isEffectFnGen ? effectFnGenParsed : effectFnUntracedGenParsed;
+              if (isSome2(effectFnParsed) && effectFnParsed.value.pipeArguments.length > 0) {
+                const fnResult = effectFnParsed.value;
+                const pipeArgs = fnResult.pipeArguments;
+                const transformations = [];
+                let subjectType;
+                for (let i = 0; i < pipeArgs.length; i++) {
+                  const arg = pipeArgs[i];
+                  const contextualType = typeChecker.getContextualType(arg);
+                  const callSigs = contextualType ? typeChecker.getSignaturesOfType(contextualType, ts.SignatureKind.Call) : [];
+                  const outType = callSigs.length > 0 ? typeChecker.getReturnTypeOfSignature(callSigs[0]) : void 0;
+                  if (i === 0 && callSigs.length > 0) {
+                    const params = callSigs[0].parameters;
+                    if (params.length > 0) {
+                      subjectType = typeChecker.getTypeOfSymbol(params[0]);
+                    }
+                  }
+                  if (ts.isCallExpression(arg)) {
+                    transformations.push({
+                      callee: arg.expression,
+                      args: Array.from(arg.arguments),
+                      outType,
+                      kind: transformationKind
+                    });
+                  } else {
+                    transformations.push({
+                      callee: arg,
+                      args: void 0,
+                      outType,
+                      kind: transformationKind
+                    });
+                  }
+                }
+                const newFlow = {
+                  node,
+                  subject: {
+                    node,
+                    outType: subjectType
+                  },
+                  transformations
+                };
+                result.push(newFlow);
+                workQueue.push([fnResult.body, void 0]);
+                for (const arg of pipeArgs) {
+                  ts.forEachChild(arg, (c) => {
+                    workQueue.push([c, void 0]);
+                  });
+                }
+                continue;
+              }
+            }
+            if (isEffectFnNonGen && isSome2(effectFnNonGenParsed) && effectFnNonGenParsed.value.pipeArguments.length > 0) {
+              const fnResult = effectFnNonGenParsed.value;
               const pipeArgs = fnResult.pipeArguments;
               const transformations = [];
               let subjectType;
@@ -34230,14 +34397,14 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                     callee: arg.expression,
                     args: Array.from(arg.arguments),
                     outType,
-                    kind: transformationKind
+                    kind: "effectFn"
                   });
                 } else {
                   transformations.push({
                     callee: arg,
                     args: void 0,
                     outType,
-                    kind: transformationKind
+                    kind: "effectFn"
                   });
                 }
               }
@@ -34250,7 +34417,16 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
                 transformations
               };
               result.push(newFlow);
-              workQueue.push([fnResult.body, void 0]);
+              const regularFn = fnResult.regularFunction;
+              if (ts.isArrowFunction(regularFn)) {
+                if (ts.isBlock(regularFn.body)) {
+                  workQueue.push([regularFn.body, void 0]);
+                } else {
+                  workQueue.push([regularFn.body, void 0]);
+                }
+              } else if (regularFn.body) {
+                workQueue.push([regularFn.body, void 0]);
+              }
               for (const arg of pipeArgs) {
                 ts.forEachChild(arg, (c) => {
                   workQueue.push([c, void 0]);
@@ -34313,6 +34489,7 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   return {
     isNodeReferenceToEffectModuleApi,
     isNodeReferenceToEffectSchemaModuleApi,
+    isNodeReferenceToEffectParseResultModuleApi,
     isNodeReferenceToEffectDataModuleApi,
     isNodeReferenceToEffectContextModuleApi,
     isNodeReferenceToEffectSqlModelModuleApi,
@@ -34326,6 +34503,8 @@ function make64(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     effectGen,
     effectFnUntracedGen,
     effectFnGen,
+    findEnclosingScopes,
+    effectFn,
     extendsCauseYieldableError,
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
@@ -36085,106 +36264,195 @@ ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageNam
 });
 
 // src/diagnostics/effectFnOpportunity.ts
-var parseEffectFnOpportunityTarget = (node, sourceFile) => gen3(function* () {
-  const ts = yield* service2(TypeScriptApi);
-  const typeChecker = yield* service2(TypeCheckerApi);
-  const typeParser = yield* service2(TypeParser);
-  const tsUtils = yield* service2(TypeScriptUtils);
-  if (!ts.isFunctionExpression(node) && !ts.isArrowFunction(node) && !ts.isFunctionDeclaration(node)) {
-    return yield* TypeParserIssue.issue;
-  }
-  if ((ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) && node.asteriskToken) {
-    return yield* TypeParserIssue.issue;
-  }
-  if (ts.isFunctionExpression(node) && node.name) {
-    return yield* TypeParserIssue.issue;
-  }
-  let bodyExpression;
-  if (ts.isArrowFunction(node)) {
-    if (ts.isBlock(node.body)) {
-      const returnStatement = findSingleReturnStatement(ts, node.body);
-      if (returnStatement?.expression) {
-        bodyExpression = returnStatement.expression;
-      }
-    } else {
-      bodyExpression = node.body;
-    }
-  } else if ((ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) && node.body) {
-    const returnStatement = findSingleReturnStatement(ts, node.body);
-    if (returnStatement?.expression) {
-      bodyExpression = returnStatement.expression;
-    }
-  }
-  if (!bodyExpression) return yield* TypeParserIssue.issue;
-  const { pipeArguments: pipeArguments2, subject } = yield* pipe(
-    typeParser.pipeCall(bodyExpression),
-    map34(({ args: args3, subject: subject2 }) => ({ subject: subject2, pipeArguments: args3 })),
-    orElse15(() => succeed17({ subject: bodyExpression, pipeArguments: [] }))
-  );
-  const { effectModule, generatorFunction } = yield* typeParser.effectGen(subject);
-  const functionType = typeChecker.getTypeAtLocation(node);
-  if (!functionType) return yield* TypeParserIssue.issue;
-  const callSignatures = typeChecker.getSignaturesOfType(functionType, ts.SignatureKind.Call);
-  if (callSignatures.length !== 1) return yield* TypeParserIssue.issue;
-  const signature = callSignatures[0];
-  const returnType = typeChecker.getReturnTypeOfSignature(signature);
-  const { A, E, R } = yield* typeParser.strictEffectType(returnType, node);
-  const effectModuleName = ts.isIdentifier(effectModule) ? ts.idText(effectModule) : tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
-    sourceFile,
-    "effect",
-    "Effect"
-  ) || "Effect";
-  const nameIdentifier = getNameIdentifier(ts, node);
-  const traceName = nameIdentifier ? ts.isIdentifier(nameIdentifier) ? ts.idText(nameIdentifier) : nameIdentifier.text : void 0;
-  const hasReturnTypeAnnotation = !!node.type;
-  return {
-    node,
-    nameIdentifier,
-    effectModule,
-    generatorFunction,
-    effectModuleName,
-    traceName,
-    hasReturnTypeAnnotation,
-    effectTypes: { A, E, R },
-    pipeArguments: pipeArguments2
-  };
-});
 var effectFnOpportunity = createDiagnostic({
   name: "effectFnOpportunity",
   code: 41,
-  description: "Suggests using Effect.fn for functions that return Effect.gen",
+  description: "Suggests using Effect.fn for functions that returns an Effect",
   severity: "suggestion",
   apply: fn2("effectFnOpportunity.apply")(function* (sourceFile, report) {
     const ts = yield* service2(TypeScriptApi);
     const typeChecker = yield* service2(TypeCheckerApi);
+    const typeCheckerUtils = yield* service2(TypeCheckerUtils);
+    const typeParser = yield* service2(TypeParser);
     const tsUtils = yield* service2(TypeScriptUtils);
-    const createReturnTypeAnnotation = (effectModuleName, effectTypes, enclosingNode) => {
-      const { A, E, R } = effectTypes;
-      const aTypeNode = typeChecker.typeToTypeNode(A, enclosingNode, ts.NodeBuilderFlags.NoTruncation);
-      const eTypeNode = typeChecker.typeToTypeNode(E, enclosingNode, ts.NodeBuilderFlags.NoTruncation);
-      const rTypeNode = typeChecker.typeToTypeNode(R, enclosingNode, ts.NodeBuilderFlags.NoTruncation);
-      if (!aTypeNode || !eTypeNode || !rTypeNode) return void 0;
-      return ts.factory.createTypeReferenceNode(
-        ts.factory.createQualifiedName(
-          ts.factory.createQualifiedName(
-            ts.factory.createIdentifier(effectModuleName),
-            "fn"
-          ),
-          "Return"
-        ),
-        [aTypeNode, eTypeNode, rTypeNode]
+    const sourceEffectModuleName = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+      sourceFile,
+      "effect",
+      "Effect"
+    ) || "Effect";
+    const findSingleReturnStatement = (block) => {
+      if (block.statements.length !== 1) return void 0;
+      const statement = block.statements[0];
+      if (!ts.isReturnStatement(statement)) return void 0;
+      return statement;
+    };
+    const getBodyExpression = (fnNode) => {
+      if (ts.isArrowFunction(fnNode)) {
+        if (ts.isBlock(fnNode.body)) {
+          return findSingleReturnStatement(fnNode.body)?.expression;
+        }
+        return fnNode.body;
+      } else if ((ts.isFunctionExpression(fnNode) || ts.isFunctionDeclaration(fnNode)) && fnNode.body) {
+        return findSingleReturnStatement(fnNode.body)?.expression;
+      }
+      return void 0;
+    };
+    const getNameIdentifier = (node) => {
+      if (ts.isFunctionDeclaration(node) && node.name) {
+        return node.name;
+      }
+      if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+        return node.parent.name;
+      }
+      if (node.parent && ts.isPropertyAssignment(node.parent)) {
+        const name = node.parent.name;
+        if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
+          return name;
+        }
+      }
+      if (node.parent && ts.isPropertyDeclaration(node.parent)) {
+        const name = node.parent.name;
+        if (ts.isIdentifier(name)) {
+          return name;
+        }
+      }
+      return void 0;
+    };
+    const areParametersReferencedIn = (fnNode, nodes2) => {
+      if (fnNode.parameters.length === 0 || nodes2.length === 0) return false;
+      const firstParam = fnNode.parameters[0];
+      const lastParam = fnNode.parameters[fnNode.parameters.length - 1];
+      const paramsStart = firstParam.pos;
+      const paramsEnd = lastParam.end;
+      const isSymbolDeclaredInParams = (symbol3) => {
+        const declarations = symbol3.declarations;
+        if (!declarations) return false;
+        return declarations.some((decl) => decl.pos >= paramsStart && decl.end <= paramsEnd);
+      };
+      const nodesToVisit = [...nodes2];
+      while (nodesToVisit.length > 0) {
+        const node = nodesToVisit.shift();
+        if (ts.isIdentifier(node)) {
+          const symbol3 = typeChecker.getSymbolAtLocation(node);
+          if (symbol3 && isSymbolDeclaredInParams(symbol3)) {
+            return true;
+          }
+        }
+        if (ts.isShorthandPropertyAssignment(node)) {
+          const valueSymbol = typeChecker.getShorthandAssignmentValueSymbol(node);
+          if (valueSymbol && isSymbolDeclaredInParams(valueSymbol)) {
+            return true;
+          }
+        }
+        ts.forEachChild(node, (child) => {
+          nodesToVisit.push(child);
+          return void 0;
+        });
+      }
+      return false;
+    };
+    const tryParseGenOpportunity = (fnNode) => gen3(function* () {
+      const bodyExpression = getBodyExpression(fnNode);
+      if (!bodyExpression) return yield* TypeParserIssue.issue;
+      const { pipeArguments: pipeArguments2, subject } = yield* pipe(
+        typeParser.pipeCall(bodyExpression),
+        map34(({ args: args3, subject: subject2 }) => ({ subject: subject2, pipeArguments: args3 })),
+        orElse15(() => succeed17({ subject: bodyExpression, pipeArguments: [] }))
+      );
+      const { effectModule, generatorFunction } = yield* typeParser.effectGen(subject);
+      const effectModuleName = ts.isIdentifier(effectModule) ? ts.idText(effectModule) : sourceEffectModuleName;
+      return { effectModuleName, generatorFunction, pipeArguments: pipeArguments2 };
+    });
+    const isInsideEffectFn = (fnNode) => {
+      const parent = fnNode.parent;
+      if (!parent || !ts.isCallExpression(parent)) {
+        return succeed17(false);
+      }
+      if (parent.arguments[0] !== fnNode) {
+        return succeed17(false);
+      }
+      return pipe(
+        typeParser.effectFn(parent),
+        orElse15(() => typeParser.effectFnGen(parent)),
+        orElse15(() => typeParser.effectFnUntracedGen(parent)),
+        map34(() => true),
+        orElse15(() => succeed17(false))
       );
     };
-    const createEffectFnNode = (originalNode, generatorFunction, effectModuleName, traceName, effectTypes, pipeArguments2) => {
-      const returnTypeAnnotation = effectTypes ? createReturnTypeAnnotation(effectModuleName, effectTypes, originalNode) : void 0;
-      const newGeneratorFunction = ts.factory.createFunctionExpression(
+    const parseEffectFnOpportunityTarget = (node) => gen3(function* () {
+      if (!ts.isFunctionExpression(node) && !ts.isArrowFunction(node) && !ts.isFunctionDeclaration(node)) {
+        return yield* TypeParserIssue.issue;
+      }
+      if ((ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) && node.asteriskToken) {
+        return yield* TypeParserIssue.issue;
+      }
+      if (ts.isFunctionExpression(node) && node.name) {
+        return yield* TypeParserIssue.issue;
+      }
+      if (yield* isInsideEffectFn(node)) {
+        return yield* TypeParserIssue.issue;
+      }
+      const functionType = typeChecker.getTypeAtLocation(node);
+      if (!functionType) return yield* TypeParserIssue.issue;
+      const callSignatures = typeChecker.getSignaturesOfType(functionType, ts.SignatureKind.Call);
+      if (callSignatures.length !== 1) return yield* TypeParserIssue.issue;
+      const signature = callSignatures[0];
+      const returnType = typeChecker.getReturnTypeOfSignature(signature);
+      const unionMembers = typeCheckerUtils.unrollUnionMembers(returnType);
+      yield* all9(...unionMembers.map((member) => typeParser.strictEffectType(member, node)));
+      const nameIdentifier = getNameIdentifier(node);
+      const traceName = nameIdentifier ? ts.isIdentifier(nameIdentifier) ? ts.idText(nameIdentifier) : nameIdentifier.text : void 0;
+      if (!traceName) return yield* TypeParserIssue.issue;
+      const opportunity = yield* pipe(
+        tryParseGenOpportunity(node),
+        orElse15(() => {
+          if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+            return TypeParserIssue.issue;
+          }
+          const body = ts.isArrowFunction(node) ? node.body : node.body;
+          if (!body || !ts.isBlock(body) || body.statements.length <= 5) {
+            return TypeParserIssue.issue;
+          }
+          return succeed17({
+            effectModuleName: sourceEffectModuleName,
+            pipeArguments: [],
+            generatorFunction: void 0
+          });
+        })
+      );
+      return {
+        node,
+        nameIdentifier,
+        effectModuleName: opportunity.effectModuleName,
+        traceName,
+        pipeArguments: opportunity.pipeArguments,
+        generatorFunction: opportunity.generatorFunction,
+        hasParamsInPipeArgs: areParametersReferencedIn(node, opportunity.pipeArguments)
+      };
+    });
+    const getFunctionBodyBlock = (node) => {
+      if (ts.isArrowFunction(node)) {
+        if (ts.isBlock(node.body)) {
+          return node.body;
+        }
+        return ts.factory.createBlock([ts.factory.createReturnStatement(node.body)], true);
+      }
+      return node.body;
+    };
+    const isGeneratorFunction2 = (node) => {
+      if (ts.isArrowFunction(node)) return false;
+      return node.asteriskToken !== void 0;
+    };
+    const createEffectFnNode = (originalNode, innerFunction, effectModuleName, traceName, pipeArguments2) => {
+      const isGenerator = isGeneratorFunction2(innerFunction);
+      const newFunction = ts.factory.createFunctionExpression(
         void 0,
-        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+        isGenerator ? ts.factory.createToken(ts.SyntaxKind.AsteriskToken) : void 0,
         void 0,
         originalNode.typeParameters,
         originalNode.parameters,
-        returnTypeAnnotation,
-        generatorFunction.body
+        void 0,
+        getFunctionBodyBlock(innerFunction)
       );
       let fnExpression = ts.factory.createPropertyAccessExpression(
         ts.factory.createIdentifier(effectModuleName),
@@ -36197,34 +36465,27 @@ var effectFnOpportunity = createDiagnostic({
           [ts.factory.createStringLiteral(traceName)]
         );
       }
-      const effectFnCall = ts.factory.createCallExpression(
-        fnExpression,
-        void 0,
-        [newGeneratorFunction, ...pipeArguments2]
-      );
+      const effectFnCall = ts.factory.createCallExpression(fnExpression, void 0, [newFunction, ...pipeArguments2]);
       if (ts.isFunctionDeclaration(originalNode)) {
         return tsUtils.tryPreserveDeclarationSemantics(originalNode, effectFnCall, false);
       }
       return effectFnCall;
     };
-    const createEffectFnUntracedNode = (originalNode, generatorFunction, effectModuleName, effectTypes, pipeArguments2) => {
-      const returnTypeAnnotation = effectTypes ? createReturnTypeAnnotation(effectModuleName, effectTypes, originalNode) : void 0;
-      const newGeneratorFunction = ts.factory.createFunctionExpression(
+    const createEffectFnUntracedNode = (originalNode, innerFunction, effectModuleName, pipeArguments2) => {
+      const isGenerator = isGeneratorFunction2(innerFunction);
+      const newFunction = ts.factory.createFunctionExpression(
         void 0,
-        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+        isGenerator ? ts.factory.createToken(ts.SyntaxKind.AsteriskToken) : void 0,
         void 0,
         originalNode.typeParameters,
         originalNode.parameters,
-        returnTypeAnnotation,
-        generatorFunction.body
+        void 0,
+        getFunctionBodyBlock(innerFunction)
       );
       const effectFnCall = ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(
-          ts.factory.createIdentifier(effectModuleName),
-          "fnUntraced"
-        ),
+        ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(effectModuleName), "fnUntraced"),
         void 0,
-        [newGeneratorFunction, ...pipeArguments2]
+        [newFunction, ...pipeArguments2]
       );
       if (ts.isFunctionDeclaration(originalNode)) {
         return tsUtils.tryPreserveDeclarationSemantics(originalNode, effectFnCall, false);
@@ -36240,88 +36501,41 @@ var effectFnOpportunity = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
-      const target = yield* pipe(
-        parseEffectFnOpportunityTarget(node, sourceFile),
-        option5
-      );
+      const target = yield* pipe(parseEffectFnOpportunityTarget(node), option5);
       if (isNone2(target)) continue;
-      const {
-        effectModuleName,
-        effectTypes,
-        generatorFunction,
-        hasReturnTypeAnnotation,
-        nameIdentifier,
-        node: targetNode,
-        pipeArguments: pipeArguments2,
-        traceName
-      } = target.value;
+      if (target.value.hasParamsInPipeArgs) continue;
+      const { effectModuleName, nameIdentifier, node: targetNode, pipeArguments: pipeArguments2, traceName } = target.value;
+      const innerFunction = target.value.generatorFunction ?? targetNode;
       const fixes = [];
       fixes.push({
         fixName: "effectFnOpportunity_toEffectFn",
         description: traceName ? `Convert to Effect.fn("${traceName}")` : "Convert to Effect.fn",
         apply: gen3(function* () {
           const changeTracker = yield* service2(ChangeTracker);
-          const newNode = createEffectFnNode(
-            targetNode,
-            generatorFunction,
-            effectModuleName,
-            traceName,
-            hasReturnTypeAnnotation ? effectTypes : void 0,
-            pipeArguments2
-          );
-          changeTracker.replaceNode(sourceFile, targetNode, newNode);
-        })
-      });
-      fixes.push({
-        fixName: "effectFnOpportunity_toEffectFnUntraced",
-        description: "Convert to Effect.fnUntraced",
-        apply: gen3(function* () {
-          const changeTracker = yield* service2(ChangeTracker);
-          const newNode = createEffectFnUntracedNode(
-            targetNode,
-            generatorFunction,
-            effectModuleName,
-            hasReturnTypeAnnotation ? effectTypes : void 0,
-            pipeArguments2
-          );
+          const newNode = createEffectFnNode(targetNode, innerFunction, effectModuleName, traceName, pipeArguments2);
           changeTracker.replaceNode(sourceFile, targetNode, newNode);
         })
       });
+      if (target.value.generatorFunction) {
+        fixes.push({
+          fixName: "effectFnOpportunity_toEffectFnUntraced",
+          description: "Convert to Effect.fnUntraced",
+          apply: gen3(function* () {
+            const changeTracker = yield* service2(ChangeTracker);
+            const newNode = createEffectFnUntracedNode(targetNode, innerFunction, effectModuleName, pipeArguments2);
+            changeTracker.replaceNode(sourceFile, targetNode, newNode);
+          })
+        });
+      }
+      const pipeArgsSuffix = pipeArguments2.length > 0 ? ` Effect.fn also accepts the piped transformations as additional arguments.` : ``;
       report({
         location: nameIdentifier ?? targetNode,
-        messageText: `This function could benefit from Effect.fn's automatic tracing and concise syntax, or Effect.fnUntraced to get just a more concise syntax.`,
+        messageText: target.value.generatorFunction ? `This function could benefit from Effect.fn's automatic tracing and concise syntax, or Effect.fnUntraced to get just a more concise syntax.${pipeArgsSuffix}` : `This function could benefit from Effect.fn's automatic tracing and concise syntax.${pipeArgsSuffix}`,
         fixes
       });
     }
   })
 });
-function findSingleReturnStatement(ts, block) {
-  if (block.statements.length !== 1) return void 0;
-  const statement = block.statements[0];
-  if (!ts.isReturnStatement(statement)) return void 0;
-  return statement;
-}
-function getNameIdentifier(ts, node) {
-  if (ts.isFunctionDeclaration(node) && node.name) {
-    return node.name;
-  }
-  if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
-    return node.parent.name;
-  }
-  if (node.parent && ts.isPropertyAssignment(node.parent)) {
-    const name = node.parent.name;
-    if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
-      return name;
-    }
-  }
-  if (node.parent && ts.isPropertyDeclaration(node.parent)) {
-    const name = node.parent.name;
-    if (ts.isIdentifier(name)) {
-      return name;
-    }
-  }
-  return void 0;
-}
 
 // src/diagnostics/effectGenUsesAdapter.ts
 var effectGenUsesAdapter = createDiagnostic({
@@ -37084,6 +37298,52 @@ var missedPipeableOpportunity = createDiagnostic({
     const typeChecker = yield* service2(TypeCheckerApi);
     const typeParser = yield* service2(TypeParser);
     const options3 = yield* service2(LanguageServicePluginOptions);
+    const isSafelyPipeableCallee = (callee) => {
+      if (ts.isCallExpression(callee)) {
+        return true;
+      }
+      if (ts.isArrowFunction(callee)) {
+        return true;
+      }
+      if (ts.isFunctionExpression(callee)) {
+        return true;
+      }
+      if (ts.isParenthesizedExpression(callee)) {
+        return isSafelyPipeableCallee(callee.expression);
+      }
+      if (ts.isIdentifier(callee)) {
+        const symbol3 = typeChecker.getSymbolAtLocation(callee);
+        if (!symbol3) return false;
+        if (symbol3.flags & (ts.SymbolFlags.Module | ts.SymbolFlags.Namespace | ts.SymbolFlags.ValueModule)) {
+          return true;
+        }
+        const declarations = symbol3.declarations;
+        if (declarations && declarations.length > 0) {
+          const decl = declarations[0];
+          if (ts.isFunctionDeclaration(decl) || ts.isVariableDeclaration(decl) || ts.isImportSpecifier(decl) || ts.isImportClause(decl) || ts.isNamespaceImport(decl)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      if (ts.isPropertyAccessExpression(callee)) {
+        const subject = callee.expression;
+        const symbol3 = typeChecker.getSymbolAtLocation(subject);
+        if (!symbol3) return false;
+        if (symbol3.flags & (ts.SymbolFlags.Module | ts.SymbolFlags.Namespace | ts.SymbolFlags.ValueModule)) {
+          return true;
+        }
+        const declarations = symbol3.declarations;
+        if (declarations && declarations.length > 0) {
+          const decl = declarations[0];
+          if (ts.isNamespaceImport(decl) || ts.isSourceFile(decl) || ts.isModuleDeclaration(decl)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      return false;
+    };
     const flows = yield* typeParser.pipingFlows(false)(sourceFile);
     for (const flow2 of flows) {
       if (flow2.transformations.length < options3.pipeableMinArgCount) {
@@ -37097,76 +37357,92 @@ var missedPipeableOpportunity = createDiagnostic({
       if (callSigs.length > 0) {
         continue;
       }
-      let firstPipeableIndex = -1;
-      const subjectType = flow2.subject.outType;
-      if (!subjectType) {
-        continue;
-      }
-      const subjectIsPipeable = yield* pipe(
-        typeParser.pipeableType(subjectType, flow2.subject.node),
-        option5
-      );
-      if (subjectIsPipeable._tag === "Some") {
-        firstPipeableIndex = 0;
-      } else {
-        for (let i = 0; i < flow2.transformations.length; i++) {
-          const t = flow2.transformations[i];
-          if (t.outType) {
-            const isPipeable = yield* pipe(
-              typeParser.pipeableType(t.outType, flow2.node),
-              option5
-            );
-            if (isPipeable._tag === "Some") {
-              firstPipeableIndex = i + 1;
-              break;
-            }
+      const isPipeableAtIndex = function* (index) {
+        if (index === 0) {
+          const subjectType = flow2.subject.outType;
+          if (!subjectType) return false;
+          const result = yield* pipe(
+            typeParser.pipeableType(subjectType, flow2.subject.node),
+            option5
+          );
+          return result._tag === "Some";
+        } else {
+          const t = flow2.transformations[index - 1];
+          if (!t.outType) return false;
+          const result = yield* pipe(
+            typeParser.pipeableType(t.outType, flow2.node),
+            option5
+          );
+          return result._tag === "Some";
+        }
+      };
+      let searchStartIndex = 0;
+      while (searchStartIndex <= flow2.transformations.length) {
+        let firstPipeableIndex = -1;
+        for (let i = searchStartIndex; i <= flow2.transformations.length; i++) {
+          if (yield* isPipeableAtIndex(i)) {
+            firstPipeableIndex = i;
+            break;
           }
         }
-      }
-      if (firstPipeableIndex === -1) {
-        continue;
-      }
-      const transformationsAfterPipeable = flow2.transformations.slice(firstPipeableIndex);
-      const callKindCount = transformationsAfterPipeable.filter((t) => t.kind === "call").length;
-      if (callKindCount < options3.pipeableMinArgCount) {
-        continue;
-      }
-      const pipeableSubjectNode = firstPipeableIndex === 0 ? flow2.subject.node : typeParser.reconstructPipingFlow({
-        subject: flow2.subject,
-        transformations: flow2.transformations.slice(0, firstPipeableIndex)
-      });
-      const pipeableTransformations = flow2.transformations.slice(firstPipeableIndex);
-      report({
-        location: flow2.node,
-        messageText: `Nested function calls can be converted to pipeable style for better readability.`,
-        fixes: [{
-          fixName: "missedPipeableOpportunity_fix",
-          description: "Convert to pipe style",
-          apply: gen3(function* () {
-            const changeTracker = yield* service2(ChangeTracker);
-            const pipeArgs = pipeableTransformations.map((t) => {
-              if (t.args) {
-                return ts.factory.createCallExpression(
-                  t.callee,
+        if (firstPipeableIndex === -1) {
+          break;
+        }
+        const pipeableTransformations = [];
+        for (let i = firstPipeableIndex; i < flow2.transformations.length; i++) {
+          const t = flow2.transformations[i];
+          if (!isSafelyPipeableCallee(t.callee)) {
+            break;
+          }
+          pipeableTransformations.push(t);
+        }
+        const callKindCount = pipeableTransformations.filter((t) => t.kind === "call").length;
+        if (callKindCount >= options3.pipeableMinArgCount) {
+          const pipeableEndIndex = firstPipeableIndex + pipeableTransformations.length;
+          const pipeableSubjectNode = firstPipeableIndex === 0 ? flow2.subject.node : typeParser.reconstructPipingFlow({
+            subject: flow2.subject,
+            transformations: flow2.transformations.slice(0, firstPipeableIndex)
+          });
+          const afterTransformations = flow2.transformations.slice(pipeableEndIndex);
+          report({
+            location: flow2.node,
+            messageText: `Nested function calls can be converted to pipeable style for better readability.`,
+            fixes: [{
+              fixName: "missedPipeableOpportunity_fix",
+              description: "Convert to pipe style",
+              apply: gen3(function* () {
+                const changeTracker = yield* service2(ChangeTracker);
+                const pipeArgs = pipeableTransformations.map((t) => {
+                  if (t.args) {
+                    return ts.factory.createCallExpression(
+                      t.callee,
+                      void 0,
+                      t.args
+                    );
+                  } else {
+                    return t.callee;
+                  }
+                });
+                const pipeNode = ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    pipeableSubjectNode,
+                    "pipe"
+                  ),
                   void 0,
-                  t.args
+                  pipeArgs
                 );
-              } else {
-                return t.callee;
-              }
-            });
-            const newNode = ts.factory.createCallExpression(
-              ts.factory.createPropertyAccessExpression(
-                pipeableSubjectNode,
-                "pipe"
-              ),
-              void 0,
-              pipeArgs
-            );
-            changeTracker.replaceNode(sourceFile, flow2.node, newNode);
-          })
-        }]
-      });
+                const newNode = afterTransformations.length > 0 ? typeParser.reconstructPipingFlow({
+                  subject: { node: pipeNode, outType: void 0 },
+                  transformations: afterTransformations
+                }) : pipeNode;
+                changeTracker.replaceNode(sourceFile, flow2.node, newNode);
+              })
+            }]
+          });
+          break;
+        }
+        searchStartIndex = firstPipeableIndex + pipeableTransformations.length + 1;
+      }
     }
   })
 });
@@ -38012,6 +38288,90 @@ var overriddenSchemaConstructor = createDiagnostic({
   })
 });
 
+// src/diagnostics/preferSchemaOverJson.ts
+var preferSchemaOverJson = createDiagnostic({
+  name: "preferSchemaOverJson",
+  code: 44,
+  description: "Suggests using Effect Schema for JSON operations instead of JSON.parse/JSON.stringify which may throw",
+  severity: "suggestion",
+  apply: fn2("preferSchemaOverJson.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(TypeParser);
+    const parseJsonMethod = (node) => gen3(function* () {
+      if (!ts.isCallExpression(node)) return yield* fail18("node is not a call expression");
+      const expression = node.expression;
+      if (!ts.isPropertyAccessExpression(expression)) return yield* fail18("expression is not a property access");
+      const objectExpr = expression.expression;
+      const methodName = ts.idText(expression.name);
+      if (!ts.isIdentifier(objectExpr) || ts.idText(objectExpr) !== "JSON") {
+        return yield* fail18("object is not JSON");
+      }
+      if (methodName !== "parse" && methodName !== "stringify") {
+        return yield* fail18("method is not parse or stringify");
+      }
+      return { node, methodName };
+    });
+    const effectTrySimple = (node) => gen3(function* () {
+      if (!ts.isCallExpression(node)) return yield* fail18("node is not a call expression");
+      yield* typeParser.isNodeReferenceToEffectModuleApi("try")(node.expression);
+      if (node.arguments.length === 0) return yield* fail18("Effect.try has no arguments");
+      const lazyFn = yield* typeParser.lazyExpression(node.arguments[0]);
+      const jsonMethod = yield* parseJsonMethod(lazyFn.expression);
+      return { node: jsonMethod.node, methodName: jsonMethod.methodName };
+    });
+    const effectTryObject = (node) => gen3(function* () {
+      if (!ts.isCallExpression(node)) return yield* fail18("node is not a call expression");
+      yield* typeParser.isNodeReferenceToEffectModuleApi("try")(node.expression);
+      if (node.arguments.length === 0) return yield* fail18("Effect.try has no arguments");
+      const arg = node.arguments[0];
+      if (!ts.isObjectLiteralExpression(arg)) return yield* fail18("argument is not an object literal");
+      const tryProp = arg.properties.find(
+        (p3) => ts.isPropertyAssignment(p3) && ts.isIdentifier(p3.name) && ts.idText(p3.name) === "try"
+      );
+      if (!tryProp) return yield* fail18("object has no 'try' property");
+      const lazyFn = yield* typeParser.lazyExpression(tryProp.initializer);
+      const jsonMethod = yield* parseJsonMethod(lazyFn.expression);
+      return { node: jsonMethod.node, methodName: jsonMethod.methodName };
+    });
+    const jsonMethodInEffectGen = (node) => gen3(function* () {
+      const jsonMethod = yield* parseJsonMethod(node);
+      const { effectGen, scopeNode } = yield* typeParser.findEnclosingScopes(node);
+      if (!effectGen || effectGen.body.statements.length === 0) {
+        return yield* fail18("not inside an Effect generator");
+      }
+      if (scopeNode && scopeNode !== effectGen.generatorFunction) {
+        return yield* fail18("inside a nested function scope");
+      }
+      return { node: jsonMethod.node, methodName: jsonMethod.methodName };
+    });
+    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);
+      const match18 = yield* pipe(
+        firstSuccessOf2([
+          effectTrySimple(node),
+          effectTryObject(node),
+          jsonMethodInEffectGen(node)
+        ]),
+        option5
+      );
+      if (isSome2(match18)) {
+        report({
+          location: match18.value.node,
+          messageText: "Consider using Effect Schema for JSON operations instead of JSON.parse/JSON.stringify",
+          fixes: []
+        });
+      }
+    }
+  })
+});
+
 // src/diagnostics/redundantSchemaTagIdentifier.ts
 var redundantSchemaTagIdentifier = createDiagnostic({
   name: "redundantSchemaTagIdentifier",
@@ -38164,108 +38524,91 @@ var runEffectInsideEffect = createDiagnostic({
         option5
       );
       if (isNone2(isEffectRunCall)) continue;
-      let currentParent = node.parent;
-      let nodeIntroduceScope = void 0;
-      while (currentParent) {
-        const possiblyEffectGen = currentParent;
-        if (!nodeIntroduceScope) {
-          if (ts.isFunctionExpression(possiblyEffectGen) || ts.isFunctionDeclaration(possiblyEffectGen) || ts.isMethodDeclaration(possiblyEffectGen) || ts.isArrowFunction(possiblyEffectGen)) {
-            nodeIntroduceScope = possiblyEffectGen;
-            continue;
-          }
-        }
-        const isInEffectGen = yield* pipe(
-          typeParser.effectGen(possiblyEffectGen),
-          orElse15(() => typeParser.effectFnUntracedGen(possiblyEffectGen)),
-          orElse15(() => typeParser.effectFnGen(possiblyEffectGen)),
-          option5
+      const { effectGen, scopeNode } = yield* typeParser.findEnclosingScopes(node);
+      if (effectGen && effectGen.body.statements.length > 0) {
+        const nodeText = sourceFile.text.substring(
+          ts.getTokenPosOfNode(node.expression, sourceFile),
+          node.expression.end
         );
-        if (isSome2(isInEffectGen) && isInEffectGen.value.body.statements.length > 0) {
-          const nodeText = sourceFile.text.substring(
-            ts.getTokenPosOfNode(node.expression, sourceFile),
-            node.expression.end
-          );
-          if (nodeIntroduceScope && nodeIntroduceScope !== isInEffectGen.value.generatorFunction) {
-            const fixAddRuntime = gen3(function* () {
-              const changeTracker = yield* service2(ChangeTracker);
-              const runtimeModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Runtime") || "Runtime";
-              const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Effect") || "Effect";
-              let runtimeIdentifier = void 0;
-              for (const statement of isInEffectGen.value.generatorFunction.body.statements) {
-                if (ts.isVariableStatement(statement) && statement.declarationList.declarations.length === 1) {
-                  const declaration = statement.declarationList.declarations[0];
-                  if (declaration.initializer && ts.isYieldExpression(declaration.initializer) && declaration.initializer.asteriskToken && declaration.initializer.expression) {
-                    const yieldedExpression = declaration.initializer.expression;
-                    if (ts.isCallExpression(yieldedExpression)) {
-                      const maybeEffectRuntime = yield* pipe(
-                        typeParser.isNodeReferenceToEffectModuleApi("runtime")(yieldedExpression.expression),
-                        option5
-                      );
-                      if (isSome2(maybeEffectRuntime) && ts.isIdentifier(declaration.name)) {
-                        runtimeIdentifier = ts.idText(declaration.name);
-                      }
+        if (scopeNode && scopeNode !== effectGen.generatorFunction) {
+          const fixAddRuntime = gen3(function* () {
+            const changeTracker = yield* service2(ChangeTracker);
+            const runtimeModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Runtime") || "Runtime";
+            const effectModuleIdentifier = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Effect") || "Effect";
+            let runtimeIdentifier = void 0;
+            for (const statement of effectGen.generatorFunction.body.statements) {
+              if (ts.isVariableStatement(statement) && statement.declarationList.declarations.length === 1) {
+                const declaration = statement.declarationList.declarations[0];
+                if (declaration.initializer && ts.isYieldExpression(declaration.initializer) && declaration.initializer.asteriskToken && declaration.initializer.expression) {
+                  const yieldedExpression = declaration.initializer.expression;
+                  if (ts.isCallExpression(yieldedExpression)) {
+                    const maybeEffectRuntime = yield* pipe(
+                      typeParser.isNodeReferenceToEffectModuleApi("runtime")(yieldedExpression.expression),
+                      option5
+                    );
+                    if (isSome2(maybeEffectRuntime) && ts.isIdentifier(declaration.name)) {
+                      runtimeIdentifier = ts.idText(declaration.name);
                     }
                   }
                 }
               }
-              if (!runtimeIdentifier) {
-                changeTracker.insertNodeAt(
-                  sourceFile,
-                  isInEffectGen.value.body.statements[0].pos,
-                  ts.factory.createVariableStatement(
+            }
+            if (!runtimeIdentifier) {
+              changeTracker.insertNodeAt(
+                sourceFile,
+                effectGen.body.statements[0].pos,
+                ts.factory.createVariableStatement(
+                  void 0,
+                  ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(
+                    "effectRuntime",
                     void 0,
-                    ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(
-                      "effectRuntime",
-                      void 0,
-                      void 0,
-                      ts.factory.createYieldExpression(
-                        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
-                        ts.factory.createCallExpression(
-                          ts.factory.createPropertyAccessExpression(
-                            ts.factory.createIdentifier(effectModuleIdentifier),
-                            "runtime"
-                          ),
-                          [ts.factory.createTypeReferenceNode("never")],
-                          []
-                        )
+                    void 0,
+                    ts.factory.createYieldExpression(
+                      ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+                      ts.factory.createCallExpression(
+                        ts.factory.createPropertyAccessExpression(
+                          ts.factory.createIdentifier(effectModuleIdentifier),
+                          "runtime"
+                        ),
+                        [ts.factory.createTypeReferenceNode("never")],
+                        []
                       )
-                    )], ts.NodeFlags.Const)
-                  ),
-                  {
-                    prefix: "\n",
-                    suffix: "\n"
-                  }
-                );
-              }
-              changeTracker.deleteRange(sourceFile, {
-                pos: ts.getTokenPosOfNode(node.expression, sourceFile),
-                end: node.arguments[0].pos
-              });
-              changeTracker.insertText(
-                sourceFile,
-                node.arguments[0].pos,
-                `${runtimeModuleIdentifier}.${isEffectRunCall.value.methodName}(${runtimeIdentifier || "effectRuntime"}, `
+                    )
+                  )], ts.NodeFlags.Const)
+                ),
+                {
+                  prefix: "\n",
+                  suffix: "\n"
+                }
               );
+            }
+            changeTracker.deleteRange(sourceFile, {
+              pos: ts.getTokenPosOfNode(node.expression, sourceFile),
+              end: node.arguments[0].pos
             });
-            report({
-              location: node.expression,
-              messageText: `Using ${nodeText} inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.
+            changeTracker.insertText(
+              sourceFile,
+              node.arguments[0].pos,
+              `${runtimeModuleIdentifier}.${isEffectRunCall.value.methodName}(${runtimeIdentifier || "effectRuntime"}, `
+            );
+          });
+          report({
+            location: node.expression,
+            messageText: `Using ${nodeText} inside an Effect is not recommended. The same runtime should generally be used instead to run child effects.
 Consider extracting the Runtime by using for example Effect.runtime and then use Runtime.${isEffectRunCall.value.methodName} with the extracted runtime instead.`,
-              fixes: [{
-                fixName: "runEffectInsideEffect_fix",
-                description: "Use a runtime to run the Effect",
-                apply: fixAddRuntime
-              }]
-            });
-          } else {
-            report({
-              location: node.expression,
-              messageText: `Using ${nodeText} inside an Effect is not recommended. Effects inside generators can usually just be yielded.`,
-              fixes: []
-            });
-          }
+            fixes: [{
+              fixName: "runEffectInsideEffect_fix",
+              description: "Use a runtime to run the Effect",
+              apply: fixAddRuntime
+            }]
+          });
+        } else {
+          report({
+            location: node.expression,
+            messageText: `Using ${nodeText} inside an Effect is not recommended. Effects inside generators can usually just be yielded.`,
+            fixes: []
+          });
         }
-        currentParent = currentParent.parent;
       }
     }
   })
@@ -38351,6 +38694,59 @@ var schemaStructWithTag = createDiagnostic({
   })
 });
 
+// src/diagnostics/schemaSyncInEffect.ts
+var syncToEffectMethod = {
+  decodeSync: "decode",
+  decodeUnknownSync: "decodeUnknown",
+  encodeSync: "encode",
+  encodeUnknownSync: "encodeUnknown"
+};
+var schemaSyncInEffect = createDiagnostic({
+  name: "schemaSyncInEffect",
+  code: 43,
+  description: "Suggests using Effect-based Schema methods instead of sync methods inside Effect generators",
+  severity: "suggestion",
+  apply: fn2("schemaSyncInEffect.apply")(function* (sourceFile, report) {
+    const ts = yield* service2(TypeScriptApi);
+    const typeParser = yield* service2(TypeParser);
+    const parseSchemaSyncMethod = (node, methodName) => pipe(
+      typeParser.isNodeReferenceToEffectParseResultModuleApi(methodName)(node),
+      map34(() => ({ node, methodName }))
+    );
+    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)) continue;
+      const isSchemaSyncCall = yield* pipe(
+        firstSuccessOf2(
+          Object.keys(syncToEffectMethod).map((methodName) => parseSchemaSyncMethod(node.expression, methodName))
+        ),
+        option5
+      );
+      if (isNone2(isSchemaSyncCall)) continue;
+      const { effectGen, scopeNode } = yield* typeParser.findEnclosingScopes(node);
+      if (!effectGen || effectGen.body.statements.length === 0) continue;
+      if (scopeNode && scopeNode !== effectGen.generatorFunction) continue;
+      const nodeText = sourceFile.text.substring(
+        ts.getTokenPosOfNode(node.expression, sourceFile),
+        node.expression.end
+      );
+      const effectMethodName = syncToEffectMethod[isSchemaSyncCall.value.methodName];
+      report({
+        location: node.expression,
+        messageText: `Using ${nodeText} inside an Effect generator is not recommended. Use Schema.${effectMethodName} instead to get properly typed ParseError in the error channel.`,
+        fixes: []
+      });
+    }
+  })
+});
+
 // src/diagnostics/schemaUnionOfLiterals.ts
 var schemaUnionOfLiterals = createDiagnostic({
   name: "schemaUnionOfLiterals",
@@ -39065,7 +39461,9 @@ var diagnostics = [
   layerMergeAllWithDependencies,
   effectMapVoid,
   effectFnOpportunity,
-  redundantSchemaTagIdentifier
+  redundantSchemaTagIdentifier,
+  schemaSyncInEffect,
+  preferSchemaOverJson
 ];
 
 // src/cli/diagnostics.ts
@@ -39991,7 +40389,7 @@ var collectSourceFileExportedSymbols = (sourceFile, tsInstance, typeChecker, max
   }
   const exports2 = typeChecker.getExportsOfModule(moduleSymbol);
   const workQueue = exports2.map((s) => {
-    const declarations = s.getDeclarations();
+    const declarations = s.declarations;
     const location = declarations && declarations.length > 0 ? getLocationFromDeclaration(declarations[0], tsInstance) : void 0;
     return [s, tsInstance.symbolName(s), location, 0];
   });
@@ -40153,7 +40551,7 @@ function collectExportedItems(sourceFile, tsInstance, typeChecker, maxSymbolDept
       maxSymbolDepth
     );
     for (const { description, location, name, symbol: symbol3, type: type2 } of exportedSymbols) {
-      const declarations = symbol3.getDeclarations();
+      const declarations = symbol3.declarations;
       const declaration = declarations && declarations.length > 0 ? declarations[0] : sourceFile;
       const contextTagResult = yield* pipe(
         typeParser.contextTag(type2, declaration),
@@ -40971,6 +41369,523 @@ var patch9 = make58(
   )
 );
 
+// src/cli/quickfixes.ts
+var import_project_service5 = __toESM(require_dist2());
+
+// src/cli/setup/text-diff-renderer.ts
+function getLines(text10) {
+  return text10.split("\n");
+}
+function getLineAndCharacterOfPosition(text10, position) {
+  const lines3 = text10.split("\n");
+  let currentPos = 0;
+  for (let lineIndex = 0; lineIndex < lines3.length; lineIndex++) {
+    const lineLength = lines3[lineIndex].length;
+    const lineEndPos = currentPos + lineLength;
+    if (position <= lineEndPos) {
+      return { line: lineIndex, character: position - currentPos };
+    }
+    currentPos = lineEndPos + 1;
+  }
+  const lastLineIndex = lines3.length - 1;
+  return { line: lastLineIndex, character: lines3[lastLineIndex]?.length ?? 0 };
+}
+function renderLine(lineNum, symbol3, text10, color3) {
+  const lineNumPart = lineNum !== void 0 ? String(lineNum).padStart(4, " ") : "    ";
+  return annotate2(text3(`${lineNumPart} ${symbol3} ${text10}`), color3);
+}
+function renderPlainTextChange(text10, textChange) {
+  const startPos = textChange.span.start;
+  const endPos = textChange.span.start + textChange.span.length;
+  const startLineAndChar = getLineAndCharacterOfPosition(text10, startPos);
+  const endLineAndChar = getLineAndCharacterOfPosition(text10, endPos);
+  const startLine = startLineAndChar.line;
+  const endLine = endLineAndChar.line;
+  const startCol = startLineAndChar.character;
+  const endCol = endLineAndChar.character;
+  const lines3 = [];
+  const allLines = getLines(text10);
+  if (startLine > 0) {
+    const contextBefore = allLines[startLine - 1];
+    lines3.push(renderLine(startLine, "|", contextBefore, blackBright2));
+  }
+  if (startLine <= endLine) {
+    const firstLineText = allLines[startLine];
+    const keptBeforeDeletion = firstLineText.slice(0, startCol);
+    const hasNonWhitespaceKept = keptBeforeDeletion.trim().length > 0;
+    if (hasNonWhitespaceKept) {
+      lines3.push(renderLine(startLine + 1, "|", keptBeforeDeletion, blackBright2));
+    }
+    const deletedOnFirstLine = startLine === endLine ? firstLineText.slice(startCol, endCol) : firstLineText.slice(startCol);
+    if (deletedOnFirstLine.length > 0) {
+      const spacePadding = hasNonWhitespaceKept ? " ".repeat(keptBeforeDeletion.length) : "";
+      lines3.push(renderLine(void 0, "-", `${spacePadding}${deletedOnFirstLine}`, red4));
+    }
+  }
+  for (let i = startLine + 1; i < endLine; i++) {
+    const lineText = allLines[i];
+    if (lineText !== void 0) {
+      lines3.push(renderLine(void 0, "-", lineText, red4));
+    }
+  }
+  if (endLine > startLine) {
+    const lastLineText = allLines[endLine];
+    const deletedOnLastLine = lastLineText.slice(0, endCol);
+    if (deletedOnLastLine.length > 0) {
+      lines3.push(renderLine(void 0, "-", deletedOnLastLine, red4));
+    }
+  }
+  if (textChange.newText.length > 0) {
+    const newTextLines = textChange.newText.split("\n");
+    const firstLineText = allLines[startLine];
+    const keptBeforeDeletion = firstLineText.slice(0, startCol);
+    const hasNonWhitespaceKept = keptBeforeDeletion.trim().length > 0;
+    const spacePadding = hasNonWhitespaceKept ? " ".repeat(keptBeforeDeletion.length) : "";
+    for (let i = 0; i < newTextLines.length; i++) {
+      const newLine = newTextLines[i];
+      if (i === newTextLines.length - 1 && newLine.length === 0 && newTextLines.length > 1) {
+        continue;
+      }
+      const padding = i === 0 && hasNonWhitespaceKept ? spacePadding : "";
+      lines3.push(renderLine(void 0, "+", `${padding}${newLine}`, green3));
+    }
+  }
+  let alignmentForKeptPart = 0;
+  if (textChange.newText.length > 0) {
+    const newTextLines = textChange.newText.split("\n");
+    const lastNewLine = newTextLines[newTextLines.length - 1];
+    if (lastNewLine.length === 0 && newTextLines.length > 1) {
+      alignmentForKeptPart = 0;
+    } else {
+      const firstLineText = allLines[startLine];
+      const keptBeforeDeletion = firstLineText.slice(0, startCol);
+      const hasNonWhitespaceKept = keptBeforeDeletion.trim().length > 0;
+      if (hasNonWhitespaceKept) {
+        if (newTextLines.length === 1) {
+          alignmentForKeptPart = keptBeforeDeletion.length + lastNewLine.length;
+        } else {
+          alignmentForKeptPart = lastNewLine.length;
+        }
+      } else {
+        alignmentForKeptPart = lastNewLine.length;
+      }
+    }
+  } else {
+    alignmentForKeptPart = endCol;
+  }
+  if (endLine > startLine) {
+    const lastLineText = allLines[endLine];
+    const keptAfterDeletion = lastLineText.slice(endCol);
+    if (keptAfterDeletion.trim().length > 0) {
+      const alignment = " ".repeat(alignmentForKeptPart);
+      lines3.push(renderLine(endLine + 1, "|", `${alignment}${keptAfterDeletion}`, blackBright2));
+    }
+  } else if (startLine === endLine) {
+    const firstLineText = allLines[startLine];
+    const keptAfterDeletion = firstLineText.slice(endCol);
+    if (keptAfterDeletion.trim().length > 0) {
+      const alignment = " ".repeat(alignmentForKeptPart);
+      lines3.push(renderLine(startLine + 1, "|", `${alignment}${keptAfterDeletion}`, blackBright2));
+    }
+  }
+  if (endLine + 1 < allLines.length) {
+    const contextAfter = allLines[endLine + 1];
+    lines3.push(renderLine(endLine + 2, "|", contextAfter, blackBright2));
+  }
+  return lines3;
+}
+function renderPlainTextFileChanges(text10, textChanges) {
+  const lines3 = [];
+  const sortedChanges = [...textChanges].sort((a, b) => a.span.start - b.span.start);
+  for (let i = 0; i < sortedChanges.length; i++) {
+    const change = sortedChanges[i];
+    const changeLines = renderPlainTextChange(text10, change);
+    for (const line4 of changeLines) {
+      lines3.push(line4);
+    }
+    if (i < sortedChanges.length - 1) {
+      lines3.push(text3(""));
+    }
+  }
+  return lines3;
+}
+
+// src/cli/setup/diff-renderer.ts
+function getLines2(text10) {
+  return text10.split("\n");
+}
+function renderLine2(lineNum, symbol3, text10, color3) {
+  const lineNumPart = lineNum !== void 0 ? String(lineNum).padStart(4, " ") : "    ";
+  return annotate2(text3(`${lineNumPart} ${symbol3} ${text10}`), color3);
+}
+function renderTextChange(sourceFile, textChange) {
+  const startPos = textChange.span.start;
+  const endPos = textChange.span.start + textChange.span.length;
+  const startLineAndChar = sourceFile.getLineAndCharacterOfPosition(startPos);
+  const endLineAndChar = sourceFile.getLineAndCharacterOfPosition(endPos);
+  const startLine = startLineAndChar.line;
+  const endLine = endLineAndChar.line;
+  const startCol = startLineAndChar.character;
+  const endCol = endLineAndChar.character;
+  const lines3 = [];
+  const allLines = getLines2(sourceFile.text);
+  if (startLine > 0) {
+    const contextBefore = allLines[startLine - 1];
+    lines3.push(renderLine2(startLine, "|", contextBefore, blackBright2));
+  }
+  if (startLine <= endLine) {
+    const firstLineText = allLines[startLine];
+    const keptBeforeDeletion = firstLineText.slice(0, startCol);
+    const hasNonWhitespaceKept = keptBeforeDeletion.trim().length > 0;
+    if (hasNonWhitespaceKept) {
+      lines3.push(renderLine2(startLine + 1, "|", keptBeforeDeletion, blackBright2));
+    }
+    const deletedOnFirstLine = startLine === endLine ? firstLineText.slice(startCol, endCol) : firstLineText.slice(startCol);
+    if (deletedOnFirstLine.length > 0) {
+      const spacePadding = hasNonWhitespaceKept ? " ".repeat(keptBeforeDeletion.length) : "";
+      lines3.push(renderLine2(void 0, "-", `${spacePadding}${deletedOnFirstLine}`, red4));
+    }
+  }
+  for (let i = startLine + 1; i < endLine; i++) {
+    const lineText = allLines[i];
+    if (lineText !== void 0) {
+      lines3.push(renderLine2(void 0, "-", lineText, red4));
+    }
+  }
+  if (endLine > startLine) {
+    const lastLineText = allLines[endLine];
+    const deletedOnLastLine = lastLineText.slice(0, endCol);
+    if (deletedOnLastLine.length > 0) {
+      lines3.push(renderLine2(void 0, "-", deletedOnLastLine, red4));
+    }
+  }
+  if (textChange.newText.length > 0) {
+    const newTextLines = textChange.newText.split("\n");
+    const firstLineText = allLines[startLine];
+    const keptBeforeDeletion = firstLineText.slice(0, startCol);
+    const hasNonWhitespaceKept = keptBeforeDeletion.trim().length > 0;
+    const spacePadding = hasNonWhitespaceKept ? " ".repeat(keptBeforeDeletion.length) : "";
+    for (let i = 0; i < newTextLines.length; i++) {
+      const newLine = newTextLines[i];
+      if (i === newTextLines.length - 1 && newLine.length === 0 && newTextLines.length > 1) {
+        continue;
+      }
+      const padding = i === 0 && hasNonWhitespaceKept ? spacePadding : "";
+      lines3.push(renderLine2(void 0, "+", `${padding}${newLine}`, green3));
+    }
+  }
+  let alignmentForKeptPart = 0;
+  if (textChange.newText.length > 0) {
+    const newTextLines = textChange.newText.split("\n");
+    const lastNewLine = newTextLines[newTextLines.length - 1];
+    if (lastNewLine.length === 0 && newTextLines.length > 1) {
+      alignmentForKeptPart = 0;
+    } else {
+      const firstLineText = allLines[startLine];
+      const keptBeforeDeletion = firstLineText.slice(0, startCol);
+      const hasNonWhitespaceKept = keptBeforeDeletion.trim().length > 0;
+      if (hasNonWhitespaceKept) {
+        if (newTextLines.length === 1) {
+          alignmentForKeptPart = keptBeforeDeletion.length + lastNewLine.length;
+        } else {
+          alignmentForKeptPart = lastNewLine.length;
+        }
+      } else {
+        alignmentForKeptPart = lastNewLine.length;
+      }
+    }
+  } else {
+    alignmentForKeptPart = endCol;
+  }
+  if (endLine > startLine) {
+    const lastLineText = allLines[endLine];
+    const keptAfterDeletion = lastLineText.slice(endCol);
+    if (keptAfterDeletion.trim().length > 0) {
+      const alignment = " ".repeat(alignmentForKeptPart);
+      lines3.push(renderLine2(endLine + 1, "|", `${alignment}${keptAfterDeletion}`, blackBright2));
+    }
+  } else if (startLine === endLine) {
+    const firstLineText = allLines[startLine];
+    const keptAfterDeletion = firstLineText.slice(endCol);
+    if (keptAfterDeletion.trim().length > 0) {
+      const alignment = " ".repeat(alignmentForKeptPart);
+      lines3.push(renderLine2(startLine + 1, "|", `${alignment}${keptAfterDeletion}`, blackBright2));
+    }
+  }
+  if (endLine + 1 < allLines.length) {
+    const contextAfter = allLines[endLine + 1];
+    lines3.push(renderLine2(endLine + 2, "|", contextAfter, blackBright2));
+  }
+  return lines3;
+}
+function renderFileChanges(sourceFile, textChanges) {
+  const lines3 = [];
+  const sortedChanges = [...textChanges].sort((a, b) => a.span.start - b.span.start);
+  for (let i = 0; i < sortedChanges.length; i++) {
+    const change = sortedChanges[i];
+    const changeLines = renderTextChange(sourceFile, change);
+    for (const line4 of changeLines) {
+      lines3.push(line4);
+    }
+    if (i < sortedChanges.length - 1) {
+      lines3.push(text3(""));
+    }
+  }
+  return lines3;
+}
+var renderCodeActions = (result, assessmentState) => gen2(function* () {
+  if (result.codeActions.length === 0) {
+    const noChanges = annotate2(
+      text3("No changes needed - your configuration is already up to date!"),
+      green3
+    );
+    const noChangesStr = noChanges.pipe(render3({ style: "pretty" }));
+    yield* log3(noChangesStr);
+    return;
+  }
+  const sourceFiles = [
+    assessmentState.packageJson.sourceFile,
+    assessmentState.tsconfig.sourceFile
+  ];
+  if (isSome2(assessmentState.vscodeSettings)) {
+    sourceFiles.push(assessmentState.vscodeSettings.value.sourceFile);
+  }
+  const plainTextFiles = [];
+  if (isSome2(assessmentState.agentsMd)) {
+    plainTextFiles.push({
+      path: assessmentState.agentsMd.value.path,
+      text: assessmentState.agentsMd.value.text
+    });
+  }
+  if (isSome2(assessmentState.claudeMd)) {
+    plainTextFiles.push({
+      path: assessmentState.claudeMd.value.path,
+      text: assessmentState.claudeMd.value.text
+    });
+  }
+  for (const codeAction of result.codeActions) {
+    for (const fileChange of codeAction.changes) {
+      const sourceFile = sourceFiles.find((sf) => sf.fileName === fileChange.fileName);
+      const plainTextFile = plainTextFiles.find((pf) => pf.path === fileChange.fileName);
+      const header = vsep2([
+        empty32,
+        annotate2(text3(codeAction.description), bold2),
+        annotate2(text3(fileChange.fileName), cyan4),
+        empty32
+      ]);
+      const headerStr = header.pipe(render3({ style: "pretty" }));
+      yield* log3(headerStr);
+      if (sourceFile) {
+        const diffLines = renderFileChanges(sourceFile, fileChange.textChanges);
+        const diff8 = vsep2(diffLines);
+        const diffStr = diff8.pipe(render3({ style: "pretty" }));
+        yield* log3(diffStr);
+      } else if (plainTextFile) {
+        const diffLines = renderPlainTextFileChanges(plainTextFile.text, fileChange.textChanges);
+        const diff8 = vsep2(diffLines);
+        const diffStr = diff8.pipe(render3({ style: "pretty" }));
+        yield* log3(diffStr);
+      } else {
+        const noticeStr = text3("  (file will be modified)").pipe(render3({ style: "pretty" }));
+        yield* log3(noticeStr);
+      }
+    }
+  }
+  if (result.messages.length > 0) {
+    yield* log3("");
+    for (const message of result.messages) {
+      const messageDoc = message.includes("WARNING") ? annotate2(text3(message), yellow3) : text3(message);
+      const messageStr = messageDoc.pipe(render3({ style: "pretty" }));
+      yield* log3(messageStr);
+    }
+  }
+});
+
+// src/cli/quickfixes.ts
+var isSkipFix = (fixName) => fixName.endsWith("_skipNextLine") || fixName.endsWith("_skipFile");
+var renderQuickFix = (sourceFile, fix) => {
+  const lines3 = [];
+  lines3.push(empty32);
+  lines3.push(
+    cat2(
+      cat2(
+        cat2(
+          annotate2(text3("  Fix: "), bold2),
+          annotate2(text3(fix.fixName), cyan4)
+        ),
+        text3(" - ")
+      ),
+      text3(fix.description)
+    )
+  );
+  lines3.push(annotate2(text3("  " + "\u2500".repeat(60)), blackBright2));
+  for (const fileChange of fix.changes) {
+    if (fileChange.fileName === sourceFile.fileName) {
+      for (const textChange of fileChange.textChanges) {
+        const diffLines = renderTextChange(sourceFile, textChange);
+        for (const diffLine of diffLines) {
+          lines3.push(cat2(text3("  "), diffLine));
+        }
+      }
+    }
+  }
+  return vsep2(lines3);
+};
+var renderDiagnosticWithFixes = (sourceFile, info2, tsInstance) => {
+  const lines3 = [];
+  const { character, line: line4 } = tsInstance.getLineAndCharacterOfPosition(sourceFile, info2.diagnostic.start);
+  const locationStr = `${sourceFile.fileName}:${line4 + 1}:${character + 1}`;
+  lines3.push(
+    cat2(
+      cat2(
+        cat2(
+          cat2(
+            annotate2(text3(locationStr), cyan4),
+            text3(" ")
+          ),
+          annotate2(text3(`effect(${info2.diagnostic.ruleName})`), yellow3)
+        ),
+        text3(": ")
+      ),
+      text3(info2.diagnostic.messageText)
+    )
+  );
+  for (const fix of info2.fixes) {
+    lines3.push(renderQuickFix(sourceFile, fix));
+  }
+  lines3.push(empty32);
+  return vsep2(lines3);
+};
+var BATCH_SIZE4 = 50;
+var quickfixes = make58(
+  "quickfixes",
+  {
+    file: file3("file").pipe(
+      optional4,
+      withDescription3("The full path of the file to check for quick fixes.")
+    ),
+    project: file3("project").pipe(
+      optional4,
+      withDescription3("The full path of the project tsconfig.json file to check for quick fixes.")
+    )
+  },
+  fn("quickfixes")(function* ({ file: file5, project: project3 }) {
+    const path2 = yield* Path2;
+    const tsInstance = yield* TypeScriptContext;
+    const filesToCheck = isSome2(project3) ? yield* getFileNamesInTsConfig(project3.value) : /* @__PURE__ */ new Set();
+    if (isSome2(file5)) {
+      filesToCheck.add(path2.resolve(file5.value));
+    }
+    if (filesToCheck.size === 0) {
+      return yield* new NoFilesToCheckError();
+    }
+    let totalDiagnosticsWithFixes = 0;
+    for (const batch of chunksOf(filesToCheck, BATCH_SIZE4)) {
+      const { service: service3 } = (0, import_project_service5.createProjectService)({ options: { loadTypeScriptPlugins: false } });
+      for (const filePath of batch) {
+        service3.openClientFile(filePath);
+        try {
+          const scriptInfo = service3.getScriptInfo(filePath);
+          if (!scriptInfo) continue;
+          const projectInfo = scriptInfo.getDefaultProject();
+          const languageService = projectInfo.getLanguageService(true);
+          const program = languageService.getProgram();
+          if (!program) continue;
+          const sourceFile = program.getSourceFile(filePath);
+          if (!sourceFile) continue;
+          const pluginConfig = extractEffectLspOptions(program.getCompilerOptions());
+          if (!pluginConfig) continue;
+          const result = pipe(
+            getSemanticDiagnosticsWithCodeFixes(diagnostics, sourceFile),
+            nanoLayer3,
+            nanoLayer2,
+            nanoLayer,
+            provideService7(TypeCheckerApi, program.getTypeChecker()),
+            provideService7(TypeScriptProgram, program),
+            provideService7(TypeScriptApi, tsInstance),
+            provideService7(
+              LanguageServicePluginOptions,
+              { ...parse4(pluginConfig), diagnosticsName: false }
+            ),
+            run9,
+            getOrElse(() => ({ diagnostics: [], codeFixes: [] }))
+          );
+          const diagnosticMap = /* @__PURE__ */ new Map();
+          for (const diagnostic of result.diagnostics) {
+            if (diagnostic.start === void 0) continue;
+            const key = `${diagnostic.start}-${diagnostic.start + (diagnostic.length ?? 0)}-${diagnostic.code}`;
+            const ruleName = Object.values(diagnostics).find((_) => _.code === diagnostic.code)?.name ?? `unknown(${diagnostic.code})`;
+            if (!diagnosticMap.has(key)) {
+              diagnosticMap.set(key, {
+                diagnostic: {
+                  start: diagnostic.start,
+                  end: diagnostic.start + (diagnostic.length ?? 0),
+                  messageText: tsInstance.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
+                  code: diagnostic.code,
+                  ruleName
+                },
+                fixes: []
+              });
+            }
+          }
+          const formatContext = tsInstance.formatting.getFormatContext(
+            tsInstance.getDefaultFormatCodeSettings(),
+            { getNewLine: () => "\n" }
+          );
+          for (const codeFix of result.codeFixes) {
+            if (isSkipFix(codeFix.fixName)) continue;
+            const key = `${codeFix.start}-${codeFix.end}-${codeFix.code}`;
+            const info2 = diagnosticMap.get(key);
+            if (!info2) continue;
+            const changes2 = tsInstance.textChanges.ChangeTracker.with(
+              {
+                formatContext,
+                host: { getNewLine: () => "\n" },
+                preferences: {}
+              },
+              (changeTracker) => pipe(
+                codeFix.apply,
+                provideService7(ChangeTracker, changeTracker),
+                run9
+              )
+            );
+            info2.fixes.push({
+              fixName: codeFix.fixName,
+              description: codeFix.description,
+              changes: changes2
+            });
+          }
+          const diagnosticsWithFixes = Array.from(diagnosticMap.values()).filter(
+            (info2) => info2.fixes.length > 0
+          );
+          if (diagnosticsWithFixes.length === 0) continue;
+          diagnosticsWithFixes.sort((a, b) => a.diagnostic.start - b.diagnostic.start);
+          totalDiagnosticsWithFixes += diagnosticsWithFixes.length;
+          for (const info2 of diagnosticsWithFixes) {
+            const doc = renderDiagnosticWithFixes(sourceFile, info2, tsInstance);
+            yield* log3(doc.pipe(render3({ style: "pretty" })));
+          }
+        } finally {
+          service3.closeClientFile(filePath);
+        }
+      }
+      yield* yieldNow4();
+    }
+    if (totalDiagnosticsWithFixes === 0) {
+      yield* log3("No quick fixes available.");
+    } else {
+      yield* log3(
+        annotate2(
+          text3(`Found ${totalDiagnosticsWithFixes} diagnostic(s) with quick fixes.`),
+          bold2
+        ).pipe(render3({ style: "pretty" }))
+      );
+    }
+  })
+).pipe(
+  withDescription6("Shows diagnostics with available quick fixes and their proposed changes.")
+);
+
 // node_modules/.pnpm/@effect+cli@0.73.0_@effect+platform@0.94.1_@effect+printer-ansi@0.47.0_@effect+printer@0.47.0_effect@3.19.14/node_modules/@effect/cli/dist/esm/internal/prompt/confirm.js
 var renderBeep7 = /* @__PURE__ */ render3(beep3, {
   style: "pretty"
@@ -42047,335 +42962,6 @@ var computeVSCodeSettingsChanges = (current, target) => {
   });
 };
 
-// src/cli/setup/text-diff-renderer.ts
-function getLines(text10) {
-  return text10.split("\n");
-}
-function getLineAndCharacterOfPosition(text10, position) {
-  const lines3 = text10.split("\n");
-  let currentPos = 0;
-  for (let lineIndex = 0; lineIndex < lines3.length; lineIndex++) {
-    const lineLength = lines3[lineIndex].length;
-    const lineEndPos = currentPos + lineLength;
-    if (position <= lineEndPos) {
-      return { line: lineIndex, character: position - currentPos };
-    }
-    currentPos = lineEndPos + 1;
-  }
-  const lastLineIndex = lines3.length - 1;
-  return { line: lastLineIndex, character: lines3[lastLineIndex]?.length ?? 0 };
-}
-function renderLine(lineNum, symbol3, text10, color3) {
-  const lineNumPart = lineNum !== void 0 ? String(lineNum).padStart(4, " ") : "    ";
-  return annotate2(text3(`${lineNumPart} ${symbol3} ${text10}`), color3);
-}
-function renderPlainTextChange(text10, textChange) {
-  const startPos = textChange.span.start;
-  const endPos = textChange.span.start + textChange.span.length;
-  const startLineAndChar = getLineAndCharacterOfPosition(text10, startPos);
-  const endLineAndChar = getLineAndCharacterOfPosition(text10, endPos);
-  const startLine = startLineAndChar.line;
-  const endLine = endLineAndChar.line;
-  const startCol = startLineAndChar.character;
-  const endCol = endLineAndChar.character;
-  const lines3 = [];
-  const allLines = getLines(text10);
-  if (startLine > 0) {
-    const contextBefore = allLines[startLine - 1];
-    lines3.push(renderLine(startLine, "|", contextBefore, blackBright2));
-  }
-  if (startLine <= endLine) {
-    const firstLineText = allLines[startLine];
-    const keptBeforeDeletion = firstLineText.slice(0, startCol);
-    const hasNonWhitespaceKept = keptBeforeDeletion.trim().length > 0;
-    if (hasNonWhitespaceKept) {
-      lines3.push(renderLine(startLine + 1, "|", keptBeforeDeletion, blackBright2));
-    }
-    const deletedOnFirstLine = startLine === endLine ? firstLineText.slice(startCol, endCol) : firstLineText.slice(startCol);
-    if (deletedOnFirstLine.length > 0) {
-      const spacePadding = hasNonWhitespaceKept ? " ".repeat(keptBeforeDeletion.length) : "";
-      lines3.push(renderLine(void 0, "-", `${spacePadding}${deletedOnFirstLine}`, red4));
-    }
-  }
-  for (let i = startLine + 1; i < endLine; i++) {
-    const lineText = allLines[i];
-    if (lineText !== void 0) {
-      lines3.push(renderLine(void 0, "-", lineText, red4));
-    }
-  }
-  if (endLine > startLine) {
-    const lastLineText = allLines[endLine];
-    const deletedOnLastLine = lastLineText.slice(0, endCol);
-    if (deletedOnLastLine.length > 0) {
-      lines3.push(renderLine(void 0, "-", deletedOnLastLine, red4));
-    }
-  }
-  if (textChange.newText.length > 0) {
-    const newTextLines = textChange.newText.split("\n");
-    const firstLineText = allLines[startLine];
-    const keptBeforeDeletion = firstLineText.slice(0, startCol);
-    const hasNonWhitespaceKept = keptBeforeDeletion.trim().length > 0;
-    const spacePadding = hasNonWhitespaceKept ? " ".repeat(keptBeforeDeletion.length) : "";
-    for (let i = 0; i < newTextLines.length; i++) {
-      const newLine = newTextLines[i];
-      if (i === newTextLines.length - 1 && newLine.length === 0 && newTextLines.length > 1) {
-        continue;
-      }
-      const padding = i === 0 && hasNonWhitespaceKept ? spacePadding : "";
-      lines3.push(renderLine(void 0, "+", `${padding}${newLine}`, green3));
-    }
-  }
-  let alignmentForKeptPart = 0;
-  if (textChange.newText.length > 0) {
-    const newTextLines = textChange.newText.split("\n");
-    const lastNewLine = newTextLines[newTextLines.length - 1];
-    if (lastNewLine.length === 0 && newTextLines.length > 1) {
-      alignmentForKeptPart = 0;
-    } else {
-      const firstLineText = allLines[startLine];
-      const keptBeforeDeletion = firstLineText.slice(0, startCol);
-      const hasNonWhitespaceKept = keptBeforeDeletion.trim().length > 0;
-      if (hasNonWhitespaceKept) {
-        if (newTextLines.length === 1) {
-          alignmentForKeptPart = keptBeforeDeletion.length + lastNewLine.length;
-        } else {
-          alignmentForKeptPart = lastNewLine.length;
-        }
-      } else {
-        alignmentForKeptPart = lastNewLine.length;
-      }
-    }
-  } else {
-    alignmentForKeptPart = endCol;
-  }
-  if (endLine > startLine) {
-    const lastLineText = allLines[endLine];
-    const keptAfterDeletion = lastLineText.slice(endCol);
-    if (keptAfterDeletion.trim().length > 0) {
-      const alignment = " ".repeat(alignmentForKeptPart);
-      lines3.push(renderLine(endLine + 1, "|", `${alignment}${keptAfterDeletion}`, blackBright2));
-    }
-  } else if (startLine === endLine) {
-    const firstLineText = allLines[startLine];
-    const keptAfterDeletion = firstLineText.slice(endCol);
-    if (keptAfterDeletion.trim().length > 0) {
-      const alignment = " ".repeat(alignmentForKeptPart);
-      lines3.push(renderLine(startLine + 1, "|", `${alignment}${keptAfterDeletion}`, blackBright2));
-    }
-  }
-  if (endLine + 1 < allLines.length) {
-    const contextAfter = allLines[endLine + 1];
-    lines3.push(renderLine(endLine + 2, "|", contextAfter, blackBright2));
-  }
-  return lines3;
-}
-function renderPlainTextFileChanges(text10, textChanges) {
-  const lines3 = [];
-  const sortedChanges = [...textChanges].sort((a, b) => a.span.start - b.span.start);
-  for (let i = 0; i < sortedChanges.length; i++) {
-    const change = sortedChanges[i];
-    const changeLines = renderPlainTextChange(text10, change);
-    for (const line4 of changeLines) {
-      lines3.push(line4);
-    }
-    if (i < sortedChanges.length - 1) {
-      lines3.push(text3(""));
-    }
-  }
-  return lines3;
-}
-
-// src/cli/setup/diff-renderer.ts
-function getLines2(text10) {
-  return text10.split("\n");
-}
-function renderLine2(lineNum, symbol3, text10, color3) {
-  const lineNumPart = lineNum !== void 0 ? String(lineNum).padStart(4, " ") : "    ";
-  return annotate2(text3(`${lineNumPart} ${symbol3} ${text10}`), color3);
-}
-function renderTextChange(sourceFile, textChange) {
-  const startPos = textChange.span.start;
-  const endPos = textChange.span.start + textChange.span.length;
-  const startLineAndChar = sourceFile.getLineAndCharacterOfPosition(startPos);
-  const endLineAndChar = sourceFile.getLineAndCharacterOfPosition(endPos);
-  const startLine = startLineAndChar.line;
-  const endLine = endLineAndChar.line;
-  const startCol = startLineAndChar.character;
-  const endCol = endLineAndChar.character;
-  const lines3 = [];
-  const allLines = getLines2(sourceFile.text);
-  if (startLine > 0) {
-    const contextBefore = allLines[startLine - 1];
-    lines3.push(renderLine2(startLine, "|", contextBefore, blackBright2));
-  }
-  if (startLine <= endLine) {
-    const firstLineText = allLines[startLine];
-    const keptBeforeDeletion = firstLineText.slice(0, startCol);
-    const hasNonWhitespaceKept = keptBeforeDeletion.trim().length > 0;
-    if (hasNonWhitespaceKept) {
-      lines3.push(renderLine2(startLine + 1, "|", keptBeforeDeletion, blackBright2));
-    }
-    const deletedOnFirstLine = startLine === endLine ? firstLineText.slice(startCol, endCol) : firstLineText.slice(startCol);
-    if (deletedOnFirstLine.length > 0) {
-      const spacePadding = hasNonWhitespaceKept ? " ".repeat(keptBeforeDeletion.length) : "";
-      lines3.push(renderLine2(void 0, "-", `${spacePadding}${deletedOnFirstLine}`, red4));
-    }
-  }
-  for (let i = startLine + 1; i < endLine; i++) {
-    const lineText = allLines[i];
-    if (lineText !== void 0) {
-      lines3.push(renderLine2(void 0, "-", lineText, red4));
-    }
-  }
-  if (endLine > startLine) {
-    const lastLineText = allLines[endLine];
-    const deletedOnLastLine = lastLineText.slice(0, endCol);
-    if (deletedOnLastLine.length > 0) {
-      lines3.push(renderLine2(void 0, "-", deletedOnLastLine, red4));
-    }
-  }
-  if (textChange.newText.length > 0) {
-    const newTextLines = textChange.newText.split("\n");
-    const firstLineText = allLines[startLine];
-    const keptBeforeDeletion = firstLineText.slice(0, startCol);
-    const hasNonWhitespaceKept = keptBeforeDeletion.trim().length > 0;
-    const spacePadding = hasNonWhitespaceKept ? " ".repeat(keptBeforeDeletion.length) : "";
-    for (let i = 0; i < newTextLines.length; i++) {
-      const newLine = newTextLines[i];
-      if (i === newTextLines.length - 1 && newLine.length === 0 && newTextLines.length > 1) {
-        continue;
-      }
-      const padding = i === 0 && hasNonWhitespaceKept ? spacePadding : "";
-      lines3.push(renderLine2(void 0, "+", `${padding}${newLine}`, green3));
-    }
-  }
-  let alignmentForKeptPart = 0;
-  if (textChange.newText.length > 0) {
-    const newTextLines = textChange.newText.split("\n");
-    const lastNewLine = newTextLines[newTextLines.length - 1];
-    if (lastNewLine.length === 0 && newTextLines.length > 1) {
-      alignmentForKeptPart = 0;
-    } else {
-      const firstLineText = allLines[startLine];
-      const keptBeforeDeletion = firstLineText.slice(0, startCol);
-      const hasNonWhitespaceKept = keptBeforeDeletion.trim().length > 0;
-      if (hasNonWhitespaceKept) {
-        if (newTextLines.length === 1) {
-          alignmentForKeptPart = keptBeforeDeletion.length + lastNewLine.length;
-        } else {
-          alignmentForKeptPart = lastNewLine.length;
-        }
-      } else {
-        alignmentForKeptPart = lastNewLine.length;
-      }
-    }
-  } else {
-    alignmentForKeptPart = endCol;
-  }
-  if (endLine > startLine) {
-    const lastLineText = allLines[endLine];
-    const keptAfterDeletion = lastLineText.slice(endCol);
-    if (keptAfterDeletion.trim().length > 0) {
-      const alignment = " ".repeat(alignmentForKeptPart);
-      lines3.push(renderLine2(endLine + 1, "|", `${alignment}${keptAfterDeletion}`, blackBright2));
-    }
-  } else if (startLine === endLine) {
-    const firstLineText = allLines[startLine];
-    const keptAfterDeletion = firstLineText.slice(endCol);
-    if (keptAfterDeletion.trim().length > 0) {
-      const alignment = " ".repeat(alignmentForKeptPart);
-      lines3.push(renderLine2(startLine + 1, "|", `${alignment}${keptAfterDeletion}`, blackBright2));
-    }
-  }
-  if (endLine + 1 < allLines.length) {
-    const contextAfter = allLines[endLine + 1];
-    lines3.push(renderLine2(endLine + 2, "|", contextAfter, blackBright2));
-  }
-  return lines3;
-}
-function renderFileChanges(sourceFile, textChanges) {
-  const lines3 = [];
-  const sortedChanges = [...textChanges].sort((a, b) => a.span.start - b.span.start);
-  for (let i = 0; i < sortedChanges.length; i++) {
-    const change = sortedChanges[i];
-    const changeLines = renderTextChange(sourceFile, change);
-    for (const line4 of changeLines) {
-      lines3.push(line4);
-    }
-    if (i < sortedChanges.length - 1) {
-      lines3.push(text3(""));
-    }
-  }
-  return lines3;
-}
-var renderCodeActions = (result, assessmentState) => gen2(function* () {
-  if (result.codeActions.length === 0) {
-    const noChanges = annotate2(
-      text3("No changes needed - your configuration is already up to date!"),
-      green3
-    );
-    const noChangesStr = noChanges.pipe(render3({ style: "pretty" }));
-    yield* log3(noChangesStr);
-    return;
-  }
-  const sourceFiles = [
-    assessmentState.packageJson.sourceFile,
-    assessmentState.tsconfig.sourceFile
-  ];
-  if (isSome2(assessmentState.vscodeSettings)) {
-    sourceFiles.push(assessmentState.vscodeSettings.value.sourceFile);
-  }
-  const plainTextFiles = [];
-  if (isSome2(assessmentState.agentsMd)) {
-    plainTextFiles.push({
-      path: assessmentState.agentsMd.value.path,
-      text: assessmentState.agentsMd.value.text
-    });
-  }
-  if (isSome2(assessmentState.claudeMd)) {
-    plainTextFiles.push({
-      path: assessmentState.claudeMd.value.path,
-      text: assessmentState.claudeMd.value.text
-    });
-  }
-  for (const codeAction of result.codeActions) {
-    for (const fileChange of codeAction.changes) {
-      const sourceFile = sourceFiles.find((sf) => sf.fileName === fileChange.fileName);
-      const plainTextFile = plainTextFiles.find((pf) => pf.path === fileChange.fileName);
-      const header = vsep2([
-        empty32,
-        annotate2(text3(codeAction.description), bold2),
-        annotate2(text3(fileChange.fileName), cyan4),
-        empty32
-      ]);
-      const headerStr = header.pipe(render3({ style: "pretty" }));
-      yield* log3(headerStr);
-      if (sourceFile) {
-        const diffLines = renderFileChanges(sourceFile, fileChange.textChanges);
-        const diff8 = vsep2(diffLines);
-        const diffStr = diff8.pipe(render3({ style: "pretty" }));
-        yield* log3(diffStr);
-      } else if (plainTextFile) {
-        const diffLines = renderPlainTextFileChanges(plainTextFile.text, fileChange.textChanges);
-        const diff8 = vsep2(diffLines);
-        const diffStr = diff8.pipe(render3({ style: "pretty" }));
-        yield* log3(diffStr);
-      } else {
-        const noticeStr = text3("  (file will be modified)").pipe(render3({ style: "pretty" }));
-        yield* log3(noticeStr);
-      }
-    }
-  }
-  if (result.messages.length > 0) {
-    yield* log3("");
-    for (const message of result.messages) {
-      const messageDoc = message.includes("WARNING") ? annotate2(text3(message), yellow3) : text3(message);
-      const messageStr = messageDoc.pipe(render3({ style: "pretty" }));
-      yield* log3(messageStr);
-    }
-  }
-});
-
 // src/cli/setup/errors.ts
 var PackageJsonNotFoundError = class extends TaggedError("PackageJsonNotFoundError") {
   get message() {
@@ -43017,7 +43603,7 @@ var cliCommand = make58(
   "effect-language-service",
   {},
   () => log3("Please select a command or run --help.")
-).pipe(withSubcommands3([setup, patch9, unpatch, check2, diagnostics2, codegen, overview, layerInfo]));
+).pipe(withSubcommands3([setup, patch9, unpatch, check2, diagnostics2, quickfixes, codegen, overview, layerInfo]));
 var main = run8(cliCommand, {
   name: "effect-language-service",
   version: package_default.version