@effect/language-service 0.65.0 → 0.67.0

package/index.js

@@ -5437,6 +5437,97 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.effectFnGen",
     (node) => node
   );
+  const findEnclosingScopes = fn("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),
+          map8((result) => ({
+            node: result.node,
+            effectModule: result.effectModule,
+            generatorFunction: result.generatorFunction,
+            body: result.body
+          })),
+          orElse2(
+            () => pipe(
+              effectFnUntracedGen(nodeToCheck),
+              map8((result) => ({
+                node: result.node,
+                effectModule: result.effectModule,
+                generatorFunction: result.generatorFunction,
+                body: result.body,
+                pipeArguments: result.pipeArguments
+              }))
+            )
+          ),
+          orElse2(
+            () => pipe(
+              effectFnGen(nodeToCheck),
+              map8((result) => ({
+                node: result.node,
+                effectModule: result.effectModule,
+                generatorFunction: result.generatorFunction,
+                body: result.body,
+                pipeArguments: result.pipeArguments
+              }))
+            )
+          ),
+          option
+        );
+        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),
+        map8(() => ({
+          node,
+          effectModule: propertyAccess.expression,
+          regularFunction,
+          pipeArguments: pipeArguments2
+        }))
+      );
+    },
+    "TypeParser.effectFn",
+    (node) => node
+  );
   const unnecessaryEffectGen2 = cachedBy(
     fn("TypeParser.unnecessaryEffectGen")(function* (node) {
       const { body } = yield* effectGen(node);
@@ -5548,6 +5639,28 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     `TypeParser.isNodeReferenceToEffectSchemaModuleApi(${memberName})`,
     (node) => node
   );
+  const isEffectParseResultSourceFile = cachedBy(
+    fn("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(
+    fn("TypeParser.isNodeReferenceToEffectParseResultModuleApi")(function* (node) {
+      return yield* isNodeReferenceToExportOfPackageModule(node, "effect", isEffectParseResultSourceFile, memberName);
+    }),
+    `TypeParser.isNodeReferenceToEffectParseResultModuleApi(${memberName})`,
+    (node) => node
+  );
   const contextTagVarianceStruct = (type, atLocation) => map8(
     all(
       varianceStructInvariantType(type, atLocation, "_Identifier"),
@@ -6328,11 +6441,65 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
           if (includeEffectFn) {
             const effectFnGenParsed = yield* pipe(effectFnGen(node), option);
             const effectFnUntracedGenParsed = isNone2(effectFnGenParsed) ? yield* pipe(effectFnUntracedGen(node), option) : 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), option) : 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;
@@ -6352,14 +6519,14 @@ function make7(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"
                   });
                 }
               }
@@ -6372,7 +6539,16 @@ function make7(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]);
@@ -6435,6 +6611,7 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
   return {
     isNodeReferenceToEffectModuleApi,
     isNodeReferenceToEffectSchemaModuleApi,
+    isNodeReferenceToEffectParseResultModuleApi,
     isNodeReferenceToEffectDataModuleApi,
     isNodeReferenceToEffectContextModuleApi,
     isNodeReferenceToEffectSqlModelModuleApi,
@@ -6448,6 +6625,8 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     effectGen,
     effectFnUntracedGen,
     effectFnGen,
+    findEnclosingScopes,
+    effectFn,
     extendsCauseYieldableError,
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
@@ -8147,106 +8326,195 @@ ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageNam
 });
 
 // src/diagnostics/effectFnOpportunity.ts
