@effect/language-service 0.64.1 → 0.66.1

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 
-// 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") {
@@ -98,7 +98,7 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   }
 }
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Equivalence.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Equivalence.js
 var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
 var array = (item) => make((self, that) => {
   if (self.length !== that.length) {
@@ -113,7 +113,7 @@ var array = (item) => make((self, that) => {
   return true;
 });
 
-// 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) => {
@@ -127,7 +127,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";
@@ -138,10 +138,10 @@ var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) &&
 var isTagged = /* @__PURE__ */ dual(2, (self, tag) => hasProperty(self, "_tag") && self["_tag"] === tag);
 var isRecord = (input) => isRecordOrArray(input) && !Array.isArray(input);
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/errors.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/errors.js
 var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;
 
-// 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;
@@ -263,7 +263,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) => {
@@ -372,7 +372,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) {
@@ -428,7 +428,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 {
@@ -486,7 +486,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:
@@ -519,16 +519,16 @@ 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";
 var OP_FAILURE = "Failure";
 var OP_WITH_RUNTIME = "WithRuntime";
 
-// 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");
@@ -615,7 +615,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,
@@ -673,7 +673,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,
@@ -735,7 +735,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;
@@ -743,10 +743,10 @@ 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 make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
 var string2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
 var number2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
@@ -760,7 +760,7 @@ var combine2 = /* @__PURE__ */ dual(2, (self, that) => make2((a1, a2) => {
 }));
 var mapInput = /* @__PURE__ */ dual(2, (self, f) => make2((b1, b2) => self(f(b1), f(b2))));
 
-// 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;
@@ -771,7 +771,7 @@ var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nu
 var getOrUndefined = /* @__PURE__ */ getOrElse2(constUndefined);
 var map2 = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
 
-// 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 map3 = /* @__PURE__ */ dual(2, (self, f) => {
   const out = {
     ...self
@@ -783,7 +783,7 @@ var map3 = /* @__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)));
@@ -887,7 +887,7 @@ var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
 var dedupe = (self) => dedupeWith(self, equivalence());
 var join = /* @__PURE__ */ dual(2, (self, sep) => fromIterable(self).join(sep));
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Chunk.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Chunk.js
 var TypeId3 = /* @__PURE__ */ Symbol.for("effect/Chunk");
 function copy(src, srcPos, dest, destPos, len) {
   for (let i = srcPos; i < Math.min(src.length, srcPos + len); i++) {
@@ -1183,14 +1183,14 @@ var isNonEmpty = (self) => self.length > 0;
 var unsafeHead = (self) => unsafeGet2(self, 0);
 var headNonEmpty2 = unsafeHead;
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/hashMap/config.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/hashMap/config.js
 var SIZE = 5;
 var BUCKET_SIZE = /* @__PURE__ */ Math.pow(2, SIZE);
 var MASK = BUCKET_SIZE - 1;
 var MAX_INDEX_NODE = BUCKET_SIZE / 2;
 var MIN_ARRAY_NODE = BUCKET_SIZE / 4;
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/hashMap/bitwise.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/hashMap/bitwise.js
 function popcount(x) {
   x -= x >> 1 & 1431655765;
   x = (x & 858993459) + (x >> 2 & 858993459);
@@ -1209,13 +1209,13 @@ function fromBitmap(bitmap, bit) {
   return popcount(bitmap & bit - 1);
 }
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/stack.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/stack.js
 var make4 = (value, previous) => ({
   value,
   previous
 });
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/hashMap/array.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/hashMap/array.js
 function arrayUpdate(mutate3, at, v, arr) {
   let out = arr;
   if (!mutate3) {
@@ -1260,7 +1260,7 @@ function arraySpliceIn(mutate3, at, v, arr) {
   return out;
 }
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/hashMap/node.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/hashMap/node.js
 var EmptyNode = class _EmptyNode {
   _tag = "EmptyNode";
   modify(edit, _shift, f, hash2, key, size4) {
@@ -1495,7 +1495,7 @@ function mergeLeaves(edit, shift, h1, n1, h2, n2) {
   }
 }
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/hashMap.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/hashMap.js
 var HashMapSymbolKey = "effect/HashMap";
 var HashMapTypeId = /* @__PURE__ */ Symbol.for(HashMapSymbolKey);
 var HashMapProto = {
@@ -1707,7 +1707,7 @@ var reduce2 = /* @__PURE__ */ dual(3, (self, zero2, f) => {
   return zero2;
 });
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/hashSet.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/hashSet.js
 var HashSetSymbolKey = "effect/HashSet";
 var HashSetTypeId = /* @__PURE__ */ Symbol.for(HashSetSymbolKey);
 var HashSetProto = {
@@ -1769,13 +1769,13 @@ var union2 = /* @__PURE__ */ dual(2, (self, that) => mutate(empty4(), (set2) =>
 }));
 var forEach2 = /* @__PURE__ */ dual(2, (self, f) => forEach(self._keyMap, (_, k) => f(k)));
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/HashSet.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/HashSet.js
 var empty5 = empty4;
 var size3 = size2;
 var add2 = add;
 var union3 = union2;
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/data.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/data.js
 var ArrayProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(Array.prototype), {
   [symbol]() {
     return cached(this, array2(this));
@@ -1798,7 +1798,7 @@ var Structural = /* @__PURE__ */ (function() {
   return Structural2;
 })();
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/opCodes/cause.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/opCodes/cause.js
 var OP_DIE = "Die";
 var OP_EMPTY = "Empty";
 var OP_FAIL = "Fail";
@@ -1806,7 +1806,7 @@ var OP_INTERRUPT = "Interrupt";
 var OP_PARALLEL = "Parallel";
 var OP_SEQUENTIAL = "Sequential";
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/cause.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/cause.js
 var CauseSymbolKey = "effect/Cause";
 var CauseTypeId = /* @__PURE__ */ Symbol.for(CauseSymbolKey);
 var variance = {
@@ -2238,7 +2238,7 @@ var prettyErrors = (cause) => reduceWithContext(cause, void 0, {
   sequentialCase: (_, l, r) => [...l, ...r]
 });
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/singleShotGen.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/singleShotGen.js
 var SingleShotGen2 = class _SingleShotGen {
   self;
   called = false;
@@ -2268,7 +2268,7 @@ var SingleShotGen2 = class _SingleShotGen {
   }
 };
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/core.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/core.js
 var EffectTypeId2 = /* @__PURE__ */ Symbol.for("effect/Effect");
 var EffectPrimitive = class {
   _op;
@@ -2552,7 +2552,7 @@ var currentSpanFromFiber = (fiber) => {
   return span !== void 0 && span._tag === "Span" ? some2(span) : none2();
 };
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Data.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Data.js
 var Class2 = Structural;
 var Error2 = /* @__PURE__ */ (function() {
   const plainArgsSymbol = /* @__PURE__ */ Symbol.for("effect/Data/Error/plainArgs");
@@ -2590,10 +2590,10 @@ var TaggedError = (tag) => {
   return O.BaseEffectError;
 };
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/encoding/common.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/encoding/common.js
 var encoder = /* @__PURE__ */ new TextEncoder();
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/encoding/base64.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/encoding/base64.js
 var encode = (bytes) => {
   const length = bytes.length;
   let result = "";
@@ -2619,13 +2619,13 @@ var encode = (bytes) => {
 };
 var base64abc = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/"];
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/internal/encoding/base64Url.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/internal/encoding/base64Url.js
 var encode2 = (data) => encode(data).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Encoding.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Encoding.js
 var encodeBase64Url = (input) => typeof input === "string" ? encode2(encoder.encode(input)) : encode2(input);
 
-// node_modules/.pnpm/effect@3.19.13/node_modules/effect/dist/esm/Graph.js
+// node_modules/.pnpm/effect@3.19.14/node_modules/effect/dist/esm/Graph.js
 var TypeId4 = "~effect/Graph";
 var Edge = class extends Class2 {
 };
@@ -3454,7 +3454,7 @@ var defaults = {
   diagnosticSeverity: {},
   diagnosticsName: true,
   missingDiagnosticNextLine: "warning",
-  reportSuggestionsAsWarningsInTsc: false,
+  includeSuggestionsInTsc: true,
   quickinfo: true,
   quickinfoEffectParameters: "whentruncated",
   quickinfoMaximumLength: -1,
@@ -3478,7 +3478,7 @@ var defaults = {
     skipLeadingPath: ["src/"]
   }],
   extendedKeyDetection: false,
-  pipeableMinArgCount: 1,
+  pipeableMinArgCount: 2,
   layerGraphFollowDepth: 0,
   mermaidProvider: "mermaid.live"
 };
@@ -3501,7 +3501,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,
@@ -4083,6 +4083,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,
@@ -4106,7 +4116,8 @@ function makeTypeScriptUtils(ts) {
     getSourceFileOfNode,
     isOuterExpression,
     skipOuterExpressions,
-    isDeclarationKind
+    isDeclarationKind,
+    isVoidExpression
   };
 }
 
@@ -5364,13 +5375,15 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
         );
       }
       const propertyAccess = node.expression;
+      const pipeArguments2 = node.arguments.slice(1);
       return pipe(
         isNodeReferenceToEffectModuleApi("fnUntraced")(propertyAccess),
         map8(() => ({
           node,
           effectModule: propertyAccess.expression,
           generatorFunction,
-          body: generatorFunction.body
+          body: generatorFunction.body,
+          pipeArguments: pipeArguments2
         }))
       );
     },
@@ -5409,19 +5422,112 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
         );
       }
       const propertyAccess = expressionToTest;
+      const pipeArguments2 = node.arguments.slice(1);
       return pipe(
         isNodeReferenceToEffectModuleApi("fn")(propertyAccess),
         map8(() => ({
           node,
           generatorFunction,
           effectModule: propertyAccess.expression,
-          body: generatorFunction.body
+          body: generatorFunction.body,
+          pipeArguments: pipeArguments2
         }))
       );
     },
     "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);
@@ -5533,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"),
@@ -5602,6 +5730,23 @@ function make7(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);
@@ -6140,9 +6285,333 @@ function make7(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),
+            map8((p) => ({ _tag: "pipe", ...p })),
+            orElse2(
+              () => pipe(
+                singleArgCall(node),
+                map8((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 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;
+              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: "effectFn"
+                  });
+                } else {
+                  transformations.push({
+                    callee: arg,
+                    args: void 0,
+                    outType,
+                    kind: "effectFn"
+                  });
+                }
+              }
+              const newFlow = {
+                node,
+                subject: {
+                  node,
+                  outType: subjectType
+                },
+                transformations
+              };
+              result.push(newFlow);
+              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]);
+                });
+              }
+              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,
+    isNodeReferenceToEffectParseResultModuleApi,
     isNodeReferenceToEffectDataModuleApi,
     isNodeReferenceToEffectContextModuleApi,
     isNodeReferenceToEffectSqlModelModuleApi,
@@ -6156,12 +6625,15 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     effectGen,
     effectFnUntracedGen,
     effectFnGen,
+    findEnclosingScopes,
+    effectFn,
     extendsCauseYieldableError,
     unnecessaryEffectGen: unnecessaryEffectGen2,
     effectSchemaType,
     contextTag,
     pipeableType,
     pipeCall,
+    singleArgCall,
     scopeType,
     promiseLike,
     extendsEffectTag,
@@ -6173,7 +6645,11 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     extendsDataTaggedError,
     extendsDataTaggedClass,
     extendsSchemaTaggedRequest,
-    extendsEffectSqlModelClass
+    extendsEffectSqlModelClass,
+    lazyExpression,
+    emptyFunction,
+    pipingFlows,
+    reconstructPipingFlow
   };
 }
 
@@ -7521,48 +7997,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);
+            })
+          }]
+        });
       }
     }
   })
