@effect/language-service 0.64.0 → 0.65.0

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,13 +5422,15 @@ 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
         }))
       );
     },
@@ -5602,6 +5617,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,6 +6172,266 @@ 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 isEffectFn = isSome2(effectFnGenParsed);
+            const effectFnParsed = isEffectFn ? effectFnGenParsed : effectFnUntracedGenParsed;
+            const transformationKind = isEffectFn ? "effectFn" : "effectFnUntraced";
+            if (isSome2(effectFnParsed) && effectFnParsed.value.pipeArguments.length > 0) {
+              const fnResult = effectFnParsed.value;
+              const pipeArgs = fnResult.pipeArguments;
+              const transformations = [];
+              let subjectType;
+              for (let i = 0; i < pipeArgs.length; i++) {
+                const arg = pipeArgs[i];
+                const contextualType = typeChecker.getContextualType(arg);
+                const callSigs = contextualType ? typeChecker.getSignaturesOfType(contextualType, ts.SignatureKind.Call) : [];
+                const outType = callSigs.length > 0 ? typeChecker.getReturnTypeOfSignature(callSigs[0]) : void 0;
+                if (i === 0 && callSigs.length > 0) {
+                  const params = callSigs[0].parameters;
+                  if (params.length > 0) {
+                    subjectType = typeChecker.getTypeOfSymbol(params[0]);
+                  }
+                }
+                if (ts.isCallExpression(arg)) {
+                  transformations.push({
+                    callee: arg.expression,
+                    args: Array.from(arg.arguments),
+                    outType,
+                    kind: transformationKind
+                  });
+                } else {
+                  transformations.push({
+                    callee: arg,
+                    args: void 0,
+                    outType,
+                    kind: transformationKind
+                  });
+                }
+              }
+              const newFlow = {
+                node,
+                subject: {
+                  node,
+                  outType: subjectType
+                },
+                transformations
+              };
+              result.push(newFlow);
+              workQueue.push([fnResult.body, void 0]);
+              for (const arg of pipeArgs) {
+                ts.forEachChild(arg, (c) => {
+                  workQueue.push([c, void 0]);
+                });
+              }
+              continue;
+            }
+          }
+        }
+        if (parentFlow && parentFlow.transformations.length > 0) {
+          result.push(parentFlow);
+        }
+        ts.forEachChild(node, (child) => {
+          workQueue.push([child, void 0]);
+        });
+      }
+      result.sort((a, b) => a.node.pos - b.node.pos);
+      return result;
+    }),
+    `TypeParser.pipingFlows(${includeEffectFn})`,
+    (sourceFile) => sourceFile
+  );
+  const reconstructPipingFlow = (flow2) => {
+    if (flow2.transformations.length > 0 && flow2.transformations.every((t) => t.kind === "effectFn" || t.kind === "effectFnUntraced")) {
+      return flow2.subject.node;
+    }
+    let result = flow2.subject.node;
+    for (const t of flow2.transformations) {
+      if (t.kind === "call") {
+        result = ts.factory.createCallExpression(
+          t.callee,
+          void 0,
+          [result]
+        );
+      } else if (t.kind === "effectFn" || t.kind === "effectFnUntraced") {
+        continue;
+      } else {
+        if (t.args) {
+          const transformCall = ts.factory.createCallExpression(
+            t.callee,
+            void 0,
+            t.args
+          );
+          result = ts.factory.createCallExpression(
+            transformCall,
+            void 0,
+            [result]
+          );
+        } else {
+          result = ts.factory.createCallExpression(
+            t.callee,
+            void 0,
+            [result]
+          );
+        }
+      }
+    }
+    return result;
+  };
   return {
     isNodeReferenceToEffectModuleApi,
     isNodeReferenceToEffectSchemaModuleApi,
@@ -6162,6 +6454,7 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     contextTag,
     pipeableType,
     pipeCall,
+    singleArgCall,
     scopeType,
     promiseLike,
     extendsEffectTag,
@@ -6173,7 +6466,11 @@ function make7(ts, tsUtils, typeChecker, typeCheckerUtils, program) {
     extendsDataTaggedError,
     extendsDataTaggedClass,
     extendsSchemaTaggedRequest,
-    extendsEffectSqlModelClass
+    extendsEffectSqlModelClass,
+    lazyExpression,
+    emptyFunction,
+    pipingFlows,
+    reconstructPipingFlow
   };
 }
 