-var parseEffectFnOpportunityTarget = (node, sourceFile) => gen(function* () {
-  const ts = yield* service(TypeScriptApi);
-  const typeChecker = yield* service(TypeCheckerApi);
-  const typeParser = yield* service(TypeParser);
-  const tsUtils = yield* service(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),
-    map8(({ args: args2, subject: subject2 }) => ({ subject: subject2, pipeArguments: args2 })),
-    orElse2(() => succeed({ 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: fn("effectFnOpportunity.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const typeParser = yield* service(TypeParser);
     const tsUtils = yield* service(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) => gen(function* () {
+      const bodyExpression = getBodyExpression(fnNode);
+      if (!bodyExpression) return yield* TypeParserIssue.issue;
+      const { pipeArguments: pipeArguments2, subject } = yield* pipe(
+        typeParser.pipeCall(bodyExpression),
+        map8(({ args: args2, subject: subject2 }) => ({ subject: subject2, pipeArguments: args2 })),
+        orElse2(() => succeed({ 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 succeed(false);
+      }
+      if (parent.arguments[0] !== fnNode) {
+        return succeed(false);
+      }
+      return pipe(
+        typeParser.effectFn(parent),
+        orElse2(() => typeParser.effectFnGen(parent)),
+        orElse2(() => typeParser.effectFnUntracedGen(parent)),
+        map8(() => true),
+        orElse2(() => succeed(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) => gen(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* all(...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),
+        orElse2(() => {
+          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 succeed({
+            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 isGeneratorFunction = (node) => {
+      if (ts.isArrowFunction(node)) return false;
+      return node.asteriskToken !== void 0;
+    };
+    const createEffectFnNode = (originalNode, innerFunction, effectModuleName, traceName, pipeArguments2) => {
+      const isGenerator = isGeneratorFunction(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),
@@ -8259,34 +8527,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 = isGeneratorFunction(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);
@@ -8302,88 +8563,41 @@ var effectFnOpportunity = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
-      const target = yield* pipe(
-        parseEffectFnOpportunityTarget(node, sourceFile),
-        option
-      );
+      const target = yield* pipe(parseEffectFnOpportunityTarget(node), option);
       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: gen(function* () {
           const changeTracker = yield* service(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: gen(function* () {
-          const changeTracker = yield* service(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: gen(function* () {
+            const changeTracker = yield* service(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({
@@ -9146,6 +9360,52 @@ var missedPipeableOpportunity = createDiagnostic({
     const typeChecker = yield* service(TypeCheckerApi);
     const typeParser = yield* service(TypeParser);
     const options = yield* service(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 < options.pipeableMinArgCount) {
@@ -9159,76 +9419,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),
-        option
-      );
-      if (subjectIsPipeable._tag === "Some") {
-        firstPipeableIndex = 0;
-      } else {
-        for (let i = 0; i < flow2.transformations.length; i++) {
+      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),
+            option
+          );
+          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),
+            option
+          );
+          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) {
+          break;
+        }
+        const pipeableTransformations = [];
+        for (let i = firstPipeableIndex; i < flow2.transformations.length; i++) {
           const t = flow2.transformations[i];
-          if (t.outType) {
-            const isPipeable = yield* pipe(
-              typeParser.pipeableType(t.outType, flow2.node),
-              option
-            );
-            if (isPipeable._tag === "Some") {
-              firstPipeableIndex = i + 1;
-              break;
-            }
+          if (!isSafelyPipeableCallee(t.callee)) {
+            break;
           }
+          pipeableTransformations.push(t);
         }
-      }
-      if (firstPipeableIndex === -1) {
-        continue;
-      }
-      const transformationsAfterPipeable = flow2.transformations.slice(firstPipeableIndex);
-      const callKindCount = transformationsAfterPipeable.filter((t) => t.kind === "call").length;
-      if (callKindCount < options.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: gen(function* () {
-            const changeTracker = yield* service(ChangeTracker);
-            const pipeArgs = pipeableTransformations.map((t) => {
-              if (t.args) {
-                return ts.factory.createCallExpression(
-                  t.callee,
+        const callKindCount = pipeableTransformations.filter((t) => t.kind === "call").length;
+        if (callKindCount >= options.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: gen(function* () {
+                const changeTracker = yield* service(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;
+      }
     }
   })
 });
@@ -10074,6 +10350,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: fn("preferSchemaOverJson.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const parseJsonMethod = (node) => gen(function* () {
+      if (!ts.isCallExpression(node)) return yield* fail3("node is not a call expression");
+      const expression = node.expression;
+      if (!ts.isPropertyAccessExpression(expression)) return yield* fail3("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* fail3("object is not JSON");
+      }
+      if (methodName !== "parse" && methodName !== "stringify") {
+        return yield* fail3("method is not parse or stringify");
+      }
+      return { node, methodName };
+    });
+    const effectTrySimple = (node) => gen(function* () {
+      if (!ts.isCallExpression(node)) return yield* fail3("node is not a call expression");
+      yield* typeParser.isNodeReferenceToEffectModuleApi("try")(node.expression);
+      if (node.arguments.length === 0) return yield* fail3("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) => gen(function* () {
+      if (!ts.isCallExpression(node)) return yield* fail3("node is not a call expression");
+      yield* typeParser.isNodeReferenceToEffectModuleApi("try")(node.expression);
+      if (node.arguments.length === 0) return yield* fail3("Effect.try has no arguments");
+      const arg = node.arguments[0];
+      if (!ts.isObjectLiteralExpression(arg)) return yield* fail3("argument is not an object literal");
+      const tryProp = arg.properties.find(
+        (p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && ts.idText(p.name) === "try"
+      );
+      if (!tryProp) return yield* fail3("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) => gen(function* () {
+      const jsonMethod = yield* parseJsonMethod(node);
+      const { effectGen, scopeNode } = yield* typeParser.findEnclosingScopes(node);
+      if (!effectGen || effectGen.body.statements.length === 0) {
+        return yield* fail3("not inside an Effect generator");
+      }
+      if (scopeNode && scopeNode !== effectGen.generatorFunction) {
+        return yield* fail3("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 match3 = yield* pipe(
+        firstSuccessOf([
+          effectTrySimple(node),
+          effectTryObject(node),
+          jsonMethodInEffectGen(node)
+        ]),
+        option
+      );
+      if (isSome2(match3)) {
+        report({
+          location: match3.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",
@@ -10226,108 +10586,91 @@ var runEffectInsideEffect = createDiagnostic({
         option
       );
       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),
-          orElse2(() => typeParser.effectFnUntracedGen(possiblyEffectGen)),
-          orElse2(() => typeParser.effectFnGen(possiblyEffectGen)),
-          option
+      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 = gen(function* () {
-              const changeTracker = yield* service(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),
-                        option
-                      );
-                      if (isSome2(maybeEffectRuntime) && ts.isIdentifier(declaration.name)) {
-                        runtimeIdentifier = ts.idText(declaration.name);
-                      }
+        if (scopeNode && scopeNode !== effectGen.generatorFunction) {
+          const fixAddRuntime = gen(function* () {
+            const changeTracker = yield* service(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),
+                      option
+                    );
+                    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;
       }
     }
   })
@@ -10413,6 +10756,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: fn("schemaSyncInEffect.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const parseSchemaSyncMethod = (node, methodName) => pipe(
+      typeParser.isNodeReferenceToEffectParseResultModuleApi(methodName)(node),
+      map8(() => ({ 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(
+        firstSuccessOf(
+          Object.keys(syncToEffectMethod).map((methodName) => parseSchemaSyncMethod(node.expression, methodName))
+        ),
+        option
+      );
+      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",
@@ -11127,7 +11523,9 @@ var diagnostics = [
   layerMergeAllWithDependencies,
   effectMapVoid,
   effectFnOpportunity,
-  redundantSchemaTagIdentifier
+  redundantSchemaTagIdentifier,
+  schemaSyncInEffect,
+  preferSchemaOverJson
 ];
 
 // src/completions/effectDiagnosticsComment.ts