@@ -7577,66 +8050,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: []
+            });
           }
         }
       }
@@ -7879,6 +8325,269 @@ ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageNam
   })
 });
 
+// src/diagnostics/effectFnOpportunity.ts
+var effectFnOpportunity = createDiagnostic({
+  name: "effectFnOpportunity",
+  code: 41,
+  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 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 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(
+          () => 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,
+        isGenerator ? ts.factory.createToken(ts.SyntaxKind.AsteriskToken) : void 0,
+        void 0,
+        originalNode.typeParameters,
+        originalNode.parameters,
+        void 0,
+        getFunctionBodyBlock(innerFunction)
+      );
+      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, [newFunction, ...pipeArguments2]);
+      if (ts.isFunctionDeclaration(originalNode)) {
+        return tsUtils.tryPreserveDeclarationSemantics(originalNode, effectFnCall, false);
+      }
+      return effectFnCall;
+    };
+    const createEffectFnUntracedNode = (originalNode, innerFunction, effectModuleName, pipeArguments2) => {
+      const isGenerator = isGeneratorFunction(innerFunction);
+      const newFunction = ts.factory.createFunctionExpression(
+        void 0,
+        isGenerator ? ts.factory.createToken(ts.SyntaxKind.AsteriskToken) : void 0,
+        void 0,
+        originalNode.typeParameters,
+        originalNode.parameters,
+        void 0,
+        getFunctionBodyBlock(innerFunction)
+      );
+      const effectFnCall = ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(effectModuleName), "fnUntraced"),
+        void 0,
+        [newFunction, ...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), option);
+      if (isNone2(target)) continue;
+      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, 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: 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
+      });
+    }
+  })
+});
+
 // src/diagnostics/effectGenUsesAdapter.ts
 var effectGenUsesAdapter = createDiagnostic({
   name: "effectGenUsesAdapter",
@@ -7966,6 +8675,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 match3 = yield* pipe(
+            typeParser.emptyFunction(callback),
+            orElse2(
+              () => pipe(
+                typeParser.lazyExpression(callback),
+                flatMap4(
+                  (lazy) => tsUtils.isVoidExpression(lazy.expression) ? succeed(lazy) : typeParserIssue("Expression is not void")
+                )
+              )
+            ),
+            option
+          );
+          if (isNone2(match3)) 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",
@@ -8574,75 +9347,153 @@ 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 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 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;
+      }
+      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;
           }
         }