@@ -7521,48 +7818,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 +7871,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 +8146,245 @@ ${versions.map((version) => `- found ${version} at ${resolvedPackages[packageNam
   })
 });
 
+// src/diagnostics/effectFnOpportunity.ts
+var parseEffectFnOpportunityTarget = (node, sourceFile) => gen(function* () {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const typeParser = yield* service(TypeParser);
+  const tsUtils = yield* service(TypeScriptUtils);
+  if (!ts.isFunctionExpression(node) && !ts.isArrowFunction(node) && !ts.isFunctionDeclaration(node)) {
+    return yield* TypeParserIssue.issue;
+  }
+  if ((ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) && node.asteriskToken) {
+    return yield* TypeParserIssue.issue;
+  }
+  if (ts.isFunctionExpression(node) && node.name) {
+    return yield* TypeParserIssue.issue;
+  }
+  let bodyExpression;
+  if (ts.isArrowFunction(node)) {
+    if (ts.isBlock(node.body)) {
+      const returnStatement = findSingleReturnStatement(ts, node.body);
+      if (returnStatement?.expression) {
+        bodyExpression = returnStatement.expression;
+      }
+    } else {
+      bodyExpression = node.body;
+    }
+  } else if ((ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) && node.body) {
+    const returnStatement = findSingleReturnStatement(ts, node.body);
+    if (returnStatement?.expression) {
+      bodyExpression = returnStatement.expression;
+    }
+  }
+  if (!bodyExpression) return yield* TypeParserIssue.issue;
+  const { pipeArguments: pipeArguments2, subject } = yield* pipe(
+    typeParser.pipeCall(bodyExpression),
+    map8(({ args: args2, subject: subject2 }) => ({ subject: subject2, pipeArguments: args2 })),
+    orElse2(() => succeed({ subject: bodyExpression, pipeArguments: [] }))
+  );
+  const { effectModule, generatorFunction } = yield* typeParser.effectGen(subject);
+  const functionType = typeChecker.getTypeAtLocation(node);
+  if (!functionType) return yield* TypeParserIssue.issue;
+  const callSignatures = typeChecker.getSignaturesOfType(functionType, ts.SignatureKind.Call);
+  if (callSignatures.length !== 1) return yield* TypeParserIssue.issue;
+  const signature = callSignatures[0];
+  const returnType = typeChecker.getReturnTypeOfSignature(signature);
+  const { A, E, R } = yield* typeParser.strictEffectType(returnType, node);
+  const effectModuleName = ts.isIdentifier(effectModule) ? ts.idText(effectModule) : tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(
+    sourceFile,
+    "effect",
+    "Effect"
+  ) || "Effect";
+  const nameIdentifier = getNameIdentifier(ts, node);
+  const traceName = nameIdentifier ? ts.isIdentifier(nameIdentifier) ? ts.idText(nameIdentifier) : nameIdentifier.text : void 0;
+  const hasReturnTypeAnnotation = !!node.type;
+  return {
+    node,
+    nameIdentifier,
+    effectModule,
+    generatorFunction,
+    effectModuleName,
+    traceName,
+    hasReturnTypeAnnotation,
+    effectTypes: { A, E, R },
+    pipeArguments: pipeArguments2
+  };
+});
+var effectFnOpportunity = createDiagnostic({
+  name: "effectFnOpportunity",
+  code: 41,
+  description: "Suggests using Effect.fn for functions that return Effect.gen",
+  severity: "suggestion",
+  apply: fn("effectFnOpportunity.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    const createReturnTypeAnnotation = (effectModuleName, effectTypes, enclosingNode) => {
+      const { A, E, R } = effectTypes;
+      const aTypeNode = typeChecker.typeToTypeNode(A, enclosingNode, ts.NodeBuilderFlags.NoTruncation);
+      const eTypeNode = typeChecker.typeToTypeNode(E, enclosingNode, ts.NodeBuilderFlags.NoTruncation);
+      const rTypeNode = typeChecker.typeToTypeNode(R, enclosingNode, ts.NodeBuilderFlags.NoTruncation);
+      if (!aTypeNode || !eTypeNode || !rTypeNode) return void 0;
+      return ts.factory.createTypeReferenceNode(
+        ts.factory.createQualifiedName(
+          ts.factory.createQualifiedName(
+            ts.factory.createIdentifier(effectModuleName),
+            "fn"
+          ),
+          "Return"
+        ),
+        [aTypeNode, eTypeNode, rTypeNode]
+      );
+    };
+    const createEffectFnNode = (originalNode, generatorFunction, effectModuleName, traceName, effectTypes, pipeArguments2) => {
+      const returnTypeAnnotation = effectTypes ? createReturnTypeAnnotation(effectModuleName, effectTypes, originalNode) : void 0;
+      const newGeneratorFunction = ts.factory.createFunctionExpression(
+        void 0,
+        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+        void 0,
+        originalNode.typeParameters,
+        originalNode.parameters,
+        returnTypeAnnotation,
+        generatorFunction.body
+      );
+      let fnExpression = ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(effectModuleName),
+        "fn"
+      );
+      if (traceName) {
+        fnExpression = ts.factory.createCallExpression(
+          fnExpression,
+          void 0,
+          [ts.factory.createStringLiteral(traceName)]
+        );
+      }
+      const effectFnCall = ts.factory.createCallExpression(
+        fnExpression,
+        void 0,
+        [newGeneratorFunction, ...pipeArguments2]
+      );
+      if (ts.isFunctionDeclaration(originalNode)) {
+        return tsUtils.tryPreserveDeclarationSemantics(originalNode, effectFnCall, false);
+      }
+      return effectFnCall;
+    };
+    const createEffectFnUntracedNode = (originalNode, generatorFunction, effectModuleName, effectTypes, pipeArguments2) => {
+      const returnTypeAnnotation = effectTypes ? createReturnTypeAnnotation(effectModuleName, effectTypes, originalNode) : void 0;
+      const newGeneratorFunction = ts.factory.createFunctionExpression(
+        void 0,
+        ts.factory.createToken(ts.SyntaxKind.AsteriskToken),
+        void 0,
+        originalNode.typeParameters,
+        originalNode.parameters,
+        returnTypeAnnotation,
+        generatorFunction.body
+      );
+      const effectFnCall = ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(
+          ts.factory.createIdentifier(effectModuleName),
+          "fnUntraced"
+        ),
+        void 0,
+        [newGeneratorFunction, ...pipeArguments2]
+      );
+      if (ts.isFunctionDeclaration(originalNode)) {
+        return tsUtils.tryPreserveDeclarationSemantics(originalNode, effectFnCall, false);
+      }
+      return effectFnCall;
+    };
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      const target = yield* pipe(
+        parseEffectFnOpportunityTarget(node, sourceFile),
+        option
+      );
+      if (isNone2(target)) continue;
+      const {
+        effectModuleName,
+        effectTypes,
+        generatorFunction,
+        hasReturnTypeAnnotation,
+        nameIdentifier,
+        node: targetNode,
+        pipeArguments: pipeArguments2,
+        traceName
+      } = target.value;
+      const fixes = [];
+      fixes.push({
+        fixName: "effectFnOpportunity_toEffectFn",
+        description: traceName ? `Convert to Effect.fn("${traceName}")` : "Convert to Effect.fn",
+        apply: gen(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          const newNode = createEffectFnNode(
+            targetNode,
+            generatorFunction,
+            effectModuleName,
+            traceName,
+            hasReturnTypeAnnotation ? effectTypes : void 0,
+            pipeArguments2
+          );
+          changeTracker.replaceNode(sourceFile, targetNode, newNode);
+        })
+      });
+      fixes.push({
+        fixName: "effectFnOpportunity_toEffectFnUntraced",
+        description: "Convert to Effect.fnUntraced",
+        apply: gen(function* () {
+          const changeTracker = yield* service(ChangeTracker);
+          const newNode = createEffectFnUntracedNode(
+            targetNode,
+            generatorFunction,
+            effectModuleName,
+            hasReturnTypeAnnotation ? effectTypes : void 0,
+            pipeArguments2
+          );
+          changeTracker.replaceNode(sourceFile, targetNode, newNode);
+        })
+      });
+      report({
+        location: nameIdentifier ?? targetNode,
+        messageText: `This function could benefit from Effect.fn's automatic tracing and concise syntax, or Effect.fnUntraced to get just a more concise syntax.`,
+        fixes
+      });
+    }
+  })
+});
+function findSingleReturnStatement(ts, block) {
+  if (block.statements.length !== 1) return void 0;
+  const statement = block.statements[0];
+  if (!ts.isReturnStatement(statement)) return void 0;
+  return statement;
+}
+function getNameIdentifier(ts, node) {
+  if (ts.isFunctionDeclaration(node) && node.name) {
+    return node.name;
+  }
+  if (node.parent && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) {
+    return node.parent.name;
+  }
+  if (node.parent && ts.isPropertyAssignment(node.parent)) {
+    const name = node.parent.name;
+    if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
+      return name;
+    }
+  }
+  if (node.parent && ts.isPropertyDeclaration(node.parent)) {
+    const name = node.parent.name;
+    if (ts.isIdentifier(name)) {
+      return name;
+    }
+  }
+  return void 0;
+}
+
 // src/diagnostics/effectGenUsesAdapter.ts
 var effectGenUsesAdapter = createDiagnostic({
   name: "effectGenUsesAdapter",
@@ -7966,6 +8472,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 +9144,91 @@ var missedPipeableOpportunity = createDiagnostic({
   apply: fn("missedPipeableOpportunity.apply")(function* (sourceFile, report) {
     const ts = yield* service(TypeScriptApi);
     const typeChecker = yield* service(TypeCheckerApi);
-    const typeCheckerUtils = yield* service(TypeCheckerUtils);
     const typeParser = yield* service(TypeParser);
     const options = yield* service(LanguageServicePluginOptions);
-    const nodeToVisit = [sourceFile];
-    const prependNodeToVisit = (node) => {
-      nodeToVisit.unshift(node);
-      return void 0;
-    };
-    const callChainNodes = /* @__PURE__ */ new WeakMap();
-    while (nodeToVisit.length > 0) {
-      const node = nodeToVisit.shift();
-      if (ts.isCallExpression(node) && node.arguments.length === 1) {
-        const isPipeCall = yield* pipe(typeParser.pipeCall(node), orElse2(() => void_));
-        if (!isPipeCall) {
-          const resolvedSignature = typeChecker.getResolvedSignature(node);
-          if (resolvedSignature) {
-            const returnType = typeChecker.getReturnTypeOfSignature(resolvedSignature);
-            if (returnType) {
-              const callSignatures = typeChecker.getSignaturesOfType(returnType, ts.SignatureKind.Call);
-              if (callSignatures.length === 0) {
-                const parentChain = callChainNodes.get(node) || [];
-                callChainNodes.set(node.arguments[0], parentChain.concat(node));
-              }
+    const flows = yield* typeParser.pipingFlows(false)(sourceFile);
+    for (const flow2 of flows) {
+      if (flow2.transformations.length < options.pipeableMinArgCount) {
+        continue;
+      }
+      const finalType = flow2.transformations[flow2.transformations.length - 1].outType;
+      if (!finalType) {
+        continue;
+      }
+      const callSigs = typeChecker.getSignaturesOfType(finalType, ts.SignatureKind.Call);
+      if (callSigs.length > 0) {
+        continue;
+      }
+      let firstPipeableIndex = -1;
+      const subjectType = flow2.subject.outType;
+      if (!subjectType) {
+        continue;
+      }
+      const subjectIsPipeable = yield* pipe(
+        typeParser.pipeableType(subjectType, flow2.subject.node),
+        option
+      );
+      if (subjectIsPipeable._tag === "Some") {
+        firstPipeableIndex = 0;
+      } else {
+        for (let i = 0; i < flow2.transformations.length; i++) {
+          const t = flow2.transformations[i];
+          if (t.outType) {
+            const isPipeable = yield* pipe(
+              typeParser.pipeableType(t.outType, flow2.node),
+              option
+            );
+            if (isPipeable._tag === "Some") {
+              firstPipeableIndex = i + 1;
+              break;
             }
           }
         }
-      } else if (callChainNodes.has(node) && ts.isExpression(node)) {
-        const parentChain = (callChainNodes.get(node) || []).slice();
-        const originalParentChain = parentChain.slice();
-        while (parentChain.length > options.pipeableMinArgCount) {
-          const subject = parentChain.pop();
-          const resultType = typeCheckerUtils.getTypeAtLocation(subject);
-          if (!resultType) continue;
-          const pipeableType = yield* pipe(typeParser.pipeableType(resultType, subject), orElse2(() => void_));
-          if (pipeableType) {
-            report({
-              location: parentChain[0],
-              messageText: `Nested function calls can be converted to pipeable style for better readability.`,
-              fixes: [{
-                fixName: "missedPipeableOpportunity_fix",
-                description: "Convert to pipe style",
-                apply: gen(function* () {
-                  const changeTracker = yield* service(ChangeTracker);
-                  changeTracker.replaceNode(
-                    sourceFile,
-                    parentChain[0],
-                    ts.factory.createCallExpression(
-                      ts.factory.createPropertyAccessExpression(
-                        subject,
-                        "pipe"
-                      ),
-                      void 0,
-                      pipe(
-                        parentChain,
-                        filter(ts.isCallExpression),
-                        map4((call) => call.expression),
-                        reverse2
-                      )
-                    )
-                  );
-                })
-              }]
-            });
-            originalParentChain.forEach((node2) => callChainNodes.delete(node2));
-            break;
-          }
-        }
       }
-      ts.forEachChild(node, prependNodeToVisit);
+      if (firstPipeableIndex === -1) {
+        continue;
+      }
+      const transformationsAfterPipeable = flow2.transformations.slice(firstPipeableIndex);
+      const callKindCount = transformationsAfterPipeable.filter((t) => t.kind === "call").length;
+      if (callKindCount < options.pipeableMinArgCount) {
+        continue;
+      }
+      const pipeableSubjectNode = firstPipeableIndex === 0 ? flow2.subject.node : typeParser.reconstructPipingFlow({
+        subject: flow2.subject,
+        transformations: flow2.transformations.slice(0, firstPipeableIndex)
+      });
+      const pipeableTransformations = flow2.transformations.slice(firstPipeableIndex);
+      report({
+        location: flow2.node,
+        messageText: `Nested function calls can be converted to pipeable style for better readability.`,
+        fixes: [{
+          fixName: "missedPipeableOpportunity_fix",
+          description: "Convert to pipe style",
+          apply: gen(function* () {
+            const changeTracker = yield* service(ChangeTracker);
+            const pipeArgs = pipeableTransformations.map((t) => {
+              if (t.args) {
+                return ts.factory.createCallExpression(
+                  t.callee,
+                  void 0,
+                  t.args
+                );
+              } else {
+                return t.callee;
+              }
+            });
+            const newNode = ts.factory.createCallExpression(
+              ts.factory.createPropertyAccessExpression(
+                pipeableSubjectNode,
+                "pipe"
+              ),
+              void 0,
+              pipeArgs
+            );
+            changeTracker.replaceNode(sourceFile, flow2.node, newNode);
+          })
+        }]
+      });
     }
   })
 });
@@ -9141,28 +9727,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 +9794,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 +10074,56 @@ var overriddenSchemaConstructor = createDiagnostic({
   })
 });
 
+// src/diagnostics/redundantSchemaTagIdentifier.ts
+var redundantSchemaTagIdentifier = createDiagnostic({
+  name: "redundantSchemaTagIdentifier",
+  code: 42,
+  description: "Suggests removing redundant identifier argument when it equals the tag value in Schema.TaggedClass/TaggedError/TaggedRequest",
+  severity: "suggestion",
+  apply: fn("redundantSchemaTagIdentifier.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeParser = yield* service(TypeParser);
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      if (ts.isClassDeclaration(node) && node.name && node.heritageClauses) {
+        const result = yield* pipe(
+          typeParser.extendsSchemaTaggedClass(node),
+          orElse2(() => typeParser.extendsSchemaTaggedError(node)),
+          orElse2(() => typeParser.extendsSchemaTaggedRequest(node)),
+          orElse2(() => void_)
+        );
+        if (result && result.keyStringLiteral && result.tagStringLiteral) {
+          const { keyStringLiteral, tagStringLiteral } = result;
+          if (keyStringLiteral.text === tagStringLiteral.text) {
+            report({
+              location: keyStringLiteral,
+              messageText: `Identifier '${keyStringLiteral.text}' is redundant since it equals the _tag value`,
+              fixes: [{
+                fixName: "redundantSchemaTagIdentifier_removeIdentifier",
+                description: `Remove redundant identifier '${keyStringLiteral.text}'`,
+                apply: gen(function* () {
+                  const changeTracker = yield* service(ChangeTracker);
+                  changeTracker.deleteRange(sourceFile, {
+                    pos: ts.getTokenPosOfNode(keyStringLiteral, sourceFile),
+                    end: keyStringLiteral.end
+                  });
+                })
+              }]
+            });
+          }
+        }
+      }
+      ts.forEachChild(node, appendNodeToVisit);
+    }
+  })
+});
+
 // src/diagnostics/returnEffectInGen.ts
 var returnEffectInGen = createDiagnostic({
   name: "returnEffectInGen",
@@ -10495,7 +11124,10 @@ var diagnostics = [
   schemaStructWithTag,
   globalErrorInEffectCatch,
   globalErrorInEffectFailure,
-  layerMergeAllWithDependencies
+  layerMergeAllWithDependencies,
+  effectMapVoid,
+  effectFnOpportunity,
+  redundantSchemaTagIdentifier
 ];
 
 // src/completions/effectDiagnosticsComment.ts
@@ -10600,7 +11232,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 +11247,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 +11262,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
       });
@@ -11379,13 +12011,6 @@ var addImportCodeAction = fn("getImportFromNamespaceCodeActions")(function* (for
       preferences: preferences || {}
     },
     (changeTracker) => {
-      if (effectAutoImport.introducedPrefix) {
-        changeTracker.insertText(
-          sourceFile,
-          effectReplaceSpan.start,
-          effectAutoImport.introducedPrefix + "."
-        );
-      }
       description = addImport(
         ts,
         sourceFile,
@@ -11393,6 +12018,13 @@ var addImportCodeAction = fn("getImportFromNamespaceCodeActions")(function* (for
         preferences,
         effectAutoImport
       ).description;
+      if (effectAutoImport.introducedPrefix) {
+        changeTracker.insertText(
+          sourceFile,
+          effectReplaceSpan.start,
+          effectAutoImport.introducedPrefix + "."
+        );
+      }
     }
   );
   return [
@@ -16382,6 +17014,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 +17097,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 +18011,7 @@ var layerMagic = createRefactor({
                 const { layerMagicNodes, missingOutputTypes } = yield* pipe(
                   convertOutlineGraphToLayerMagic(
                     extractedLayers,
-                    _targetLayer.ROut
+                    [_targetLayer.ROut]
                   ),
                   provideService(TypeCheckerApi, typeChecker),
                   provideService(TypeCheckerUtils, typeCheckerUtils),