@effect/language-service 0.64.0 → 0.65.0

package/transform.js

@@ -24,7 +24,7 @@ __export(transform_exports, {
 });
 module.exports = __toCommonJS(transform_exports);
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Function.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
 var dual = function(arity, body) {
   if (typeof arity === "function") {
@@ -120,7 +120,7 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   }
 }
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/GlobalValue.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/GlobalValue.js
 var globalStoreId = `effect/GlobalValue`;
 var globalStore;
 var globalValue = (id, compute) => {
@@ -134,7 +134,7 @@ var globalValue = (id, compute) => {
   return globalStore.get(id);
 };
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Predicate.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Predicate.js
 var isString = (input) => typeof input === "string";
 var isNumber = (input) => typeof input === "number";
 var isBoolean = (input) => typeof input === "boolean";
@@ -144,7 +144,7 @@ var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
 var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) && property in self);
 var isRecord = (input) => isRecordOrArray(input) && !Array.isArray(input);
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Utils.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Utils.js
 var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
 var GenKindImpl = class {
   value;
@@ -266,7 +266,7 @@ var internalCall = isNotOptimizedAway ? standard.effect_internal_function : forc
 var genConstructor = function* () {
 }.constructor;
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Hash.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Hash.js
 var randomHashCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/randomHashCache"), () => /* @__PURE__ */ new WeakMap());
 var symbol = /* @__PURE__ */ Symbol.for("effect/Hash");
 var hash = (self) => {
@@ -368,7 +368,7 @@ var cached = function() {
   return hash2;
 };
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Equal.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Equal.js
 var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
 function equals() {
   if (arguments.length === 1) {
@@ -424,7 +424,7 @@ function compareBoth(self, that) {
 var isEqual = (u) => hasProperty(u, symbol2);
 var equivalence = () => equals;
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Inspectable.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJSON = (x) => {
   try {
@@ -476,7 +476,7 @@ var redact = (u) => {
   return u;
 };
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Pipeable.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Pipeable.js
 var pipeArguments = (self, args2) => {
   switch (args2.length) {
     case 0:
@@ -509,14 +509,14 @@ var pipeArguments = (self, args2) => {
   }
 };
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/opCodes/effect.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/opCodes/effect.js
 var OP_COMMIT = "Commit";
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/version.js
-var moduleVersion = "3.19.13";
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/version.js
+var moduleVersion = "3.19.14";
 var getCurrentVersion = () => moduleVersion;
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/effectable.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/effectable.js
 var EffectTypeId = /* @__PURE__ */ Symbol.for("effect/Effect");
 var StreamTypeId = /* @__PURE__ */ Symbol.for("effect/Stream");
 var SinkTypeId = /* @__PURE__ */ Symbol.for("effect/Sink");
@@ -603,7 +603,7 @@ var StructuralCommitPrototype = {
   ...StructuralPrototype
 };
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/option.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/option.js
 var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
 var CommonProto = {
   ...EffectPrototype,
@@ -661,7 +661,7 @@ var some = (value) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/either.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/either.js
 var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
 var CommonProto2 = {
   ...EffectPrototype,
@@ -723,7 +723,7 @@ var right = (right3) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Either.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Either.js
 var right2 = right;
 var left2 = left;
 var isLeft2 = isLeft;
@@ -731,14 +731,14 @@ var isRight2 = isRight;
 var map = /* @__PURE__ */ dual(2, (self, f) => isRight2(self) ? right2(f(self.right)) : left2(self.left));
 var getOrElse = /* @__PURE__ */ dual(2, (self, onLeft) => isLeft2(self) ? onLeft(self.left) : self.right);
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/array.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/array.js
 var isNonEmptyArray = (self) => self.length > 0;
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Order.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Order.js
 var make = (compare) => (self, that) => self === that ? 0 : compare(self, that);
 var string2 = /* @__PURE__ */ make((self, that) => self < that ? -1 : 1);
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Option.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Option.js
 var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
@@ -748,7 +748,7 @@ var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : se
 var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
 var getOrUndefined = /* @__PURE__ */ getOrElse2(constUndefined);
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Record.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Record.js
 var map2 = /* @__PURE__ */ dual(2, (self, f) => {
   const out = {
     ...self
@@ -760,7 +760,7 @@ var map2 = /* @__PURE__ */ dual(2, (self, f) => {
 });
 var keys = (self) => Object.keys(self);
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Array.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Array.js
 var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
 var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
@@ -783,7 +783,6 @@ var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
 var head = /* @__PURE__ */ get(0);
 var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
 var tailNonEmpty = (self) => self.slice(1);
-var reverse = (self) => Array.from(self).reverse();
 var sort = /* @__PURE__ */ dual(2, (self, O) => {
   const out = Array.from(self);
   out.sort(O);
@@ -1202,7 +1201,7 @@ var defaults = {
   diagnosticSeverity: {},
   diagnosticsName: true,
   missingDiagnosticNextLine: "warning",
-  reportSuggestionsAsWarningsInTsc: false,
+  includeSuggestionsInTsc: true,
   quickinfo: true,
   quickinfoEffectParameters: "whentruncated",
   quickinfoMaximumLength: -1,
@@ -1226,7 +1225,7 @@ var defaults = {
     skipLeadingPath: ["src/"]
   }],
   extendedKeyDetection: false,
-  pipeableMinArgCount: 1,
+  pipeableMinArgCount: 2,
   layerGraphFollowDepth: 0,
   mermaidProvider: "mermaid.live"
 };
@@ -1249,7 +1248,7 @@ function parse(config) {
     diagnosticSeverity: isObject(config) && hasProperty(config, "diagnosticSeverity") && isRecord(config.diagnosticSeverity) ? parseDiagnosticSeverity(config.diagnosticSeverity) : defaults.diagnosticSeverity,
     diagnosticsName: isObject(config) && hasProperty(config, "diagnosticsName") && isBoolean(config.diagnosticsName) ? config.diagnosticsName : defaults.diagnosticsName,
     missingDiagnosticNextLine: isObject(config) && hasProperty(config, "missingDiagnosticNextLine") && isString(config.missingDiagnosticNextLine) && isValidSeverityLevel(config.missingDiagnosticNextLine) ? config.missingDiagnosticNextLine : defaults.missingDiagnosticNextLine,
-    reportSuggestionsAsWarningsInTsc: isObject(config) && hasProperty(config, "reportSuggestionsAsWarningsInTsc") && isBoolean(config.reportSuggestionsAsWarningsInTsc) ? config.reportSuggestionsAsWarningsInTsc : defaults.reportSuggestionsAsWarningsInTsc,
+    includeSuggestionsInTsc: isObject(config) && hasProperty(config, "includeSuggestionsInTsc") && isBoolean(config.includeSuggestionsInTsc) ? config.includeSuggestionsInTsc : defaults.includeSuggestionsInTsc,
     quickinfo: isObject(config) && hasProperty(config, "quickinfo") && isBoolean(config.quickinfo) ? config.quickinfo : defaults.quickinfo,
     quickinfoEffectParameters: isObject(config) && hasProperty(config, "quickinfoEffectParameters") && isString(config.quickinfoEffectParameters) && ["always", "never", "whentruncated"].includes(config.quickinfoEffectParameters.toLowerCase()) ? config.quickinfoEffectParameters.toLowerCase() : defaults.quickinfoEffectParameters,
     quickinfoMaximumLength: isObject(config) && hasProperty(config, "quickinfoMaximumLength") && isNumber(config.quickinfoMaximumLength) ? config.quickinfoMaximumLength : defaults.quickinfoMaximumLength,
@@ -1819,6 +1818,16 @@ function makeTypeScriptUtils(ts) {
   function isDeclarationKind(kind) {
     return kind === ts.SyntaxKind.ArrowFunction || kind === ts.SyntaxKind.BindingElement || kind === ts.SyntaxKind.ClassDeclaration || kind === ts.SyntaxKind.ClassExpression || kind === ts.SyntaxKind.ClassStaticBlockDeclaration || kind === ts.SyntaxKind.Constructor || kind === ts.SyntaxKind.EnumDeclaration || kind === ts.SyntaxKind.EnumMember || kind === ts.SyntaxKind.ExportSpecifier || kind === ts.SyntaxKind.FunctionDeclaration || kind === ts.SyntaxKind.FunctionExpression || kind === ts.SyntaxKind.GetAccessor || kind === ts.SyntaxKind.ImportClause || kind === ts.SyntaxKind.ImportEqualsDeclaration || kind === ts.SyntaxKind.ImportSpecifier || kind === ts.SyntaxKind.InterfaceDeclaration || kind === ts.SyntaxKind.JsxAttribute || kind === ts.SyntaxKind.MethodDeclaration || kind === ts.SyntaxKind.MethodSignature || kind === ts.SyntaxKind.ModuleDeclaration || kind === ts.SyntaxKind.NamespaceExportDeclaration || kind === ts.SyntaxKind.NamespaceImport || kind === ts.SyntaxKind.NamespaceExport || kind === ts.SyntaxKind.Parameter || kind === ts.SyntaxKind.PropertyAssignment || kind === ts.SyntaxKind.PropertyDeclaration || kind === ts.SyntaxKind.PropertySignature || kind === ts.SyntaxKind.SetAccessor || kind === ts.SyntaxKind.ShorthandPropertyAssignment || kind === ts.SyntaxKind.TypeAliasDeclaration || kind === ts.SyntaxKind.TypeParameter || kind === ts.SyntaxKind.VariableDeclaration || kind === ts.SyntaxKind.JSDocTypedefTag || kind === ts.SyntaxKind.JSDocCallbackTag || kind === ts.SyntaxKind.JSDocPropertyTag || kind === ts.SyntaxKind.NamedTupleMember;
   }
+  function isVoidExpression(node) {
+    const unwrapped = ts.isExpression(node) ? skipOuterExpressions(node) : node;
+    if (ts.isVoidExpression(unwrapped) && ts.isNumericLiteral(unwrapped.expression) && unwrapped.expression.text === "0") {
+      return true;
+    }
+    if (ts.isIdentifier(unwrapped) && ts.idText(unwrapped) === "undefined") {
+      return true;
+    }
+    return false;
+  }
   return {
     findNodeAtPositionIncludingTrivia,
     parsePackageContentNameAndVersionFromScope,
@@ -1842,7 +1851,8 @@ function makeTypeScriptUtils(ts) {
     getSourceFileOfNode,
     isOuterExpression,
     skipOuterExpressions,
-    isDeclarationKind
+    isDeclarationKind,
+    isVoidExpression
   };
 }
 
@@ -3019,13 +3029,15 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
         );
       }
       const propertyAccess = node.expression;
+      const pipeArguments2 = node.arguments.slice(1);
       return pipe(
         isNodeReferenceToEffectModuleApi("fnUntraced")(propertyAccess),
         map4(() => ({
           node,
           effectModule: propertyAccess.expression,
           generatorFunction,
-          body: generatorFunction.body
+          body: generatorFunction.body,
+          pipeArguments: pipeArguments2
         }))
       );
     },
@@ -3064,13 +3076,15 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
         );
       }
       const propertyAccess = expressionToTest;
+      const pipeArguments2 = node.arguments.slice(1);
       return pipe(
         isNodeReferenceToEffectModuleApi("fn")(propertyAccess),
         map4(() => ({
           node,
           generatorFunction,
           effectModule: propertyAccess.expression,
-          body: generatorFunction.body
+          body: generatorFunction.body,
+          pipeArguments: pipeArguments2
         }))
       );
     },
@@ -3257,6 +3271,23 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     "TypeParser.pipeCall",
     (node) => node
   );
+  const singleArgCall = cachedBy(
+    function(node) {
+      if (!ts.isCallExpression(node)) {
+        return typeParserIssue("Node is not a call expression", void 0, node);
+      }
+      if (node.arguments.length !== 1) {
+        return typeParserIssue("Node must have exactly one argument", void 0, node);
+      }
+      return succeed({
+        node,
+        callee: node.expression,
+        subject: node.arguments[0]
+      });
+    },
+    "TypeParser.singleArgCall",
+    (node) => node
+  );
   const scopeType = cachedBy(
     fn("TypeParser.scopeType")(function* (type, atLocation) {
       yield* pipeableType(type, atLocation);
@@ -3795,6 +3826,266 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     `TypeParser.isNodeReferenceToEffectLayerModuleApi(${memberName})`,
     (node) => node
   );
+  const lazyExpression = cachedBy(
+    function(node) {
+      if (!ts.isArrowFunction(node) && !ts.isFunctionExpression(node)) {
+        return typeParserIssue("Node is not an arrow function or function expression", void 0, node);
+      }
+      if (node.parameters.length !== 0) {
+        return typeParserIssue("Function must have zero parameters", void 0, node);
+      }
+      if (node.typeParameters && node.typeParameters.length > 0) {
+        return typeParserIssue("Function must have no type parameters", void 0, node);
+      }
+      const body = node.body;
+      const returnType = node.type;
+      if (ts.isArrowFunction(node) && !ts.isBlock(body)) {
+        return succeed({
+          node,
+          body,
+          expression: body,
+          returnType
+        });
+      }
+      if (ts.isBlock(body)) {
+        if (body.statements.length !== 1) {
+          return typeParserIssue("Block must have exactly one statement", void 0, node);
+        }
+        const stmt = body.statements[0];
+        if (!ts.isReturnStatement(stmt)) {
+          return typeParserIssue("Statement must be a return statement", void 0, node);
+        }
+        if (!stmt.expression) {
+          return typeParserIssue("Return statement must have an expression", void 0, node);
+        }
+        return succeed({
+          node,
+          body,
+          expression: stmt.expression,
+          returnType
+        });
+      }
+      return typeParserIssue("Invalid function body", void 0, node);
+    },
+    "TypeParser.lazyExpression",
+    (node) => node
+  );
+  const emptyFunction = cachedBy(
+    function(node) {
+      if (!ts.isArrowFunction(node) && !ts.isFunctionExpression(node)) {
+        return typeParserIssue("Node is not an arrow function or function expression", void 0, node);
+      }
+      const body = node.body;
+      const returnType = node.type;
+      if (!ts.isBlock(body)) {
+        return typeParserIssue("Body must be a block", void 0, node);
+      }
+      if (body.statements.length !== 0) {
+        return typeParserIssue("Block must have zero statements", void 0, node);
+      }
+      return succeed({
+        node,
+        body,
+        returnType
+      });
+    },
+    "TypeParser.emptyFunction",
+    (node) => node
+  );
+  const pipingFlows = (includeEffectFn) => cachedBy(
+    fn("TypeParser.pipingFlows")(function* (sourceFile) {
+      const result = [];
+      const workQueue = [[sourceFile, void 0]];
+      while (workQueue.length > 0) {
+        const [node, parentFlow] = workQueue.pop();
+        if (ts.isCallExpression(node)) {
+          const parsed = yield* pipe(
+            pipeCall(node),
+            map4((p) => ({ _tag: "pipe", ...p })),
+            orElse2(
+              () => pipe(
+                singleArgCall(node),
+                map4((s) => ({ _tag: "call", ...s }))
+              )
+            ),
+            option
+          );
+          if (isSome2(parsed)) {
+            const result2 = parsed.value;
+            let transformations;
+            let flowNode;
+            let childrenToTraverse = [];
+            if (result2._tag === "pipe") {
+              const signature = typeChecker.getResolvedSignature(result2.node);
+              const typeArguments = signature ? typeChecker.getTypeArgumentsForResolvedSignature(signature) : void 0;
+              transformations = [];
+              for (let i = 0; i < result2.args.length; i++) {
+                const arg = result2.args[i];
+                const outType = typeArguments?.[i + 1];
+                if (ts.isCallExpression(arg)) {
+                  transformations.push({
+                    callee: arg.expression,
+                    // e.g., Effect.map
+                    args: Array.from(arg.arguments),
+                    // e.g., [(x) => x + 1]
+                    outType,
+                    kind: result2.kind
+                  });
+                } else {
+                  transformations.push({
+                    callee: arg,
+                    // e.g., Effect.asVoid
+                    args: void 0,
+                    outType,
+                    kind: result2.kind
+                  });
+                }
+              }
+              flowNode = result2.node;
+              childrenToTraverse = result2.args;
+            } else {
+              const callSignature = typeChecker.getResolvedSignature(node);
+              const outType = callSignature ? typeChecker.getReturnTypeOfSignature(callSignature) : void 0;
+              transformations = [{
+                callee: result2.callee,
+                args: void 0,
+                outType,
+                kind: "call"
+              }];
+              flowNode = node;
+            }
+            if (parentFlow) {
+              parentFlow.transformations.unshift(...transformations);
+              parentFlow.subject = {
+                node: result2.subject,
+                outType: typeCheckerUtils.getTypeAtLocation(result2.subject)
+              };
+              workQueue.push([result2.subject, parentFlow]);
+            } else {
+              const newFlow = {
+                node: flowNode,
+                subject: {
+                  node: result2.subject,
+                  outType: typeCheckerUtils.getTypeAtLocation(result2.subject)
+                },
+                transformations
+              };
+              workQueue.push([result2.subject, newFlow]);
+            }
+            for (const child of childrenToTraverse) {
+              ts.forEachChild(child, (c) => {
+                workQueue.push([c, void 0]);
+              });
+            }
+            continue;
+          }
+          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 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 (parentFlow && parentFlow.transformations.length > 0) {
+          result.push(parentFlow);
+        }
+        ts.forEachChild(node, (child) => {
+          workQueue.push([child, void 0]);
+        });
+      }
+      result.sort((a, b) => a.node.pos - b.node.pos);
+      return result;
+    }),
+    `TypeParser.pipingFlows(${includeEffectFn})`,
+    (sourceFile) => sourceFile
+  );
+  const reconstructPipingFlow = (flow2) => {
+    if (flow2.transformations.length > 0 && flow2.transformations.every((t) => t.kind === "effectFn" || t.kind === "effectFnUntraced")) {
+      return flow2.subject.node;
+    }
+    let result = flow2.subject.node;
+    for (const t of flow2.transformations) {
+      if (t.kind === "call") {
+        result = ts.factory.createCallExpression(
+          t.callee,
+          void 0,
+          [result]
+        );
+      } else if (t.kind === "effectFn" || t.kind === "effectFnUntraced") {
+        continue;
+      } else {
+        if (t.args) {
+          const transformCall = ts.factory.createCallExpression(
+            t.callee,
+            void 0,
+            t.args
+          );
+          result = ts.factory.createCallExpression(
+            transformCall,
+            void 0,
+            [result]
+          );
+        } else {
+          result = ts.factory.createCallExpression(
+            t.callee,
+            void 0,
+            [result]
+          );
+        }
+      }
+    }
+    return result;
+  };
   return {
     isNodeReferenceToEffectModuleApi,
     isNodeReferenceToEffectSchemaModuleApi,
@@ -3817,6 +4108,7 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     contextTag,
     pipeableType,
     pipeCall,
+    singleArgCall,
     scopeType,
     promiseLike,
     extendsEffectTag,
@@ -3828,7 +4120,11 @@ function make2(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     extendsDataTaggedError,
     extendsDataTaggedClass,
     extendsSchemaTaggedRequest,
-    extendsEffectSqlModelClass
+    extendsEffectSqlModelClass,
+    lazyExpression,
+    emptyFunction,
+    pipingFlows,
+    reconstructPipingFlow
   };
 }
 
@@ -3982,48 +4278,45 @@ var catchAllToMapError = createDiagnostic({
         return none2();
       });
     };
-    const nodeToVisit = [];
-    const appendNodeToVisit = (node) => {
-      nodeToVisit.push(node);
-      return void 0;
-    };
-    ts.forEachChild(sourceFile, appendNodeToVisit);
-    while (nodeToVisit.length > 0) {
-      const node = nodeToVisit.shift();
-      ts.forEachChild(node, appendNodeToVisit);
-      if (ts.isCallExpression(node)) {
+    const flows = yield* typeParser.pipingFlows(true)(sourceFile);
+    for (const flow2 of flows) {
+      for (const transformation of flow2.transformations) {
+        if (!transformation.args || transformation.args.length === 0) {
+          continue;
+        }
         const isCatchAllCall = yield* pipe(
-          typeParser.isNodeReferenceToEffectModuleApi("catchAll")(node.expression),
+          typeParser.isNodeReferenceToEffectModuleApi("catchAll")(transformation.callee),
           option
         );
-        if (isSome2(isCatchAllCall)) {
-          const callback = node.arguments[0];
-          if (!callback) continue;
-          const functionBody = getFunctionBody(callback);
-          if (!functionBody) continue;
-          const failCallInfo = yield* getEffectFailCallInfo(functionBody);
-          if (isNone2(failCallInfo)) continue;
-          const { failArg, failCall } = failCallInfo.value;
-          report({
-            location: node.expression,
-            messageText: `You can use Effect.mapError instead of Effect.catchAll + Effect.fail to transform the error type.`,
-            fixes: [{
-              fixName: "catchAllToMapError_fix",
-              description: "Replace with Effect.mapError",
-              apply: gen(function* () {
-                const changeTracker = yield* service(ChangeTracker);
-                if (ts.isPropertyAccessExpression(node.expression)) {
-                  changeTracker.replaceNode(
-                    sourceFile,
-                    node.expression.name,
-                    ts.factory.createIdentifier("mapError")
-                  );
-                }
-                changeTracker.replaceNode(sourceFile, failCall, failArg);
-              })
-            }]
-          });
+        if (isNone2(isCatchAllCall)) {
+          continue;
         }
+        const callback = transformation.args[0];
+        if (!callback) continue;
+        const functionBody = getFunctionBody(callback);
+        if (!functionBody) continue;
+        const failCallInfo = yield* getEffectFailCallInfo(functionBody);
+        if (isNone2(failCallInfo)) continue;
+        const { failArg, failCall } = failCallInfo.value;
+        report({
+          location: transformation.callee,
+          messageText: `You can use Effect.mapError instead of Effect.catchAll + Effect.fail to transform the error type.`,
+          fixes: [{
+            fixName: "catchAllToMapError_fix",
+            description: "Replace with Effect.mapError",
+            apply: gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              if (ts.isPropertyAccessExpression(transformation.callee)) {
+                changeTracker.replaceNode(
+                  sourceFile,
+                  transformation.callee.name,
+                  ts.factory.createIdentifier("mapError")
+                );
+              }
+              changeTracker.replaceNode(sourceFile, failCall, failArg);
+            })
+          }]
+        });
       }
     }
   })
@@ -4038,66 +4331,39 @@ var catchUnfailableEffect = createDiagnostic({
   apply: fn("catchUnfailableEffect.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeParser = yield* service(TypeParser);
-    const typeChecker = yield* service(TypeCheckerApi);
-    const typeCheckerUtils = yield* service(TypeCheckerUtils);
-    const nodeToVisit = [];
-    const appendNodeToVisit = (node) => {
-      nodeToVisit.push(node);
-      return void 0;
-    };
-    ts.forEachChild(sourceFile, appendNodeToVisit);
-    while (nodeToVisit.length > 0) {
-      const node = nodeToVisit.shift();
-      ts.forEachChild(node, appendNodeToVisit);
-      if (ts.isCallExpression(node)) {
-        const catchFunctions = ["catchAll", "catch", "catchIf", "catchSome", "catchTag", "catchTags"];
+    const catchFunctions = ["catchAll", "catch", "catchIf", "catchSome", "catchTag", "catchTags"];
+    const flows = yield* typeParser.pipingFlows(true)(sourceFile);
+    for (const flow2 of flows) {
+      for (let i = 0; i < flow2.transformations.length; i++) {
+        const transformation = flow2.transformations[i];
+        if (!transformation.args || transformation.args.length === 0) {
+          continue;
+        }
         const isCatchCall = yield* pipe(
           firstSuccessOf(
-            catchFunctions.map((catchFn) => typeParser.isNodeReferenceToEffectModuleApi(catchFn)(node.expression))
+            catchFunctions.map((catchFn) => typeParser.isNodeReferenceToEffectModuleApi(catchFn)(transformation.callee))
           ),
           option
         );
-        if (isSome2(isCatchCall)) {
-          const parent = node.parent;
-          if (parent && ts.isCallExpression(parent)) {
-            const pipeCallResult = yield* pipe(
-              typeParser.pipeCall(parent),
-              option
-            );
-            if (isSome2(pipeCallResult)) {
-              const { args: args2, node: pipeCallNode, subject } = pipeCallResult.value;
-              const argIndex = args2.findIndex((arg) => arg === node);
-              if (argIndex !== -1) {
-                let effectTypeToCheck;
-                if (argIndex === 0) {
-                  effectTypeToCheck = typeCheckerUtils.getTypeAtLocation(subject);
-                } else {
-                  const signature = typeChecker.getResolvedSignature(pipeCallNode);
-                  if (signature) {
-                    const typeArguments = typeChecker.getTypeArgumentsForResolvedSignature(signature);
-                    if (typeArguments && typeArguments.length > argIndex) {
-                      effectTypeToCheck = typeArguments[argIndex];
-                    }
-                  }
-                }
-                if (effectTypeToCheck) {
-                  const effectType = yield* pipe(
-                    typeParser.effectType(effectTypeToCheck, node),
-                    option
-                  );
-                  if (isSome2(effectType)) {
-                    const { E } = effectType.value;
-                    if (E.flags & ts.TypeFlags.Never) {
-                      report({
-                        location: node.expression,
-                        messageText: `Looks like the previous effect never fails, so probably this error handling will never be triggered.`,
-                        fixes: []
-                      });
-                    }
-                  }
-                }
-              }
-            }
+        if (isNone2(isCatchCall)) {
+          continue;
+        }
+        const inputType = i === 0 ? flow2.subject.outType : flow2.transformations[i - 1].outType;
+        if (!inputType) {
+          continue;
+        }
+        const effectType = yield* pipe(
+          typeParser.effectType(inputType, transformation.callee),
+          option
+        );
+        if (isSome2(effectType)) {
+          const { E } = effectType.value;
+          if (E.flags & ts.TypeFlags.Never) {
+            report({
+              location: transformation.callee,
+              messageText: `Looks like the previous effect never fails, so probably this error handling will never be triggered.`,
+              fixes: []
+            });
           }
         }
       }
@@ -4406,6 +4672,245 @@ ${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),
+    map4(({ 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",
+  severity: "suggestion",
+  apply: fn("effectFnOpportunity.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    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 createEffectFnNode = (originalNode, generatorFunction, effectModuleName, traceName, effectTypes, pipeArguments2) => {
+      const returnTypeAnnotation = effectTypes ? createReturnTypeAnnotation(effectModuleName, effectTypes, originalNode) : void 0;
+      const newGeneratorFunction = ts.factory.createFunctionExpression(
+        void 0,
+        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+        void 0,
+        originalNode.typeParameters,
+        originalNode.parameters,
+        returnTypeAnnotation,
+        generatorFunction.body
+      );
+      let fnExpression = ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectModuleName),
+        "fn"
+      );
+      if (traceName) {
+        fnExpression = ts.factory.createCallExpression(
+          fnExpression,
+          void 0,
+          [ts.factory.createStringLiteral(traceName)]
+        );
+      }
+      const effectFnCall = ts.factory.createCallExpression(
+        fnExpression,
+        void 0,
+        [newGeneratorFunction, ...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(
+        void 0,
+        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+        void 0,
+        originalNode.typeParameters,
+        originalNode.parameters,
+        returnTypeAnnotation,
+        generatorFunction.body
+      );
+      const effectFnCall = ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(
+          ts.factory.createIdentifier(effectModuleName),
+          "fnUntraced"
+        ),
+        void 0,
+        [newGeneratorFunction, ...pipeArguments2]
+      );
+      if (ts.isFunctionDeclaration(originalNode)) {
+        return tsUtils.tryPreserveDeclarationSemantics(originalNode, effectFnCall, false);
+      }
+      return effectFnCall;
+    };
+    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 target = yield* pipe(
+        parseEffectFnOpportunityTarget(node, sourceFile),
+        option
+      );
+      if (isNone2(target)) continue;
+      const {
+        effectModuleName,
+        effectTypes,
+        generatorFunction,
+        hasReturnTypeAnnotation,
+        nameIdentifier,
+        node: targetNode,
+        pipeArguments: pipeArguments2,
+        traceName
+      } = target.value;
+      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
+          );
+          changeTracker.replaceNode(sourceFile, targetNode, newNode);
+        })
+      });
+      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.`,
+        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({
   name: "effectGenUsesAdapter",
@@ -4493,6 +4998,70 @@ var effectInVoidSuccess = createDiagnostic({
   })
 });
 
+// src/diagnostics/effectMapVoid.ts
+var effectMapVoid = createDiagnostic({
+  name: "effectMapVoid",
+  code: 40,
+  description: "Suggests using Effect.asVoid instead of Effect.map(() => void 0), Effect.map(() => undefined), or Effect.map(() => {})",
+  severity: "suggestion",
+  apply: fn("effectMapVoid.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isCallExpression(node)) {
+        const isMapCall = yield* pipe(
+          typeParser.isNodeReferenceToEffectModuleApi("map")(node.expression),
+          option
+        );
+        if (isSome2(isMapCall)) {
+          const callback = node.arguments[0];
+          if (!callback) continue;
+          const match2 = yield* pipe(
+            typeParser.emptyFunction(callback),
+            orElse2(
+              () => pipe(
+                typeParser.lazyExpression(callback),
+                flatMap2(
+                  (lazy) => tsUtils.isVoidExpression(lazy.expression) ? succeed(lazy) : typeParserIssue("Expression is not void")
+                )
+              )
+            ),
+            option
+          );
+          if (isNone2(match2)) continue;
+          report({
+            location: node.expression,
+            messageText: "Effect.asVoid can be used instead to discard the success value",
+            fixes: [{
+              fixName: "effectMapVoid_fix",
+              description: "Replace with Effect.asVoid",
+              apply: gen(function* () {
+                const changeTracker = yield* service(ChangeTracker);
+                if (ts.isPropertyAccessExpression(node.expression)) {
+                  const newNode = ts.factory.createPropertyAccessExpression(
+                    node.expression.expression,
+                    ts.factory.createIdentifier("asVoid")
+                  );
+                  changeTracker.replaceNode(sourceFile, node, newNode);
+                }
+              })
+            }]
+          });
+        }
+      }
+    }
+  })
+});
+
 // src/diagnostics/floatingEffect.ts
 var floatingEffect = createDiagnostic({
   name: "floatingEffect",
@@ -5101,75 +5670,91 @@ var missedPipeableOpportunity = createDiagnostic({
   apply: fn("missedPipeableOpportunity.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 options = yield* service(LanguageServicePluginOptions);
-    const nodeToVisit = [sourceFile];
-    const prependNodeToVisit = (node) => {
-      nodeToVisit.unshift(node);
-      return void 0;
-    };
-    const callChainNodes = /* @__PURE__ */ new WeakMap();
-    while (nodeToVisit.length > 0) {
-      const node = nodeToVisit.shift();
-      if (ts.isCallExpression(node) && node.arguments.length === 1) {
-        const isPipeCall = yield* pipe(typeParser.pipeCall(node), orElse2(() => void_));
-        if (!isPipeCall) {
-          const resolvedSignature = typeChecker.getResolvedSignature(node);
-          if (resolvedSignature) {
-            const returnType = typeChecker.getReturnTypeOfSignature(resolvedSignature);
-            if (returnType) {
-              const callSignatures = typeChecker.getSignaturesOfType(returnType, ts.SignatureKind.Call);
-              if (callSignatures.length === 0) {
-                const parentChain = callChainNodes.get(node) || [];
-                callChainNodes.set(node.arguments[0], parentChain.concat(node));
-              }
+    const flows = yield* typeParser.pipingFlows(false)(sourceFile);
+    for (const flow2 of flows) {
+      if (flow2.transformations.length < options.pipeableMinArgCount) {
+        continue;
+      }
+      const finalType = flow2.transformations[flow2.transformations.length - 1].outType;
+      if (!finalType) {
+        continue;
+      }
+      const callSigs = typeChecker.getSignaturesOfType(finalType, ts.SignatureKind.Call);
+      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 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;
             }
           }
         }
-      } else if (callChainNodes.has(node) && ts.isExpression(node)) {
-        const parentChain = (callChainNodes.get(node) || []).slice();
-        const originalParentChain = parentChain.slice();
-        while (parentChain.length > options.pipeableMinArgCount) {
-          const subject = parentChain.pop();
-          const resultType = typeCheckerUtils.getTypeAtLocation(subject);
-          if (!resultType) continue;
-          const pipeableType = yield* pipe(typeParser.pipeableType(resultType, subject), orElse2(() => void_));
-          if (pipeableType) {
-            report({
-              location: parentChain[0],
-              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);
-                  changeTracker.replaceNode(
-                    sourceFile,
-                    parentChain[0],
-                    ts.factory.createCallExpression(
-                      ts.factory.createPropertyAccessExpression(
-                        subject,
-                        "pipe"
-                      ),
-                      void 0,
-                      pipe(
-                        parentChain,
-                        filter(ts.isCallExpression),
-                        map3((call) => call.expression),
-                        reverse
-                      )
-                    )
-                  );
-                })
-              }]
-            });
-            originalParentChain.forEach((node2) => callChainNodes.delete(node2));
-            break;
-          }
-        }
       }
-      ts.forEachChild(node, prependNodeToVisit);
+      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,
+                  void 0,
+                  t.args
+                );
+              } else {
+                return t.callee;
+              }
+            });
+            const newNode = ts.factory.createCallExpression(
+              ts.factory.createPropertyAccessExpression(
+                pipeableSubjectNode,
+                "pipe"
+              ),
+              void 0,
+              pipeArgs
+            );
+            changeTracker.replaceNode(sourceFile, flow2.node, newNode);
+          })
+        }]
+      });
     }
   })
 });
@@ -5668,28 +6253,34 @@ var multipleEffectProvide = createDiagnostic({
       "effect",
       "Layer"
     ) || "Layer";
-    const parseEffectProvideLayer = (node) => {
-      if (ts.isCallExpression(node) && node.arguments.length > 0) {
-        const layer = node.arguments[0];
-        const type = typeCheckerUtils.getTypeAtLocation(layer);
-        if (!type) return void_;
-        return pipe(
-          typeParser.isNodeReferenceToEffectModuleApi("provide")(node.expression),
-          flatMap2(() => typeParser.layerType(type, layer)),
-          map4(() => ({ layer, node })),
-          orElse2(() => void_)
-        );
-      }
-      return void_;
-    };
-    const parsePipeCall = (node) => gen(function* () {
-      const { args: args2 } = yield* typeParser.pipeCall(node);
+    const flows = yield* typeParser.pipingFlows(true)(sourceFile);
+    for (const flow2 of flows) {
       let currentChunk = 0;
       const previousLayers = [[]];
-      for (const pipeArg of args2) {
-        const parsedProvide = yield* parseEffectProvideLayer(pipeArg);
-        if (parsedProvide) {
-          previousLayers[currentChunk].push(parsedProvide);
+      for (const transformation of flow2.transformations) {
+        if (!transformation.args || transformation.args.length === 0) {
+          currentChunk++;
+          previousLayers.push([]);
+          continue;
+        }
+        const isProvideCall = yield* pipe(
+          typeParser.isNodeReferenceToEffectModuleApi("provide")(transformation.callee),
+          option
+        );
+        if (isSome2(isProvideCall)) {
+          const layer = transformation.args[0];
+          const type = typeCheckerUtils.getTypeAtLocation(layer);
+          const node = ts.findAncestor(transformation.callee, ts.isCallExpression);
+          const isLayerType = type ? yield* pipe(
+            typeParser.layerType(type, layer),
+            option
+          ) : none2();
+          if (isSome2(isLayerType) && node) {
+            previousLayers[currentChunk].push({ layer, node });
+          } else {
+            currentChunk++;
+            previousLayers.push([]);
+          }
         } else {
           currentChunk++;
           previousLayers.push([]);
@@ -5729,19 +6320,6 @@ var multipleEffectProvide = createDiagnostic({
           }]
         });
       }
-    });
-    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)) {
-        yield* pipe(parsePipeCall(node), ignore);
-      }
     }
   })
 });
@@ -7055,6 +7633,56 @@ var overriddenSchemaConstructor = createDiagnostic({
   })
 });
 
+// src/diagnostics/redundantSchemaTagIdentifier.ts
+var redundantSchemaTagIdentifier = createDiagnostic({
+  name: "redundantSchemaTagIdentifier",
+  code: 42,
+  description: "Suggests removing redundant identifier argument when it equals the tag value in Schema.TaggedClass/TaggedError/TaggedRequest",
+  severity: "suggestion",
+  apply: fn("redundantSchemaTagIdentifier.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
+        const result = yield* pipe(
+          typeParser.extendsSchemaTaggedClass(node),
+          orElse2(() => typeParser.extendsSchemaTaggedError(node)),
+          orElse2(() => typeParser.extendsSchemaTaggedRequest(node)),
+          orElse2(() => void_)
+        );
+        if (result && result.keyStringLiteral && result.tagStringLiteral) {
+          const { keyStringLiteral, tagStringLiteral } = result;
+          if (keyStringLiteral.text === tagStringLiteral.text) {
+            report({
+              location: keyStringLiteral,
+              messageText: `Identifier '${keyStringLiteral.text}' is redundant since it equals the _tag value`,
+              fixes: [{
+                fixName: "redundantSchemaTagIdentifier_removeIdentifier",
+                description: `Remove redundant identifier '${keyStringLiteral.text}'`,
+                apply: gen(function* () {
+                  const changeTracker = yield* service(ChangeTracker);
+                  changeTracker.deleteRange(sourceFile, {
+                    pos: ts.getTokenPosOfNode(keyStringLiteral, sourceFile),
+                    end: keyStringLiteral.end
+                  });
+                })
+              }]
+            });
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/returnEffectInGen.ts
 var returnEffectInGen = createDiagnostic({
   name: "returnEffectInGen",
@@ -8055,7 +8683,10 @@ var diagnostics = [
   schemaStructWithTag,
   globalErrorInEffectCatch,
   globalErrorInEffectFailure,
-  layerMergeAllWithDependencies
+  layerMergeAllWithDependencies,
+  effectMapVoid,
+  effectFnOpportunity,
+  redundantSchemaTagIdentifier
 ];
 
 // src/transform.ts