-      } 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),
-                        map4((call) => call.expression),
-                        reverse2
-                      )
-                    )
-                  );
-                })
-              }]
-            });
-            originalParentChain.forEach((node2) => callChainNodes.delete(node2));
+        if (firstPipeableIndex === -1) {
+          break;
+        }
+        const pipeableTransformations = [];
+        for (let i = firstPipeableIndex; i < flow2.transformations.length; i++) {
+          const t = flow2.transformations[i];
+          if (!isSafelyPipeableCallee(t.callee)) {
             break;
           }
+          pipeableTransformations.push(t);
+        }
+        const callKindCount = pipeableTransformations.filter((t) => t.kind === "call").length;
+        if (callKindCount >= 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,
+                  pipeArgs
+                );
+                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;
       }
-      ts.forEachChild(node, prependNodeToVisit);
     }
   })
 });
@@ -9141,28 +9992,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),
-          flatMap4(() => typeParser.layerType(type, layer)),
-          map8(() => ({ 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([]);
@@ -9202,19 +10059,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);
-      }
     }
   })
 });
@@ -9495,6 +10339,140 @@ 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",
+  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",
@@ -9597,108 +10575,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;
       }
     }
   })
@@ -9784,6 +10745,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",
@@ -10495,7 +11509,12 @@ var diagnostics = [
   schemaStructWithTag,
   globalErrorInEffectCatch,
   globalErrorInEffectFailure,
-  layerMergeAllWithDependencies
+  layerMergeAllWithDependencies,
+  effectMapVoid,
+  effectFnOpportunity,
+  redundantSchemaTagIdentifier,
+  schemaSyncInEffect,
+  preferSchemaOverJson
 ];
 
 // src/completions/effectDiagnosticsComment.ts
@@ -10600,7 +11619,7 @@ var effectSchemaSelfInClasses = createCompletion({
       completions2.push({
         name: `TaggedError<${name}>`,
         kind: ts.ScriptElementKind.constElement,
-        insertText: isFullyQualified ? `${schemaIdentifier}.TaggedError<${name}>("${errorTagKey}")("${errorTagKey}", {${"${0}"}}){}` : `TaggedError<${name}>("${errorTagKey}")("${errorTagKey}", {${"${0}"}}){}`,
+        insertText: isFullyQualified ? `${schemaIdentifier}.TaggedError<${name}>()("${errorTagKey}", {${"${0}"}}){}` : `TaggedError<${name}>()("${errorTagKey}", {${"${0}"}}){}`,
         replacementSpan,
         isSnippet: true
       });
@@ -10615,7 +11634,7 @@ var effectSchemaSelfInClasses = createCompletion({
       completions2.push({
         name: `TaggedClass<${name}>`,
         kind: ts.ScriptElementKind.constElement,
-        insertText: isFullyQualified ? `${schemaIdentifier}.TaggedClass<${name}>("${name}")("${name}", {${"${0}"}}){}` : `TaggedClass<${name}>("${name}")("${name}", {${"${0}"}}){}`,
+        insertText: isFullyQualified ? `${schemaIdentifier}.TaggedClass<${name}>()("${name}", {${"${0}"}}){}` : `TaggedClass<${name}>()("${name}", {${"${0}"}}){}`,
         replacementSpan,
         isSnippet: true
       });
@@ -10630,7 +11649,7 @@ var effectSchemaSelfInClasses = createCompletion({
       completions2.push({
         name: `TaggedRequest<${name}>`,
         kind: ts.ScriptElementKind.constElement,
-        insertText: isFullyQualified ? `${schemaIdentifier}.TaggedRequest<${name}>("${name}")("${name}", {${"${0}"}}){}` : `TaggedRequest<${name}>("${name}")("${name}", {${"${0}"}}){}`,
+        insertText: isFullyQualified ? `${schemaIdentifier}.TaggedRequest<${name}>()("${name}", {${"${0}"}}){}` : `TaggedRequest<${name}>()("${name}", {${"${0}"}}){}`,
         replacementSpan,
         isSnippet: true
       });
@@ -16382,6 +17401,23 @@ var extractOutlineGraph = fn("extractOutlineGraph")(function* (layerGraph) {
   }
   return endMutation2(mutableGraph);
 });
+var collectOutlineGraphActualProvides = fn("collectOutlineGraphActualProvides")(
+  function* (outlineGraph) {
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const seenTypes = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const nodeInfo of values2(nodes(outlineGraph))) {
+      for (const actualProvide of nodeInfo.actualProvides) {
+        if (!seenTypes.has(actualProvide)) {
+          seenTypes.add(actualProvide);
+          result.push(actualProvide);
+        }
+      }
+    }
+    result.sort(typeCheckerUtils.deterministicTypeOrder);
+    return result;
+  }
+);
 var formatLayerOutlineGraph = fn("formatLayerOutlineGraph")(
   function* (layerOutlineGraph, fromSourceFile) {
     const tsUtils = yield* service(TypeScriptUtils);
@@ -16448,11 +17484,12 @@ var dfsPostOrderWithOrder = (graph, config) => {
   }));
 };
 var convertOutlineGraphToLayerMagic = fn("convertOutlineGraphToLayerMagic")(
-  function* (outlineGraph, targetOutput) {
+  function* (outlineGraph, targetOutputs) {
     const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const ts = yield* service(TypeScriptApi);
     const result = [];
-    const missingOutputTypes = new Set(typeCheckerUtils.unrollUnionMembers(targetOutput));
+    const outputTypes = flatten(map4(targetOutputs, (_) => typeCheckerUtils.unrollUnionMembers(_)));
+    const missingOutputTypes = new Set(outputTypes);
     const currentRequiredTypes = /* @__PURE__ */ new Set();
     const orderByProvidedCount = mapInput(
       reverse(number2),
@@ -17361,7 +18398,7 @@ var layerMagic = createRefactor({
                 const { layerMagicNodes, missingOutputTypes } = yield* pipe(
                   convertOutlineGraphToLayerMagic(
                     extractedLayers,
-                    _targetLayer.ROut
+                    [_targetLayer.ROut]
                   ),
                   provideService(TypeCheckerApi, typeChecker),
                   provideService(TypeCheckerUtils, typeCheckerUtils),